Python从函数、列表到字典和文件操作大全

前言

刚开始学 Python 的朋友，最容易卡住的地方往往不是“语法有多难”，而是“知识点太散”。

函数、列表、元组、字典、文件操作——这些东西每一个单独拎出来都不复杂。可要是没有一条清晰的主线把它们串起来，学完之后很可能只记住了几个零散的写法，真正要写代码的时候，还是不知道该怎么组织程序。

这篇文章打算把 Python 中几个非常核心的基础语法串成一条线：

• 函数：如何把重复代码封装起来
• 参数和返回值：函数如何接收数据、返回结果
• 变量作用域：为什么函数里面的变量外面不能直接用
• 递归：函数调用自己的特殊情况
• 列表和元组：如何保存一组数据
• 字典：如何保存“键值对”数据
• 文件操作：如何把数据保存到硬盘里

准备好了吗？咱们开始。

一、函数：把重复代码封装起来

在没有函数之前，如果想分别求：

• 1 到 100 的和
• 300 到 400 的和
• 1 到 1000 的和

大概率会写成这样：

# 求 1 到 100 的和
total = 0
for i in range(1, 101):
    total += i
print(total)
# 求 300 到 400 的和
total = 0
for i in range(300, 401):
    total += i
print(total)
# 求 1 到 1000 的和
total = 0
for i in range(1, 1001):
    total += i
print(total)

这段代码能跑，但问题肉眼可见：重复内容太多了。

真正写项目的时候，复制粘贴从来都不是好习惯。因为一旦重复代码里有一个地方需要修改，你可能要改十几处甚至几十处，一不留神就漏掉。

这时候就该把重复逻辑封装成函数：

def calc_sum(beg, end):
    total = 0
    for i in range(beg, end + 1):
        total += i
    return total
print(calc_sum(1, 100))
print(calc_sum(300, 400))
print(calc_sum(1, 1000))

函数的作用是什么？简单来说：把你想要反复使用的代码段起个名字，以后需要的时候直接点名调用它。

Python 中定义函数的基本格式是：

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

比如：

def say_hello():
    print("hello")
say_hello()

这里需要特别注意一点：函数定义本身不会执行函数体，只有调用函数时才会真正执行。很多人一开始会误会这一点。

def test():
    print("函数被执行了")
# 这里只是定义函数，不会打印任何内容
test()  # 调用函数，才会真正执行

二、函数参数：让函数处理不同的数据

如果函数只能处理固定数据，那它的作用就比较有限了。参数的意义就在于：让同一个函数可以处理不同的数据。

继续看前面那个 calc_sum：

def calc_sum(beg, end):
    total = 0
    for i in range(beg, end + 1):
        total += i
    return total

这里的 beg 和 end 就是形参——函数定义时写在括号里的占位符。

调用函数时传进去的具体值叫实参：

result = calc_sum(1, 100)
print(result)

在这次调用中，发生的事情是：

beg = 1
end = 100

再看另一次调用：

result = calc_sum(300, 400)
print(result)

这次就是：

beg = 300
end = 400

所以函数参数本质上就是一种“外部给函数传数据”的方式。你给不同的值，它就算出不同的结果。

1. 参数个数要匹配

函数定义时需要几个参数，调用时就应该传几个参数。

def add(x, y):
    return x + y
print(add(10, 20))

如果少传参数：

print(add(10))

程序会直接报错——Python 不知道 y 该是多少。

2. Python 的参数不需要写类型

和 C/C++、Ja va 不同，Python 是动态类型语言。定义函数时，参数名旁边通常不用写类型。

def show(value):
    print(value)
show(10)
show("hello")
show(True)

这段代码都没问题，都能运行。

不过这也带来了一个隐忧：函数更灵活了，但你自己要清楚这个函数“期望接收什么类型的数据”。否则写着写着就可能传错数据，而 Python 直到运行时才会告诉你“类型不对”。

三、函数返回值：把结果交还给调用者

函数的参数可以看成输入，返回值可以看成输出。

比如下面这个版本：

def calc_sum(beg, end):
    total = 0
    for i in range(beg, end + 1):
        total += i
    print(total)

它能打印结果，但它把“计算”和“输出”死死绑在了一起。在实际开发中，这不够灵活——我们写代码的时候，最好的守则是“低耦合，高内聚”。

因此更推荐写成：

def calc_sum(beg, end):
    total = 0
    for i in range(beg, end + 1):
        total += i
    return total
result = calc_sum(1, 100)
print(result)

这样函数只负责计算，至于结果是打印到控制台、写入文件，还是显示到网页上，都由调用者决定。

这就引出一个很重要的编程习惯：

计算逻辑和用户交互尽量分开。

1. return 会结束函数

函数执行到 return 后，会立即结束，后面的代码不会继续执行。

def is_odd(num):
    if num % 2 == 0:
        return False
    return True
print(is_odd(10))
print(is_odd(11))

当 num 是偶数时，执行到 return False，函数就结束了，后面的 return True 不会被执行。

2. Python 可以返回多个值

Python 的函数可以一次返回多个值：

def get_point():
    x = 10
    y = 20
    return x, y
a, b = get_point()
print(a, b)

输出：

10 20

如果你只关心其中一部分返回值，可以用 _ 忽略不需要的值：

_, y = get_point()
print(y)

这里 _ 只是一个常见写法，表示“这个值我不打算用”。

四、变量作用域：为什么函数里的变量外面不能直接用

先看一段代码：

def get_point():
    x = 10
    y = 20
    return x, y
get_point()
print(x, y)

这段代码会报错。原因很简单：x 和 y 是在函数内部定义的变量，它们只在函数内部有效。函数执行结束后，外面根本访问不到它们。

这种变量叫局部变量。

def test():
    x = 10
    print(f"函数内部 x = {x}")
test()

而定义在函数外部的变量叫全局变量。

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

这里 test() 内部没有定义 x，Python 就会沿着作用域链向外查找，找到了全局的 x = 20。

简单来说：内部可以访问外部，但外部不能直接访问内部。

global：在函数内部修改全局变量

如果你想在函数内部修改全局变量，需要使用 global 关键字声明：

x = 20
def test():
    global x
    x = 10
    print(f"函数内部 x = {x}")
test()
print(f"函数外部 x = {x}")

输出结果中，函数外部的 x 也会变成 10。

不过实际写代码时，不建议大量使用 global。全局变量改来改去，很容易让程序变得难以维护。更多时候，我们应该通过参数和返回值来传递数据，而不是依赖全局变量的副作用。

五、函数调用过程：代码是怎么执行的

函数不是从定义处开始执行的，而是从调用处开始执行的。这一点初学者容易混淆。

def test():
    print("执行函数内部代码")
    print("执行函数内部代码")
    print("执行函数内部代码")
print("1111")
test()
print("2222")
test()
print("3333")

执行顺序是：

1111
执行函数内部代码
执行函数内部代码
执行函数内部代码
2222
执行函数内部代码
执行函数内部代码
执行函数内部代码
3333

每次调用函数，程序都会进入函数内部执行；函数执行结束后，再回到原来的调用位置继续往下执行。

如果你用 PyCharm 或 VS Code 调试代码，可以通过断点和单步执行观察这个过程。初学函数时，强烈建议自己打断点走一遍，这比单纯看文字更容易理解实际发生了什么。

六、链式调用和嵌套调用

1. 链式调用

有时候我们会先接收函数返回值，再把它传给另一个函数：

result = is_odd(10)
print(result)

也可以直接写成：

print(is_odd(10))

这就是一种简单的链式调用——把一个函数的返回值，直接作为另一个函数的参数。

2. 嵌套调用

函数内部也可以调用其他函数。

def a():
    print("函数 a")
def b():
    a()
    print("函数 b")
b()

输出：

函数 a
函数 b

b() 内部调用了 a()，这就是嵌套调用。

七、递归：函数调用自己

递归是函数嵌套调用的一种特殊情况：函数内部调用自己。

比如计算阶乘：

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

5! 可以拆成：

5! = 5 * 4!
4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1!
1! = 1

对应到代码里，就是函数不断调用自己。

写递归时有两个要点必须牢记：

1. 必须有结束条件
2. 每次递归都要逐渐靠近结束条件

比如下面这个错误的版本——没有结束条件，会无限调用自己：

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

这段代码运行时会抛出“递归深度超限”的错误。

递归的优点是代码短，适合描述某些天然递归的问题，比如树、文件夹遍历、数学递推等。

但递归也有缺点：理解成本更高，而且递归层数太深时容易导致栈溢出。初学阶段不要为了递归而递归——能用循环清晰表达的问题，用循环往往更稳。

八、默认参数和关键字参数

1. 默认参数

Python 函数可以给参数指定默认值。

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

如果不传第三个参数，debug 默认就是 False。

需要注意：带默认值的参数要放在没有默认值的参数后面。

错误写法（编译就会报错）：

def add(x, debug=False, y):
    return x + y

正确写法：

def add(x, y, debug=False):
    return x + y

2. 关键字参数

正常情况下，函数传参是按照位置顺序传递的。

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

也可以显式指定参数名：

test(x=10, y=20)
test(y=100, x=200)

这种写法叫关键字参数。它的优点是代码更清楚——尤其是参数比较多的时候，不容易搞错顺序。

九、列表：保存一组可以修改的数据

如果只有几个数据，可以写多个变量：

num1 = 10
num2 = 20
num3 = 30

但要是有一百个数据呢？总不能写一百个变量吧。这个时候就需要用到列表。

列表可以一次保存多个数据。

nums = [10, 20, 30, 40]
print(nums)

1. 创建列表

创建空列表：

alist = []

或者：

alist = list()

创建带初始值的列表：

alist = [1, 2, 3, 4]

Python 的列表里可以放不同类型的数据：

alist = [1, "hello", True]
print(alist)

不过实际开发中，一个列表里通常会放同一类数据——比如学生成绩列表、商品价格列表、文件名列表。这样代码更容易理解和维护。

2. 通过下标访问元素

列表下标从 0 开始。

alist = [1, 2, 3, 4]
print(alist[0])  # 1
print(alist[2])  # 3

也可以修改元素：

alist[2] = 100
print(alist)

如果下标越界，会报错。

print(alist[100roke)

alist = [1, 2, 3, 4]

print(len(alistroke)