Python 大数据分析基础 · 第 5 次课

第 5 章 函数与类

函数的定义与调用 · 函数参数 · 变量作用域 · lambda 表达式 · 递归(选学) · 类与对象 · 综合应用(7 个知识模块 + 40 余段可运行演示 + 15 张插图 + 6 个动态演示图)

中华女子学院4 学时(讲授 2 + 上机 2)授课人:孙琪翔第 7 周
导

本讲导览

Lesson Overview · 从"把代码写下来"到"把功能装起来"

前四章写的程序,都是"从上往下一路执行"。程序一长,就会遇到两个麻烦:同样的几行代码重复写好几遍,以及主程序被细节淹没,看不出在做什么。函数就是解决这两个麻烦的工具——把一段有特定功能的代码装起来、起个名字,需要的时候喊名字就行。这一章还会往前走一步,认识"类":它是把数据和操作数据的函数装在一起的容器。

第 1 讲 · 45 分钟
函数基础与参数
为什么要函数 · def 定义语法 · 调用与执行过程 · return 的三种情况 · 位置 / 默认值 / 关键字 / 可变长参数
第 2 讲 · 45 分钟
作用域 · lambda · 类
局部变量与全局变量 · global · lambda 表达式 · 类与对象 · __init__ 与 self · 圆的面积与周长
上机一 · 45 分钟
把重复代码改造成函数
成绩平均分 · 分段函数 · 阶梯水费 · 三角形面积 · 默认值与关键字参数改写
上机二 · 45 分钟
类的第一次实践
定义圆类 · 创建对象 · 学生成绩类 · 用 lambda 给结果排序 · 综合应用题
学习目标:① 会写 def 定义函数并正确调用,说清形参与实参的区别;② 掌握位置参数、默认值参数、关键字参数、可变长参数四种传参方式,知道各自的报错情况;③ 能区分局部变量与全局变量,会用 global 在函数内修改全局变量;④ 会写 lambda 表达式,能用 sorted(key=...) 按自定义规则排序;⑤(选学)理解递归的终止条件与调用栈;⑥ 会用 class 定义类、用 __init__ 初始化属性、创建对象并调用方法;⑦ 能把"重复代码"识别出来并改造成函数。

本课地图

本章知识点总览

点击节点可跳转到对应讲解位置,点击三角可展开 / 收起分支。

第 5 章 函数与类
▶函数的定义与调用模块一
为什么需要函数:复用与模块化
定义语法:def / 形参表 / 冒号 / 缩进
返回值:return、多个返回值、没有 return 得 None
调用与执行过程:实参 → 形参 → 函数体 → 返回值
▶函数参数模块二
位置参数:数量、顺序必须一致
默认值参数:不传就用默认值,且必须写在最后
关键字参数:按名字传,顺序可换
可变长参数:*args 打包成元组、**kwargs 打包成字典
▶变量作用域模块三
局部变量与全局变量
同名时局部优先
global:在函数内修改全局变量
▶lambda · 递归 · 类模块四—六
lambda 语法:一行写完一个函数
配合 sorted / max 的 key 使用
递归的两个要素:终止条件 + 自己调用自己
类与对象:模板与实例
定义类:class / __init__ / self
创建对象、访问属性与方法
▶综合应用与 AI 渗透模块七
分段函数
阶梯水费(函数改造版)
三角形面积(海伦公式)
上机任务与课后作业
AI 渗透:函数、参数与类在 AI 里的对应物
说明:本章依据课程课件《5-函数 - 新》《5-函数与类》与《Python 编程与数据分析基础》(陈洁、刘姝,清华大学出版社)第 5 章整理;页面中每段代码都是真实运行后回填的结果,运行结果默认隐藏,点"运行"才显示。
先记住三句话:① 函数是"给一段代码起名字",def 是定义,写函数名加括号是调用;② 参数是"调用时递进去的东西",按位置递、按名字递、不递就用默认值;③ 变量有"地盘"——函数内部定义的变量出了函数就没了,这就是作用域。
一

函数的定义与调用 本章重点

为什么要函数 · def 语法 · 调用与执行过程 · return 与 print 的区别 · 例 5-1 成绩平均分

1.1 为什么需要函数

函数是实现特定功能的代码段。Python 里能用的函数有三类:内置函数(print、len、sum 这些,拿了就用)、标准库函数(要先 import,比如 math.sqrt)、以及我们自己写的函数。本章讲的就是第三类。

Python 里能用的三类函数 ① 内置函数 print() input() len() sum() max() min() round() sorted() 拿了就用,不用导入 第 2 章已经用过一大部分 ② 标准库 / 第三方库函数 import math → math.sqrt() math.pi import random → random.randint() 先 import,再调用 库 = 别人写好的函数集合 ③ 自定义函数 def cal_avg(alist): … 自己的算法,起个名字装起来 本章主角 复用 + 模块化,都靠它 三类的调用写法完全一样:函数名(参数)
图 5-1 函数的三个来源:内置、库、自定义——区别只在"从哪来",调用方式都一样

不用函数会怎样?看下面这张对比图:左边是"同一个算法抄三遍",右边是"写一遍、调三次"。程序一旦变长,左边的写法改一处就会漏改另一处。

不用函数:同一段代码抄三遍 用函数:写一遍,调三次 s1 = [75, 80, 85, 70, 65, 90] print(round(sum(s1)/len(s1), 1)) s2 = [88, 92, 79] print(round(sum(s2)/len(s2), 1)) s3 = [60, 66, 72, 58] print(round(sum(s3)/len(s3), 1)) def cal_avg(alist): return round(sum(alist)/len(alist), 1) # 算法只写一遍 print(cal_avg([75, 80, 85, 70, 65, 90])) print(cal_avg([88, 92, 79])) print(cal_avg([60, 66, 72, 58])) 改算法要改 3 处,容易漏 改算法只改 1 处 函数带来的两件事:代码复用率提高、主程序模块化(看得清在做什么)
图 5-2 同一个"求平均分"的两种写法:右边的 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
同一个算法:抄三遍 vs 写一遍调三次
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
✅ 本节小结:函数就是给一段代码起名字。好处有两个——复用(写一遍调多次)和模块化(主程序只看得见"做什么",看不见"怎么做")。Python 的函数有三个来源:内置、库、自定义。

1.2 定义函数的语法:五个部分

定义函数用 def 关键字。下面这张图把一行 def 语句拆开,每部分都有讲究——尤其注意冒号和缩进,初学最常见的错误就出在这里。

一条 def 语句,拆成五个部分 def my_add(x, y): '''add the two arguments''' s = x + y return s def 关键字 告诉 Python: 下面要定义函数 函数名 自己起,见名知意,小写字母 + 下划线 形参表(x, y) 多个参数用英文逗号分隔, 不用写类型 冒号 : 后面必须换行 + 缩进 文档字符串(可选):写清功能与参数,可用 函数名.__doc__ 查看 函数体:整体缩进 4 个空格 return:把结果交回调用处;没有它就返回 None 记住顺序:def → 函数名 → (形参) → : → 缩进的函数体
图 5-3 def 语句的五个组成部分(颜色与代码块一一对应)
定义 my_add() 并调用:形参、实参与类型自动推断
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
用 help() 看函数的说明书(和内置函数一样)
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() 既能加数字,也能拼字符串、合并列表。

1.3 返回值:return 的三种情况

函数把结果交给调用者,靠的是 return。这里有三个必须分清的情况——尤其是第三种,它是初学者最容易踩的坑。

写法返回什么调用处拿到
return s一个值那个值本身(可以是任意类型)
return a, b多个值一个元组 (a, b),可以用解包接收
没有 return(或只写 return)NoneNone——想去运算就会报错
三种返回值一次看全(含 return 会立刻结束函数)
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 ≠ return。函数里写了 print(x + y),屏幕上确实出现了结果,但函数没有把值交回——调用处拿到的还是 None。屏幕上的字是"给人看的",return 的值才是"给程序用的"。
✗ 只打印:拿不回来
def add_wrong(x, y):
    print(x + y)

print(add_wrong(3, 5))
✓ 用 return:能拿回来
def add_right(x, y):
    return x + y

print(add_right(3, 5))
print(add_right(3, 5) * 10)
坑一:只 print 不 return,调用处拿到 None
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'>
坑二:拿 None 去做运算,直接报错
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'
🎬 动态演示:8 去哪了——print 和 return 的区别
✅ 本节小结:有 return 才有返回值;返回多个值得到元组;没有 return 就是 None,拿 None 去加减乘除会报 TypeError。return 一旦执行,函数立刻结束。

1.4 调用与执行过程:实参怎么变成返回值

自定义函数和内置函数的调用方法完全一样:函数名加括号,括号里写实际参数。下面这张图是调用 my_add(3, 5) 时,程序内部依次发生的四件事。

调用 my_add(3, 5) 的四步 ① 函数定义 def my_add(x, y): s = x + y return s ② 函数调用 my_add(3, 5) 括号里的 3、5 是实参 表示形参的实际取值 ③ 参数绑定 x = 3,y = 5 实参按位置赋给形参 类型由实参决定 ④ 执行并返回 s = 3 + 5 = 8 return 8 结果交回调用处 函数执行结束后,函数内部的 x、y、s 全部消失,只有 return 的值留在调用处 形参(形式参数)是定义时的占位名字,实参(实际参数)是调用时的真实数据
图 5-4 从实参到返回值的四步:定义 → 调用 → 绑定 → 执行并返回
🎬 动态演示:my_add(3, 5) 到底怎么跑出 8 的
形参不写类型:Python 按实参自动推断
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
例 5-1 定义函数计算一组成绩的平均值(课件例题)
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 的值交回调用处,函数内部的变量随之消失。函数可以互相调用——前一个函数的返回值,直接当作后一个函数的实参,这就是"模块化"的实际写法。
配套视频 黑马程序员 · 第 52 讲 函数的基础定义语法 B站 · 定义与调用,6 分钟讲完
配套视频 黑马程序员 · 第 56 讲 函数的返回值定义语法 B站 · 想知道 return 和 print 的区别,看这一讲
二

函数参数 本章重点

位置参数 · 默认值参数 · 关键字参数 · 可变长参数(*args / **kwargs)

参数是函数与外界交换数据的接口。同样一个函数,用不同的传参方式调用,写法不同、报错也不同。课件里把参数分成四类,这一节一类一类过,并且每一类都配了"写错的后果"——看懂报错信息,比背语法有用得多。

四类参数:什么时候用哪一种 位置参数 my_add(3, 5) 按位置一一对应 数量、顺序都不能错 默认值参数 def f(x, y=10) 不传就用默认值 必须写在形参表最后 关键字参数 my_add(y=5, x=4) 按名字配对,顺序可换 位置参数要在关键字之前 可变长参数 *nums **kwargs 个数不定 打包成元组 / 字典 口诀:先位置、后关键字;默认值垫底;个数不定用星号
图 5-5 四类参数速查:位置 / 默认值 / 关键字 / 可变长

2.1 位置参数:数量相同、顺序一致

位置参数是最常见的形式。调用时实参和形参的数量必须相同、位置顺序必须一致——第一个实参给第一个形参,第二个给第二个,以此类推。

位置参数:第 1 个给 x,第 2 个给 y def my_add(x, y) ← 定义:两个形参 x、y my_add(3, 5) ← 调用:两个实参 3、5 3 5 x = 3 y = 5 位置对得上 → 结果 8 少一个、换顺序 → 报错
图 5-6 位置参数靠"站位"传递数据,站位错了数据就错
位置参数:按顺序一一对应(示例来自课件)
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,看到这句话就知道:某个形参没接到值。

2.2 默认值参数:不传就用默认值

定义函数时可以直接给形参写一个默认值,语法是 形参名=默认值。调用时不传就用默认值,传了就用实参替换掉默认值。你其实已经用过很多次了——range(10) 就是默认值参数的典型例子。

默认值参数:def my_add(x, y=10) 调用一:只传 1 个实参 my_add(3) x = 3 y = 10(默认值) 结果:3 + 10 = 13 调用二:传 2 个实参 my_add(3, 5) x = 3 y = 5(实参覆盖) 结果:3 + 5 = 8 注意:默认值参数必须写在形参表的最后,否则语法错误
图 5-7 默认值参数:传了就覆盖,没传就用默认值
默认值参数:只传一个也合法(课件示例)
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 再在函数里新建。

2.3 关键字参数:按名字传,顺序可以换

调用函数时写成 形参名=值,就是关键字参数。它靠名字配对,所以实参顺序可以和定义时不一致。这在参数很多的时候特别有用——plt.plot(x, y, color='red', linewidth=2) 就是典型的可读写法。

关键字参数:按"名字"配对,不看站位 def my_add(x, y): my_add(y=5, x=4) y = 5 x = 4 名字对上了,位置无所谓 两条规矩 ① 名字必须是定义里的形参名,写错 → TypeError ② 位置实参必须在关键字实参之前, my_add(y=5, 4) → SyntaxError ✓ 合法写法:my_add(4, y=5)
图 5-8 关键字参数按名字传递:顺序可换,但"位置在前、关键字在后"的规矩不能破
关键字参数:三种合法写法(课件示例)
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'
✅ 本节小结:关键字参数用名字指明给谁传值,顺序随便换;但必须位置实参在前、关键字实参在后,而且名字要和形参完全一致。参数多的时候,用关键字参数能让代码"自己解释自己"。

2.4 可变长参数:个数不定也能收(了解)

有时候事先不知道要传几个参数——比如"求任意多个数的累加和"。在形参名前加一个 *,Python 会把多出来的实参打包成元组;加两个 **,则打包成字典。

星号的作用:把不定个数的实参"打包" *nums → 打包成元组 def my_sum(*nums): my_sum(4, 5, 6, 7) nums = (4, 5, 6, 7) 函数里把 nums 当成元组用:for n in nums **kwargs → 打包成字典 def my_sum2(**nums): my_sum2(a=1, b=2, c=3) nums = {'a':1, 'b':2, 'c':3} 函数里把 nums 当成字典用:nums[key] 名字可以自己起,约定俗成写 *args / **kwargs;星号参数要放在形参表的最后面
图 5-9 *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。
配套视频 黑马程序员 · 第 54 讲 函数的传入参数 B站 · 位置参数与形参实参对照
配套视频 黑马程序员 · 第 82 讲 函数的多种参数使用形式 B站 · 默认值、关键字、可变长参数一讲看完
三

变量作用域

局部变量 · 全局变量 · 同名遮蔽 · global 关键字

作用域就是变量"起作用的代码范围"。函数给变量划了边界:函数内部定义的变量出了函数就消失。理解这一点,才能解释为什么有的变量"明明赋过值却说不存在"。

两块地盘:全局区与函数局部区 全局区 · 整个程序都能用 global_num = 5 函数局部区 · 只在 my_add2() 执行期间存在 local_num = 3 return global_num + local_num → 5 + 3 = 8 函数一结束 局部变量消失 全局变量在函数里可以读;要在函数里改它,必须先用 global 声明
图 5-10 全局变量与局部变量:局部变量随函数"生",随函数"灭"

3.1 局部变量与全局变量

局部变量:在函数内部定义的变量,作用范围只限这个函数,函数执行结束后自动删除。全局变量:在函数外部定义,作用范围是整个程序,函数里也可以读。

函数里能用全局变量,函数外拿不到局部变量(课件示例)
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。

3.2 同名时,局部优先

如果函数内部和外部定义了同名变量,函数体里用的是局部那个,外部的被"遮住"(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
🎬 动态演示:函数里的 x 到底用哪一个
✅ 本节小结:Python 找变量的顺序是先局部、再全局。同名时"近的赢"——函数里用的是局部变量,全局那个毫发无损。变量重名看着方便,实际是 bug 的温床,起名时尽量避开。

3.3 global:在函数里修改全局变量

如果确实要在函数内部修改全局变量,必须先用 global 声明它。不声明就赋值,Python 会把它当成一个新的局部变量——这时如果函数里还想先读后写,就会撞上那个著名的 UnboundLocalError。

用 global 在函数内修改全局变量(课件示例)
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
写错会怎样:函数里先读后写全局变量,却没写 global
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 到底改的是哪一个
✅ 本节小结:global x 是"声明",不是"赋值"——它告诉 Python"接下来这个 x 指的是全局那个"。函数里改全局变量属于需要谨慎的写法:改的地方多了,程序就很难追踪。更好的做法是把值作为参数传进去、把结果 return 出来。
配套视频 黑马程序员 · 第 60 讲 变量在函数中的作用域 B站 · 局部变量与全局变量
四

lambda 表达式

匿名函数 · 一行写完 · 配合 sorted / max / map / filter 的 key 使用

有些函数小到"只做一次加法",为它专门写一个 def 显得啰嗦。lambda 表达式就是为这种情况准备的:不用起名字、一行写完、只放一个表达式。它最实用的场合不是"造函数",而是当"排序依据"——告诉 sorted() 该按什么排。

4.1 语法:lambda 参数 : 表达式

同一个函数,两种写法 def 写法:有名字,可以多行 def add(x, y): return x + y print(add(3, 5)) # 8 lambda 写法:没有名字,只有一行 add = lambda x, y: x + y # lambda 参数 : 表达式 print(add(3, 5)) # 8 lambda 的返回值就是那个表达式的结果——不用写 return,也不能写多条语句(不能赋值、不能放 if 语句块)。 所以 lambda 只适合"一行能算完"的功能;复杂逻辑还是老老实实用 def。
图 5-11 lambda 与 def 的对照:省掉名字和 return,只留一行表达式
lambda 基础:定义、调用、看类型
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!
写错会怎样: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。

4.2 真正的用武之地:当"排序依据"

sorted()、max()、min() 都有一个 key 参数,用来指定"按什么排 / 按什么比"。往里传一个 lambda,是最常见的写法。

sorted(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)]
max / min 也能配 key:找"成绩最高的那个人"
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)
分数最高的科目: 数学
按分数排的科目: ['英语', '语文', '数学']
分数最低的两个科目: ['英语', '语文']
map / filter:对一批数据批量加工、筛选
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 次
🎬 动态演示:key 到底怎么决定排序结果
✅ 本节小结:lambda 最实用的写法是 sorted(数据, key=lambda x: 依据)——key 只决定"按什么排",不改变元素本身。按元组第 2 项排就写 s[1],按字典的值排就写 kv[1],要多级排序就返回一个元组。
配套视频 黑马程序员 · 第 84 讲 lambda 匿名函数 B站 · 4 分钟讲清 lambda 语法
配套视频 黑马程序员 · 第 83 讲 函数作为参数传递 B站 · 理解"函数也能当参数"(key 参数的原理)
五

递归函数 选学

自己调用自己 · 终止条件 · 调用栈 · 与循环的取舍

说明:课件目录里列了 5.5 递归函数,但幻灯片没有展开;教学进度表对本章的要求是"函数的定义与调用、函数参数、变量作用域、lambda 表达式、函数综合应用"。这一节按选学处理——理解思想即可,考试与上机不涉及。但它值得看一眼:递归是"函数调用自己",里面藏着函数调用栈最直观的样子,而且后面讲"树结构、文件夹遍历"时会再遇到它。

5.1 递归的两个要素

递归函数就是在函数体里调用自己。但它必须写清楚两件事,缺一个就会无限调用下去:

  1. 终止条件(base case):什么时候停下来,直接返回一个确定的值,不再调用自己;
  2. 递归式:把问题变小一步,再交给自己处理——每一次调用都要比上一次更接近终止条件。
递归计算 4! 的过程:一路往下压栈,再一路往上返回 factorial(4) → 4 * factorial(3) 等着 factorial(3) → 3 * factorial(2) 等着 factorial(2) → 2 * factorial(1) 等着 factorial(1) → 命中终止条件:return 1 开始返回:factorial(1) 返回 1 factorial(2) = 2 × 1 = 2 → factorial(3) = 3 × 2 = 6 factorial(4) = 4 × 6 = 24 ① 往下:4 层调用 层层压入调用栈, 每层都在"等"下一层 ② 触底后往上 一层层算出结果 并释放栈帧 "压栈"就是函数还没算完、先记住自己算到哪一步——这也是递归占内存的原因
图 5-12 递归的两段路程:先一路压栈到底(找终止条件),再一路返回求和
递归①:阶乘 n! = n × (n-1)!,0! = 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
递归②:斐波那契数列 1, 1, 2, 3, 5, 8…(前两项是终止条件)
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
写错会怎样:忘了终止条件 → RecursionError
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
🎬 动态演示:递归的"压栈与出栈"(factorial(3))

5.2 递归还是循环?

同一个"求和",循环和递归都能做。工程上的默认选择是循环——它更省内存、没有深度限制;递归的优势在"问题本身就是分层的":文件夹里的文件夹、菜单里的子菜单、族谱里的分支,用递归写出来几乎就是问题本身的样子。

比较项循环(for / while)递归
写法复杂度直白,一眼看到"从头到尾"代码更短,但要想清终止条件
内存占用几乎不额外占内存每一层调用都压一个栈帧,深度越大越占内存
深度限制没有限制Python 默认约 1000 层,超了报 RecursionError
适合什么一维、顺序处理的数据天然分层的结构:树、目录、嵌套列表
本章建议首选看懂即可,别用来处理大批数据
递归有多"深"才安全:看看 Python 的默认上限
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 个数要调用上千万次——这类问题必须改用循环或缓存)
✅ 本节小结:递归 = 终止条件 + 自己调用自己(并且规模要变小)。它的两段路程是"先压栈到底、再出栈返回"。写不出来就先用循环,真正适合递归的是天然分层的结构。
配套视频 黑马程序员 · 第 164 讲 递归 B站 · 该系列最后的递归专题,讲完刚好本章收尾
六

类的定义与使用 本章重点

类与对象 · class 语法 · __init__ 与 self · 创建对象 · 例 5-11 / 例 5-12 圆类

6.1 类与对象:模板与实例

到这里为止,函数和数据是分开的:列表存数据,函数处理数据。类(class)把两者装在一起——它描述"这类东西有什么数据(属性)、能做什么(方法)"。类是抽象的模板,对象是按模板造出来的具体实例。

类 = 模板,对象 = 按模板造出来的具体实例 类:猫 属性(静态特征):毛色、公母、大小 方法(动态行为):抓老鼠、伸懒腰 ——这是一张"设计图",不是某只猫 ——它规定了"猫"这类事物有什么 实例化 对象一:小猫"咪咪" 毛色=黑白 公母=母 大小=小 → 抓老鼠() 它是一只有具体属性值的"真猫" 对象二:公猫"豆豆" 毛色=橘色 公母=公 大小=大 → 伸懒腰() 同一个类造出来的,属性值各不相同 面向对象的基本思想:"万物皆对象"——对象都是某个类的实例
图 5-13 类与对象:一个模板可以造出无数个属性值不同的实例
概念是什么在圆的例子里
类(class)模板、抽象,描述一类事物的共同特征与行为MyCircle
对象(实例)按模板造出来的具体个体c1 = MyCircle(2)
属性对象的数据(静态特征)self.r 半径
方法对象的函数(动态行为),第一个参数必须是 selfarea()、perimeter()
✅ 本节小结:类是模板,对象是实例。类里规定两件事:属性(有什么数据)和方法(能做什么)。造对象的过程叫"实例化"——同一个类可以造出很多对象,它们的属性值互不相同。

6.2 用 class 定义类:__init__ 与 self

定义类用 class 语句。类的设计包含三个要素:类名(抽象事物的名字)、属性(特征)、方法(行为)。其中 __init__ 是一个特殊方法——它不用你调用,创建对象时会自动执行,用来给对象准备初始数据。

一个类的最小结构 class MyCircle: '''一个圆:半径是属性,面积和周长是方法''' def __init__(self, r): self.r = r def area(self): return round(math.pi * self.r ** 2, 2) ① class 类名:  类名约定首字母大写(MyCircle),区别于函数名 ② def __init__(self, 参数):  创建对象时自动执行,负责把参数存成属性 ③ self: 代表"对象自己",方法里访问自己的属性必须写 self.属性名
图 5-14 class 语句的组成:类名、__init__ 初始化属性、方法里的 self
例 5-11 设计一个"圆"类:半径 + 面积 + 周长
import 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
类的说明文档: 一个圆:半径是属性,计算面积和周长是方法
(注意:类只是模板,到这里还没有任何一个圆)
写错会怎样:方法忘了写 self
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.属性名 访问自己的数据。

6.3 创建对象、访问属性与调用方法

创建对象的写法就是类名加括号:c1 = MyCircle(2)。拿到对象之后,用点号 . 访问它的属性、调用它的方法。

例 5-12 创建两个不同半径的圆对象,算面积与周长
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
🎬 动态演示:从"类的模板"到"两个圆对象"
🎬 动态演示:方法里的 self 到底指向谁
实战:把"学生成绩"做成一个类(类 + lambda 一起用)
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
✅ 本节小结:对象 = 类名(参数),用 对象.属性 读数据、对象.方法() 做事。同一个类造出的对象互相独立——改一个不影响另一个。类的好处是"数据 + 处理数据的函数"打包在一起,用起来不会拿错对象。
配套视频 黑马程序员 · 第 111 讲 初识对象 B站 · 面向对象第一课
配套视频 黑马程序员 · 第 113 讲 类和对象 B站 · 类与对象的关系,配合本节食用
七

函数与类的综合应用

分段函数 · 阶梯水费 · 三角形面积 · 上机任务与作业 · AI 渗透

这一节把本章学的东西用起来。三个例题都来自课件:把原本写在主程序里的判断逻辑装进函数,主程序立刻变得清爽。做题时注意一个套路——先想清楚"这个功能要不要复用",要复用就写成函数。

7.1 例:分段函数(课件上机题 1)

分段函数本来就是"按区间分别计算",是 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 的分段赋值时还会遇到同样的思路)。

7.2 例:阶梯水费(课件上机题 2)

阶梯水费是"用得越多,单价越高"的累进制计费。它的分段逻辑比上一题复杂,所以更值得做成函数——函数把"怎么算"关在里面,主程序只关心输入输出。

阶梯水费:三段累加,不是"整体套一个单价" 吨数 单价 5 元 / 吨 7 元 / 吨 9 元 / 吨 0 — 180 吨 180 — 260 吨 260 吨以上 用水 300 吨的费用 = 180×5 + 80×7 + 40×9 = 900 + 560 + 360 = 1820 元
图 5-15 三段单价累加:前 180 吨按 5 元、180—260 吨部分按 7 元、超出部分按 9 元
🎬 动态演示:阶梯水费怎么一段一段算出来
阶梯水费:把累进算法关进函数(课件示例 ex_5-2)
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 元

7.3 例:三角形面积(课件上机题 3)

海伦公式本身要写三行,如果再算上"能不能构成三角形"的判断,主程序会变得很长。把两件事都做成函数: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) 不能构成三角形(两边之和没有大于第三边)
✅ 本节小结:三个例题都是同一种改造——把主程序里的计算逻辑抽成函数。判断"要不要抽"的方法很简单:如果这段逻辑要用第二次,或者它让主程序变得难读,就抽成函数。

7.4 上机任务与课后作业

下面四道题都要求写成函数或类,主程序只负责输入输出——这是本章最核心的训练:把"做什么"和"怎么做"分开。

作业 5-1 素数判断函数

定义函数 is_prime(n):是素数返回 True,否则返回 False,然后输出 2~50 之间的所有素数。

作业 5-1 参考写法:判断素数 + 找出 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

作业 5-2 成绩统计函数

定义函数 stat(scores),返回平均分和及格率;主程序读入人数与成绩,输出统计结果(用两个返回值接收)。

作业 5-2 参考写法:输入 5 个成绩,输出平均分与及格率
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

作业 5-3 词频统计函数(用上 lambda)

定义函数 word_rank(text, top=3),返回出现次数最多的前 top 个词及其次数。

作业 5-3 参考写法:词频 + 排序 + 取前几名
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-4 给圆类加两个方法

在例 5-11 的 MyCircle 类上增加 set_r(r)(改半径)和 bigger_than(other)(和另一个圆比面积大小)。

作业 5-4 参考写法:方法的参数可以是"另一个同类的对象"
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

7.5 AI 渗透:这一章的东西,AI 里全都在用

"函数"听起来是基础语法,但它在 AI 里不是比喻,而是字面意义上就是 AI 的骨架:一个神经元是一次函数调用,一层网络是一批函数调用,训练就是反复调整函数里的参数,模型对比就是给候选答案打分排序。下面这张图把本章的概念和 AI 里的对应物摆在一起。

本章学的 → AI 里对应的东西 函数:输入 → 输出 模型的一次"前向计算" 参数:函数里可变的量 权重与偏置(训练就是在调它们) 默认值参数:不传就用默认值 超参数(学习率、层数——要先定好) 类:属性 + 方法打包 模型对象(参数 + 前向 + 损失) 还有一条:lambda 常被当成"打分器"——给每个候选答案算一个分数,再按分数排序(这就是大模型"重排"的基本动作) 所以在学 NumPy / Pandas / 机器学习之前,先把"函数"练熟——它是所有模型的地基
图 5-16 本章概念与 AI 的对应关系:函数、参数、默认值、类、lambda 各有落点
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,让输出越来越接近正确答案)
AI 渗透②:损失函数也是函数——它衡量"错得有多离谱"
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
所以"训练"就是:想办法让这个函数的值变小
AI 渗透③:用类封装一个"迷你模型",并让它自己变准
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)
(这就是机器学习最小可运行的骨架:定义模型、算损失、调参数)
AI 渗透④:用 lambda 当"打分器",给候选答案排序(重排/Rerank)
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)"
✅ 本节小结:这一章的东西在 AI 里全是"零件"——函数是前向计算,参数是权重与偏置,默认值参数是超参数,类是模型对象,lambda 是打分器。第 7 章学 NumPy 时会看到"批量运算",第 8 章 Pandas 里会看到"对整列做同一件事"——本质都是这一节的延伸。
配套视频 黑马程序员 · 第 61 讲 函数综合案例 B站 · 把定义、参数、返回值串起来用
八

交互演示区

改参数、点按钮,立刻看结果 · 浏览器内 JS 模拟(已与 Python 运行结果逐一对齐)

演示一:参数绑定模拟器

函数定义是 def my_add(x, y=10)。选一种调用方式,看实参怎么落到形参上,以及写错时 Python 报什么错。

点上面的按钮试试

演示二:递归调用栈(跟着 factorial(n) 走一遍)

对应 5.1 节。点"开始",看栈帧一层层压进去、再一层层弹出来。

点上面的按钮试试

演示三:变量查找顺序(先局部,再全局)

对应 3.2 节。勾选"谁定义了同名变量",再看函数里读到的到底是哪一个。

点上面的按钮试试

演示四:sorted 的 key 决定排序结果

对应 4.2 节。同一组数据,换个 key 就是完全不同的顺序——key 只负责"按什么排"。

点上面的按钮试试

演示五:MyCircle 类实例生成器

对应 6.3 节。输入半径,相当于执行 c = MyCircle(r),然后调用它的方法。

点上面的按钮试试
这些面板都是"照抄 Python 的算法"用 JS 重写的:面积用 math.pi 的取值 3.14159…,四舍五入保留两位;排序结果和 Python 的 sorted() 完全一致。想核对的话,把面板里的数据复制到上面任意一段示例代码里跑一遍即可。
结

知识点总结卡 · 易错清单 · 作业

复习用:下面每一条都能自己讲出来,这一章就算过关

一、知识点总结卡

函数基础

  • 定义:def 函数名(形参): + 缩进的函数体
  • 调用:函数名(实参),实参按位置交给形参
  • 函数必须先定义、后调用
  • 没有 return → 返回 None
  • 返回多个值 → 元组,可用解包接收
  • 形参不写类型,由实参决定

函数参数

  • 位置参数:数量相同、顺序一致
  • 默认值参数:def f(x, y=10),必须写在最后
  • 关键字参数:f(y=5, x=4),顺序可换
  • 混用时:位置在前、关键字在后
  • *args 打包成元组,**kwargs 打包成字典
  • 默认值别用可变对象(写 None 再新建)

变量作用域

  • 局部变量:函数内定义,函数结束即销毁
  • 全局变量:函数外定义,函数内可读
  • 同名时局部优先(遮蔽)
  • 要在函数内改全局变量 → global 变量名
  • 查找顺序:先局部,再全局

lambda · 递归

  • lambda 参数: 表达式,没有名字、只有一行
  • 不能赋值、不能写语句
  • 最常用:sorted(数据, key=lambda x: 依据)
  • 递归 = 终止条件 + 自己调用自己(规模要变小)
  • 递归有深度限制,能用循环就用循环

类与对象

  • 类 = 模板,对象 = 实例
  • class 类名:,类名首字母大写
  • __init__(self, …) 创建对象时自动执行,用来存属性
  • 方法的第一个参数必须是 self
  • 访问:对象.属性、对象.方法()
  • 同一个类造出的对象互相独立

一句话主线

  • 主程序应该只看见"做什么",看不见"怎么做"
  • 能用名字复用的逻辑 → 写成函数
  • 数据和处理数据的方法总是一起出现 → 写成类
  • 参数是接口,返回值是结果,作用域是边界
  • AI 里的前向计算、权重、超参数、模型对象,都从这里长出来

二、易错清单

现象原因怎么改
调用结果打印出来是 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 递归没有终止条件,或数据规模没有缩小 补终止条件;大批量数据处理改用循环

三、课后作业(四个题,都要"写成函数或类")

本章作业

  1. 素数判断:写 is_prime(n),输出 2~50 的所有素数。
  2. 成绩统计:写 stat(scores) 返回平均分与及格率(两个返回值),主程序读入成绩并输出。
  3. 词频统计:写 word_rank(text, top=3),用 lambda 排序,输出出现次数最多的前几名。
  4. 给圆类加方法:为 MyCircle 增加 set_r() 和 bigger_than()。

提交要求:每题给出代码 + 运行结果截图;函数 / 类要有文档字符串;变量名要能读懂(不要用 a、b、c 一路到底)。

四、下讲预告

第 6 次课 · 第 6 章 文件与目录操作
文件与编码 · 打开与关闭 · 读写与文件指针 · CSV 文件读写 · 目录常用操作 · 综合应用 · AI 语料文件(50 余段实测代码 + 20 张插图 + 12 个动态演示图 + 6 个交互面板)
进入第 6 次课 →
本章自测(不查资料,先自己在纸上写)
  1. 写一个函数 max3(a, b, c) 返回三个数中的最大值,并说出它有几个形参、怎么调用。
  2. 下面两种调用有什么区别:f(3, 5) 和 f(y=5, x=3)?
  3. 为什么函数里 print(x) 之后又写 x = 3 会报 UnboundLocalError?
  4. 用一行 lambda 写出"按绝对值排序":sorted(data, key=_____)。
  5. __init__ 什么时候被执行?self 到底指什么?