Python 函数、列表与元组核心用法及实战案例
前言
作为 Python 初学者，掌握函数、、是从'写代码'到'写好代码'的关键一步。它们不仅是 Python 语法的核心，更是后续处理复杂数据、构建高效程序的基础。
Python
Python 函数、列表与元组核心用法及实战案例
Python 函数用于代码复用，列表与元组管理批量数据。内容涵盖函数定义、参数传递、返回值、作用域及递归调用；详解列表增删改查、切片操作及元组不可变特性。通过实战案例演示求和、阶乘计算等场景，帮助初学者掌握核心语法。
Python 函数用于代码复用，列表与元组管理批量数据。内容涵盖函数定义、参数传递、返回值、作用域及递归调用；详解列表增删改查、切片操作及元组不可变特性。通过实战案例演示求和、阶乘计算等场景，帮助初学者掌握核心语法。
作为 Python 初学者，掌握函数、、是从'写代码'到'写好代码'的关键一步。它们不仅是 Python 语法的核心，更是后续处理复杂数据、构建高效程序的基础。
写代码最忌讳的就是'复制粘贴'。比如计算不同区间的数列和（1-100、300-400、1-1000），如果不使用函数，需要重复写多组几乎一样的循环代码：
# 1. 计算 1-100 的和
theSum = 0
for i in range(1, 101):
theSum = theSum + i
print(theSum)
# 2. 计算 300-400 的求和
theSum = 0
for i in range(300, 401):
theSum = theSum + i
print(theSum)
# 计算 1-1000 的和
theSum = 0
for i in range(1, 1001):
theSum = theSum + i
print(theSum)
一旦需要修改计算逻辑（比如改成求平方和），所有重复代码都要改，效率极低。而函数的核心作用，就是提取重复代码，实现代码复用，让程序更简洁、更好维护。
简单理解：函数就像一个'工厂'，输入'原材料'（参数），经过内部加工（函数体），输出'产品'（返回值），一次定义，多次调用。
函数版本代码：
# 使用函数的方式来解决刚刚的问题
# 定义一个求和函数
def calc_sum(begin, end):
the_sum = 0
for i in range(begin, end + 1):
the_sum = the_sum + i
print(the_sum)
# 使用函数
# 求 1-100 的和
calc_sum(1, 100)
# 求 300-400 的和
calc_sum(300, 400)
# 求 1-1000 的和
calc_sum(1, 1000)
# 1. 定义函数：def 函数名 (形参列表): 函数体 return 返回值
def calc_sum(beg, end):
# beg、end 是'形式参数'（形参），相当于工厂的'原材料入口'
sum_val = 0
for i in range(beg, end + 1):
sum_val += i
return sum_val
# return 输出结果，相当于工厂的'产品出口'
# 2. 调用函数：函数名 (实参列表)
result1 = calc_sum(1, 100) # 1、100 是'实际参数'（实参），是真正传入的原材料
result2 = calc_sum(300, 400)
print(result1, result2) # 输出：5050 35150
def test(a, b, c):
print(a, b, c)
# 实参个数不能多也不能少，除非形参有默认参数
test(10, 20, 30)
⚠️ 关键注意点：
NameError；TypeError；Python 的函数参数比 C++、Java 更灵活，核心有 3 个特性：
1. 动态类型：形参无需指定类型，一个函数可接收多种类型参数
def print_param(a):
print(a)
print_param(10) # 整数
print_param("hello") # 字符串
print_param(True) # 布尔值（均能正常执行）
def add(x, y):
return x + y
print(add(10, 20))
print(add(1.5, 2.5))
print(add('hello', 'world'))
# print(add(10, 'hello')) # 这个就不行了，不符合函数体内执行逻辑
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}")
# 关键字参数，顺序无关，输出：x = 10, y = 20
test(x=10, y=20)
test(y=100, x=200)
test(100, y=200)
# test(x=100, 200) # 这样写就不行了
返回值是函数的'输出'，核心用法有两点：
1. 一个函数可以有多个 return 语句，执行到 return 时函数立刻结束 (后续代码不执行)
# 一般情况下多个 return 语句是搭配分支语句/循环语句的
# 用来判断 num 是不是奇数
def is_odd(num):
if num % 2 == 0:
return False
else:
return True
print(is_odd(10))
print(is_odd(19))
2. 一次返回多个值：用逗号分隔，接收时用多个变量接收 (无需接收的用 _ 忽略)
# 写一个函数，返回平面上的一个点（横坐标，纵坐标）
def get_point():
x = 10
y = 20
return x, y # 可以返回两个值
# a, b = get_point() # 接收所有返回值
# 如果只想用其中一个可以使用 _ 占位
_, b = get_point() # 忽略 x，只接收 y
变量的作用域决定了'变量能在哪些地方使用'，核心规则：
global 声明；x = 10
def test():
x = 20
print(f'函数内部:{x}')
test()
print(f'函数外部:{x}')
x = 10 # 全局变量在函数里也可以使用
def test():
global x
x = 20
test()
print(f'x = {x}')
def is_odd(num):
if num % 2 == 0:
return False
return True
def add(x, y):
return x + y
# print(is_odd((add(5, 5))))
def test():
print("hello")
test() # 嵌套调用可以有很多层
def a():
num = 10
print("函数 a")
def b():
num = 20
a()
print("函数 b")
def c():
num = 30
b()
print("函数 c")
def d():
num = 40
c()
print("函数 d")
d()
函数之间的调用关系，在 Python 中会使用一个特定的数据结构来表示，称为函数调用栈，每次函数调用，都会在调用栈里新增一个元素，称为栈帧。
思考：上述代码，a,b,c,d 函数中的局部变量名各不相同，如果变量名是相同的，比如都是 num，那么这四个函数中的 num 是属于同一个变量，还是不同变量呢？ – 不同变量
递归是嵌套调用的特殊情况，核心是'有结束条件 + 每次逼近结束条件'，否则会无限递归导致 RecursionError。
案例：递归计算 5 的阶乘 (5! = 5 * 4 * 3 * 2 * 1)
# 写一个函数，来求 n 的阶乘 (n 是正整数)
# n! => n * (n-1)!
# 1! => 1
def factor(n):
if n == 1:
return 1
return n * factor(n - 1)
print(factor(5))
if n == 1 就是结束条件。当 n 为 1 的时候，递归就结束了。⚠️ 注意：递归代码简洁但难理解，易栈溢出，实际开发中优先用循环替代。
掌握 3 点，搞定 Python 函数：
def 函数名 (形参)：函数体 return 返回值；当需要存储多个数据（比如 10 个学生的成绩，20 个城市名）时，单独定义多个变量不现实，此时就需要列表（list）和元组（tuple）—— 它们是 Python 中最常用的'序列类型'，专门用来批量存储数据。
核心区别（一句话记牢）：
列表（list）：可变容器（像'散装辣条'），元素可增删改；元组（tuple）：不可变容器（像'包装辣条'），元素创建后无法修改。两种核心方式，推荐用 [ ] (更简洁)
# 创建列表
# 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 等。
列表的操作都围绕'下标'展开，下标从 0 开始（负数表示倒数，-1 是最后一个元素），核心操作如下：
| 操作目的 | 代码示例 | 说明 |
|---|---|---|
| 访问元素 | list3[2] | 访问下标 2 的元素，下标越界报 IndexError |
| 修改元素 | list3[2] = 100 | 把下标 2 的元素改成 100 |
| 切片（取子列表） | list3[1:3] | 取下标 1 到 3（左闭右开）的元素 |
| 新增元素 | list3.append(5) | 尾插（添加到末尾）；list3.insert(1, "a")（插入到下标 1） |
| 删除元素 | list3.pop() | 删除末尾元素；list3.pop(2)（删除下标 2 元素）；list3.remove(2)（按值删除） |
| 查找元素 | 2 in list3 | 判断元素是否存在（返回布尔值）；list3.index(2)（找下标，不存在报异常） |
| 连接列表 | list3 + list4 | 拼接两个列表（生成新列表）；list3.extend(list4)（拼接到 list3 末尾，修改原列表） |
| 遍历元素 | for elem in list3: | 直接遍历元素（推荐）；也可按下标遍历 |
# 5. 使用下标来访问列表元素
a = [1, 2, 3, 4]
print(a[2]) # 3
# 6. 使用下标来修改列表元素
a = [1, 2, 3, 4]
a[2] = 100
print(a)
# 7. 超出下标有效范围，就会出现异常
# a = [1, 2, 3, 4]
# a[100] = 0
# print(a) # IndexError: list assignment index out of range
# 8. 可以使用内建函数 len 来获取列表的长度 (元素个数),和字符串类似
a = [1, 2, 3, 4]
print(len(a))
# 9. Python 中的下标，其实还可以写成负数!!!
# 例如写成 -1，其实等价于 len(a) - 1
a = [1, 2, 3, 4]
print(a[len(a) - 1]) # -1 就是倒数第一个元素
print(a[-1])
# 1. 使用 for 循环来遍历列表
# 不会改变原来的数组
# a = [1, 2, 3, 4, 5]
# for elem in a:
# elem = elem + 10
# print(elem)
# print(a)
# 2. 使用 for 循环遍历，通过下标的方式
# 会改变原来的数组
# a = [1, 2, 3, 4, 5]
# for i in range(0, len(a)):
# a[i] = a[i] + 10
# print(a)
# 3. 使用 while 循环，通过下标遍历这个列表
a = [1, 2, 3, 4, 5]
i = 0
while i < len(a):
print(a[i])
i += 1
# 1. 使用 append 往列表末尾新增一个元素
# a = [1, 2, 3, 4]
# a.append(5)
# a.append("hello")
# print(a)
# 2. 还可以使用 insert 方法，往列表的任意位置来新增元素
a = [1, 2, 3, 4]
a.insert(1, "hello")
a.insert(100, "hello") # 会在最后插入一个 hello
print(a)
# 1. 使用 in 来判定某个元素是否在列表中存在
# a = [1, 2, 3, 4]
# print(1 in a)
# print(1 not in a)
# 2. 使用 index 方法，来判定当前元素在列表中的位置，得到一个下标
a = [1, 2, 3, 4]
print(a.index(2))
print(a.index(3))
# print(a.index(10)) # 会报错
# 1. 使用 pop 删除列表中的最末尾的元素
a = [1, 2, 3, 4]
a.pop()
print(a)
# 2. 使用 pop 还能删除任意位置的元素，pop 的参数
a = [1, 2, 3, 4]
a.pop(1)
print(a)
# 3. 使用 remove 方法，可以按照值来进行删除
a = ["aa", "bb", "cc", "dd"]
a.remove("cc")
print(a)
# 1. 使用 + 针对两个列表进行拼接
# a = [1, 2, 3, 4]
# b = [5, 6, 7, 8]
# c = b + a
# print(c)
# 2. 使用 extend 来进行拼接
# 这个拼接是把后一个列表的内容拼接到前一个列表里头
# a = [1, 2, 3, 4]
# b = [5, 6, 7, 8]
# c = a.extend(b) # extend 不返回任何内容
# a.extend(b)
# print(a) # a 这里改变了
# print(b)
# 3. 使用 += 来进行拼接
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
a += b # a = a + b
print(a)
print(b)
切片是列表的'灵魂操作'，支持省略边界、指定步长（正数从左到右，负数从右到左）：
# 1. 切片操作的基本使用
a = [1, 2, 3, 4]
# 左闭右开区间
print(a[1:3])
# 2. 使用切片的时候，可以省略边界
a = [1, 2, 3, 4]
# 省略右边界，意思是从指定的开始位置，一直取到整个列表结束
print(a[1:])
# 省略左边界，意思是从列表的 0 号元素开始取，一直取到指定的结束位置
print(a[:2])
# 此处切边中的下标也可以写成负数
print(a[:-1])
# 还可以把开始边界和结束边界都省掉，得到的就还是列表本身
print(a[:])
# 3. 带有步长的切片操作
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[::1])
print(a[::2])
print(a[::3])
print(a[1:-1:2])
# 4. 步长的数值还可以是负数，当步长为负数的时候，意思是从后往前来取元素
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[::-1])
print(a[::-2])
# 5. 当切片中的范围超出有效下标之后，不会出现异常!,而是尽可能的把符合要求的元素给获取到
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[1:100])
元组的用法和列表几乎一致，但核心区别是'不可变'(元素无法增删改)，适合存储不需要修改的数据 (比如身份证号，坐标)。
用()表示，空元组用()或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)
append/insert/pop/remove/extend# 4. 通过下标来访问元组中的元素，下标也是从 0 开始，到 len - 1 结束
a = (1, 2, 3, 4)
print(a[1])
print(a[-1])
# print(a[100]) # 错误
# 5. 通过切片来获取元组的一部分
a = [1, 2, 3, 4]
print(a[1:3])
# 6. 也同样可以使用 for 循环等方式来进行遍历元素
a = (1, 2, 3, 4)
for elem in a:
print(elem)
# 7. 可以使用 in 来判断元素是否存在，使用 index 查找元素的下标
a = (1, 2, 3, 4)
print(3 in a)
print(a.index(3))
# 8. 可以使用 + 来拼接两个元组
a = (1, 2, 3)
b = (4, 5, 6)
print(a + b)
# 9. 元组只支持'读'操作，不能支持'修改'操作
a = (1, 2, 3, 4)
# 不支持以下修改的操作
# a[0] = 100
# a.append(5)
# a.pop()
# a.extend()
# 10. 当进行多元赋值的时候，其实本质上是按照元组的方式来进行工作的
def get_point():
x = 10
y = 20
return x, y
x, y = get_point()
print(type(get_point()))
| 特性 | 列表（list） | 元组（tuple） |
|---|---|---|
| 定义方式 | [] 或 list() | () 或 tuple() |
| 是否可变 | 可变（增删改） | 不可变（无增删改） |
| 适用场景 | 需频繁修改数据（比如学生成绩） | 数据无需修改（比如身份证号） |
| 核心操作 | 支持所有序列操作 + 增删改 | 仅支持读操作，无写操作 |
[ ] 来按下标操作。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online