今天我们要探索的是Python世界里一个既基础又充满奥秘的概念——函数参数的传递！别看它日常得就像家常便饭，但里面的门道多着呢，保证让你有新发现。让我们一起，以最轻松愉快的方式，揭开它的面纱。

1. 函数参数初探：那些基本的家伙们

想象一下，你是个大厨，函数就是你的拿手菜谱，形参（形式参数）就像是菜谱上写的食材名称，而实参（实际参数）则是你真正放入锅中的材料。比如，我们的“炒鸡蛋”函数：

def cook_egg(ingredient):

    print(f"开始炒{ingredient}啦！")

这里的ingredient就是形参，调用时，比如cook_egg("鸡蛋")，"鸡蛋"就是实参。简单吧？但，这只是开始！

2. 默认参数值：让函数更贴心

有时候，你不想每次炒蛋都指定是鸡蛋，这时候默认参数就派上用场了。

def cook_egg(ingredient="鸡蛋"):

    print(f"开始炒{ingredient}啦！")

不传参数调用cook_egg()，它默认就用“鸡蛋”。这就像给菜谱加了个小注脚：“默认情况下，我们用鸡蛋。”

3. 关键字参数：明明白白我的心

调用函数时，直接指定参数名，这叫关键字参数。它让代码一目了然，特别适合长参数列表。

def make_smoothie(fruit="草莓", milk="豆奶"):

    print(f"制作中：{fruit} {milk} smoothie")

make_smoothie(milk="牛奶", fruit="香蕉")

这样调用，就算参数顺序错了，程序也能正确理解你的意图，是不是很贴心？

4. *args：拥抱不确定的美

有时候，你不知道会收到多少食材，这时*args就来了，它能接收任意数量的位置参数，打包成一个元组。

def make_salad(*ingredients):

    print("准备材料：", ingredients)

make_salad("生菜", "番茄", "黄瓜")

瞧，不管多少种蔬菜，它都能一一收下！

5. **kwargs：名字与值的浪漫邂逅

当你想处理未知数量的关键字参数时，**kwargs登场，它将参数打包成字典。

def celebrate(**details):

    for key, value in details.items():

        print(f"{key}: {value}")

celebrate(birthday="今天", cake="巧克力")

每个细节都被温柔地记录下来，是不是很有仪式感？

6. 参数传递的真相：引用还是复制？

Python中的参数传递，其实是一种“传引用”的行为，但要注意，对于不可变对象（如数字、字符串），虽然看起来像是传值，实际上改变的是引用的对象不会影响原变量。

def change_number(num):

    num += 1

    print("函数内:", num)

num = 10

change_number(num)

print("函数外:", num)  # 函数外的num不变

而对于列表这样的可变对象，故事就不一样了。

def add_item(my_list):

    my_list.append("新成员")

my_list = [1, 2, 3]

add_item(my_list)

print(my_list)  # 看，列表变了！

这里，因为列表是可变的，函数内的操作直接影响到了外部的列表。

7. 不可不知的局部与全局

在函数内部定义的变量，默认是局部变量。但如果你想修改全局变量，得用global关键字来声明。

x = "外面的世界"

def inner():

    global x

    x = "里面的世界"

    print(x)

inner()

print(x)  # 现在，x的值改变了

记住，频繁使用全局变量不是好习惯哦，保持代码的模块化和清晰更重要。

8. 局部变量的高级玩法：nonlocal

当我们嵌套函数时，如果想要修改外层（非全局）函数的变量，nonlocal来帮忙。

def outer():

    count = 0

    def inner():

        nonlocal count

        count += 1

        print(count)

    inner()

outer()  # 输出1，count被成功修改

这样，我们可以在不破坏全局变量的同时，灵活控制作用域。

9. 高阶函数：函数也可以是参数

Python的高阶函数允许函数作为参数传递给另一个函数，或者返回一个函数。这是函数式编程的魅力所在。

def greet(name):

    return f"Hello, {name}"

def greet_all(names, greeting_func):

    for name in names:

        print(greeting_func(name))

greet_all(["Alice", "Bob"], greet)

看，greet作为参数传给了greet_all，是不是很酷？

10. 匿名函数lambda：简洁之美

当你需要一个小巧的函数，只用一次，lambda表达式是不二之选。

double = lambda x: x * 2

print(double(5))  # 输出10

一行代码，解决问题，简洁到让人爱不释手。

11. map()与filter()：批量操作的艺术

这两个函数结合lambda，可以高效处理列表等可迭代对象。

numbers = [1, 2, 3, 4]

# 双倍

doubled = list(map(lambda x: x * 2, numbers))

print(doubled)  # [2, 4, 6, 8]

# 偶数筛选

even = list(filter(lambda x: x % 2 == 0, numbers))

print(even)  # [2, 4]

批量处理数据，优雅又高效。

12. 装饰器：给函数穿花衣

装饰器，听起来高大上，其实是个简单的小能手，它能让函数在不被修改的情况下增加额外功能。让我们用简单的例子来揭开它的神秘面纱。

def my_decorator(func):

    def wrapper():

        print("装饰器开始工作...")

        func()

        print("装饰器工作结束。")

    return wrapper

@my_decorator

def say_hello():

    print("Hello, World!")

say_hello()

这段代码中，@my_decorator就像给say_hello函数穿上了一件花衣，自动调用了wrapper函数，添加了前后打印的功能，而无需直接修改原函数。

13. 可变参数的高级应用：合并参数

有时候，我们需要合并多个列表或参数，* 和 ** 这对好搭档又来了。

def merge_lists(*lists):

    return sum(lists, [])

list1 = [1, 2]

list2 = [3, 4]

merged = merge_lists(list1, list2, [5, 6])

print(merged)  # 输出：[1, 2, 3, 4, 5, 6]

这里，*lists接收任意数量的列表，sum(lists, [])巧妙地将它们合并成一个新的列表。

14. 参数的默认检查与安全

在设置默认参数时，如果参数是可变对象，要小心避免潜在的问题。比如：

def append_to_list(input_list=[]):

    input_list.append("新元素")

    return input_list

print(append_to_list())  # 第一次调用

print(append_to_list())  # 第二次调用，咦？为什么列表里已经有东西了？

为了避免这种情况，最佳实践是在函数体内初始化可变默认参数。

​更多相关技术内容咨询欢迎前往并持续关注好学星城论坛了解详情。

想高效系统的学习Python编程语言，推荐大家关注一个微信公众号：Python编程学习圈。每天分享行业资讯、技术干货供大家阅读，关注即可免费领取整套Python入门到进阶的学习资料以及教程，感兴趣的小伙伴赶紧行动起来吧。