一文详解Python函数定义的12个参数传递技巧

目录

• 1 理解Python函数与参数基础
• 1.1 函数定义的基本结构
• 1.2 参数的概念
• 1.3 函数返回值
• 2 位置参数的使用技巧
• 2.1 理解位置参数的基本规则
• 2.2 位置参数的灵活应用
• 2.3 注意事项：避免参数数量不匹配
• 3 默认值参数的灵活应用
• 3.1 简化函数调用，提升代码可读性
• 3.2 动态设置默认值，避免常见陷阱
• 4 关键字参数的定义与调用
• 4.1 什么是关键字参数？
• 4.2 关键字参数的优势
• 4.3 实战技巧：混合使用位置参数和关键字参数
• 5 可变位置参数（*args）详解
• 5.1 *args是什么？
• 5.2 使用场景
• 5.3 高级技巧
• 6 可变关键字参数（**kwargs）解析
• 6.1 **kwargs 的基本概念
• 6.2 实践场景：动态生成 HTML 标签
• 7 参数解包的高级用法
• 7.1 使用*和**进行参数解包
• 7.2 结合*args和**kwargs的解包
• 8 局部变量与全局变量在参数中的作用
• 8.1 局部变量与全局变量的区别
• 8.2 在函数参数中使用全局变量
• 8.3 避免滥用全局变量
• 9 使用lambda表达式简化参数传递
• 9.1 lambda表达式的简单介绍
• 9.2 在参数传递中的实际应用
• 10 装饰器对函数参数的影响
• 10.1 理解装饰器如何改变函数签名
• 10.2 使用functools.wraps保留函数签名
• 11 命名关键字参数的场景应用
• 11.1 控制函数调用时的参数顺序
• 11.2 提高代码可读性
• 12 参数校验与类型提示的最佳实践
• 12.1 使用类型提示增强代码可读性
• 12.2 利用assert进行简单校验
• 13 实战案例：设计一个支持多种输入格式的日志记录函数

在Python中，函数是代码复用的核心工具。通过def关键字可以定义一个函数。比如下面这个简单的例子：

def greet(name):  # 定义一个函数，接收一个参数name
    print(f"Hello, {name}!")  # 打印问候语

greet("Alice")  # 调用函数，传入参数"Alice"

输出结果：

Hello, Alice!

这里，greet是一个函数，name是它的参数。

函数的参数就是传递给函数的数据。在上面的例子中，name就是参数。调用函数时，传递的具体值（如"Alice"）称为“实参”，而函数定义中的变量（如name）称为“形参”。

函数可以通过return语句返回计算结果。如果没有return，函数默认返回None。例如：

def add(a, b):  # 定义一个加法函数
    return a + b  # 返回两个数的和

result = add(3, 5)  # 调用函数并接收返回值
print(result)  # 输出结果

输出结果：

8

通过这些基础概念，我们可以逐步深入到更复杂的参数传递技巧！

在Python中，位置参数是最常见的参数类型。它们按照函数定义时的顺序一一对应传递值。比如下面的例子：

def greet(name, age):
    """打印名字和年龄"""
    print(f"Hello, {name}. You are {age} years old.")

greet("Alice", 25)  # 输出: Hello, Alice. You are 25 years old.

这里，"Alice"会自动传给name，25会传给age，完全依赖于位置顺序。

我们还可以通过调整调用顺序来改变参数传递方式，但需要明确指定参数名：

greet(age=30, name="Bob")  # 输出: Hello, Bob. You are 30 years old.

这种方式叫“关键字传参”，虽然不属于位置参数，但在实际开发中经常结合使用。

如果传递的参数数量不对，程序会报错！例如：

greet("Charlie")  # 报错：缺少参数age

因此，在定义函数时，要确保参数的数量和调用时一致，或者结合后面章节提到的默认值参数来解决这个问题。

总结一下，位置参数简单易用，但需要注意参数顺序和数量，这样才能写出更可靠的代码！

默认值参数是Python函数中非常实用的功能。它可以让函数调用时省略某些参数，从而让代码更简洁易懂。比如下面这个例子：

def greet(name, greeting="Hello"):
    # 如果没有传入greeting，默认使用"Hello"
    return f"{greeting}, {name}!"

print(greet("Alice"))  # 输出: Hello, Alice!
print(greet("Bob", "Hi"))  # 输出: Hi, Bob!

这里我们定义了一个greet函数，其中greeting参数有默认值“Hello”。当我们调用greet("Alice")时，由于没有提供greeting，函数自动使用默认值。

需要注意的是，默认值在函数定义时只计算一次。如果默认值是一个可变对象（如列表），可能会引发意外行为。看下面的例子：

def add_item(item, items=[]):  # 默认值items是空列表
    items.append(item)
    return items

print(add_item(1))  # 输出: [1]
print(add_item(2))  # 输出: [1, 2]！并不是预期的[2]

为什么第二次调用会返回[1, 2]呢？因为items列表在函数定义时就已经创建了，后续每次调用都会复用这个列表。为了避免这个问题，可以这样改写：

def add_item(item, items=None):
    if items is None:  # 每次调用都创建新的列表
        items = []
    items.append(item)
    return items

print(add_item(1))  # 输出: [1]
print(add_item(2))  # 输出: [2]，符合预期

这样就安全多了！是不是很实用呢？

关键字参数是通过“键=值”的方式传递给函数的参数，它让代码更清晰易懂！比如下面这个例子：

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

# 使用关键字参数调用
greet(name="Alice", greeting="Hi")  # 输出：Hi, Alice!

这里，name 和 greeting 都是关键字参数。即使改变顺序，只要指定键名，也能正确运行！

相比位置参数，关键字参数可以随意调整顺序，减少出错概率。例如：

def info(age, name):
    print(f"{name} is {age} years old.")

# 混淆顺序时，使用关键字参数避免错误
info(name="Bob", age=25)  # 输出：Bob is 25 years old.

位置参数必须在关键字参数之前！看这个正确示例：

def multiply(x, y, factor=1):
    return x * y * factor

result = multiply(3, 5, factor=2)  # 输出：30
print(result)

以上就是关键字参数的核心用法啦！是不是很实用？

*args 是一种特殊语法，允许函数接收任意数量的位置参数。它会将传入的多个值打包成一个元组，方便我们处理不确定数量的输入。

当你不知道用户会传入多少个参数时，*args 就派上用场了！比如计算一组数字的总和：

def sum_numbers(*args):  # *args 收集所有位置参数
    return sum(args)      # 计算元组中所有数字的和

result = sum_numbers(1, 2, 3, 4)
print(result)  # 输出：10

解释：这里 *args 把 1, 2, 3, 4 打包成了一个元组 (1, 2, 3, 4)，然后用 sum() 函数求和。

*args 还可以和其他参数混用！例如，固定第一个参数，后面用 *args 接收剩余值：

def greet(name, *args):
    message = f"Hello, {name}!"
    for arg in args:
        message += f" And hello to you too, {arg}!"
    return message

print(greet("Alice", "Bob", "Charlie"))
# 输出：Hello, Alice! And hello to you too, Bob! And hello to you too, Charlie!

小贴士：*args 的名字不是固定的，* 才是关键符号哦！

在 Python 中，**kwargs 是一种特殊的参数形式，它可以接收任意数量的关键字参数，并将它们存储为一个字典。如果你需要设计一个灵活的函数接口，允许用户传入不确定的关键字参数，那 **kwargs 就是你的最佳选择！

来看一个简单的例子：

def greet(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# 调用函数
greet(name="Alice", age=25, city="Beijing")

输出结果：

name: Alice
age: 25
city: Beijing

假设你想写一个函数，用来生成 HTML 标签，并支持传递任意属性。这时就可以用到 **kwargs！

def create_html_tag(tag_name, content, **attributes):
    # 构建属性部分
    attr_str = ' '.join([f'{k}="{v}"' for k, v in attributes.items()])
    return f"<{tag_name} {attr_str}>{content}</{tag_name}>"

# 使用示例
html = create_html_tag("a", "Click me!", href="https://example.com" rel="external nofollow"  rel="external nofollow" , target="_blank")
print(html)

输出结果：

<a href="https://example.com" target="_blank">Click me!</a>

通过以上两个例子，我们可以看到 **kwargs 在处理未知数量的关键字参数时非常强大。下次当你需要设计灵活的函数接口时，不妨试试这个技巧吧！

在函数调用时，可以用 * 解包列表或元组，用 ** 解包字典。这样可以更灵活地传递参数。

# 定义一个函数
def my_function(a, b, c):
    print(f"a={a}, b={b}, c={c}")

# 列表解包
my_list = [1, 2, 3]
my_function(*my_list)  # 输出: a=1, b=2, c=3

# 字典解包
my_dict = {'a': 4, 'b': 5, 'c': 6}
my_function(**my_dict)  # 输出: a=4, b=5, c=6

这段代码展示了如何通过解包将数据结构中的值传递给函数参数，是不是很方便？

如果函数接收可变参数，也可以用解包的方式传递参数。

def another_function(*args, **kwargs):
    print("Positional arguments:", args)
    print("Keyword arguments:", kwargs)

# 使用解包传递参数
another_function(*[7, 8], **{'key': 'value'})
# 输出:
# Positional arguments: (7, 8)
# Keyword arguments: {'key': 'value'}

通过这种方式，你可以轻松处理复杂的参数传递场景！

局部变量和全局变量是Python函数中非常重要的概念。简单来说，局部变量是在函数内部定义的变量，只能在函数内部使用；而全局变量**是在函数外部定义的变量，可以在整个程序中访问。

来看一个例子：

global_var = 10  # 全局变量

def my_function(local_var):
    print(f"局部变量: {local_var}")  # 访问局部变量
    print(f"全局变量: {global_var}")  # 访问全局变量

my_function(5)  # 调用函数并传递局部变量

输出：

局部变量: 5
全局变量: 10

有时候我们希望在函数内部修改全局变量的值，这时需要使用global关键字。例如：

count = 0  # 定义全局变量

def increment():
    global count  # 声明使用全局变量
    count += 1
    print(f"当前计数: {count}")

increment()  # 调用函数
increment()

输出：

当前计数: 1
当前计数: 2

虽然全局变量很方便，但过度使用可能会导致代码难以维护。尽量将变量的作用域限制在函数内部，或者通过参数传递来实现功能。

总结一下：局部变量和全局变量各有用途，合理使用它们能让代码更清晰、更高效！

Lambda表达式是Python中一种简洁的匿名函数定义方式，特别适合用来简化短小的函数逻辑。比如，你想快速定义一个计算两数之和的函数，可以用lambda轻松搞定！来看个例子：

add = lambda x, y: x + y  # 定义一个简单的加法函数
print(add(3, 5))  # 输出结果为8

这里lambda x, y: x + y相当于定义了一个函数，输入两个参数x和y，返回它们的和。

Lambda表达式在需要传递简单函数作为参数时非常有用。例如，在排序或过滤操作中：

# 按字符串长度排序
words = ["apple", "banana", "cherry", "date"]
sorted_words = sorted(words, key=lambda word: len(word))
print(sorted_words)  # 输出['date', 'apple', 'banana', 'cherry']

# 过滤出偶数
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出[2, 4, 6]

通过以上代码可以看到，使用lambda表达式可以让代码更简洁、易读，同时避免了定义冗长的函数。

装饰器可能会改变被装饰函数的参数签名，导致原函数的行为发生意外变化。例如，某些装饰器可能丢失原始函数的元信息（如参数名）。来看一个例子：

def my_decorator(func):
    def wrapper(*args, **kwargs):  # 使用通用参数接收
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result
    return wrapper

@my_decorator
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")  # 输出：Before function callnHello, Alice!nAfter function call

装饰后，greet 的签名看起来像是接受任意参数，但实际调用仍需满足原函数需求。

为了避免装饰器破坏函数签名，可以使用 functools.wraps：

from functools import wraps

def my_decorator(func):
    @wraps(func)  # 保留原函数的元信息
    def wrapper(*args, **kwargs):
        print("Before function call")
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def greet(name):
    """Greet someone by name."""
    print(f"Hello, {name}!")

print(greet.__name__)  # 输出：greet
print(greet.__doc__)   # 输出：Greet someone by name.

通过 wraps，我们可以确保函数的名称、文档字符串等信息不被装饰器覆盖。

装饰器虽然强大，但在处理参数时需要格外小心！

命名关键字参数是 Python 中一个非常实用的功能，它可以让函数调用更清晰、更安全。下面我们来深入探讨它的实际应用场景。

有时候，函数有多个参数，如果直接使用位置参数，可能会因为顺序问题而出错。这时，命名关键字参数就能帮上忙！例如：

def calculate_price(item, *, tax_rate, discount):
    """计算商品价格（包含税率和折扣）"""
    price = item['price']
    taxed_price = price * (1 + tax_rate)
    final_price = taxed_price * (1 - discount)
    return final_price

# 调用函数时必须指定参数名称
item = {'price': 100}
result = calculate_price(item, tax_rate=0.1, discount=0.2)
print(result)  # 输出：88.0

在这段代码中，tax_rate 和 discount 是命名关键字参数，调用时必须显式指定它们的名字。这样可以避免因参数顺序错误而导致的 bug。

通过命名关键字参数，可以让函数调用更加直观。比如上面的例子中，tax_rate=0.1 和 discount=0.2 清楚地表达了每个参数的含义，而不需要依赖于参数的位置。

总之，命名关键字参数在需要强制指定某些参数或者提高代码可读性时非常有用！

在Python中，参数校验和类型提示是编写高质量代码的重要部分。从Python 3.5开始引入的类型注解功能，可以让代码更清晰、更易于维护。

类型提示告诉开发者函数期望接收什么类型的参数。例如：

def add_numbers(a: int, b: int) -> int:
    return a + b

result = add_numbers(5, 10)  # 正确用法
print(result)  # 输出：15

这里add_numbers函数明确要求传入两个整数，并返回一个整数。

assert语句可以用来确保参数符合预期：

def divide(a: float, b: float) -> float:
    assert b != 0, "除数不能为零"
    return a / b

print(divide(10, 2))  # 输出：5.0
# print(divide(10, 0))  # 触发断言错误

通过这些技巧，你可以让代码更加健壮和易懂！

在实际开发中，日志记录是不可或缺的功能。我们可以通过灵活使用前面章节的参数技巧，设计一个强大的日志记录函数，支持字符串、字典、列表等多种输入格式。

示例代码

def log_message(message, *, level="INFO", **kwargs):
    """
    日志记录函数，支持多种输入格式。
    :param message: 要记录的日志信息（可以是字符串、字典或列表）
    :param level: 日志级别，默认为 "INFO"
    :param kwargs: 其他可选参数
    """
    timestamp = kwargs.get("timestamp", "N/A")  # 获取时间戳，默认为 "N/A"
    if isinstance(message, str):  # 如果是字符串
        formatted_message = f"[{level}] [{timestamp}] {message}"
    elif isinstance(message, dict):  # 如果是字典
        formatted_message = f"[{level}] [{timestamp}] {dict(message)}"
    elif isinstance(message, list):  # 如果是列表
        formatted_message = f"[{level}] [{timestamp}] {list(message)}"
    else:
        formatted_message = f"[{level}] [{timestamp}] Unsupported type: {type(message)}"

    print(formatted_message)  # 输出日志

# 测试代码
log_message("This is a test log.")  # 字符串输入
log_message({"key": "value"}, level="DEBUG", timestamp="2023-03-01 12:00:00")  # 字典输入
log_message([1, 2, 3], level="WARNING")  # 列表输入

输出结果

[INFO] [N/A] This is a test log.
[DEBUG] [2023-03-01 12:00:00] {'key': 'value'}
[WARNING] [N/A] [1, 2, 3]

解释

• 使用了命名关键字参数 level 和可变关键字参数 **kwargs，使函数更灵活。
• 通过 isinstance 检查输入类型，并根据不同类型格式化日志内容。
• 支持自定义时间戳和日志级别，满足不同场景需求。

这个例子结合了前几章的知识点，让初学者也能轻松上手！

以上就是一文详解Python函数定义的12个参数传递技巧的详细内容，更多关于Python函数参数传递技巧的资料请关注风君子博客其它相关文章！

您可能感兴趣的文章:

• 一文深度解析Python函数参数传递机制
• Python中实现传递未知数量的函数参数
• 深入理解Python中的函数参数传递机制
• Python中的函数参数传递问题
• Python函数值传递引用传递及形式参数和实际参数的区别
• python函数装饰器构造和参数传递