• 命名规则：
  • 由字母（AZ, az）、数字（0~9）和下划线（_）组成。
  • 不能以数字开头。
  • 区分大小写（如 Name 和 name 不同）。
  • 不能与保留字（关键字）重名。
• 命名规范（PEP 8 建议）：
  • 变量名、函数名、方法名：全小写，单词间用下划线分隔（如 my_var）。
  • 类名：首字母大写（驼峰命名法，如 MyClass）。
  • 常量名：全大写，单词间用下划线分隔（如 MAX_SIZE）。
• 合法性检查：可通过 str.isidentifier() 方法判断一个字符串是否为合法标识符。

2. 保留字（关键字）

• Python 保留字不能用作标识符，否则会引发语法错误。
• 保留字列表如下（不同版本略有增减，以实际环境为准）：

  1	False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield, match, case

• 可通过 import keyword; print(keyword.kwlist) 查看当前环境的所有关键字。

3. 常量和变量

• 常量：在程序运行过程中值保持不变的量。
  • 字面常量：直接写出的值，如 123、"hello"、3.14。
  • 命名常量：通常用全大写变量名表示（约定，非强制），如 PI = 3.14159。
• 变量：通过赋值语句动态绑定数据类型和值。
  • 赋值格式：变量名 = 表达式（如 x = 10）。
  • 支持链式赋值：a = b = c = 0。
  • 支持增量赋值（增强赋值运算符，见 5.3 节）。
• 动态类型：变量无需显式声明类型，可随时指向不同类型对象（如 x = 5 后 x = "text" 是合法的）。

4. 基本数据类型

4.1 数字型 (Numeric)

4.1.1 整数型 (int)

• 任意大小的整数（仅受内存限制）。
• 支持多种进制表示：
  • 十进制：123, -456
  • 二进制：0b1010（前缀 0b 或 0B）
  • 八进制：0o177（前缀 0o 或 0O）
  • 十六进制：0x1F（前缀 0x 或 0X）
• 进制转换函数：bin()、oct()、hex() 分别返回二进制、八进制、十六进制字符串。

4.1.2 浮点数型 (float)

• 双精度浮点数（遵循 IEEE 754 标准），精度约为 15~17 位有效数字。
• 支持科学计数法：1.23e-4 表示 0.000123。
• 注意：浮点数运算可能存在精度误差（如 0.1 + 0.2 != 0.3），可借助 decimal 模块进行精确计算。

4.1.3 复数型 (complex)

• 形式：a + bj 或 a + bJ，其中 a 为实部，b 为虚部（均为浮点数）。
• 可通过 real 和 imag 属性获取实部和虚部（均为 float 类型）。
• 示例：

  1 2 3

  c = 3.1 + 4j print(c.real) # 输出 3.1 print(c.imag) # 输出 4.0

4.2 字符串型 (str)

• 用单引号（'...'）、双引号（"..."）或三引号（'''...''' 或 """..."""）括起来的字符序列。
• 三引号可用于多行字符串，保留换行格式。
• 转义字符：如 \n（换行）、\t（制表符）、\\（反斜杠）、\'（单引号）、\"（双引号）等。
• 原始字符串：在引号前加 r（如 r'C:\Users'），转义字符不生效，常用于文件路径和正则表达式。
• 字符串是不可变序列：不能通过下标修改单个字符，只能生成新字符串。

4.3 布尔型 (bool)

• 只有两个值：True 和 False（注意首字母大写）。
• 布尔值实际上是 int 的子类，True 对应整数 1，False 对应 0，可参与算术运算（但通常不推荐）。
• 在条件判断中，以下值会被视为 False：None、False、数值零（0, 0.0, 0j）、空序列（"", [], (), {}, set()）等。

4.4 type() 函数与类型检查

• type(obj) 返回对象 obj 的数据类型（如 <class 'int'>）。
• 更推荐使用 isinstance(obj, type) 进行类型检查，因其支持继承关系。

  1 2	isinstance(3.14, float) # True isinstance(True, int) # True（因为 bool 是 int 的子类）

4.5 数据类型转换（显式转换）

• 常用转换函数：
  • int(x)：将 x 转换为整数（支持字符串、浮点数等）。
  • float(x)：转换为浮点数。
  • str(x)：转换为字符串。
  • bool(x)：转换为布尔值。
  • complex(real[, imag])：创建复数。
• 注意：
  • 浮点数转整数时直接截断小数部分（非四舍五入）。
  • 字符串转数字时，字符串必须符合数字字面量格式。int("123") 合法，int("12.3") 会抛出 ValueError，int("abc") 同样报错。
• 隐式类型转换：混合类型运算时，Python 自动提升为更高级类型（如 int + float → float）。

字符编码相关函数：chr(x) 返回 Unicode 编码 x 对应的单字符；ord(x) 返回单字符 x 的 Unicode 编码（整数）。二者互为逆操作。

5. 运算符

5.1 基本算术运算符

注意：/ 和 // 的区别；取余结果的符号由除数决定。

5.2 字符串运算符

• +：字符串拼接，例如 "Hello" + " " + "World" → "Hello World"。
• *：重复复制，例如 "Hi" * 3 → "HiHiHi"。
• in / not in：成员判断，检查子串是否存在于字符串中，返回布尔值。
• 字符串也支持 ==、!=、>、<、>=、<= 等比较运算符，按字典序（Unicode码点）逐字符比较。

5.3 赋值运算符与增强赋值运算符

• 基本赋值：=。
• 增强赋值（将算术运算与赋值结合）：
  +=、-=、*=、/=、//=、%=、**=。
• 示例：x += 3 等价于 x = x + 3。
• 增强赋值会原地修改可变对象（如列表），但对不可变对象（如数字、字符串）会创建新对象。

5.4 关系运算符（比较运算符）

• 包括：==（等于）、!=（不等于）、>、<、>=、<=。
• 返回布尔值 True 或 False。
• 支持链式比较：a < b <= c 等价于 a < b and b <= c，代码更简洁。
• 不同类型之间比较时，Python 会尝试进行合理比较（如数字与数字），否则可能引发 TypeError。

5.5 逻辑运算符

• and、or、not。
• 操作数不限于布尔值，Python 会将其隐式转换为布尔值进行判断，但返回的是最后一个被求值的操作数（短路求值）。
  • x and y：若 x 为假则返回 x，否则返回 y。
  • x or y：若 x 为真则返回 x，否则返回 y。
  • not x：返回布尔值，始终为 True 或 False。
• 优先级：not > and > or（可用括号调整）。

5.6 运算符优先级（从高到低简要）

1. 圆括号 ()
2. 幂运算 **
3. 正负号 +x, -x
4. 乘除、取余、整除 *, /, //, %
5. 加减 +, -
6. 比较运算符 ==, !=, >, <, >=, <=
7. 逻辑非 not
8. 逻辑与 and
9. 逻辑或 or
10. 赋值运算符（最低）

建议在复杂表达式中使用括号增强可读性，避免依赖优先级记忆。

6. input() 函数的使用

• 功能：从标准输入读取一行文本，以字符串形式返回（不包含末尾换行符）。
• 语法：input([提示信息])，提示信息为可选字符串。
• 重要：input() 始终返回字符串类型，即使输入数字。
• 类型转换：
  • 安全做法：使用 int()、float() 等显式转换，并配合 try-except 处理无效输入。
  • 示例：

    1 2 3 4 5 6

    try: a = float(input("第一个数：")) b = float(input("第二个数：")) print(a + b) except ValueError: print("请输入有效数字！")

  • 不建议使用 eval(input())，因为 eval() 会执行任意表达式，存在安全风险（用户可输入恶意代码）。
• 多个输入可结合 split() 处理，例如 x, y = map(int, input().split())。

7. 输出不换行（print() 的 end 参数）

• print() 函数默认以换行符 \n 结尾。
• 通过 end 参数自定义结尾字符。
• 示例：

  1 2 3

  print("111", end="") # 结尾为空字符串 print("222", end="") # 输出：111222（无换行） print("333", end=" ") # 输出：333 （末尾加空格，不换行）

• sep 参数：控制多个输出项之间的分隔符，默认为空格。

  1	print("a", "b", "c", sep="-") # 输出：a-b-c

• 函数是一段具有特定功能的、可重用的语句组，是一种功能的抽象。
• 用函数名来表示并通过函数名进行完成功能调用。
• 两个作用：降低编程难度和代码复用。
• Python定义一个函数语法形式：

1
2
3

def <函数名>(<参数列表>):
    <函数体>
    return <返回值列表>

• 注意：函数体相对于 def 关键字必须缩进（通常为 4 个空格或 1 个 Tab），这是 Python 语法的强制要求。
• 即便函数没有参数，括号也不能省略，如 def func():。
• 函数定义时参数列表中的变量称为形参，函数体中的代码不会立即执行，只有在函数被调用时才会运行。

2、函数的调用

• 调用程序在 调用处 暂停执行；
• 在调用时将 实参复制 给函数的 形参；
• 执行 函数体语句；
• 函数执行结束给出返回值，程序回到调用前的 暂停处 继续执行。

调用方式：直接使用 函数名(实参列表) 即可，如 result = add(3, 5)。在调用之前，函数必须已经被定义。

3、lambda函数（匿名函数）

• 一种特殊的函数——匿名函数，又称 lambda 函数；
• 匿名函数并非没有名字，而是将函数名作为函数结果返回；
• lambda 函数用于定义简单的、能够在一行内表示的函数；
• 定义形式：<函数名> = lambda <参数列表> : <表达式>

1
2

f = lambda x, y: x + y
print(f(3, 5))   # 输出 8

• 二级考试常考结合：lambda 常作为 sort()、sorted()、map()、filter() 等高阶函数的参数使用。

1
2
3
4

# 按元组第二个元素排序
pairs = [(1, 'one'), (3, 'three'), (2, 'two')]
pairs.sort(key=lambda pair: pair[1])
print(pairs)  # 按字母顺序排序

4、函数参数的传递

4.1、基本概念：形参与实参

• 形参：函数定义时函数头中所包含的参数，类似于占位符，本身并不是拥有值的变量。
• 实参：函数调用时所使用的实际参数。
• 传递机制：只有当函数被调用时，调用者将实参的值传递给形参，形参才具有值。

4.2、可选参数和可变数量参数

1. 可选参数（默认参数）

• 在定义函数时，允许某些参数存在默认值，调用时若未传入该参数，则使用默认值。
• 示例：

  1 2 3 4 5 6 7 8

  def dup(str, times=2): print(str * times) >>> dup("knock~") # 未传 times，使用默认值 2 knock~knock~ >>> dup("knock~", 4) # 传入 times=4，覆盖默认值 knock~knock~knock~knock~

• ⚠️ 重要规则：如果函数中混用默认值参数和非默认值参数，则非默认值参数必须定义在默认值参数之前。即 def func(a, b=1): 合法，def func(a=1, b): 非法。

2. 可变数量参数

• 指在函数定义时可以使用个数不确定的参数，使得同一函数可以接受不同数量的实参。
• 定义方式：在参数前增加星号（*）来指定该参数为可变数量参数。
• 特性：传入的多个实参会自动打包成一个元组（tuple） 类型。
• 示例：

  1 2 3 4 5 6 7 8

  def vfunc(a, *b): print(type(b)) # <class 'tuple'> for n in b: a += n return a >>> vfunc(1, 2, 3, 4, 5) 15 # 返回 1+2+3+4+5 的结果

• 双星号（**）可变参数：接收关键字参数，打包成字典（dict），形如 def func(**kwargs):，二级考试偶有出现，了解即可。

4.3、参数的位置和名称传递

1. 位置传递（默认方式）

• 实参默认按照位置顺序一一对应地传递给形参。
• 示例：调用 dup("knock~", 4) 时，第一个实参 "knock~" 默认赋值给形参 str，第二个实参 4 赋值给形参 times。

2. 名称传递（关键字传递）

• 调用函数时，通过指定参数名称来传递实参。
• 优点：由于显式指定了形参名，参数之间的顺序可以任意调整，不影响传递结果。
• 调用示例：dup(times=4, str="knock~")，顺序颠倒依然有效。
• ⚠️ 混用规则：位置参数必须在关键字参数之前，如 dup("knock~", times=4) 合法，dup(times=4, "knock~") 非法。

5、函数的返回值

• return 语句用来退出函数，并将程序返回到函数被调用的位置继续执行。
• 可以将 0 个、1 个或多个 结果返回给函数被调用处的变量。
• 当返回多个值时，这些值以 元组（tuple）类型 保存。
• 函数可以没有 return 语句，此时函数并不返回值（相当于返回 None）。
• 执行机制：函数一旦执行到 return 语句，立即结束函数执行，后续代码不再运行。

6、变量作用域（全局变量与局部变量）

• 程序中的变量分为两类：全局变量 和 局部变量。
• 全局变量：在函数之外定义的变量，一般没有缩进，在程序执行全过程有效。
• 局部变量：在函数内部使用的变量，仅在函数内部有效，当函数退出时变量将不存在。

6.1、变量的作用域原则

• 简单数据类型变量（如 int、float、str、bool 等）：无论是否与全局变量重名，在函数内部默认均为 局部变量，仅在函数内部创建和使用，函数退出后变量被释放。
• 若要将简单数据类型变量声明为全局变量，需在函数内部使用 global 保留字显式声明。

  1 2 3 4 5 6

  x = 10 def func(): global x x = 20 func() print(x) # 输出 20（全局变量被修改）

• 组合数据类型变量（如 list、dict、set 等）：
  • 如果在函数内部 没有 被真实创建（即未赋值）的同名变量，则函数内部会将其视为 全局变量，可直接使用并修改其内容（如 append、update 等操作）。
  • 如果在函数内部 真实创建（即赋值）了组合数据类型变量，则无论是否存在同名全局变量，该变量均为 局部变量，函数仅对局部变量进行操作，不影响全局变量。

  1 2 3 4 5 6 7 8 9

  lst = [1, 2, 3] def func1(): lst.append(4) # 未赋值，视为全局变量，修改生效 def func2(): lst = [5, 6] # 赋值了，视为局部变量，全局不受影响 lst.append(7) func1() func2() print(lst) # 输出 [1, 2, 3, 4]

7、递归函数（新增 ⭐ 考纲必考）

• 定义：函数在内部调用自身，称为递归调用。
• 两个必要条件：
  1. 递归基例（终止条件）：明确指定函数在什么情况下不再调用自身，直接返回结果。
  2. 递归链条（递推公式）：将原问题分解为规模更小的子问题，通过调用自身来解决。
• 经典示例 —— 阶乘：

  1 2 3 4 5 6 7

  def factorial(n): if n == 0: # 递归基例 return 1 else: # 递归链条 return n * factorial(n - 1) print(factorial(5)) # 输出 120

• 经典示例 —— 斐波那契数列：

  1 2 3 4 5 6 7

  def fib(n): if n <= 1: # 递归基例 return n else: # 递归链条 return fib(n - 1) + fib(n - 2) print(fib(6)) # 输出 8（第6项为8）

• ⚠️ 易错点：
  • 必须保证递归能在有限次调用后终止，否则会触发 RecursionError（超过递归深度限制）。
  • Python 默认递归深度限制约为 1000，二级考试中递归深度很小，无需担心。
• 常见考题形式：给出递归函数代码，要求填写缺失部分，或写出函数执行结果。

8、高阶函数与函数作为参数（扩展，二级常考）

• Python 中函数也是对象，可以像其他数据类型一样赋值给变量，或作为参数传递给另一个函数。
• map(function, iterable)：将 function 依次作用于 iterable 的每个元素，返回一个迭代器。

  1 2 3

  nums = [1, 2, 3, 4] squared = map(lambda x: x**2, nums) print(list(squared)) # 输出 [1, 4, 9, 16]

• filter(function, iterable)：保留 function 返回 True 的元素，返回一个迭代器。

  1 2 3

  nums = [1, 2, 3, 4, 5, 6] evens = filter(lambda x: x % 2 == 0, nums) print(list(evens)) # 输出 [2, 4, 6]

• sorted(iterable, key=func)：通过 key 指定的函数来提取排序依据。

  1 2 3

  words = ["apple", "banana", "kiwi"] sorted_words = sorted(words, key=lambda w: len(w)) print(sorted_words) # 按长度排序：['kiwi', 'apple', 'banana']

🧾 函数模块速查表

1.1 顺序结构

• 程序按代码的书写顺序从上到下逐条执行，每条语句执行一次（除非被分支或循环改变流程）。

1.2 分支结构（选择结构）

• 通过 if、elif、else 实现多路条件判断。
• 基本语法：

  1 2 3 4 5 6

  if 条件表达式1: 语句块1 elif 条件表达式2: 语句块2 else: 语句块3

• elif 可以有零个或多个，else 最多一个且放在最后。
• 条件表达式的结果会被隐式转换为布尔值（True 或 False）。
• 注意：Python 3.10 之前没有 switch/case 语句，使用 if-elif-else 实现多分支判断。二级考试环境（3.5.3~3.9.10）不支持 match 语句。
• 常见易错点：
  • 不要忘记冒号（:）。
  • 缩进必须严格一致（建议使用 4 个空格，不要混用 Tab 和空格）。
  • 条件中慎用赋值（=），避免误写成比较（==）。

1.3 循环结构

1.3.1 for 循环

• 用于遍历可迭代对象（字符串、列表、元组、字典、range 等）。
• 基本语法：

  1 2	for 变量 in 可迭代对象: 循环体

• 遍历字典时默认遍历键，可通过 .keys()、.values()、.items() 分别获取键、值、键值对。
• 与 range() 结合使用最频繁（见 1.3.4 节）。

1.3.2 while 循环

• 当条件为真时重复执行循环体，直到条件为假。
• 基本语法：

  1 2	while 条件表达式: 循环体

• 注意：必须确保循环条件最终会变为假，否则形成死循环。可在循环体内通过修改条件变量或使用 break 退出。

1.3.3 循环控制语句

• break：立即终止整个循环，跳出循环体。
• continue：跳过本次循环剩余语句，立即进入下一次循环判断。
• else 子句（与循环搭配）：
  • 当循环正常结束（未触发 break）时执行 else 块。
  • 若遇到 break，则跳过 else。
  • 示例：

    1 2 3 4 5 6

    for i in range(3): if i == 1: break print(i) else: print("循环正常结束") # 不会执行，因为 break 了

1.3.4 range() 函数详述

• 生成一个不可变的整数序列，常用于 for 循环。
• 三种调用方式：
  • range(stop)：生成 0 到 stop-1。
  • range(start, stop)：生成 start 到 stop-1。
  • range(start, stop, step)：step 可为正或负（负值表示递减）。
• range 对象是惰性求值的，节省内存。可用 list(range(...)) 转为列表。
• 注意：stop 取值是开区间，不包含 stop 本身。

2. 异常处理 try-except

• 作用：捕获并处理运行时错误，避免程序崩溃，提供更友好的错误提示。

• 基本结构：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  try: # 可能引发异常的代码 except 异常类型1: # 处理异常类型1 except 异常类型2 as e: # 可获取异常对象 # 处理异常类型2 except (TypeError, ValueError): # 多个异常合并处理 # ... except Exception: # 捕获所有异常（谨慎使用） # ... else: # 没有异常发生时执行 finally: # 无论是否发生异常，最后一定会执行（如释放资源）

• 执行流程：

  • 先执行 try 块，若发生异常，则按顺序匹配 except；若匹配成功则执行对应处理块。
  • 若没有匹配的 except，异常继续向上抛出（导致程序终止）。
  • 若 try 块无异常，则执行 else 块（如果存在）。
  • 无论是否异常，最后都会执行 finally 块（常用于关闭文件、释放锁等）。

• 常见内置异常：

  • ValueError：值错误（如 int("abc")）
  • TypeError：类型错误（如 "1" + 2）
  • ZeroDivisionError：除零错误
  • IndexError：索引越界
  • KeyError：字典键不存在
  • FileNotFoundError：文件未找到

• 示例代码：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  try: score = float(input("请输入分数：")) print("你的分数为：", score) result = 1 / 0 except ValueError: print("出现异常！请输入数字！") except ZeroDivisionError: print("出现异常，除数不能为零！") except Exception as e: print(f"未知错误：{e}") else: print("计算成功！") finally: print("无论是否异常，此句都会执行。")

• ⚠️ 捕获异常的规范写法：

  • 优先捕获具体的异常类型（如 ValueError、ZeroDivisionError），而非直接使用 except: 或 except Exception。
  • except: 会捕获包括 SystemExit、KeyboardInterrupt 在内的所有异常，可能掩盖程序终止信号，非特殊情况应避免使用。
  • 如果确实需要捕获所有异常，建议使用 except Exception as e:，至少保留了异常对象的获取能力。