def 函数名(参数1，参数2....):
    ...
    reture 结果 #可以不返回

def greet_user():
    """显示简单的问候语"""
    print("hello") 
greet_user()

参数

关键字参数

指定参数指向，如果不加关键字必须顺序一致

def greet_user(animal_type, pet_name):
    print(f"我有一只宠物{animal_type},它叫做{pet_name}") greet_user( pet_name="皮特",animal_type="狗")
greet_user("狗", "皮特")

默认参数

函数参数可以有默认值。如果没有为这些参数提供值，将自动使用定义函数时指定的默认值。

定义具有默认值的参数只需要在函数定义中将值赋给参数即可。

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

greet("Alice")  # 使用默认消息
greet("Bob", "Good morning")  # 提供自定义消息

在这个例子中， msg 参数有一个默认值 "Hello"。如果调用 greet 时没有提供 msg 参数的值，就会使用这个默认值。

当默认值是可变对象（例如列表、字典或其他可变类型）时，可能会遇到预期之外的行为。

def append_number(numbers=[]):
    numbers.append(1)
    return numbers

print(append_number())  # 输出: [1]
print(append_number())  # 输出: [1, 1]

这个行为是因为函数的默认值只在函数定义时评估一次，所以每次调用 append_number 时，如果不提供 numbers 参数，都会使用同一个列表对象。为了避免这个问题，推荐使用不可变对象作为默认值。

对于需要使用可变对象作为默认值的情况，推荐的做法是使用 None 作为默认值，在函数体内部检查它，并据此初始化。

def append_number(numbers=None):
    if numbers is None:
        numbers = []
    numbers.append(1)
    return numbers

print(append_number())  # 输出: [1]
print(append_number())  # 输出: [1]

这样每次调用 append_number 时，如果没有提供 numbers 参数，都会创建一个新的空列表。

可变参数

可变参数允许函数调用时传入任意数量的参数，无论是位置参数还是关键字参数。这通过使用 *args 和 **kwargs 语法实现。

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

当你在函数定义中使用 *args 时，所有传入的位置参数都会被收集到一个名为 args 的元组中。 args 是约定俗成的名称，你也可以使用其他名称，但 * 符号是必须的。

def print_args(*args):
    for arg in args:
        print(arg)

print_args('hello', 'world', 123)

这里， print_args 可以接受任意数量的位置参数，并将它们依次打印出来。

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

使用 **kwargs 时，所有传入的关键字参数都会被收集到一个名为 kwargs 的字典中。同样地， kwargs 只是一个习惯用法，你可以使用任何你喜欢的参数名，关键是 ** 符号。

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

print_kwargs(name='Alice', age=30)

在这个例子中， print_kwargs 函数接受任意数量的关键字参数，并遍历 kwargs 字典，打印出所有的键值对。

同时使用*args和**kwargs

你可以在同一个函数中同时使用 *args 和 **kwargs 来让它接受任意数量的位置参数和关键字参数。

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

print_everything('apple', 'banana', color='red', count=5)

在这个例子中， print_everything 函数同时接受任意数量的位置参数和关键字参数，并分别处理它们。

注意

• 当同时使用 *args 和 **kwargs 时， *args 必须位于 **kwargs 之前。
• 在调用函数时，位置参数必须在关键字参数之前。
• 使用可变参数时，要注意函数内部对 args 和 kwargs 的处理逻辑，确保函数的行为符合预期。

函数返回值

通过 return 语句，函数能够返回一个或多个值。

单个返回值

最基本的形式是函数返回单个值。这通过简单地在函数中使用 return 语句实现。

def square(number):
    return number ** 2

result = square(4)
print(result)  # 输出: 16

在这个例子中， square 函数计算传入数字的平方并返回结果。

返回多个值

可以一次性返回多个值，这通常是通过返回一个元组实现的。在实际应用中，你不需要显式地创建元组；只需在 return 语句中用逗号分隔多个返回值即可。

def get_user():
    name = "Alice"
    age = 30
    return name, age
# 直接解包赋值
user_name, user_age = get_user()
print(user_name, user_age)  # 输出: Alice 30

这里， get_user 函数返回了两个值： name 和 age。调用函数时，可以通过多个变量接收这些返回值。

没有返回值

如果函数没有 return 语句，或者 return 语句没有跟随任何值，那么函数会默认返回 None。

def print_message(message):
    print(message)

result = print_message("Hello, Python!")
print(result)  # 输出: None

即便 print_message 函数执行了打印操作，但由于没有 return 语句，它返回了 None。

使用return提前退出函数

return 语句不仅用于返回值，还可以用于提前退出函数，即使在函数的其他部分还有代码。

def divide(x, y):
    if y == 0:
        print("Error: Division by zero.")
        return
    return x / y

result = divide(10, 0)
print(result)  # 输出: Error: Division by zero.
               # None

在这个例子中，如果尝试除以零，则函数会打印错误消息并提前退出，返回 None。

匿名函数

匿名函数或 lambda 函数是一种定义简单函数的快捷方式，它们不需要使用标准的 def 关键字。匿名函数主要用于编写简洁的代码，尤其是在需要将函数作为参数传递给其他函数的场景中。

基本语法

匿名函数的基本语法如下：

lambda arguments: expression

这里， lambda 是定义匿名函数的关键字， arguments 是函数的参数， expression 是函数体，它是一个表达式，表达式的计算结果就是函数的返回值。

square = lambda x: x ** 2
print(square(5))  # 输出: 25

在这个例子中，我们定义了一个匿名函数来计算数字的平方，并将这个函数赋值给变量 square。然后，我们调用这个匿名函数并打印结果。

使用场景

匿名函数通常用于函数调用的参数中，特别是那些接受其他函数作为参数的高阶函数。例如， filter()、 map() 和 sorted() 等。

使用map()应用匿名函数

map() 函数可以将匿名函数应用于序列中的每个元素。

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

使用filter()过滤序列

filter() 函数可以使用匿名函数来过滤序列，只保留满足条件的元素。

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

在sorted()中使用自定义排序

通过 sorted() 函数的 key 参数，我们可以使用匿名函数来自定义排序逻辑。

points = [(1, 2), (3, 1), (5, 4)]
sorted_points = sorted(points, key=lambda point: point[1])
print(sorted_points)  # 输出: [(3, 1), (1, 2), (5, 4)]

限制

虽然匿名函数非常灵活且代码简洁，但它们也有一些限制：

• 只能包含一个表达式，不能包含复杂的逻辑。
• 不能包含命令，例如循环或多个语句。