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 时函数立刻结束

# 判断 num 是不是奇数
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()  # 接收所有返回值
_, b = get_point()     # 忽略 x，只接收 y

（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

# result = is_odd((add(5, 5)))

（2）嵌套调用

函数内部调用其他函数（包括自身）。每次函数调用，都会在调用栈里新增一个元素，称为栈帧。在调试状态下，可以看到函数调用栈和各自栈帧中的局部变量。

（3）递归调用

递归是嵌套调用的特殊情况，核心是'有结束条件 + 每次逼近结束条件'，否则会无限递归导致 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 函数核心小结

掌握 3 点，搞定 Python 函数：

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

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

当需要存储多个数据（比如 10 个学生的成绩，20 个城市名）时，单独定义多个变量不现实，此时就需要列表（list）和元组（tuple）——它们是 Python 中最常用的'序列类型'，专门用来批量存储数据。

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

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

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

（1）创建列表

两种核心方式，推荐用 [ ]（更简洁）。

# 1. 直接使用字面值来创建
a = []
print(type(a))

# 2. 使用 list() 来创建
b = list()
print(type(b))

# 3. 可以在创建列表的时候，在[]中指定列表的初始值
a = [1, 2, 3, 4]
print(a)

# 4. 可以在同一个列表里放不同类型的变量
a = [1, 'hello', True, [4, 5, 6]]
print(a)

⚠️ 注意：不要用 list 作为变量名（会覆盖内置函数 list()），建议命名为 list1、alist 等。

（2）列表的核心操作

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

下标访问：

a = [1, 2, 3, 4]
print(a[2])      # 3
print(a[-1])     # 4 (倒数第一个元素)
print(len(a))    # 4

循环遍历：

# 1. 使用 for 循环来遍历列表
for elem in a:
    print(elem)

# 2. 使用 while 循环，通过下标遍历这个列表
i = 0
while i < len(a):
    print(a[i])
    i += 1

增删查改 && 连接等：

# 1. 使用 append 往列表末尾新增一个元素
a = [1, 2, 3, 4]
a.append(5)
print(a)

# 2. 还可以使用 insert 方法，往列表的任意位置来新增元素
a.insert(1, "hello")
print(a)

# 3. 使用 pop 删除列表中的最末尾的元素
a.pop()
print(a)

# 4. 使用 remove 方法，可以按照值来进行删除
a = ["aa", "bb", "cc"]
a.remove("cc")
print(a)

# 5. 使用 extend 来进行拼接
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a)  # [1, 2, 3, 4, 5, 6]

（3）切片操作的灵活用法

切片是列表的'灵魂操作'，支持省略边界、指定步长（正数从左到右，负数从右到左）。

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

# 1. 基本使用（左闭右开区间）
print(a[1:3])  # [2, 3]

# 2. 省略边界
print(a[1:])   # 从索引 1 到最后
print(a[:2])   # 从头到索引 2
print(a[:-1])  # 排除最后一个
print(a[:])    # 整个列表的拷贝

# 3. 带有步长的切片操作
print(a[::2])  # 每隔一个取一个
print(a[1:-1:2])  # 从 1 到倒数第二个，步长为 2

# 4. 步长为负数，从后往前取
print(a[::-1])  # 反转列表

# 5. 超出有效下标之后，不会出现异常，而是尽可能获取符合要求的元素
print(a[1:100])

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

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

（1）创建元组

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

# 1. 创建元组
a = ()
print(type(a))
b = tuple()
print(type(b))

# 2. 创建元组的时候，指定初始值
a = (1, 2, 3, 4)
print(a)

# 3. 元组中的元素也可以是任意类型的
a = (1, 2, 'hello', True, [])
print(a)

（2）元组的核心操作

• 支持的操作（和列表一致）：访问下标、切片、遍历、in 判断、index 查找、+ 拼接；
• 不支持的操作（因为不可变）：修改元素、append/insert/pop/remove/extend。

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

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

# 判断元素是否存在
print(3 in a)     # True
print(a.index(3)) # 2

# 拼接
b = (4, 5, 6)
print(a + b)      # (1, 2, 3, 4, 4, 5, 6)

# 多元赋值本质上是按照元组的方式进行的
def get_point():
    x = 10
    y = 20
    return x, y

x, y = get_point()
print(type(get_point()))  # <class 'tuple'>

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

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

2.3 列表和元组小结

列表和元组都是日常开发中最常用到的类型，最核心的操作就是根据 [ ] 来按下标操作。如果元素不需要改变，则优先考虑元组；如果元素需要改变，则优先考虑列表。

结尾

掌握函数、列表与元组，意味着你掌握了 Python 编程的基石。函数让逻辑清晰可复用，列表与元组让数据处理更高效。在实际项目中，合理选择可变与不可变容器，不仅能提升代码健壮性，还能避免许多潜在的 Bug。希望这些内容能帮你打通学习中的卡点，在 Python 之路上走得更稳。