Python 函数、列表与元组核心用法及实战

（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 语句，执行到 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()
# 忽略 x，只接收 y
_, b = get_point()

（4）变量作用域

变量的作用域决定了'变量能在哪些地方使用'。

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

x = 10

def test():
    global x
    x = 20

test()
print(f"x = {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）递归调用

递归是嵌套调用的特殊情况，核心是'有结束条件 + 每次逼近结束条件'，否则会无限递归导致 RecursionError。

案例：递归计算 5 的阶乘 (5! = 5 * 4 * 3 * 2 * 1)。

def factor(n):
    if n == 1:
        return 1
    return n * factor(n - 1)

print(factor(5))  # 120

务必存在递归结束条件，且每次递归时实参要逐渐逼近结束条件。注意：递归代码简洁但难理解，易栈溢出，实际开发中优先用循环替代。

1.4 函数核心小结

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

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

当需要存储多个数据时，单独定义多个变量不现实，此时就需要列表（list）和元组（tuple）。它们是 Python 中最常用的'序列类型'。

核心区别（一句话记牢）：

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

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

（1）创建列表

推荐用 [ ]，更简洁。

# 空列表
a = []
b = list()

# 指定初始值
a = [1, 2, 3, 4]

# 不同类型混合
a = [1, 'hello', True, [4, 5, 6]]

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

（2）列表的核心操作

列表的操作都围绕'下标'展开，下标从 0 开始（负数表示倒数，-1 是最后一个元素）。

下标访问与遍历：

a = [1, 2, 3, 4]
print(a[-1])  # 4
print(len(a)) # 4

# 遍历
for elem in a:
    print(elem)

切片操作的灵活用法：

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[::1])   # 步长为 1
print(a[::-1])  # 步长为 -1，反转列表
print(a[1:-1:2])# 从第 2 个到倒数第 2 个，步长 2

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

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

（1）创建元组

用 () 表示，单个元素的元组要加逗号（避免被当作普通括号）。

a = ()
b = tuple()
a = (1, 2, 3, 4)
a = (1,)  # 单元素元组

（2）元组的核心操作

• 支持的操作：访问下标、切片、遍历、in 判断、index 查找、+ 拼接；
• 不支持的操作：修改元素、append/insert/pop/remove/extend。

a = (1, 2, 3, 4)
print(a[1])
print(a.index(3))
# a[0] = 100  # 报错：TypeError

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

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

2.3 列表与元组小结

在需要表示一个'序列'的场景下，就可以考虑使用列表和元组。如果元素不需要改变，则优先考虑元组；如果元素需要改变，则优先考虑列表。