目录

1.自定义函数

1.1Pycharm相关设置

1.2定义

函数内存图

1.3python作用

1.4定义函数

1.5调用函数

1.6返回值

1.7可变/不可变类型在传参

1.8函数参数

1.8.1实参传递方式argument

1.8.2形参定义方式parameter

1.9作用域LEGB

1.9.1变量名的查找规则

1.9.2局部变量

1.9.3全局变量

1.9.4 global语句

1.9.4 nonlocal语句

练习

---

1.自定义函数

def attack():  # 定义函数（做功能），使用功能的话要调用print("摆拳")print("直拳")print("肘击")print()
​
​
# 调用函数
attack()
attack()
attack()

def attack():  # 定义函数（做功能），使用功能的话要调用print("摆拳")print("直拳")print("肘击")print()
​
​
def attack_repeated(count):  # 形式参数for i in range(count):  # 次数不能写死了print("摆拳")print("直拳")print("肘击")print("临门一脚")print()
​
​
attack_repeated(2)  # 调用函数的时候（2）是实际参数

1.1Pycharm相关设置

1. F8 -->逐过程调试（调试时跳过方法）；F7 -->逐语句调试（调试时进入方法）

2. “代码自动完成”时间延时设置

   File -> Setting->Editor->General->Code com

3. 快捷键：

   Ctrl + P：参数信息（在方法中调用参数）

   Ctrl + Q：快速查看文档

   Ctrl + Akt + M：提取方法

1.2定义

• 函数用于封装一个特定的功能，表示一个功能或者行为。

• 函数是可以重复执行的语句块，可以重复调用。

• 注意：自定义函数的调试快捷键是F7（逐语句），其中F8是逐过程。

函数内存图

# 在方法区中存储函数代码，不执行函数体
def fun01(a):a = 100
​
​
num01 = 1
fun01(num01) # 因为调用函数，所以开辟一块内存图，叫做栈帧，由于存储在函数内部定义的变量
# 函数执行完毕后，栈帧立即释放（其中定义的变量也会销毁）
print(num01)  # 1

def fun02(a):a[0] = 100# 改变的是传入的可变对象
​
​
list01 = [1]
fun02(list01)
print(list01[0])

def fun03(a):a = 100# 改变的是fun03栈帧中变量a的指向
​
​
list01 = [1]
fun03(list01)
print(list01[0])  # 1

def fun04(a):a[1] = [200]b = 10
​
​
list01 = [1, [2, 3]]
fun04(list01)
print(list01[1])  # [200]

g01 = "ok"
​
​
def fun05():l01 = 100global g01g01 = "no"
​global g02g02 = 250
​
​
fun05()
print(g01) # no
print(g02) # 250

1.3python作用

函数可以提高代码的可重用性和可维护性（代码层次结构更清晰）。

1.4定义函数

• 语法

  def 函数名(形式参数):函数体

• 说明：

  def关键字：全称是“define”，意为“定义”

  函数名：对函数体中语句的描述（见名知意），规则与变量名要求相同。

  形式参数：方法定义者要求调用者提供的信息。

  函数体：完成该功能的语句。

• 函数的第一行语句建议使用文档字符串描述函数的功能

def attack_repeated(count):  # 形式参数"""单次攻击:param count:攻击次数:return:"""for i in range(count):  # 次数不能写死了print("摆拳")print("直拳")print("肘击")print("临门一脚")print()

1.5调用函数

• 语法：函数名(实际参数)

• 说明：根据形式参数传递内容

1.6返回值

• 定义：方法定义者告诉调用者的结果

• 语法：

  return 结果

• 说明：

  return后没有语句，相当于返回None；

  函数体没有return，相当于返回None。

• 通过元组向外返回多个结果（返回多个结果时默认是元组）

1.7可变/不可变类型在传参

（结合1.2中的函数内存图看）

• 不可变类型参数有：

  数值型（整数、浮点数、复数）

  布尔值bool

  None空值

  字符串str

  元组tuple

  固定集合frozenset

• 可变类型参数有：

  列表list

  字典dict

  集合set

• 传参说明：

  不可变类型的数据在传参时，函数内部不会改变原数据的值。

  可变类型的数据在传参时，函数内部可以改变原数据。（可以不是一定）

1.8函数参数

函数参数包括实际参数和形式参数。

1.8.1实参传递方式argument

def fun01(a, b, c, d):print(a)print(b)print(c)print(d)
​
​
# 位置实参：实参和形参根据位置依次对应
# fun01(1, 2, 3, 4)
​
# 关键字实参：实参和形参根据名称进行对应
# fun01(b=1, d=2, c=3, a=4)
​
# 序列实参：星号将序列拆分后按位置与形参进行对应
# 序列实参属于位置实参
# 如果参数很多，可以存储在序列（字符串/列表/元组）中，再通过*拆分直接传入函数
list01 = ['a', 'b', 'c', 'd']
# fun01(list01) # 报错，缺3个位置实参
fun01(*list01)
​
# 字典实参:双星号将字典拆分后按名称与形参进行对应
# 如果参数很多可以存储在字典中，再通过**拆分，传入函数
dict01 = {"a":1,"c":3,"d":4,"b":2}
# fun01(dict01) # 报错，缺3个位置实参
fun01(**dict01)

1.8.2形参定义方式parameter

# 缺省（默认）参数：如果实参不提供，可以使用默认值（允许实参不提供）
def fun01(a=0, b=0, c=0, d=0):print(a)print(b)print(c)print(d)
​
​
fun01(b=2, c=3) # 0 2 3 0
fun01(2,3) # 2 3 0 0
# 关键字实参+缺省实参：调用者可以随意传递参数
# 练习：根据小时、分钟、秒计算总秒数
def time(hour=0, min=0, sec=0):return hour * 60 * 60 + min * 60 + sec
​
​
a = time(min=1, sec=52)
print(a)

# 星号元组形参：*将所有实参合并为一个元组
# 作用：让实参个数无限制（最好写作args）
def fun01(*args):print(args)
​
​
fun01()  # ()
fun01(1)  # (1,)
fun01(1, 2, 3)  # (1, 2, 3)
fun01(1, '2', 3)  # (1, '2', 3)
​
​
# 练习：定义数值相加的函数
def add(*args):result = 0for item in args:result += itemreturn result
​
​
print(add(1, 2, 3, 4, 5))

# 命名关键字形参：在星号元组形参以后的位置形参
# 目的：要求实参必须使用关键字实参
def fun01(a, *args, b):print(a)print(args)print(b)
​
​
fun01(1, b=2)
print()
​
fun01(1, 2, 3, 4, 5, 6, b=2)
print()
​
​
def fun02(*, a, b):print(a)print(b)
​
​
print(fun02(a=1, b=2))

# 双星号字典形参：实参可以传递数量无限的关键字实参
# **目的是将实参合并为字典
def fun01(**kwargs):print(kwargs)
​
​
fun01(a=1, b=2)
# {'a': 1, 'b': 2}

参数自左至右的顺序：

位置形参 -> 星号元组形参 -> 命名关键字形参 -> 双星号字典形参

def fun01(a, b, *args, c, d, **kwargs):pass
​
​
fun01(1,2,c=3, d=4)

1.9作用域LEGB

• 作用域：变量起作用的范围

• local局部作用域：函数内部（局部作用域定义的变量称为局部变量）

• enclosing外部嵌套作用域：函数嵌套

• global全局作用域：模块（.py文件）内部（全局作用域定义的变量称为全局变量）

• builtin内置模块作用域：builtins.py文件（如查看print，点在print然后Ctrl+鼠标左键）需注意变量名不与关键字重复

# 全局变量
g01 = "ok"
​
​
def fun01():l01 = 100  # 局部变量
​print(l01)  # 100g01 = "no"  # 创建了一个局部变量g01而不是修改全局变量print(g01)  # no
​
​
fun01()
print(g01)  # ok
"""
在函数内部可以读取全局变量，如果在函数内部修改全局变量则相当于在函数内部创建了一个局部变量，原先的全局变量并没有被修改（如果一定要在函数内部修改全局变量则需要用global）
"""
# ----------------------------------------------------------
# 全局变量
g01 = "ok"
​
​
def fun01():l01 = 100  # 局部变量
​print(l01)  # 100global g01 # 定义全局变量g01g01 = "no" # 此时修改的是全局变量print(g01)  # no
​
​
fun01()
print(g01)  # no

1.9.1变量名的查找规则

• 由内而外：L -> E -> G -> B

• 在访问变量时，先查找本地变量，然后是包裹此函数的变量，再是全局变量，最后是内置变量

1.9.2局部变量

• 定义在函数内部的变量（形参也是局部变量）

• 只能在函数内部使用

• 调用函数时才被创建，函数结束后自动销毁

1.9.3全局变量

• 定义在函数外部，模块内部的变量

• 在整个模块（py文件）范围内访问（但函数内不能将其直接赋值）

1.9.4 global语句

• 作用：

  在函数内部修改全局变量

  在函数内部定义全局变量（全局声明）

• 语法：

  global 变量1，变量2

• 说明

  在函数内直接为全局变量赋值，视为创建新的局部变量

  不能先声明局部的变量，再用global声明为全局变量

1.9.4 nonlocal语句

练习

1.将下列代码定义到函数中，再调用一次。

for r in range(3):for c in range(4):print("*",end=" ")print()
def rectangle(row, column):"""矩形绘图:param row: 行:param column: 列:return:"""for r in range(row):for c in range(column):print("*", end=" ")print()
​
​
rectangle(2, 5)

2.定义在控制台中打印一维列表的函数

例如：[1,2,3] --->（每个元素一行）
1
2
3
def print_list(list_target):"""打印一维列表:param list_target: 目标列表:return:"""for item in list_target:print(item)
​
​
print_list([1, 2, 3])

3.在控制台中打印输出多维列表的函数

[
[1,2,3,4],
[4,5,5],
[7,59,2,1,3]
] ---->
1 2 3 4
4 5 5
7 59 2 1 3
# 自己做
def print_multidimensional_list(target_list):"""
​:param target_list: 要打印的列表:return:"""for r in range(len(target_list)):for item in target_list[r]:print(item,end=" ")print()
​
​
print_multidimensional_list([
[1,2,3,4],
[4,5,5],
[7,59,2,1,3]
])

# 老师讲解：
def print_double_list(double_list):"""打印二维列表:param double_list: 需要打印的列表:return: """for line in double_list:for item in line:print(item, end=" ")print()
​
​
list01 = [[1, 2, 5, 88],[4, 5, 8, 9, 7, 8, 88, 999, 666, 3, 8, 7],[7, 5, 9687]
]
print_double_list(list01)

4.定义函数打印输出已知方形矩阵（n*n）的转置矩阵（思路：主对角矩阵元素不变，其他对称交换）

TIPS：外层循环执行一次，外层循环执行多次；外层循环控制行，内层循环控制列。

def transpose_matrix(target_matrix):"""
​:param target_matrix: 已知的矩阵:return:"""for r in range(len(target_matrix) - 1):for c in range(r + 1, len(target_matrix)):target_matrix[r][c], target_matrix[c][r] = target_matrix[c][r], target_matrix[r][c]print(target_matrix)
​
​
transpose_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]
])

# 老师讲解思路
list01 = [[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12],[13, 14, 15, 16]
]
"""
思路：主对角元素不变
list01[1][0] <-->list01[0][1]
list01[2][0] <-->list01[0][2]
list01[3][0] <-->list01[0][3]
"""
for r in range(1, 4):list01[r][0], list01[0][r] = list01[0][r], list01[r][0]
# -----------------------------------------------------
"""
list01[2][1] <-->list01[1][2]
list01[3][1] <-->list01[1][3]
"""
for r in range(2,4):list01[r][1], list01[1][r] = list01[1][r], list01[r][1]

5.定义函数：根据两计算几斤零几两的函数

def get_weight_for_jin(liang_weight):"""根据两，计算几斤几两:param liang_weight: 需要计算的两数:return: 元组(斤，两)"""
​jin = liang_weight // 16liang = liang_weight % 16return (jin, liang)

6.自定义函数，通过分数计算分数等级

def get_score_grade(score):"""根据分数计算相应的成绩等级:param score: 分数:return: 等级(字符串)"""if score > 100 or score < 0:return "输入有误"elif score >= 90:return "优秀"elif score >= 80:return "良好"elif score >= 60:return "优秀"return "不及格"

7.定义函数：判断列表中是否存在相同元素(善用return减少嵌套层级，逻辑更为清晰)

两种可能结果返回布尔值（True/False）

def is_repeating(num_list):"""判断列表中是否存在相同元素:param num_list: 已知的数字列表:return:"""flag = Falsefor i in range(len(num_list) - 1):for j in range(i + 1, len(num_list)):if num_list[i] == num_list[j]:return True # 有重复return False # 没有重复
​
​
print(is_repeating([1, 2, 3, 4, 5]))

8.定义函数：通过月份输出天数(要求考虑闰年)

建议返回整型而不是字符串。不建议方法的返回值类型可能是多种

def month_to_day(year, month):"""通过年月判断有多少天:param year: 已知年:param month: 已知月:return: 天数"""
​leap_year_day = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,)# 判断是否闰年flag = year % 4 == 0 and year % 100 != 0 or year % 400 == 0
​if month not in range(1, 13):return "月份输入有误"elif month == 2:if flag:return 29return 28return leap_year_day[month - 1]
​
​
print(month_to_day(1999, 2))
print(month_to_day(2000, 2))

# 老师讲解
def is_leap_year(year):return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
​
​
def get_day_by_month(year, month):if month < 1 or month > 12:return 0if month == 2:return 29 if is_leap_year(year) else 28if month in (4, 6, 9, 11,):return 30return 31
​
​
print(get_day_by_month(1999, 2))
print(get_day_by_month(2000, 2))

注意：与主题无关的东西可以先提出去做一个函数，函数与函数之间可以相互调用，保证每个函数只做一件事。

9.定义列表升序排列的函数

注意：①传入的是可变对象，②函数体修改的是传入的对象，两个条件都满足则不需要通过返回值传递结果

def list_ascending(num_list):"""将列表升序排列:param num_list: 已知某列表:return: 升序排列的列表传入的是可变对象，函数体修改的是传入的对象，不需要通过返回值传递结果"""for r in range(len(num_list) - 1):for c in range(r + 1, len(num_list)):if num_list[r] > num_list[c]:num_list[r], num_list[c] = num_list[c], num_list[r]
​
​
num = [1, 4, 7, 2, 5, 8, 3, 6, 9]
list_ascending(num)
print(num)

10，定义方阵转置的函数

def transpose_matrix(list_target):for r in range(len(list_target[0]) - 1):for c in range(r + 1, len(list_target)):list_target[r][c], list_target[c][r] = list_target[c][r], list_target[r][c]
​
​
num = [[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12],[13, 14, 15, 16]
]
transpose_matrix(num)
print(num)

# 老师讲解
def square_matrix_transpose(sqr_matrix):"""方阵转置:param sqr_matrix: 二维列表类型的方阵"""
​for c in range(1, len(sqr_matrix)):for r in range(c, len(sqr_matrix)):sqr_matrix[r][c - 1], sqr_matrix[c - 1][r] = sqr_matrix[c - 1][r], sqr_matrix[r][c - 1]
​
​
num_list = [[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12],[13, 14, 15, 16]
]
square_matrix_transpose(num_list)
print(num_list)

11.记录函数 fun01的执行次数（借助全局变量在函数内部使用）

count = 0 # 计数器
​
​
def fun01():global countcount += 1
​
​
fun01()
fun01()
fun01()
fun01()
text = "函数fun01一共调用{}次".format(count)
print(text)

12.完成字符串练习

msg = "  校  训 ： 自  强不息、厚德载物。   "
# 1.查找空格的数量
count = msg.count(" ")
print("空格的数量为：%d" % count)
​
# 2.删除字符串前后空格
print(msg.strip())
​
# 3.删除字符串所有空格
print(msg.replace(" ",""))
​
# 4.查找"载物"的位置
print("载物的位置为：{}".format(msg.find("载物")))
​
# 5.判断字符串是否以"校训"开头
print(msg.startswith("校训"))

13.定义函数，计算指定范围内的素数

def prime_number(start_num, end_num):"""
​计算指定范围内的素数:param start_num: 范围开始值，默认为0:param end_num: 范围结束值（不包括结束值）:return:"""result = []
​for number in range(start_num, end_num):for rem in range(2, number):if number % rem == 0:breakelse:result.append(number)return result
​
​
print(prime_number(5, 30))

# 优化：把一个大问题分成若干个小问题
def is_prime(number):"""判断指定的数字是否是素数:param number::return:True表示是素数，False表示不是素数"""for item in range(2, number):if number % item == 0:return Falsereturn True
​
​
def get_prime(begin, end):"""生成指定范围的素数:param begin::param end::return:"""return [number for number in range(begin, end) if is_prime(number)]
​
​
print(get_prime(5, 30))

注意：将代码提取成一个函数——Ctrl+Alt+M；选中后右键->重构->提取方法

14.讨论is和"=="的区别

is是地址相同，而"=="是值相同

15.玩2048游戏

# 1. 将某个已知列表中的0元素移到列表最后
# [2,0,2,0]->[2,2,0,0]
# [2,0,0,2]->[2,2,0,0]
# [2,4,0,2]->[2,4,2,0]
# 法1：判断是零则和右边元素交换(性能好)
def zero_to_end(list_merge):for index in range(len(list_merge) - 1):if list_merge[index] == 0:list_merge[index], list_merge[index + 1] = list_merge[index + 1], list_merge[index]
​
# ---------------------------------------------------
# 法2：从右往左判断是零则删除并在末尾添加一个零(简单)
def zero_to_end(list_merge):for index in range(len(list_merge) - 1, -1, -1):if list_merge[index] == 0:del list_merge[index]list_merge.append(0)
# 2. 将相同数字进行合并
# [2,0,2,0]->[4,0,0,0]
# [2,0,0,2]->[4,0,0,0]
# [2,0,4,0]->[2,4,0,0]
# 法1：自己做
def merge(list_merge):for i in range(len(list_merge) - 1):for j in range(i + 1, len(list_merge)):if list_merge[i] == list_merge[j]:list_merge[i] *= 2list_merge[j] = 0zero_to_end(list_merge)# ---------------------------------------------------------
# 法2：
def merge(list_merge):"""先将中间的零元素移植末尾，再合并相邻相同元素"""zero_to_end(list_merge)for index in range(len(list_merge)-1):if list_merge[index]==list_merge[index+1]:list_merge[index]*=2del list_merge[index+1]list_merge.append(0)

"""
2048游戏核心算法
"""
list_merge = [0, 2, 2, 0]
​
​
# 1. 将某个已知列表中的0元素移到列表最后
# [2,0,2,0]->[2,2,0,0]
# [2,0,0,2]->[2,2,0,0]
# [2,4,0,2]->[2,4,2,0]
# 从右往左判断是零则删除并在末尾添加一个零(简单)
def zero_to_end():"""零元素移动到末尾思想：从后往前，如果发现零元素，删除并追加"""for index in range(len(list_merge) - 1, -1, -1):if list_merge[index] == 0:del list_merge[index]list_merge.append(0)
​
​
# 2. 将相同数字进行合并
# [2,0,2,0]->[4,0,0,0]
# [2,0,0,2]->[4,0,0,0]
# [2,0,4,0]->[2,4,0,0]
def merge():"""先将零元素移至末尾，再合并相等且相邻的元素"""zero_to_end()for index in range(len(list_merge) - 1):if list_merge[index] == list_merge[index + 1]:list_merge[index] *= 2del list_merge[index + 1]list_merge.append(0)
​
​
# 3. 地图向左移动
map = [[2, 0, 0, 2],[4, 4, 2, 2],[2, 4, 0, 4],[0, 0, 2, 2]
]
​
​
def move_left():"""向左移动，核心思想：将二维列表中每行交给merge函数进行操作:return:"""for line in map:global list_mergelist_merge = linemerge()
​
​
def move_right():"""向右移动，核心思想：将二维列表中每行（从右往左）交给merge函数进行操作"""for line in map:global list_mergelist_merge = line[::-1]  # 从右往左取出数据形成新列表merge()line[::-1] = list_merge  # 从右往左接收合并后的数据
​
​
# 4.向上移动  向下移动(矩阵转置后上下就变成了左右)
def square_matrix_transpose(sqr_matrix):for r in range(len(sqr_matrix) - 1):for c in range(r + 1, len(sqr_matrix)):sqr_matrix[r][c], sqr_matrix[c][r] = sqr_matrix[c][r], sqr_matrix[r][c]
​
​
def move_up():square_matrix_transpose(map)move_left()square_matrix_transpose(map)
​
​
def move_down():square_matrix_transpose(map)move_right()square_matrix_transpose(map)

不谈细节不谈算法，谈思想：

不论是左移、右移、上移、下移，行与行、列与列之间的逻辑都是相似的，所以对于二维项目而言，由于行与列之间互不干扰，可以降维（上移等同于左移、下移等同于右移），将二维问题（上下左右）降为一维问题（左右）。2048的具体降维方法：左右为一维列表，上下则通过矩阵转置变为左右，仍是一维列表

16.完善 shopping.py 程序

dict_commodity_info = {101: {"name": "屠龙刀", "price": 10000},102: {"name": "倚天剑", "price": 10000},103: {"name": "九阴白骨爪", "price": 8000},104: {"name": "九阳神功", "price": 9000},105: {"name": "降龙十八掌", "price": 8000},106: {"name": "乾坤大挪移", "price": 10000},
}
​
list_order = []
​
​
def select_menu():"""选择菜单:return:"""while True:item = int(input("1键购买，2键结算："))if item == 1:buying()elif item == 2:settlement()
​
​
def settlement():total_price = calculate_total_price()
​paying(total_price)
​
​
def paying(total_price):"""支付过程:param total_price: :return: """while True:money = float(input("总价{}元，请输入金额：".format(total_price)))if money >= total_price:print("购买成功，找回{}元".format(money - total_price))list_order.clear()breakelse:print("金额不足")
​
​
def calculate_total_price():total_price = 0for order in list_order:commodity = dict_commodity_info[order["cid"]]print("商品：{}，单价：{}，数量：{}".format(commodity["name"], commodity["price"], order["count"]))total_price += commodity["price"] * order["count"]return total_price
​
​
def buying():"""购买:return:"""print_commodity_info()creat_order()print("添加到购物车")
​
​
def creat_order():"""创建订单:return:"""cid = int(input("请输入商品编号："))count = int(input("请输入购买数量："))order = {"cid": cid, "count": count}list_order.append(order)
​
​
def input_commodity_id():"""获取商品订单:return:"""while True:cid = int(input("请输入商品编号："))if cid in dict_commodity_info:breakelse:print("该商品不存在")return cid
​
​
def print_commodity_info():"""打印商品信息:return:"""for key, value in dict_commodity_info.items():print("编号：{}，名称：{}，单价：{}".format(key, value["name"], value["price"]))
​
​
select_menu()

Python基础-08相关推荐

1. Python基础08 面向对象的基本概念

   Python使用类(class)和对象(object),进行面向对象(object-oriented programming,简称OOP)的编程. 面向对象的最主要目的是提高程序的重复使用性.我们这么 ...

2. [Python基础08]列表和循环操作

   文章目录 1. 循环操作 1.1. 列表构建器 1.2. 列表动态构建器 1.3. 循环列表 1.4. 循环字典 1.5.循环判断 1. 循环操作 1.1. 列表构建器 常规情况下,我们定义列表的语法 ...

3. 刻意练习：Python基础 -- Task08. 异常处理

   背景 我们准备利用17天时间,将 "Python基础的刻意练习" 分为如下任务: Task01:变量.运算符与数据类型(1day) Task02:条件与循环(1day) Task0 ...

4. Python基础知识实例讲解

   Python作为一种面向对象.解释型计算机程序设计语言,语法简洁而清晰,具有丰富和强大的类库,在网站开发,数据处理,网络编程,图形处理,网络爬虫.机器学习.科学计算.自动化测试.系统运维等方面应用广泛 ...

5. 七月在线python数据分析_七月在线Python基础+数据分析班+爬虫项目

   资源介绍 七月在线Python基础+数据分析班+爬虫项目 目录 ├─Python基础入门班2017年 ││代码.rar │└─视频 │xa0 xa0 01.第1课 入门基础.rar │xa0 xa0 ...

6. 【Python基础】GitHub 星标 8.8w+，Python 小白 100 天学习计划，从新手到大师！

   本篇给大家介绍一个Python骨灰级别的学习项目. 2019年10月份的时候,一个<Python-100-days>的GitHub项目火了,霸榜GitHub热榜.此项目截止目前已经8.8万 ...

7. Python基础day09【面向对象(封装、继承、多态)、重写、私有权限】

   视频.源码.课件.软件.笔记:超全面Python基础入门教程[十天课程]博客笔记汇总表[黑马程序员] Python基础day09[面向对象(封装.继承.多态).重写.私有权限] Python基础day ...

8. Python基础day07【文件读写、文件夹操作、面向对象(类、对象)】

   视频.源码.课件.软件.笔记:超全面Python基础入门教程[十天课程]博客笔记汇总表[黑马程序员]   目录 01.复习 1.1.递归函数参数问题 1.2.格式化输出位数 1.3.extend函数解 ...

9. Python基础day05【函数（局部变量、全局变量、多函数执行流程、函数返回值、函数参数）、拆包、引用、可变与不可变类型、函数注意事项】

   视频.源码.课件.软件.笔记:超全面Python基础入门教程[十天课程]博客笔记汇总表[黑马程序员] Python基础day05[函数(函数传参的两种形式.函数形参).拆包.引用.可变与不可变类型.引 ...

最新文章

1. 【转载】C/C++中long long与__int64的区别
2. 使用JavaScript修改浏览器URL地址栏的实现代码
3. Shell定时删除日志
4. appium工作原理及启动方式
5. 让自己的网站可以被搜索
6. rust进水器怎么用_RO反渗透净水器的正确使用方式 你都Get了吗？
7. http权威指南完整版
8. 网页版结题报告html没了,[转载]我的结题报告
9. 学生成绩管理系统（JAVA_GUI+Mysql）
10. 容器学习点点滴滴（三）
11. 卷积神经网络（ CNN）与全卷积神经网络（FCN）
12. 前端使用jquery.wordexport.js导出word
13. win10 神州网信政府版 (V0-G.1014.000) 关闭屏幕保护
14. 温故而知新的知识蒸馏 Distilling Knowledge
15. 群晖存储服务器型号,群晖存储服务器
16. 洛阳市计算机学校分布在什么地方,2019年洛阳中小学学区划分最新分布图_洛阳学区划分图...
17. Curved-Voxel Clustering 曲率体素聚类点云分割
18. 火绒安全软件（安全防护软件）官方中文版V5.0.59.0 | 火绒安全软件好用吗
19. matlab小波变换数据少,一维离散数据小波变换实用案例
20. 二维图像旋转的坐标公式推导

热门文章

1. 微型计算机实验仪,微机万能试验机
2. 深度学习用Ubuntu 18.04装机记录
3. 车辆派遣管理系统需求分析
4. win7计算机没有光驱图标不见了,win7系统光驱图标消失怎么办
5. 对抗脂肪君经拿滚系列之三 - 关于减脂区的迷思 最有效率减脂
6. python go 入门_GitHub - gochao/codeparkshare: Python初学者（零基础学习Python、Python入门）书籍、视频、资料、社区推荐...
7. 请观看吉良吉影咏唱，并从头列出数字，包括但不限于阿拉伯数字。并按以下规则排列。1、字幕数字（只记中文字幕）＞场景数字（比如时钟上的数字）2、阿拉伯数字＞中文数字（有中文写中文）3、因切换场景重复
8. 性能测试-定义以及指标
9. linux东软培训答案,东软Linux实验报告.doc
10. TeXworks文献引用问题