Python 函数 · 精讲 2026-08-30

函数是什么，为什么需要函数

给一段代码起名字，独立调用、重复使用。让编写、阅读、升级都更容易。

     比喻：函数是“电梯里的楼层按钮”。
     不用重新造电梯，按“10楼”即可
 调用函数，内部处理加速、减速、开关门

  

定义 & 调用

 def print_hello():
    """ 这是一个函数的定义，用于打印一段文字 """
    print("hello world")

# 调用函数（不要忘了括号）
print_hello()
print_hello()

def 关键字
函数名 + () + :
文档字符串 (docstring)
通过名字 + 括号重复调用

参数 · 4种类型

参数是“函数与外界的接口”，让函数不再是孤岛。

     
    为什么需要参数？

    如果函数没有参数，你遇到稍微不同的需求就得重新写一个新函数：

    · print_hello() 打印"你好"

    · print_hi() 打印"嗨"

    · print_goodbye() 打印"再见"

    你会发现代码里塞满了长得几乎一样、只有细微差别的函数——这不叫编程，这叫重复造轮子大赛。

    而有了参数，你只需要一个函数 print_msg(msg)，传什么就打印什么，干净利落。

     参数就是“函数和外界的接口”——它让函数不再是封闭的孤岛，而是能跟外部世界交互的桥梁。

1. 位置参数（最基础）按顺序一一对应，多一个少一个都报错。

 def greet(name, msg):
    print(f"{name}，{msg}")

greet("小明", "你好")   # 必须按顺序 不能乱

2. 默认参数（偷懒神器）给参数提前设个“保底值”，调用时如果不传就用默认的。

 def greet(name, msg="你好"):
    print(f"{name}，{msg}")

greet("小明")          # 小明，你好
greet("小明", "再见")   # 覆盖默认值

3. 关键字参数（不怕顺序乱）：调用时直接指定参数名，想先传哪个都行

greet(msg="你好", name="小明") # 顺序随意

4. 不定长参数 *args / **kwargs
不知道调用时会传几个参数，就用*args（收一堆位置参数）和**kwargs（收一堆关键字参数）。

 def collect(*args, **kwargs):
    print(args)    # 元组 (1,2,3)
    print(kwargs)  # 字典 {'a':1, 'b':2}

collect(1, 2, 3, a=1, b=2)

返回值 return

return 是函数的“产出”，决定干完活后送回什么。

     比喻：让室友带饭 — 你调用函数，室友出门买饭，return 就是把饭递到你手上。
  

没有 return → 返回 None
return 会“当场终止”函数，后续代码不执行

 def test():
    return 1
    print("这行永远不会执行")   # 被 return 截胡

print vs return 终极测试

 def add(a, b):
    print(a + b)      # 只打印，不返回

def add2(a, b):
    return a + b      # 返回结果，不打印

# 调用 add(1,2) → 看到3，但变量拿不到
# result = add2(1,2) → 看不到3，但 result 里存着3

print 是给人看的，return 是给代码用的。
如果你想让函数的结果参与后续逻辑（比如判断、循环、再计算），就必须return。

return 可以返回哪些值

整数、浮点、字符串、布尔、None

列表、元组、字典、集合

函数 / 方法（一等公民）

对象实例

任何 Python 对象

     
    返回函数 / 方法 —— 寄个“工具”给别人

    Python 里函数是“一等公民”，可以当数据传递。

 def outer():
    def inner():
        return "我是内部函数"
    return inner  # 返回函数本身

func = outer()  # func 就是 inner 函数
result = func()  # 调用它，得到 "我是内部函数"
# 比喻：就像你寄了个“多功能军刀”（函数），对方收到后可以随时打开用。

     
    返回对象实例 —— 寄个“活的”东西

    如果你定义了类，可以返回类的实例。

 class Person:
    def __init__(self, name):
        self.name = name

def create_person():
    return Person("小明")  # 返回对象

p = create_person()
print(p.name)  # 输出：小明
# 比喻：就像你寄了个“机器人”（对象），对方收到后可以调它的功能（方法）、查看它的属性。

 # 返回多个值自动打包成元组
def get_user():
    return "小明", 18
name, age = get_user()   # 解包赋值

lambda 匿名函数

一句话写完的函数，不用 def、不用 return，一行搞定。

 # 普通函数（正餐）
def add(x, y):
    return x + y

# lambda（快餐）
lambda x, y: x + y

只能写一行表达式，自动返回
搭配 map、filter、sorted 最经典

场景1：map 批量处理

 nums = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, nums))   # [1, 4, 9, 16]

场景2：filter 筛选

 nums = [1, 2, 3, 4, 5, 6]
evens = list(filter(lambda x: x % 2 == 0, nums))   # [2, 4, 6]

场景3：sorted 自定义排序

 students = [("小明", 90), ("小红", 85), ("小刚", 95)]
sorted(students, key=lambda x: x[1])   # 按成绩排序

     金句：
    map 每个元素都变一下，
    filter 每个元素都问一下（留不留），
    sorted 每个元素都比一下（谁在前）。
  

什么时候用内置函数 / 自己写 for

     能用内置函数：数据独立处理，每个元素互不影响。

     必须自己写 for：数据相互依赖，后面的操作依赖前面的结果。

终极判断：“处理每个元素时，需不需要知道其他元素的状态？”