函数基础
- 定义:
def 函数名(形参):+ 缩进的函数体 - 调用:
函数名(实参),实参按位置交给形参 - 函数必须先定义、后调用
- 没有
return→ 返回None - 返回多个值 → 元组,可用解包接收
- 形参不写类型,由实参决定
函数的定义与调用 · 函数参数 · 变量作用域 · lambda 表达式 · 递归(选学) · 类与对象 · 综合应用(7 个知识模块 + 40 余段可运行演示 + 15 张插图 + 6 个动态演示图)
Lesson Overview · 从"把代码写下来"到"把功能装起来"
前四章写的程序,都是"从上往下一路执行"。程序一长,就会遇到两个麻烦:同样的几行代码重复写好几遍,以及主程序被细节淹没,看不出在做什么。函数就是解决这两个麻烦的工具——把一段有特定功能的代码装起来、起个名字,需要的时候喊名字就行。这一章还会往前走一步,认识"类":它是把数据和操作数据的函数装在一起的容器。
def 定义函数并正确调用,说清形参与实参的区别;② 掌握位置参数、默认值参数、关键字参数、可变长参数四种传参方式,知道各自的报错情况;③ 能区分局部变量与全局变量,会用 global 在函数内修改全局变量;④ 会写 lambda 表达式,能用 sorted(key=...) 按自定义规则排序;⑤(选学)理解递归的终止条件与调用栈;⑥ 会用 class 定义类、用 __init__ 初始化属性、创建对象并调用方法;⑦ 能把"重复代码"识别出来并改造成函数。
点击节点可跳转到对应讲解位置,点击三角可展开 / 收起分支。
def 是定义,写函数名加括号是调用;② 参数是"调用时递进去的东西",按位置递、按名字递、不递就用默认值;③ 变量有"地盘"——函数内部定义的变量出了函数就没了,这就是作用域。为什么要函数 · def 语法 · 调用与执行过程 · return 与 print 的区别 · 例 5-1 成绩平均分
函数是实现特定功能的代码段。Python 里能用的函数有三类:内置函数(print、len、sum 这些,拿了就用)、标准库函数(要先 import,比如 math.sqrt)、以及我们自己写的函数。本章讲的就是第三类。
不用函数会怎样?看下面这张对比图:左边是"同一个算法抄三遍",右边是"写一遍、调三次"。程序一旦变长,左边的写法改一处就会漏改另一处。
cal_avg() 可以复用无数次nums = [75, 80, 85, 70, 65, 90]
print('长度:', len(nums))
print('总和:', sum(nums))
print('最大值 / 最小值:', max(nums), min(nums))
print('平均分:', round(sum(nums) / len(nums), 1))
print('排序后(不改原列表):', sorted(nums))
print('绝对值与幂:', abs(-3), pow(2, 10))
print('四舍五入:', round(3.14159, 2), round(2.5), round(3.5))
长度: 6 总和: 465 最大值 / 最小值: 90 65 平均分: 77.5 排序后(不改原列表): [65, 70, 75, 80, 85, 90] 绝对值与幂: 3 1024 四舍五入: 3.14 2 4
s1 = [75, 80, 85, 70, 65, 90]
s2 = [88, 92, 79]
s3 = [60, 66, 72, 58]
# 写法一:每算一次,就把公式抄一遍
print('第 1 组平均分:', round(sum(s1) / len(s1), 1))
print('第 2 组平均分:', round(sum(s2) / len(s2), 1))
print('第 3 组平均分:', round(sum(s3) / len(s3), 1))
print('-' * 24)
# 写法二:把公式装进函数,然后调用三次
def cal_avg(alist):
return round(sum(alist) / len(alist), 1)
print('第 1 组平均分:', cal_avg(s1))
print('第 2 组平均分:', cal_avg(s2))
print('第 3 组平均分:', cal_avg(s3))
第 1 组平均分: 77.5 第 2 组平均分: 86.3 第 3 组平均分: 64.0 ------------------------ 第 1 组平均分: 77.5 第 2 组平均分: 86.3 第 3 组平均分: 64.0
定义函数用 def 关键字。下面这张图把一行 def 语句拆开,每部分都有讲究——尤其注意冒号和缩进,初学最常见的错误就出在这里。
def 语句的五个组成部分(颜色与代码块一一对应)def my_add(x, y):
'''把两个参数相加后返回'''
s = x + y
return s
print(my_add(3, 5)) # 实参是整数 → 做加法
print(my_add('hello ', 'World')) # 实参是字符串 → 做拼接
print(my_add([1, 2], [3, 4])) # 实参是列表 → 做合并
print('文档字符串:', my_add.__doc__)
print('函数名:', my_add.__name__)
8 hello World [1, 2, 3, 4] 文档字符串: 把两个参数相加后返回 函数名: my_add
def my_add(x, y):
'''add the two arguments'''
s = x + y
return s
help(my_add)
Help on function my_add in module __main__:
my_add(x, y)
add the two arguments
help(函数名) 能打印出函数的说明书,内容正是定义时写在函数体第一行的文档字符串。print(my_add.__doc__) 直接取出这段文字。给别人(也给你自己)写一段文档字符串,是专业习惯——尤其在做数据分析、别人要复用你的清洗函数时。def、函数名、形参表、冒号、缩进的函数体;return 负责把结果交回去;形参不写类型,Python 按实参的类型决定行为,所以同一个 my_add() 既能加数字,也能拼字符串、合并列表。函数把结果交给调用者,靠的是 return。这里有三个必须分清的情况——尤其是第三种,它是初学者最容易踩的坑。
| 写法 | 返回什么 | 调用处拿到 |
|---|---|---|
return s | 一个值 | 那个值本身(可以是任意类型) |
return a, b | 多个值 | 一个元组 (a, b),可以用解包接收 |
没有 return(或只写 return) | None | None——想去运算就会报错 |
def f1(a, b):
print('f1 只打印不返回:', a + b) # 没有 return
def f2(a, b):
return a + b # 返回一个值
def f3(a, b):
return a + b, a * b, a - b # 返回多个值 → 元组
def f4(n):
if n > 0:
return '正数'
return '非正数'
print('这行永远不会执行') # return 之后函数就结束了
print('f1(3, 5) →', f1(3, 5))
print('f2(3, 5) →', f2(3, 5))
r = f3(6, 4)
print('f3(6, 4) →', r, type(r))
x, y, z = f3(6, 4) # 元组解包接收多个返回值
print('解包后:x =', x, ' y =', y, ' z =', z)
print('f4(10) →', f4(10), ' f4(0) →', f4(0))
f1 只打印不返回: 8 f1(3, 5) → None f2(3, 5) → 8 f3(6, 4) → (10, 24, 2) <class 'tuple'> 解包后:x = 10 y = 24 z = 2 f4(10) → 正数 f4(0) → 非正数
print(x + y),屏幕上确实出现了结果,但函数没有把值交回——调用处拿到的还是 None。屏幕上的字是"给人看的",return 的值才是"给程序用的"。def add_wrong(x, y):
print(x + y)
print(add_wrong(3, 5))
def add_right(x, y):
return x + y
print(add_right(3, 5))
print(add_right(3, 5) * 10)
def add_wrong(x, y):
print(x + y) # 只打印,没有 return
print('函数调用的结果是:', add_wrong(3, 5))
print('它的类型是:', type(add_wrong(3, 5)))
8 函数调用的结果是: None 8 它的类型是: <class 'NoneType'>
def add_wrong(x, y):
print(x + y)
total = add_wrong(3, 5) + 1 # None + 1 → 报错
8
Traceback (most recent call last):
File "<pyshell>", line 4, in <module>
total = add_wrong(3, 5) + 1 # None + 1 → 报错
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
return 才有返回值;返回多个值得到元组;没有 return 就是 None,拿 None 去加减乘除会报 TypeError。return 一旦执行,函数立刻结束。自定义函数和内置函数的调用方法完全一样:函数名加括号,括号里写实际参数。下面这张图是调用 my_add(3, 5) 时,程序内部依次发生的四件事。
def show(x, y):
print(' 形参 x =', x, '类型', type(x).__name__, '|形参 y =', y, '类型', type(y).__name__)
return x + y
print('整数:', show(3, 5))
print('小数:', show(2.5, 0.5))
print('字符串:', show('Python', ' 真好用'))
print('列表:', show([1, 2], [3, 4]))
print('布尔:', show(True, False))
形参 x = 3 类型 int |形参 y = 5 类型 int 整数: 8 形参 x = 2.5 类型 float |形参 y = 0.5 类型 float 小数: 3.0 形参 x = Python 类型 str |形参 y = 真好用 类型 str 字符串: Python 真好用 形参 x = [1, 2] 类型 list |形参 y = [3, 4] 类型 list 列表: [1, 2, 3, 4] 形参 x = True 类型 bool |形参 y = False 类型 bool 布尔: 1
print(my_add(3, 5)) # 此时 Python 还不知道 my_add 是什么
def my_add(x, y):
return x + y
Traceback (most recent call last):
File "<pyshell>", line 1, in <module>
print(my_add(3, 5)) # 此时 Python 还不知道 my_add 是什么
NameError: name 'my_add' is not defined
def cal_avg(alist): # 定义函数
s = sum(alist)
n = len(alist)
avg = round(s / n, 1)
return avg
# 主程序
scores = [75, 80, 85, 70, 65, 90] # 输入
result = cal_avg(scores) # 调用函数
print('平均分:', result) # 输出
print('再算一组:', cal_avg([88, 92, 79]))
print('(函数一次定义,可以多次调用)')
平均分: 77.5 再算一组: 86.3 (函数一次定义,可以多次调用)
def calc_avg(alist):
return round(sum(alist) / len(alist), 1)
def judge_level(avg):
if avg >= 90:
return '优秀'
elif avg >= 80:
return '良好'
elif avg >= 60:
return '及格'
else:
return '不及格'
for name, scores in [('一班', [88, 92, 79, 95, 84]),
('二班', [70, 65, 72, 68]),
('三班', [55, 60, 48, 52])]:
avg = calc_avg(scores) # 第一个函数算平均分
print(name, '平均分', avg, '等级', judge_level(avg)) # 结果喂给第二个函数
一班 平均分 87.6 等级 良好 二班 平均分 68.8 等级 及格 三班 平均分 53.8 等级 不及格
return 的值交回调用处,函数内部的变量随之消失。函数可以互相调用——前一个函数的返回值,直接当作后一个函数的实参,这就是"模块化"的实际写法。位置参数 · 默认值参数 · 关键字参数 · 可变长参数(*args / **kwargs)
参数是函数与外界交换数据的接口。同样一个函数,用不同的传参方式调用,写法不同、报错也不同。课件里把参数分成四类,这一节一类一类过,并且每一类都配了"写错的后果"——看懂报错信息,比背语法有用得多。
位置参数是最常见的形式。调用时实参和形参的数量必须相同、位置顺序必须一致——第一个实参给第一个形参,第二个给第二个,以此类推。
def my_add(x, y):
'''把形参的值打印出来,看看谁接到了谁'''
print('x=' + str(x) + ';' + 'y=' + str(y))
s = x + y
return s
print(my_add(3, 5)) # 实参一一对应传递给形参
print(my_add(5, 3)) # 换个顺序:x 和 y 的值就交换了
print(my_add(1.5, 2.5)) # 类型也一样自动推断
x=3;y=5 8 x=5;y=3 8 x=1.5;y=2.5 4.0
def my_add(x, y):
return x + y
print(my_add(3)) # 只传了一个实参,y 没接到值
Traceback (most recent call last):
File "<pyshell>", line 4, in <module>
print(my_add(3)) # 只传了一个实参,y 没接到值
TypeError: my_add() missing 1 required positional argument: 'y'
def my_add(x, y):
return x + y
print(my_add()) # 两个形参都没有实参
Traceback (most recent call last):
File "<pyshell>", line 4, in <module>
print(my_add()) # 两个形参都没有实参
TypeError: my_add() missing 2 required positional arguments: 'x' and 'y'
TypeError: missing … required positional argument,看到这句话就知道:某个形参没接到值。定义函数时可以直接给形参写一个默认值,语法是 形参名=默认值。调用时不传就用默认值,传了就用实参替换掉默认值。你其实已经用过很多次了——range(10) 就是默认值参数的典型例子。
def my_add(x, y=10):
'''第二个参数有默认值 10'''
print('x=' + str(x) + ';' + 'y=' + str(y))
return x + y
print(my_add(3)) # 只传递第 1 个参数 → 用默认值 10
print(my_add(3, 5)) # 传递 2 个参数 → 默认值被覆盖
print(my_add(3, y=100)) # 也可以只指定要改的那一个
print('-' * 26)
print('内置函数 range() 也有默认值:')
print('range(5) →', list(range(5))) # 默认从 0 开始,步长 1
print('range(2, 6) →', list(range(2, 6)))
print('range(0, 10, 3) →', list(range(0, 10, 3)))
x=3;y=10 13 x=3;y=5 8 x=3;y=100 103 -------------------------- 内置函数 range() 也有默认值: range(5) → [0, 1, 2, 3, 4] range(2, 6) → [2, 3, 4, 5] range(0, 10, 3) → [0, 3, 6, 9]
def my_add(x=1, y): # 有默认值的 x 跑到了没有默认值的 y 前面
return x + y
Traceback (most recent call last):
File "<pyshell>", line 1
def my_add(x=1, y): # 有默认值的 x 跑到了没有默认值的 y 前面
SyntaxError: parameter without a default follows parameter with a default
def add_item(item, box=[]): # 默认值是一个空列表
box.append(item)
return box
print('第 1 次:', add_item('a'))
print('第 2 次:', add_item('b')) # 直觉是 ['b'],实际不是
print('第 3 次:', add_item('c'))
print('-' * 26)
# 正确写法:默认值写 None,进函数之后再新建一个列表
def add_item_safe(item, box=None):
if box is None:
box = []
box.append(item)
return box
print('安全版第 1 次:', add_item_safe('a'))
print('安全版第 2 次:', add_item_safe('b'))
print('安全版第 3 次:', add_item_safe('c'))
第 1 次: ['a'] 第 2 次: ['a', 'b'] 第 3 次: ['a', 'b', 'c'] -------------------------- 安全版第 1 次: ['a'] 安全版第 2 次: ['b'] 安全版第 3 次: ['c']
range(10) 就是),必须写在形参表最后;不传用默认值、传了就覆盖。默认值不要用可变的列表 / 字典,要写成 None 再在函数里新建。调用函数时写成 形参名=值,就是关键字参数。它靠名字配对,所以实参顺序可以和定义时不一致。这在参数很多的时候特别有用——plt.plot(x, y, color='red', linewidth=2) 就是典型的可读写法。
def my_add(x, y):
print('x=' + str(x) + ';' + 'y=' + str(y))
return x + y
print(my_add(x=4, y=5)) # 全部用关键字
print(my_add(y=5, x=4)) # 顺序反过来,结果一样
print(my_add(4, y=5)) # 位置参数在前,关键字参数在后(推荐写法)
x=4;y=5 9 x=4;y=5 9 x=4;y=5 9
def my_add(x, y):
return x + y
print(my_add(y=5, 4)) # 语法错误:位置参数不能跟在关键字参数后面
Traceback (most recent call last):
File "<pyshell>", line 4
print(my_add(y=5, 4)) # 语法错误:位置参数不能跟在关键字参数后面
SyntaxError: positional argument follows keyword argument
def my_add(x, y):
return x + y
print(my_add(x=4, z=5)) # 形参表里没有 z
Traceback (most recent call last):
File "<pyshell>", line 4, in <module>
print(my_add(x=4, z=5)) # 形参表里没有 z
TypeError: my_add() got an unexpected keyword argument 'z'
有时候事先不知道要传几个参数——比如"求任意多个数的累加和"。在形参名前加一个 *,Python 会把多出来的实参打包成元组;加两个 **,则打包成字典。
*args 收成元组、**kwargs 收成字典def my_sum(*nums):
print('nums: ', nums, ' 类型:', type(nums).__name__)
s = 0
for n in nums:
s += n
return s
print(my_sum(4, 5))
print(my_sum(4, 5, 6, 7, 8))
print(my_sum()) # 一个都不传也合法
print(my_sum(*[1, 2, 3, 4])) # 反过来:把列表"拆开"传进去
nums: (4, 5) 类型: tuple 9 nums: (4, 5, 6, 7, 8) 类型: tuple 30 nums: () 类型: tuple 0 nums: (1, 2, 3, 4) 类型: tuple 10
def my_sum2(**nums):
print('nums: ', nums, ' 类型:', type(nums).__name__)
s = 0
for key in nums:
s += nums[key]
print('sum =', s)
my_sum2(a=1, b=2, c=3)
my_sum2(语文=88, 数学=95, 英语=79)
nums: {'a': 1, 'b': 2, 'c': 3} 类型: dict
sum = 6
nums: {'语文': 88, '数学': 95, '英语': 79} 类型: dict
sum = 262
def order(name, count=1, *items, discount=1.0, **info):
'''参数顺序:位置 → 默认值 → *可变长 → 关键字(默认值)→ **可变长关键字'''
print('客户:', name, '|数量:', count)
print('商品:', items)
print('优惠:', discount)
print('备注:', info)
return count * discount
order('小李')
print('-' * 26)
order('小王', 3)
print('-' * 26)
order('小张', 2, '铅笔', '橡皮', discount=0.9, 电话='13800000000', 备注='加急')
客户: 小李 |数量: 1
商品: ()
优惠: 1.0
备注: {}
--------------------------
客户: 小王 |数量: 3
商品: ()
优惠: 1.0
备注: {}
--------------------------
客户: 小张 |数量: 2
商品: ('铅笔', '橡皮')
优惠: 0.9
备注: {'电话': '13800000000', '备注': '加急'}
| 参数类型 | 写法 | 最容易出的错 | 怎么改 |
|---|---|---|---|
| 位置参数 | f(3, 5) | missing 1 required positional argument | 补齐实参,或给形参加默认值 |
| 默认值参数 | def f(x, y=10) | non-default argument follows default argument | 把有默认值的形参挪到最后 |
| 关键字参数 | f(y=5, x=4) | positional argument follows keyword argument | 位置实参写在关键字实参前面 |
| 关键字参数 | f(x=4, z=5) | got an unexpected keyword argument | 名字要和形参表一致(区分大小写) |
| 可变长参数 | def f(*args) | 星号参数写到了普通形参前面 | 星号参数放形参表最后 |
*nums 把不定个数的实参打包成元组,**nums 打包成字典;两者都是"了解"级别,但看懂它们很重要——后面学 print(*args)、plt.plot(**style)、以及读别人的代码,都靠这一节。顺序记住:位置 → 默认值 → *args → **kwargs。局部变量 · 全局变量 · 同名遮蔽 · global 关键字
作用域就是变量"起作用的代码范围"。函数给变量划了边界:函数内部定义的变量出了函数就消失。理解这一点,才能解释为什么有的变量"明明赋过值却说不存在"。
局部变量:在函数内部定义的变量,作用范围只限这个函数,函数执行结束后自动删除。全局变量:在函数外部定义,作用范围是整个程序,函数里也可以读。
global_num = 5 # 全局变量
def my_add2():
local_num = 3 # 局部变量
return global_num + local_num # 局部里读不到 global_num?→ 会去全局区找
print('函数内用全局变量:', my_add2())
print('函数外读全局变量:', global_num)
函数内用全局变量: 8 函数外读全局变量: 5
def my_add2():
local_num = 3
return local_num
print(my_add2()) # 函数里面用,没问题
print(local_num) # 函数外面用 → 局部变量已经消失了
3
Traceback (most recent call last):
File "<pyshell>", line 6, in <module>
print(local_num) # 函数外面用 → 局部变量已经消失了
NameError: name 'local_num' is not defined
NameError: name 'xxx' is not defined。如果函数内部和外部定义了同名变量,函数体里用的是局部那个,外部的被"遮住"(shadow),而且函数内的修改不会影响外部那个。
x = 5 # 全局变量
def my_add3():
x = 3 # 局部变量,和全局的 x 同名
return x + x # 用的是局部那个 3
print('函数内的结果:', my_add3()) # 3 + 3 = 6
print('函数外的 x:', x) # 全局那个没被改动,还是 5
def my_add3b():
return x + x # 函数内没有定义 x → 去全局区找到 5
print('函数内没有同名变量时:', my_add3b()) # 5 + 5 = 10
函数内的结果: 6 函数外的 x: 5 函数内没有同名变量时: 10
如果确实要在函数内部修改全局变量,必须先用 global 声明它。不声明就赋值,Python 会把它当成一个新的局部变量——这时如果函数里还想先读后写,就会撞上那个著名的 UnboundLocalError。
x = 5
def my_add4():
global x # 声明:下面操作的 x 是全局那个
print('函数内读到 x =', x) # 读到 5
x = 3 # 修改全局变量
return x + x
print('返回值:', my_add4())
print('函数执行后,函数外的 x =', x) # 被改成了 3
print('-' * 26)
def my_add5():
# 没有 global,这里只是在函数内新建了一个局部变量
y = 100
return y
my_add5()
print('全局区并没有 y:', 'y' in dir()) # 验证一下:全局名字里没有 y
函数内读到 x = 5 返回值: 6 函数执行后,函数外的 x = 3 -------------------------- 全局区并没有 y: False
x = 5
def my_add4():
print(x) # 想读全局的 x
x = 3 # 这里又给 x 赋值 → Python 认定 x 是局部变量
return x + x
print(my_add4())
Traceback (most recent call last):
File "<pyshell>", line 8, in <module>
print(my_add4())
File "<pyshell>", line 4, in my_add4
print(x) # 想读全局的 x
UnboundLocalError: cannot access local variable 'x' where it is not associated with a value
x = 3,Python 就把 x 登记成局部变量;于是前面那句 print(x) 读的是"还没赋值的局部 x",直接报 UnboundLocalError。记住这条:想在函数里改全局变量,先写 global 变量名;只是读的话,不用写。global x 是"声明",不是"赋值"——它告诉 Python"接下来这个 x 指的是全局那个"。函数里改全局变量属于需要谨慎的写法:改的地方多了,程序就很难追踪。更好的做法是把值作为参数传进去、把结果 return 出来。匿名函数 · 一行写完 · 配合 sorted / max / map / filter 的 key 使用
有些函数小到"只做一次加法",为它专门写一个 def 显得啰嗦。lambda 表达式就是为这种情况准备的:不用起名字、一行写完、只放一个表达式。它最实用的场合不是"造函数",而是当"排序依据"——告诉 sorted() 该按什么排。
return,只留一行表达式add = lambda x, y: x + y # 赋给变量,然后像普通函数一样调用
print('相加:', add(3, 5))
square = lambda n: n * n
print('平方:', square(7))
print('类型:', type(add).__name__) # 它也是一个 function
print('立即调用:', (lambda a, b: a * b)(6, 7)) # 不用变量,当场调用
hello = lambda: 'Hello, lambda!'
print('没有参数:', hello())
相加: 8 平方: 49 类型: function 立即调用: 42 没有参数: Hello, lambda!
f = lambda x: y = x + 1 # 右边必须是"表达式",赋值是"语句" print(f(3))
Traceback (most recent call last):
File "<pyshell>", line 1
f = lambda x: y = x + 1 # 右边必须是"表达式",赋值是"语句"
SyntaxError: cannot assign to lambda
lambda 参数: 表达式 就是一个没有名字的小函数,结果就是表达式的值。它不能放语句、不能写多行——一行能算完的才适合用 lambda。sorted()、max()、min() 都有一个 key 参数,用来指定"按什么排 / 按什么比"。往里传一个 lambda,是最常见的写法。
students = [('张', 88), ('李', 95), ('王', 79), ('赵', 95)]
print('原顺序:', students)
print('直接 sorted():', sorted(students)) # 先比姓名,和成绩无关
print('按成绩升序:', sorted(students, key=lambda s: s[1]))
print('按成绩降序:', sorted(students, key=lambda s: s[1], reverse=True))
print('成绩相同再按姓名:', sorted(students, key=lambda s: (s[1], s[0])))
print('原列表没变:', students) # sorted 返回新列表
原顺序: [('张', 88), ('李', 95), ('王', 79), ('赵', 95)]
直接 sorted(): [('张', 88), ('李', 95), ('王', 79), ('赵', 95)]
按成绩升序: [('王', 79), ('张', 88), ('李', 95), ('赵', 95)]
按成绩降序: [('李', 95), ('赵', 95), ('张', 88), ('王', 79)]
成绩相同再按姓名: [('王', 79), ('张', 88), ('李', 95), ('赵', 95)]
原列表没变: [('张', 88), ('李', 95), ('王', 79), ('赵', 95)]
students = [('张', 88), ('李', 95), ('王', 79)]
print('最高分(返回整个元组):', max(students, key=lambda s: s[1]))
print('最低分(返回整个元组):', min(students, key=lambda s: s[1]))
scores = {'语文': 88, '数学': 95, '英语': 79}
print('分数最高的科目:', max(scores, key=lambda k: scores[k]))
print('按分数排的科目:', sorted(scores, key=lambda k: scores[k]))
print('分数最低的两个科目:', sorted(scores, key=lambda k: scores[k])[:2])
最高分(返回整个元组): ('李', 95)
最低分(返回整个元组): ('王', 79)
分数最高的科目: 数学
按分数排的科目: ['英语', '语文', '数学']
分数最低的两个科目: ['英语', '语文']
scores = [88, 95, 79, 62, 100, 45]
# map:对每个元素做同一件事
print('每人加 5 分(封顶 100):', list(map(lambda x: min(x + 5, 100), scores)))
print('换算成等级:', list(map(lambda x: '及格' if x >= 60 else '不及格', scores)))
# filter:按条件筛出元素
print('及格分数:', list(filter(lambda x: x >= 60, scores)))
print('90 分以上:', list(filter(lambda x: x >= 90, scores)))
print('等价的列表推导式:', [x for x in scores if x >= 60])
每人加 5 分(封顶 100): [93, 100, 84, 67, 100, 50] 换算成等级: ['及格', '及格', '及格', '及格', '及格', '不及格'] 及格分数: [88, 95, 79, 62, 100] 90 分以上: [95, 100] 等价的列表推导式: [88, 95, 79, 62, 100]
text = 'python 数据分析 与 python 可视化 还有 python 基础'
words = text.split()
counts = {}
for w in words:
counts[w] = counts.get(w, 0) + 1
print('词频:', counts)
# 按次数从多到少排序:items() 里的元素是 (词, 次数),取下标 1 当依据
rank = sorted(counts.items(), key=lambda kv: kv[1], reverse=True)
print('排行榜:', rank)
for word, n in rank[:2]:
print(' ', word, '出现了', n, '次')
词频: {'python': 3, '数据分析': 1, '与': 1, '可视化': 1, '还有': 1, '基础': 1}
排行榜: [('python', 3), ('数据分析', 1), ('与', 1), ('可视化', 1), ('还有', 1), ('基础', 1)]
python 出现了 3 次
数据分析 出现了 1 次
sorted(数据, key=lambda x: 依据)——key 只决定"按什么排",不改变元素本身。按元组第 2 项排就写 s[1],按字典的值排就写 kv[1],要多级排序就返回一个元组。自己调用自己 · 终止条件 · 调用栈 · 与循环的取舍
递归函数就是在函数体里调用自己。但它必须写清楚两件事,缺一个就会无限调用下去:
def factorial(n):
'''计算 n 的阶乘:终止条件写在最前面'''
if n <= 1: # 终止条件:不再调用自己
return 1
return n * factorial(n - 1) # 递归式:规模缩小 1
for n in range(1, 7):
print(n, '的阶乘 =', factorial(n))
print('组合数 C(5,2) = 5! / (2! × 3!) =', factorial(5) // (factorial(2) * factorial(3)))
1 的阶乘 = 1 2 的阶乘 = 2 3 的阶乘 = 6 4 的阶乘 = 24 5 的阶乘 = 120 6 的阶乘 = 720 组合数 C(5,2) = 5! / (2! × 3!) = 10
def fib(n):
'''返回第 n 个斐波那契数(n 从 1 开始)'''
if n <= 2: # 终止条件:前两个数都是 1
return 1
return fib(n - 1) + fib(n - 2)
print('前 10 个:', [fib(i) for i in range(1, 11)])
前 10 个: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
def sum_rec(nums):
'''递归求和:空列表返回 0,否则"第一个 + 剩下的"'''
if not nums: # 终止条件:没有元素了
return 0
return nums[0] + sum_rec(nums[1:])
def sum_loop(nums):
'''循环求和:同一个问题的常规写法'''
total = 0
for n in nums:
total += n
return total
data = [1, 2, 3, 4, 5, 6]
print('递归结果:', sum_rec(data))
print('循环结果:', sum_loop(data))
print('内置函数:', sum(data))
print('三者一致:', sum_rec(data) == sum_loop(data) == sum(data))
递归结果: 21 循环结果: 21 内置函数: 21 三者一致: True
def boom(n):
return n * boom(n - 1) # 没有终止条件,永远停不下来
print(boom(5))
Traceback (most recent call last):
File "<pyshell>", line 4, in <module>
print(boom(5))
File "<pyshell>", line 2, in boom
return n * boom(n - 1) # 没有终止条件,永远停不下来
File "<pyshell>", line 2, in boom
return n * boom(n - 1) # 没有终止条件,永远停不下来
File "<pyshell>", line 2, in boom
return n * boom(n - 1) # 没有终止条件,永远停不下来
[Previous line repeated 995 more times]
RecursionError: maximum recursion depth exceeded
同一个"求和",循环和递归都能做。工程上的默认选择是循环——它更省内存、没有深度限制;递归的优势在"问题本身就是分层的":文件夹里的文件夹、菜单里的子菜单、族谱里的分支,用递归写出来几乎就是问题本身的样子。
| 比较项 | 循环(for / while) | 递归 |
|---|---|---|
| 写法复杂度 | 直白,一眼看到"从头到尾" | 代码更短,但要想清终止条件 |
| 内存占用 | 几乎不额外占内存 | 每一层调用都压一个栈帧,深度越大越占内存 |
| 深度限制 | 没有限制 | Python 默认约 1000 层,超了报 RecursionError |
| 适合什么 | 一维、顺序处理的数据 | 天然分层的结构:树、目录、嵌套列表 |
| 本章建议 | 首选 | 看懂即可,别用来处理大批数据 |
import sys
print('Python 默认递归深度上限:', sys.getrecursionlimit())
def depth(n):
'''往下数 n 层,返回一共深入了多少层'''
if n == 0:
return 0
return 1 + depth(n - 1)
print('成功递归 500 层:', depth(500))
print('(注意:斐波那契那种"一次分成两支"的递归,深度不大但调用次数爆炸,')
print(' 算第 35 个数要调用上千万次——这类问题必须改用循环或缓存)')
Python 默认递归深度上限: 1000 成功递归 500 层: 500 (注意:斐波那契那种"一次分成两支"的递归,深度不大但调用次数爆炸, 算第 35 个数要调用上千万次——这类问题必须改用循环或缓存)
类与对象 · class 语法 · __init__ 与 self · 创建对象 · 例 5-11 / 例 5-12 圆类
到这里为止,函数和数据是分开的:列表存数据,函数处理数据。类(class)把两者装在一起——它描述"这类东西有什么数据(属性)、能做什么(方法)"。类是抽象的模板,对象是按模板造出来的具体实例。
| 概念 | 是什么 | 在圆的例子里 |
|---|---|---|
| 类(class) | 模板、抽象,描述一类事物的共同特征与行为 | MyCircle |
| 对象(实例) | 按模板造出来的具体个体 | c1 = MyCircle(2) |
| 属性 | 对象的数据(静态特征) | self.r 半径 |
| 方法 | 对象的函数(动态行为),第一个参数必须是 self | area()、perimeter() |
定义类用 class 语句。类的设计包含三个要素:类名(抽象事物的名字)、属性(特征)、方法(行为)。其中 __init__ 是一个特殊方法——它不用你调用,创建对象时会自动执行,用来给对象准备初始数据。
__init__ 初始化属性、方法里的 selfimport math
class MyCircle:
'''一个圆:半径是属性,计算面积和周长是方法'''
def __init__(self, r):
self.r = r # 把参数存成对象的属性
def area(self):
'''面积 = πr²'''
return round(math.pi * self.r ** 2, 2)
def perimeter(self):
'''周长 = 2πr'''
return round(2 * math.pi * self.r, 2)
print('类定义完成:', MyCircle.__name__)
print('类的说明文档:', MyCircle.__doc__)
print('(注意:类只是模板,到这里还没有任何一个圆)')
类定义完成: MyCircle 类的说明文档: 一个圆:半径是属性,计算面积和周长是方法 (注意:类只是模板,到这里还没有任何一个圆)
import math
class MyCircle:
def __init__(self, r):
self.r = r
def area(): # 忘了写 self
return round(math.pi * self.r ** 2, 2)
c = MyCircle(2)
print(c.area())
Traceback (most recent call last):
File "<pyshell>", line 11, in <module>
print(c.area())
TypeError: MyCircle.area() takes 0 positional arguments but 1 was given
class 类名: 定义模板;__init__ 在创建对象时自动执行,用来存属性;方法(包括 __init__)的第一个参数必须是 self,它代表对象自己。方法里用 self.属性名 访问自己的数据。创建对象的写法就是类名加括号:c1 = MyCircle(2)。拿到对象之后,用点号 . 访问它的属性、调用它的方法。
import math
class MyCircle:
def __init__(self, r):
self.r = r
def area(self):
return round(math.pi * self.r ** 2, 2)
def perimeter(self):
return round(2 * math.pi * self.r, 2)
# 创建两个对象
c1 = MyCircle(2)
c2 = MyCircle(5)
print('c1 的半径:', c1.r) # 访问属性
print('c1 面积:', c1.area(), ' 周长:', c1.perimeter()) # 调用方法
print('c2 的半径:', c2.r)
print('c2 面积:', c2.area(), ' 周长:', c2.perimeter())
# 两个对象完全独立
c2.r = 10
print('-' * 26)
print('改了 c2 的半径之后:')
print('c2 面积:', c2.area())
print('c1 半径不受影响:', c1.r, ' 面积:', c1.area())
print('两个对象是不同的实例:', c1 is c2)
c1 的半径: 2 c1 面积: 12.57 周长: 12.57 c2 的半径: 5 c2 面积: 78.54 周长: 31.42 -------------------------- 改了 c2 的半径之后: c2 面积: 314.16 c1 半径不受影响: 2 面积: 12.57 两个对象是不同的实例: False
class Student:
'''一个学生:属性有姓名和三科成绩,方法算总分和平均分'''
def __init__(self, name, scores):
self.name = name
self.scores = scores
def total(self):
return sum(self.scores)
def avg(self):
return round(sum(self.scores) / len(self.scores), 1)
def info(self):
return self.name + '|总分 ' + str(self.total()) + '|平均 ' + str(self.avg())
students = [
Student('张', [88, 92, 79]),
Student('李', [95, 88, 90]),
Student('王', [70, 65, 72]),
]
for s in students:
print(s.info())
print('-' * 30)
print('按总分排名:')
for i, s in enumerate(sorted(students, key=lambda st: st.total(), reverse=True), 1):
print(' 第', i, '名:', s.name, '总分', s.total())
张|总分 259|平均 86.3 李|总分 273|平均 91.0 王|总分 207|平均 69.0 ------------------------------ 按总分排名: 第 1 名: 李 总分 273 第 2 名: 张 总分 259 第 3 名: 王 总分 207
对象 = 类名(参数),用 对象.属性 读数据、对象.方法() 做事。同一个类造出的对象互相独立——改一个不影响另一个。类的好处是"数据 + 处理数据的函数"打包在一起,用起来不会拿错对象。分段函数 · 阶梯水费 · 三角形面积 · 上机任务与作业 · AI 渗透
这一节把本章学的东西用起来。三个例题都来自课件:把原本写在主程序里的判断逻辑装进函数,主程序立刻变得清爽。做题时注意一个套路——先想清楚"这个功能要不要复用",要复用就写成函数。
分段函数本来就是"按区间分别计算",是 if-elif-else 最典型的应用。做成分段函数后,主程序只需要 piecewise(x) 一行。
def piecewise(x):
'''分段函数:
x < 0 → y = x²
0 ≤ x < 5 → y = 3x - 5
x ≥ 5 → y = 0.5x - 2
'''
if x < 0:
y = x ** 2
elif x < 5: # 走到这里已经隐含 x >= 0
y = 3 * x - 5
else:
y = 0.5 * x - 2
return y
for x in [-3, -0.5, 0, 2, 4.9, 5, 10]:
print('x =', x, '→ y =', piecewise(x))
x = -3 → y = 9 x = -0.5 → y = 0.25 x = 0 → y = -5 x = 2 → y = 1 x = 4.9 → y = 9.700000000000001 x = 5 → y = 0.5 x = 10 → y = 3.0
elif x < 5 里不用再写 0 <= x——因为能走到 elif,说明前面的 if x < 0 已经不成立,x 必然 ≥ 0。这是"条件的顺序本身就在传递信息",多写反而容易出错(下一章学 Pandas 的分段赋值时还会遇到同样的思路)。阶梯水费是"用得越多,单价越高"的累进制计费。它的分段逻辑比上一题复杂,所以更值得做成函数——函数把"怎么算"关在里面,主程序只关心输入输出。
def cal_rate(x):
'''按阶梯水价计算水费:≤180 吨 5 元/吨;180—260 吨部分 7 元/吨;超出 260 吨部分 9 元/吨'''
if x <= 180:
y = 5 * x
elif x <= 260:
y = 180 * 5 + (x - 180) * 7
else:
y = 180 * 5 + (260 - 180) * 7 + (x - 260) * 9
return y
for t in [100, 180, 200, 260, 300]:
print('用水', t, '吨 → 水费', cal_rate(t), '元')
print('-' * 30)
print('检查上一页的算式:300 吨 =', 180 * 5 + 80 * 7 + 40 * 9, '元')
用水 100 吨 → 水费 500 元 用水 180 吨 → 水费 900 元 用水 200 吨 → 水费 1040 元 用水 260 吨 → 水费 1460 元 用水 300 吨 → 水费 1820 元 ------------------------------ 检查上一页的算式:300 吨 = 1820 元
def cal_rate(x):
if x <= 180:
y = 5 * x
elif x <= 260:
y = 180 * 5 + (x - 180) * 7
else:
y = 180 * 5 + (260 - 180) * 7 + (x - 260) * 9
return y
# 主程序:课件要求——输入小于零时提示错误
for _ in range(3): # 演示里连续处理 3 次输入
x = float(input('请输入用水量(吨):'))
if x < 0:
print('输入错误:用水量不能为负数')
else:
print('应缴水费:', cal_rate(x), '元')
请输入用水量(吨):150 应缴水费: 750.0 元 请输入用水量(吨):-20 输入错误:用水量不能为负数 请输入用水量(吨):275 应缴水费: 1595.0 元
海伦公式本身要写三行,如果再算上"能不能构成三角形"的判断,主程序会变得很长。把两件事都做成函数:is_triangle() 判断,cal_area() 计算——一个函数只做一件事。
import math
def is_triangle(a, b, c):
'''两边之和大于第三边'''
return a + b > c and a + c > b and b + c > a
def cal_area(a, b, c):
'''海伦公式:p 是半周长'''
p = (a + b + c) / 2
return math.sqrt(p * (p - a) * (p - b) * (p - c))
for sides in [(3, 4, 5), (6, 6, 6), (1, 1, 3)]:
a, b, c = sides
if is_triangle(a, b, c):
print(sides, '能构成三角形,面积 =', round(cal_area(a, b, c), 2))
else:
print(sides, '不能构成三角形(两边之和没有大于第三边)')
(3, 4, 5) 能构成三角形,面积 = 6.0 (6, 6, 6) 能构成三角形,面积 = 15.59 (1, 1, 3) 不能构成三角形(两边之和没有大于第三边)
下面四道题都要求写成函数或类,主程序只负责输入输出——这是本章最核心的训练:把"做什么"和"怎么做"分开。
定义函数 is_prime(n):是素数返回 True,否则返回 False,然后输出 2~50 之间的所有素数。
def is_prime(n):
'''判断 n 是否为素数'''
if n < 2: # 1 和负数都不是素数
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0: # 找到能整除的因数
return False
return True
primes = [n for n in range(2, 51) if is_prime(n)]
print('2~50 之间的素数:')
print(primes)
print('一共', len(primes), '个')
print('顺便验算:97 是素数吗?', is_prime(97), ' 91 呢?', is_prime(91))
2~50 之间的素数: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47] 一共 15 个 顺便验算:97 是素数吗? True 91 呢? False
定义函数 stat(scores),返回平均分和及格率;主程序读入人数与成绩,输出统计结果(用两个返回值接收)。
def stat(scores):
'''返回 (平均分, 及格率%),两个值一次交回'''
n = len(scores)
avg = round(sum(scores) / n, 1)
passed = len([s for s in scores if s >= 60])
rate = round(passed / n * 100, 1)
return avg, rate
n = int(input('请输入学生人数:'))
scores = []
for i in range(n):
scores.append(float(input('第 ' + str(i + 1) + ' 个成绩:')))
avg, rate = stat(scores) # 解包接收两个返回值
print('成绩单:', scores)
print('平均分:', avg)
print('及格率:', str(rate) + '%')
print('最高分 / 最低分:', max(scores), '/', min(scores))
请输入学生人数:5 第 1 个成绩:88 第 2 个成绩:95 第 3 个成绩:59 第 4 个成绩:72 第 5 个成绩:100 成绩单: [88.0, 95.0, 59.0, 72.0, 100.0] 平均分: 82.8 及格率: 80.0% 最高分 / 最低分: 100.0 / 59.0
定义函数 word_rank(text, top=3),返回出现次数最多的前 top 个词及其次数。
def word_rank(text, top=3):
'''返回出现次数最多的前 top 个词:[(词, 次数), ...]'''
counts = {}
for w in text.split():
counts[w] = counts.get(w, 0) + 1
rank = sorted(counts.items(), key=lambda kv: kv[1], reverse=True)
return rank[:top]
text = 'python 数据分析 数据 可视化 数据 python 建模 数据 python'
print('词频前 3 名:')
for i, (w, c) in enumerate(word_rank(text), 1):
print(' 第', i, '名:', w, '(', c, '次 )')
print('如果只看前 2 名:', word_rank(text, 2))
词频前 3 名:
第 1 名: python ( 3 次 )
第 2 名: 数据 ( 3 次 )
第 3 名: 数据分析 ( 1 次 )
如果只看前 2 名: [('python', 3), ('数据', 3)]
在例 5-11 的 MyCircle 类上增加 set_r(r)(改半径)和 bigger_than(other)(和另一个圆比面积大小)。
import math
class MyCircle:
def __init__(self, r):
self.r = r
def area(self):
return round(math.pi * self.r ** 2, 2)
def set_r(self, r):
'''修改半径'''
self.r = r
def bigger_than(self, other):
'''比较两个圆的面积,other 是另一个 MyCircle 对象'''
return self.area() > other.area()
c1 = MyCircle(3)
c2 = MyCircle(5)
print('c1 半径', c1.r, '面积', c1.area())
print('c2 半径', c2.r, '面积', c2.area())
print('c2 比 c1 大?', c2.bigger_than(c1))
c1.set_r(8) # 调用 set_r 改半径
print('-' * 30)
print('c1 改半径为 8 后,面积', c1.area())
print('现在 c1 比 c2 大?', c1.bigger_than(c2))
c1 半径 3 面积 28.27 c2 半径 5 面积 78.54 c2 比 c1 大? True ------------------------------ c1 改半径为 8 后,面积 201.06 现在 c1 比 c2 大? True
"函数"听起来是基础语法,但它在 AI 里不是比喻,而是字面意义上就是 AI 的骨架:一个神经元是一次函数调用,一层网络是一批函数调用,训练就是反复调整函数里的参数,模型对比就是给候选答案打分排序。下面这张图把本章的概念和 AI 里的对应物摆在一起。
import math
def sigmoid(z):
'''激活函数:把任意数压到 0~1 之间'''
return 1 / (1 + math.exp(-z))
def neuron(inputs, weights, bias):
'''一个神经元:先加权求和,再过激活函数'''
z = bias + sum(x * w for x, w in zip(inputs, weights))
return round(z, 3), round(sigmoid(z), 3)
inputs = [0.8, 0.5, 0.2] # 输入特征,相当于实参
weights = [0.7, -0.4, 1.2] # 权重
bias = -0.1 # 偏置
z, a = neuron(inputs, weights, bias)
print('输入:', inputs)
print('加权和 z =', z)
print('激活后 a = sigmoid(z) =', a)
print('-' * 30)
print('换一组"训练好"的权重,同一个函数算出的结果就变了:')
print('新的 a =', neuron(inputs, [1.5, 0.9, -0.3], 0.2))
print('(训练 = 不断调整 weights 和 bias,让输出越来越接近正确答案)')
输入: [0.8, 0.5, 0.2] 加权和 z = 0.5 激活后 a = sigmoid(z) = 0.622 ------------------------------ 换一组"训练好"的权重,同一个函数算出的结果就变了: 新的 a = (1.79, 0.857) (训练 = 不断调整 weights 和 bias,让输出越来越接近正确答案)
def mse(preds, truths):
'''均方误差:预测值与真实值差多少(越小越好)'''
n = len(preds)
total = sum((p - t) ** 2 for p, t in zip(preds, truths))
return round(total / n, 4)
truths = [1.0, 0.0, 1.0, 0.0] # 真实答案
poor = [0.5, 0.5, 0.5, 0.5] # 预测一:全猜 0.5
good = [1.0, 0.1, 0.9, 0.2] # 预测二:比较接近
print('真实值:', truths)
print('预测一', poor, '→ MSE =', mse(poor, truths))
print('预测二', good, '→ MSE =', mse(good, truths))
print('所以"训练"就是:想办法让这个函数的值变小')
真实值: [1.0, 0.0, 1.0, 0.0] 预测一 [0.5, 0.5, 0.5, 0.5] → MSE = 0.25 预测二 [1.0, 0.1, 0.9, 0.2] → MSE = 0.015 所以"训练"就是:想办法让这个函数的值变小
class TinyModel:
'''把"参数 + 前向计算 + 损失 + 训练"装进一个类:这就是模型对象'''
def __init__(self, w=0.5, b=0.0):
self.w = w
self.b = b
def forward(self, x):
'''前向计算:y = wx + b'''
return self.w * x + self.b
def loss(self, xs, ys):
'''均方误差'''
return round(sum((self.forward(x) - y) ** 2 for x, y in zip(xs, ys)) / len(xs), 4)
def fit(self, xs, ys, lr=0.02):
'''一步梯度下降:往"让损失变小"的方向挪一点点'''
n = len(xs)
gw = sum(2 * (self.forward(x) - y) * x for x, y in zip(xs, ys)) / n
gb = sum(2 * (self.forward(x) - y) for x, y in zip(xs, ys)) / n
self.w -= lr * gw
self.b -= lr * gb
xs = [1, 2, 3, 4, 5]
ys = [3, 5, 7, 9, 11] # 真实规律是 y = 2x + 1
m = TinyModel()
print('训练前:w =', round(m.w, 3), ' b =', round(m.b, 3), ' 损失 =', m.loss(xs, ys))
for _ in range(300):
m.fit(xs, ys)
print('训练后:w =', round(m.w, 3), ' b =', round(m.b, 3), ' 损失 =', m.loss(xs, ys))
print('拿它预测没见过的 x = 6 →', round(m.forward(6), 2), '(真实答案 13)')
print('(这就是机器学习最小可运行的骨架:定义模型、算损失、调参数)')
训练前:w = 0.5 b = 0.0 损失 = 34.75 训练后:w = 2.02 b = 0.929 损失 = 0.0009 拿它预测没见过的 x = 6 → 13.05 (真实答案 13) (这就是机器学习最小可运行的骨架:定义模型、算损失、调参数)
candidates = [
'Python 是一种解释型语言',
'今天天气不错,适合出门散步',
'Python 支持面向对象,也常用于数据分析',
'喵',
]
def score(text, keyword):
'''打分规则(简化的"重排模型"):命中关键词加分,太长的稍微减分'''
s = 10 if keyword in text else 0
s += min(len(text), 20) / 5
return round(s, 2)
keyword = 'Python'
print('原始候选:')
for i, t in enumerate(candidates, 1):
print(' ', i, t, '|得分', score(t, keyword))
print('-' * 30)
print('按得分重排后(lambda 当 key):')
for i, t in enumerate(sorted(candidates, key=lambda c: score(c, keyword), reverse=True), 1):
print(' ', i, t, '|得分', score(t, keyword))
print('说明:大模型生成多个答案后,常再用一个打分函数排序——学名叫"重排(Rerank)"')
原始候选: 1 Python 是一种解释型语言 |得分 13.0 2 今天天气不错,适合出门散步 |得分 2.6 3 Python 支持面向对象,也常用于数据分析 |得分 14.0 4 喵 |得分 0.2 ------------------------------ 按得分重排后(lambda 当 key): 1 Python 支持面向对象,也常用于数据分析 |得分 14.0 2 Python 是一种解释型语言 |得分 13.0 3 今天天气不错,适合出门散步 |得分 2.6 4 喵 |得分 0.2 说明:大模型生成多个答案后,常再用一个打分函数排序——学名叫"重排(Rerank)"
改参数、点按钮,立刻看结果 · 浏览器内 JS 模拟(已与 Python 运行结果逐一对齐)
函数定义是 def my_add(x, y=10)。选一种调用方式,看实参怎么落到形参上,以及写错时 Python 报什么错。
点上面的按钮试试
对应 5.1 节。点"开始",看栈帧一层层压进去、再一层层弹出来。
点上面的按钮试试
对应 3.2 节。勾选"谁定义了同名变量",再看函数里读到的到底是哪一个。
点上面的按钮试试
对应 4.2 节。同一组数据,换个 key 就是完全不同的顺序——key 只负责"按什么排"。
点上面的按钮试试
对应 6.3 节。输入半径,相当于执行 c = MyCircle(r),然后调用它的方法。
点上面的按钮试试
math.pi 的取值 3.14159…,四舍五入保留两位;排序结果和 Python 的 sorted() 完全一致。想核对的话,把面板里的数据复制到上面任意一段示例代码里跑一遍即可。复习用:下面每一条都能自己讲出来,这一章就算过关
def 函数名(形参): + 缩进的函数体函数名(实参),实参按位置交给形参return → 返回 Nonedef f(x, y=10),必须写在最后f(y=5, x=4),顺序可换*args 打包成元组,**kwargs 打包成字典None 再新建)global 变量名lambda 参数: 表达式,没有名字、只有一行sorted(数据, key=lambda x: 依据)class 类名:,类名首字母大写__init__(self, …) 创建对象时自动执行,用来存属性self对象.属性、对象.方法()| 现象 | 原因 | 怎么改 |
|---|---|---|
调用结果打印出来是 None |
函数里只写了 print,没有 return |
要"交回结果给程序用"就写 return |
NameError: name 'xxx' is not defined |
函数定义在调用之后,或在函数外用了局部变量 | 定义放前面;局部变量只在函数内用 |
missing 1 required positional argument |
实参个数少于没有默认值的形参个数 | 补齐实参,或给形参加默认值 |
non-default argument follows default argument |
有默认值的形参写在了没有默认值的形参前面 | 把带默认值的形参挪到最后 |
positional argument follows keyword argument |
位置实参写在了关键字实参后面 | 位置在前、关键字在后 |
got an unexpected keyword argument |
关键字名字写错(或大小写不一致) | 名字与形参表完全一致 |
UnboundLocalError: cannot access local variable |
函数内先读后写全局变量,但没写 global |
加 global 变量名,或改用参数与返回值 |
| 第二次调用函数,列表里"还留着上次的元素" | 默认值用了可变对象(box=[]) |
默认值写 None,进函数再 box = [] |
TypeError: xxx() takes 1 positional argument but 2 were given |
类的方法忘了写 self |
所有实例方法的第一个参数都写 self |
RecursionError: maximum recursion depth exceeded |
递归没有终止条件,或数据规模没有缩小 | 补终止条件;大批量数据处理改用循环 |
is_prime(n),输出 2~50 的所有素数。stat(scores) 返回平均分与及格率(两个返回值),主程序读入成绩并输出。word_rank(text, top=3),用 lambda 排序,输出出现次数最多的前几名。MyCircle 增加 set_r() 和 bigger_than()。提交要求:每题给出代码 + 运行结果截图;函数 / 类要有文档字符串;变量名要能读懂(不要用 a、b、c 一路到底)。
max3(a, b, c) 返回三个数中的最大值,并说出它有几个形参、怎么调用。f(3, 5) 和 f(y=5, x=3)?print(x) 之后又写 x = 3 会报 UnboundLocalError?sorted(data, key=_____)。__init__ 什么时候被执行?self 到底指什么?