Python 核心基础：函数、列表与元组实战指南

⚠️ 关键注意点：

• 函数必须先定义，再调用，否则会报 NameError；
• 定义时不会执行函数体，只有调用时才执行；
• 形参和实参的个数必须匹配，否则报 TypeError。

（2）参数的灵活用法

Python 的函数参数比 C++、Java 更灵活，核心有 3 个特性：

1. 动态类型：形参无需指定类型，一个函数可接收多种类型参数。

def print_param(a):
    print(a)

print_param(10)       # 整数
print_param("hello")  # 字符串
print_param(True)     # 布尔值

2. 默认参数：给形参设置默认值，调用时可省略该参数（默认值参数必须在无默认值参数后面）。

def add(x, y, debug=False):
    if debug:
        print(f"调试：x={x}, y={y}")
    return x + y

print(add(10, 20))          # 省略 debug，使用默认值 False
print(add(10, 20, True))    # 显式传参

3. 关键字参数：调用时显示指定'实参对应哪个形参'，可打乱传参顺序。

def test(x, y):
    print(f"x = {x}")
    print(f"y = {y}")

test(x=10, y=20)   # 顺序无关
test(y=100, x=200) 

（3）返回值

1. 多个 return 语句：执行到 return 时函数立刻结束。

def is_odd(num):
    if num % 2 == 0:
        return False
    else:
        return True

print(is_odd(10))  # False
print(is_odd(19))  # True

2. 返回多个值：用逗号分隔，接收时用多个变量接收。

def get_point():
    x = 10
    y = 20
    return x, y  # 返回两个值

a, b = get_point()      # 接收所有
_, c = get_point()      # 忽略 x，只接收 y

（4）变量作用域

• 局部变量：函数内部定义，仅在函数内生效；
• 全局变量：函数外部定义，函数内可访问，但修改时需声明 global；
• 同名变量：不同作用域可存在同名变量，互不影响。

x = 10

def test():
    global x
    x = 20

test()
print(x)  # 20

1.3 进阶用法：嵌套与递归

（1）链式调用：把一个函数的返回值，作为另一个函数的参数。

def is_odd(num):
    return num % 2 != 0

def add(x, y):
    return x + y

# 直接嵌套调用
print(is_odd(add(5, 5)))

（2）嵌套调用：函数内部调用其他函数。每次调用都会在调用栈里新增一个元素（栈帧）。

def a():
    num = 10
    print("函数 a")

def b():
    num = 20
    a()
    print("函数 b")

def c():
    num = 30
    b()
    print("函数 c")

c()

思考：上述代码中，如果变量名都是 num，它们是同一个变量吗？不是，不同作用域的局部变量互不影响。

（3）递归调用：函数调用自身。核心是'有结束条件 + 每次逼近结束条件'，否则会导致 RecursionError。

def factor(n):
    if n == 1:  # 结束条件
        return 1
    return n * factor(n - 1)  # 递归调用

print(factor(5))  # 120

⚠️ 注意：递归代码简洁但难理解，易栈溢出，实际开发中优先用循环替代。

1.4 函数小结

• 定义：def 函数名 (形参): 函数体 return 返回值；
• 调用：支持默认值、关键字参数；
• 核心价值：复用代码，拆分逻辑，便于维护。

二、列表和元组：批量存储数据的容器

当需要存储多个数据时，单独定义多个变量不现实，此时就需要列表（list）和元组（tuple）。

核心区别：

• 列表（list）：可变容器，元素可增删改；
• 元组（tuple）：不可变容器，元素创建后无法修改。

2.1 列表（list）：最常用的可变容器

（1）创建列表

# 字面值创建
a = [1, 2, 3, 4]

# 使用 list() 创建
b = list([1, 2])

# 混合类型
c = [1, 'hello', True, [4, 5]]

⚠️ 注意：不要用 list 作为变量名，这会覆盖内置函数。

（2）核心操作

列表的操作都围绕'下标'展开，下标从 0 开始（负数表示倒数）。

# 下标访问与修改
a = [1, 2, 3, 4]
print(a[-1])      # 4
a[2] = 100

# 切片操作
print(a[1:3])     # [2, 100]
print(a[::-1])    # 反转列表

# 增删查改
a.append(5)
a.pop(1)
if 100 in a:
    print("存在")

2.2 元组（tuple）：不可变的序列容器

元组的用法和列表几乎一致，但核心区别是'不可变'。适合存储不需要修改的数据（如身份证号、坐标）。

# 创建元组
a = (1, 2, 3)
b = ()  # 空元组
c = (1,)  # 单元素元组需加逗号

# 支持读操作
print(a[0])
print(a[1:3])

# 不支持写操作
# a[0] = 100  # TypeError
# a.append(4) # AttributeError

为什么有了列表，还需要元组？

1. 安全性：传递数据时，用元组可避免数据被意外修改；
2. 字典键：字典的键必须是'可哈希对象'（不可变类型），元组可以，列表不行。

2.3 列表与元组对比

• 日常开发中，如果元素不需要改变，优先考虑元组；如果需要改变，则优先考虑列表。

结语

掌握函数、列表和元组，就掌握了 Python 数据处理的基础。函数让逻辑复用，列表提供灵活的存储，元组保障数据安全。在实际项目中，根据数据是否需要修改来选择合适的容器，能让代码更健壮、更高效。