python函数

最新推荐文章于 2024-09-09 23:28:21 发布

丁金金

最新推荐文章于 2024-09-09 23:28:21 发布

阅读量893

点赞数 20

文章标签： python 开发语言前端

本文链接：https://blog.csdn.net/qq_55125921/article/details/140896651

版权

文章目录

函数传参原理
将函数作为参数传递
lambda
变量的作用域

位置参数

当我们定义一个函数并使用位置参数时，我们需要确保在调用该函数时按照定义的顺序和数量传递参数。下面我将通过一个简单的 Python 函数示例来说明这一点。

假设我们有一个函数 greet，它接受两个参数：name 和 time_of_day，用于打印一条问候消息。这里我们不指定参数的数据类型，Python 会根据传入的实际参数自动推断。

def greet(name, time_of_day):
    print(f"Good {time_of_day}, {name}!")

# 调用函数
greet("Alice", "morning")

在这个例子中，greet 函数期望第一个参数是 name（名字），第二个参数是 time_of_day（一天中的时间段）。当我们将 "Alice" 和 "morning" 作为参数传递给 greet 函数时，它们分别对应 name 和 time_of_day，因此输出将是：

Good morning, Alice!

如果我们颠倒了参数的顺序或者少传了一个参数，将会导致错误或意外的行为。例如：

# 错误的参数顺序
greet("morning", "Alice")  # 输出：Good Alice! morning,  (这并不是我们想要的结果)

# 少传了一个参数
greet("Alice")  # 这将引发 TypeError: greet() missing 1 required positional argument: 'time_of_day'

让我们再看一个更具体的例子，这次我们将创建一个计算矩形面积的函数，并演示如何正确地使用位置参数。

def rectangle_area(length, width):
    return length * width

# 正确的参数顺序
area = rectangle_area(10, 5)
print(area)  # 输出：50

# 错误的参数顺序
wrong_area = rectangle_area(5, 10)  # 输出：50 (虽然结果是正确的，但参数的意义被颠倒了)

在这个例子中，rectangle_area 函数接受长度 length 和宽度 width 作为参数，并返回矩形的面积。如果我们将参数顺序颠倒，虽然计算出的结果数值上可能是正确的，但参数的实际意义已经发生了变化。

python 函数可以有多个返回值，返回数据类型不受限制

在 Python 中，一个函数可以通过返回一个元组（tuple）来“模拟”返回多个值。实际上，Python 函数只能返回一个对象，但这个对象可以是一个包含多个元素的容器，比如元组、列表或字典等。当函数返回多个值时，这些值通常会被自动解包到多个变量中。

下面是一个示例函数，它返回两个值：一个整数和一个字符串。

def get_info():
    age = 25
    name = "Alice"
    return age, name  # 返回一个元组 (age, name)

# 调用函数并接收返回的多个值
age, name = get_info()
print(age)  # 输出：25
print(name)  # 输出：Alice

在这个例子中，get_info 函数返回了一个元组 (age, name)，但实际上我们可以直接将其解包为两个变量 age 和 name。如果你想要明确看到这个元组，可以这样写：

result = get_info()
print(result)  # 输出：(25, 'Alice')

你也可以选择只接收部分返回值，或者将所有返回值作为一个整体接收：

age, _ = get_info()  # 只关心年龄，忽略名字
_, name = get_info()  # 只关心名字，忽略年龄

info_tuple = get_info()  # 接收整个元组

此外，函数可以返回任何类型的对象，包括其他容器类型，如列表或字典。例如，下面的函数返回一个包含两个列表的元组：

def get_lists():
    list1 = [1, 2, 3]
    list2 = [4, 5, 6]
    return list1, list2

list1, list2 = get_lists()
print(list1)  # 输出：[1, 2, 3]
print(list2)  # 输出：[4, 5, 6]

甚至可以返回一个字典：

def get_dict():
    info = {"name": "Alice", "age": 25}
    return info

data = get_dict()
print(data)  # 输出：{'name': 'Alice', 'age': 25}

这里的关键点是，无论函数返回什么类型的对象，只要它是一个有效的 Python 对象，就可以被返回。你可以根据需要自由选择返回单个值、多个值（通过元组或其他容器）以及任何数据类型。

关键字参数默认参数

在 Python 中，函数支持使用关键字参数（keyword arguments）的方式传递参数。关键字参数允许你在调用函数时指定参数的名字和对应的值，这样就不必关心参数的顺序。这对于拥有多个参数的函数特别有用，尤其是当你希望改变某些特定参数的值而不影响其他参数时。

下面我将给出一个具体的例子来说明如何使用关键字参数。

假设我们有一个函数 create_user，它接受三个参数：username、email 和 age，用于创建用户信息。我们可以在调用这个函数时使用关键字参数，这样就不必关心参数的顺序。

def create_user(username, email, age):
    user_info = {
        'username': username,
        'email': email,
        'age': age
    }
    return user_info

# 使用关键字参数调用函数
user1 = create_user(email='alice@example.com', username='alice', age=25)
print(user1)  # 输出：{'username': 'alice', 'email': 'alice@example.com', 'age': 25}

# 也可以混合使用位置参数和关键字参数
user2 = create_user('bob', email='bob@example.com', age=30)
print(user2)  # 输出：{'username': 'bob', 'email': 'bob@example.com', 'age': 30}

在这个例子中，create_user 函数定义了三个参数：username、email 和 age。我们可以通过关键字参数的形式来传递这些参数，这样即使改变了参数的顺序也不会影响函数的执行结果。

关键点总结：

关键字参数：通过指定参数名和对应的值来传递参数。
位置参数：按照函数定义的顺序传递参数。
混合使用：可以同时使用位置参数和关键字参数。

使用关键字参数的一个主要优点是可以提高代码的可读性，特别是在函数有许多参数的情况下。你还可以使用关键字参数来更改默认参数值而不需要修改所有参数。

下面是一个更详细的示例，展示如何使用关键字参数来调整默认参数值：

def create_user(username, email, age=18):  # 年龄设为默认值18
    user_info = {
        'username': username,
        'email': email,
        'age': age
    }
    return user_info

# 使用关键字参数覆盖默认值
user3 = create_user('carol', 'carol@example.com', age=22)
print(user3)  # 输出：{'username': 'carol', 'email': 'carol@example.com', 'age': 22}

# 不指定 age 参数，使用默认值
user4 = create_user('dave', 'dave@example.com')
print(user4)  # 输出：{'username': 'dave', 'email': 'dave@example.com', 'age': 18}

在这个例子中，create_user 函数的 age 参数设置了一个默认值 18。当你调用这个函数并使用关键字参数覆盖 age 的值时，它会使用你提供的值；如果没有提供，则使用默认值。这种方式使得函数更加灵活，也更容易维护和理解。

默认参数

在 Python 中，函数可以定义带有默认值的参数，也称为缺省参数或默认参数。这意味着当调用函数时，如果没有为某个参数提供值，那么将使用该参数的默认值。这可以让你的函数更加灵活和方便使用。

定义带有默认参数的函数

当你定义函数时，可以在参数后面加上一个等号 =，后面跟着一个表达式，该表达式的结果将成为该参数的默认值。如果在调用函数时没有为该参数提供值，那么就使用默认值。

示例：

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

# 调用函数并使用默认值
greet("Alice")  # 输出：Hello, Alice!

# 调用函数并提供自定义值
greet("Bob", "Hi")  # 输出：Hi, Bob!

在这个例子中，greet 函数有两个参数：name 和 greeting。greeting 参数有一个默认值 "Hello"。因此，当你调用 greet("Alice") 时，只有 name 被提供，greeting 使用其默认值。而当你调用 greet("Bob", "Hi") 时，两个参数都被提供了，所以 greeting 使用 "Hi" 而不是默认值。

注意事项

不可变对象作为默认值：
- 默认值是在函数定义时计算一次的，因此如果使用可变对象（如列表或字典）作为默认值，可能会导致意料之外的行为，因为这些对象会在每次调用函数时共享相同的实例。

示例：

def append_item(item, items=[]):
    items.append(item)
    return items

print(append_item("apple"))  # 输出：['apple']
print(append_item("banana"))  # 输出：['apple', 'banana']  # 意外行为

在这个例子中，items 参数使用了一个空列表作为默认值。但是，由于列表是可变对象并且在函数定义时仅计算一次，默认的列表实例在多次调用之间被共享，导致了意外的行为。

为了避免这种情况，可以使用 None 作为默认值，并在函数内部初始化可变对象：

def append_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(append_item("apple"))  # 输出：['apple']
print(append_item("banana"))  # 输出：['banana']

参数顺序：
- 当定义带有默认值的参数时，请确保所有没有默认值的参数都出现在带有默认值的参数之前。这是因为 Python 在解析参数时遵循从左到右的顺序。

示例

def calculate_area(length, width=10):
    return length * width

# 调用函数
print(calculate_area(5))  # 输出：50  # 使用默认宽度 10
print(calculate_area(5, 15))  # 输出：75  # 提供宽度 15

在这个例子中，calculate_area 函数的第一个参数 length 没有默认值，而第二个参数 width 有一个默认值 10。因此，当调用 calculate_area(5) 时，宽度使用默认值 10。

总结一下：

默认参数：在定义函数时可以为参数指定默认值。
调用函数：如果提供了参数值，则使用提供的值；否则，使用默认值。
注意事项：避免使用可变对象作为默认值，并确保所有没有默认值的参数都位于带有默认值的参数之前。

可变参数

在 Python 中，函数可以支持可变参数（也称为不定长参数），这意味着你可以定义函数来接受任意数量的位置参数或关键字参数。这在你不知道调用函数时会传递多少个参数的情况下非常有用。

1. 使用 *args 接受任意数量的位置参数

如果你想要定义一个函数，使其能够接受任意数量的位置参数，你可以使用星号 * 前缀来定义这些参数。这样的参数会被收集到一个名为 args 的元组中。

示例：

def sum_numbers(*args):
    total = 0
    for number in args:
        total += number
    return total

# 调用函数并传递任意数量的参数
result = sum_numbers(1, 2, 3, 4, 5)
print(result)  # 输出：15

在这个例子中，sum_numbers 函数接受任意数量的参数并将它们相加。*args 表示函数可以接收任意数量的位置参数，这些参数将被收集到一个名为 args 的元组中。

2. 使用 **kwargs 接受任意数量的关键字参数

如果你想要定义一个函数，使其能够接受任意数量的关键字参数，你可以使用双星号 ** 前缀来定义这些参数。这样的参数会被收集到一个名为 kwargs 的字典中。

示例：

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

# 调用函数并传递任意数量的关键字参数
print_details(name="Alice", age=25, city="New York")

# 输出：
# name: Alice
# age: 25
# city: New York

在这个例子中，print_details 函数接受任意数量的关键字参数，并打印出每个参数的键和值。**kwargs 表示函数可以接收任意数量的关键字参数，这些参数将被收集到一个名为 kwargs 的字典中。

3. 结合使用 *args 和 **kwargs

你可以同时使用 *args 和 **kwargs 来使你的函数更加灵活，能够接受任意数量的位置参数和关键字参数。

示例：

def process_data(*args, **kwargs):
    print("Positional arguments:")
    for arg in args:
        print(arg)
    
    print("\nKeyword arguments:")
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# 调用函数并传递位置参数和关键字参数
process_data(1, 2, 3, name="Alice", age=25, city="New York")

# 输出：
# Positional arguments:
# 1
# 2
# 3

# Keyword arguments:
# name: Alice
# age: 25
# city: New York

在这个例子中，process_data 函数可以接收任意数量的位置参数和关键字参数。位置参数被收集到 args 元组中，关键字参数被收集到 kwargs 字典中。

总结

*args 收集位置参数到一个元组中。
**kwargs 收集关键字参数到一个字典中。

这些机制使得函数更加灵活，可以适应不同情况下的参数需求。

Python 文件中调用另一个文件中的函数。

在 Python 中，你可以通过导入模块的方式来调用另一个 .py 文件中的函数。以下是一些步骤和示例，说明如何在一个 Python 文件中调用另一个文件中的函数。

步骤

创建模块：首先，你需要创建一个包含函数的 Python 文件。这个文件通常被称为模块。
导入模块：然后，在你想使用该函数的 Python 文件中，你需要导入包含该函数的模块。
调用函数：最后，你可以使用模块名和函数名来调用该函数。

示例

假设你有两个文件：functions.py 和 main.py。

functions.py

# functions.py

def greet(name):
    """Prints a greeting message."""
    print(f"Hello, {name}!")

def add(a, b):
    """Adds two numbers and returns the result."""
    return a + b

main.py

# main.py

# 导入 functions 模块
import functions

# 使用 functions 模块中的函数
functions.greet("Alice")
result = functions.add(5, 10)
print(result)

在这个例子中，functions.py 包含了两个函数：greet 和 add。main.py 文件导入了 functions 模块，并使用了这两个函数。

运行程序

要运行 main.py 文件，你可以打开命令行或终端，然后导航到包含这两个文件的目录，并执行以下命令：

python main.py

输出应该是：

Hello, Alice!
15

更简洁的导入方式

如果你只想导入特定的函数而不是整个模块，可以使用 from ... import ... 语法：

main.py

# main.py

# 从 functions 模块中导入特定的函数
from functions import greet, add

# 使用导入的函数
greet("Alice")
result = add(5, 10)
print(result)

这种方式使得代码更简洁，因为你不需要每次调用函数时都带上模块名。

相对导入

如果你的项目结构比较复杂，你可能需要使用相对导入。假设你的项目结构如下：

project/
│
├── module1/
│   ├── __init__.py
│   └── functions.py
│
└── main.py

在这种情况下，你可以在 main.py 中使用相对导入：

main.py

# main.py

from module1.functions import greet, add

# 使用导入的函数
greet("Alice")
result = add(5, 10)
print(result)

注意事项

命名冲突：如果你的项目中有多个模块，确保它们的名称不会冲突。
路径问题：确保你的 Python 文件能够找到导入的模块。如果你在不同的目录层级下工作，可能需要调整系统路径或使用相对导入。

通过这些步骤，你就可以在 Python 文件中调用另一个文件中的函数了。

函数传参原理

在 Python 中，所有的数据都是以对象的形式存在的。这意味着当你传递字符串或者数值类型给函数时，你实际上是在传递这些对象的引用。

Python 中的参数传递机制可以简单概括为“按值传递”，但这里的“值”是指对对象的引用而不是对象本身。对于不可变对象（如字符串、整数等），改变这个对象意味着创建一个新的对象，因此在函数内部对这些对象所做的任何改变都不会影响到原始变量。而对于可变对象（如列表或字典），则可以在不创建新对象的情况下改变其内容。

不可变类型的传参机制

字符串 和 数值类型 都是不可变类型。这意味着一旦一个字符串或数值被创建，你就不能改变它的值。如果你试图在函数中修改它，实际上是创建了一个新的对象，并将该对象赋值给函数内的局部变量。这不会影响到原始变量。

示例：

def modify_value(value):
    value += 1  # 这里会创建一个新的整数对象并将其赋值给 value

x = 5
modify_value(x)
print(x)  # 输出 5，因为 x 指向的原始对象没有改变

def modify_string(s):
    s += " world"  # 创建新的字符串对象并将其赋值给 s

text = "hello"
modify_string(text)
print(text)  # 输出 "hello"，因为 text 指向的原始对象没有改变

可变类型的传参机制

与不可变类型不同，可变类型的变量（例如列表）可以在不创建新对象的情况下改变。这意味着在函数内部对可变对象所做的任何改变都会反映到原始变量上。

示例：

def append_to_list(lst):
    lst.append(4)  # 改变 lst 所指向的对象的内容

numbers = [1, 2, 3]
append_to_list(numbers)
print(numbers)  # 输出 [1, 2, 3, 4]，因为 numbers 指向的对象内容改变了

总结来说，在 Python 中传递字符串或数值类型时，由于它们是不可变类型，所以函数内的修改不会影响到原始变量。而传递可变类型时，则需要小心处理，因为函数内的修改可能会影响原始变量。

在 Python 中，函数是一等公民，这意味着你可以将函数赋值给变量、将函数作为参数传递给其他函数，甚至可以从函数中返回另一个函数。这种特性使得 Python 成为了一个非常适合函数式编程的语言。

下面我将详细介绍如何将函数作为参数传递，并给出一些示例。

将函数作为参数传递

你可以将函数名直接写入参数列表中，就像传递一个普通的变量一样。接收函数作为参数的函数通常称为高阶函数。

示例 1: 使用内置函数 `map()`

map() 函数接受一个函数和一个可迭代对象作为参数，并将可迭代对象中的每一个元素都应用该函数。

def square(x):
    return x * x

numbers = [1, 2, 3, 4, 5]
squared_numbers = map(square, numbers)

# 转换成列表输出结果
print(list(squared_numbers))  # 输出 [1, 4, 9, 16, 25]

示例 2: 自定义函数来接受其他函数作为参数

你也可以定义自己的函数来接受其他函数作为参数。

def apply_function(func, value):
    return func(value)

# 定义一个简单的函数
def add_one(x):
    return x + 1

# 使用 apply_function
result = apply_function(add_one, 5)
print(result)  # 输出 6

示例 3: 使用匿名函数 (lambda 表达式)

有时候你可能只需要临时使用一个函数一次，这时可以使用 lambda 表达式来定义匿名函数。

numbers = [1, 2, 3, 4, 5]
doubled_numbers = map(lambda x: x * 2, numbers)

# 转换成列表输出结果
print(list(doubled_numbers))  # 输出 [2, 4, 6, 8, 10]

示例 4: 使用装饰器

装饰器本质上是一个接受函数作为参数的函数，并返回一个新的函数。装饰器经常用于修改函数的行为，而不改变函数本身的代码。

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")

    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()
# 输出:
# Something is happening before the function is called.
# Hello!
# Something is happening after the function is called.

示例 5: 使用函数作为参数进行排序

假设你有一个列表，你想根据某个条件对其进行排序，你可以传递一个函数作为排序的键。

people = [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 20},
    {"name": "Charlie", "age": 30}
]

# 按年龄排序
sorted_people = sorted(people, key=lambda person: person["age"])

for person in sorted_people:
    print(person["name"], person["age"])
# 输出:
# Bob 20
# Alice 25
# Charlie 30

通过这些例子，你可以看到函数作为参数传递在 Python 中是非常灵活且强大的功能。这允许你编写更加模块化和重用性更高的代码。

lambda

在 Python 中，lambda 是一个关键字，用于创建小型的匿名函数。通常，当我们只需要一个简短的功能性操作，并且不希望定义一个完整的函数时，就会使用 lambda 函数。lambda 函数可以被当作表达式来使用，而不是像普通的 def 关键字那样定义一个函数。

基本语法

lambda 函数的基本语法如下：

lambda arguments: expression

这里：

arguments 是传递给 lambda 函数的参数列表。
expression 是一个计算表达式，它会被执行并返回结果。

示例

让我们来看几个使用 lambda 函数的例子。

示例 1: 简单的加法

add = lambda x, y: x + y
result = add(5, 3)
print(result)  # 输出 8

在这个例子中，我们定义了一个简单的 lambda 函数 add，它接受两个参数 x 和 y 并返回它们的和。

示例 2: 使用 `map()` 函数

map() 函数可以接受一个函数和一个序列，然后应用这个函数到序列的所有元素上。我们可以使用 lambda 函数来简化这个过程。

numbers = [1, 2, 3, 4, 5]
squared_numbers = map(lambda x: x ** 2, numbers)
print(list(squared_numbers))  # 输出 [1, 4, 9, 16, 25]

在这个例子中，我们定义了一个 lambda 函数，它接受一个参数 x 并返回 x 的平方。然后我们将这个 lambda 函数和一个数字列表一起传递给 map() 函数，从而得到一个包含每个数字平方的新列表。

示例 3: 使用 `filter()` 函数

filter() 函数类似于 map()，但它根据提供的函数过滤序列中的元素。

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

这里我们定义了一个 lambda 函数，它接受一个参数 x 并检查 x 是否是偶数。我们使用 filter() 函数和这个 lambda 函数来从列表 numbers 中过滤出偶数。

示例 4: 使用 `sorted()` 函数

sorted() 函数可以接受一个 key 参数来指定如何对列表进行排序。我们可以使用 lambda 函数来定义排序的关键字。

students = [
    {'name': 'Alice', 'age': 25},
    {'name': 'Bob', 'age': 20},
    {'name': 'Charlie', 'age': 30}
]

sorted_students = sorted(students, key=lambda student: student['age'])
for student in sorted_students:
    print(student['name'], student['age'])
# 输出:
# Bob 20
# Alice 25
# Charlie 30

在这个例子中，我们定义了一个 lambda 函数来指定按照字典中的 'age' 键对列表进行排序。

总结

lambda 函数非常适用于那些需要简短逻辑的情况，特别是在需要传递函数作为参数给其他函数时非常有用。然而，对于更复杂的逻辑，使用传统的 def 关键字定义函数通常更为清晰和易于维护。

变量的作用域

在 Python 中，变量的作用域决定了变量可以在哪些部分被访问。Python 中主要有四种作用域：

局部作用域 (Local Scope): 在函数内部定义的变量只能在该函数内部被访问。
嵌套作用域 (Enclosing Scope): 当一个函数内部又定义了另一个函数时，内部函数可以访问外部函数的变量。
全局作用域 (Global Scope): 在程序的顶层定义的变量可以在整个程序中被访问。
内置作用域 (Built-in Scope): Python 内置的一些全局变量，比如 None, True, False 等。

下面通过具体的例子来说明每种作用域的特点。

局部作用域 (Local Scope)

局部作用域的变量只能在定义它们的函数内部访问。

def local_scope_example():
    x = 10
    print(x)  # 输出 10

local_scope_example()
# 如果尝试在函数外部访问 x，将会引发 NameError
# print(x)  # NameError: name 'x' is not defined

全局作用域 (Global Scope)

全局作用域的变量在整个模块内都可以被访问。

global_variable = 20

def global_scope_example():
    print(global_variable)  # 输出 20

global_scope_example()
print(global_variable)  # 输出 20

嵌套作用域 (Enclosing Scope)

当一个函数内部定义了另一个函数时，内部函数可以访问外部函数的变量。

def outer_function():
    x = 30
    
    def inner_function():
        print(x)  # 输出 30
        
    inner_function()

outer_function()

如果内部函数试图修改外部函数的变量，需要使用 nonlocal 关键字。

def outer_function():
    x = 30
    
    def inner_function():
        nonlocal x
        x = 40
        print(x)  # 输出 40
        
    inner_function()
    print(x)  # 输出 40

outer_function()

内置作用域 (Built-in Scope)

内置作用域包含了 Python 内置的全局变量。

print(True)  # 输出 True
print(False)  # 输出 False
print(None)  # 输出 None

修改全局变量

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

global_variable = 20

def modify_global():
    global global_variable
    global_variable = 25

modify_global()
print(global_variable)  # 输出 25

示例：混合使用作用域

这里有一个综合的例子，展示了不同作用域的使用：

def outer():
    x = 10

    def inner():
        nonlocal x
        x = 20
        print(f"Inner x: {x}")

    inner()
    print(f"Outer x: {x}")

outer()
print(f"Global x: {x}")  # 这一行会引发 NameError，因为 x 是在 outer 函数内部定义的

在这个例子中，outer 函数定义了一个局部变量 x，并且定义了一个内部函数 inner。inner 函数使用 nonlocal 关键字来修改 outer 函数中的 x。当调用 outer 函数时，x 的值首先被 inner 函数修改为 20，然后 outer 函数打印修改后的 x。最后尝试在全局范围内访问 x 会引发 NameError，因为 x 是局部变量，不是全局变量。

理解作用域对于避免命名冲突和正确地管理程序中的变量非常重要。

丁金金

关注

20
点赞
踩
18

收藏

觉得还不错? 一键收藏
打赏
0
评论
python函数

关键字参数：通过指定参数名和对应的值来传递参数。位置参数：按照函数定义的顺序传递参数。混合使用：可以同时使用位置参数和关键字参数。使用关键字参数的一个主要优点是可以提高代码的可读性，特别是在函数有许多参数的情况下。你还可以使用关键字参数来更改默认参数值而不需要修改所有参数。def create_user(username, email, age=18): # 年龄设为默认值18'age': age# 使用关键字参数覆盖默认值。
复制链接

扫一扫