使用Python定义的函数的方法包括：定义函数、调用函数、传递参数、使用默认参数、返回值、文档字符串。 在这些方法中，定义函数是最基础也是最重要的一步。
定义函数
在Python中，定义函数使用 def 关键字，后跟函数名和括号内的参数列表。函数体用缩进表示。下面是一个简单的函数定义示例：
def greet(name):
print(f"Hello, {name}!")
这个函数名为 greet，接受一个参数 name，并在调用时输出一条问候消息。
一、定义函数
函数定义的基本语法
在Python中，函数的定义使用 def 关键字。函数名后面跟着圆括号，圆括号内可以包含参数。函数体是缩进的代码块。以下是一个基本的函数定义：
def function_name(parameters):
# function body
return expression
其中，function_name 是函数的名称，parameters 是函数的参数列表，expression 是返回值。
示例
以下是一个示例函数，该函数计算两个数的和：
def add_numbers(a, b):
return a + b
在这个示例中，add_numbers 是函数名，a 和 b 是参数，函数返回 a 和 b 的和。
二、调用函数
基本调用方法
定义函数之后，可以通过其名称加上圆括号来调用它。如果函数有参数，则需要在调用时传递参数。以下是一个示例：
result = add_numbers(3, 4)
print(result) # Output: 7
在这个示例中，add_numbers 函数被调用，传递了参数 3 和 4，返回值被存储在变量 result 中并打印出来。
带有参数的调用
函数可以接受多个参数。在调用时，这些参数按顺序传递。以下是一个示例：
def multiply_numbers(x, y):
return x * y
result = multiply_numbers(2, 5)
print(result) # Output: 10
在这个示例中，multiply_numbers 函数被调用，传递了参数 2 和 5，返回值为 10。
三、传递参数
位置参数
位置参数是最常见的参数类型。它们按顺序传递给函数。以下是一个示例：
def subtract_numbers(a, b):
return a - b
result = subtract_numbers(10, 3)
print(result) # Output: 7
在这个示例中，subtract_numbers 函数被调用，参数 10 和 3 按顺序传递。
关键字参数
关键字参数通过指定参数名进行传递，这使得参数的顺序变得不重要。以下是一个示例：
def divide_numbers(a, b):
return a / b
result = divide_numbers(b=4, a=20)
print(result) # Output: 5.0
在这个示例中，divide_numbers 函数被调用，参数 a 和 b 通过指定参数名进行传递。
四、使用默认参数
默认参数的定义
函数可以有默认参数，这些参数在调用时如果没有传递值，则使用默认值。以下是一个示例：
def greet(name, message="Hello"):
print(f"{message}, {name}!")
greet("Alice") # Output: Hello, Alice!
greet("Bob", "Hi") # Output: Hi, Bob!
在这个示例中，greet 函数有一个默认参数 message，如果调用时没有传递 message 参数，则使用默认值 "Hello"。
默认参数的使用
默认参数使得函数调用更加灵活，用户可以选择性地传递某些参数。以下是一个示例：
def display_info(name, age, city="Unknown"):
print(f"Name: {name}, Age: {age}, City: {city}")
display_info("Alice", 30) # Output: Name: Alice, Age: 30, City: Unknown
display_info("Bob", 25, "New York") # Output: Name: Bob, Age: 25, City: New York
在这个示例中，display_info 函数有一个默认参数 city，可以选择性地传递。
五、返回值
返回单个值
函数可以返回一个值，使用 return 关键字。以下是一个示例：
def square(number):
return number * number
result = square(5)
print(result) # Output: 25
在这个示例中，square 函数返回参数 number 的平方。
返回多个值
函数可以返回多个值，使用逗号分隔。以下是一个示例：
def get_name_and_age():
name = "Alice"
age = 30
return name, age
name, age = get_name_and_age()
print(name) # Output: Alice
print(age) # Output: 30
在这个示例中，get_name_and_age 函数返回两个值，分别是 name 和 age。
六、文档字符串
使用文档字符串
文档字符串（docstring）用于为函数提供说明。它们在函数体的第一行，使用三引号括起来。以下是一个示例：
def multiply(a, b):
"""This function multiplies two numbers."""
return a * b
print(multiply.__doc__) # Output: This function multiplies two numbers.
在这个示例中，multiply 函数有一个文档字符串，描述了函数的功能。
文档字符串的作用
文档字符串有助于提高代码的可读性和可维护性。它们为函数提供了说明，使得其他开发者可以更容易地理解函数的功能。以下是一个示例：
def factorial(n):
"""
This function calculates the factorial of a number.
Parameters:
n (int): The number to calculate the factorial of.
Returns:
int: The factorial of the number.
"""
if n == 0:
return 1
else:
return n * factorial(n - 1)
print(factorial.__doc__)
在这个示例中，factorial 函数有一个详细的文档字符串，描述了函数的参数和返回值。
七、嵌套函数
定义嵌套函数
在Python中，可以在函数内部定义另一个函数，这种函数称为嵌套函数。以下是一个示例：
def outer_function(text):
def inner_function():
print(text)
inner_function()
outer_function("Hello, World!") # Output: Hello, World!
在这个示例中，inner_function 是一个嵌套函数，定义在 outer_function 的内部。
嵌套函数的作用
嵌套函数可以用于封装逻辑，创建闭包，或实现装饰器。以下是一个示例，展示了如何使用嵌套函数创建闭包：
def make_multiplier(x):
def multiplier(n):
return x * n
return multiplier
doubler = make_multiplier(2)
tripler = make_multiplier(3)
print(doubler(5)) # Output: 10
print(tripler(5)) # Output: 15
在这个示例中，make_multiplier 函数返回一个 multiplier 函数，后者是一个闭包，可以记住 make_multiplier 的参数 x。
八、匿名函数
定义匿名函数
在Python中，可以使用 lambda 关键字定义匿名函数。匿名函数是一种简单的、单行的函数。以下是一个示例：
add = lambda x, y: x + y
print(add(3, 5)) # Output: 8
在这个示例中，lambda 表达式定义了一个匿名函数，接受两个参数 x 和 y，返回它们的和。
匿名函数的作用
匿名函数通常用于需要一个简单函数的场景，例如在排序或过滤操作中。以下是一个示例，展示了如何在排序操作中使用匿名函数：
points = [(1, 2), (3, 4), (5, 1), (2, 3)]
points.sort(key=lambda point: point[1])
print(points) # Output: [(5, 1), (1, 2), (2, 3), (3, 4)]
在这个示例中，lambda 表达式定义了一个匿名函数，按第二个坐标对点进行排序。
九、装饰器
定义装饰器
装饰器是一种高阶函数，它接受一个函数作为参数，并返回一个新的函数。以下是一个示例，展示了如何定义一个简单的装饰器：
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()
在这个示例中，my_decorator 是一个装饰器，接受 say_hello 函数作为参数，并返回一个新的函数 wrapper，在调用 say_hello 之前和之后打印消息。
装饰器的作用
装饰器用于在不修改原函数代码的情况下，增强或修改函数的行为。它们常用于日志记录、权限检查、缓存等场景。以下是一个示例，展示了如何使用装饰器进行日志记录：
import functools
def log_decorator(func):
@functools.wraps(func)
def wrapper(*args, kwargs):
print(f"Calling {func.__name__} with arguments {args} and {kwargs}")
result = func(*args, kwargs)
print(f"{func.__name__} returned {result}")
return result
return wrapper
@log_decorator
def add(a, b):
return a + b
add(3, 5)
在这个示例中，log_decorator 是一个装饰器，记录函数调用的参数和返回值。
十、递归函数
定义递归函数
递归函数是指在函数内部调用自身的函数。以下是一个示例，展示了如何定义一个递归函数来计算阶乘：
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1)
print(factorial(5)) # Output: 120
在这个示例中，factorial 函数递归调用自身，直到 n 等于 0。
递归函数的作用
递归函数常用于解决具有重复子问题的复杂问题，例如斐波那契数列、树的遍历、汉诺塔问题等。以下是一个示例，展示了如何使用递归函数计算斐波那契数列：
def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(6)) # Output: 8
在这个示例中，fibonacci 函数递归调用自身，计算斐波那契数列的第 n 项。
十一、生成器函数
定义生成器函数
生成器函数使用 yield 关键字返回一个生成器对象，可以逐个生成值。以下是一个示例，展示了如何定义一个生成器函数：
def countdown(n):
while n > 0:
yield n
n -= 1
for number in countdown(5):
print(number)
在这个示例中，countdown 函数是一个生成器函数，逐个生成从 n 到 1 的值。
生成器函数的作用
生成器函数用于处理需要大量内存的数据，可以逐个生成值，而不是一次性返回所有值。以下是一个示例，展示了如何使用生成器函数生成斐波那契数列：
def fibonacci_generator():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
fib = fibonacci_generator()
for _ in range(10):
print(next(fib))
在这个示例中，fibonacci_generator 函数是一个生成器函数，逐个生成斐波那契数列的值。
十二、函数的类型注解
使用类型注解
Python 3.5 及以上版本支持函数参数和返回值的类型注解。以下是一个示例，展示了如何使用类型注解：
def add(a: int, b: int) -> int:
return a + b
print(add(3, 5)) # Output: 8
在这个示例中，add 函数的参数 a 和 b 以及返回值都进行了类型注解。
类型注解的作用
类型注解有助于提高代码的可读性和可维护性，可以为开发者提供更多的上下文信息，并帮助静态类型检查工具进行类型检查。以下是一个示例，展示了如何使用类型注解进行类型检查：
from typing import List
def sum_list(numbers: List[int]) -> int:
return sum(numbers)
print(sum_list([1, 2, 3, 4])) # Output: 10
在这个示例中，sum_list 函数的参数 numbers 使用了类型注解 List[int]，表示它是一个整数列表。
十三、函数的参数解包
使用参数解包
Python 支持使用 * 和 进行参数解包，可以将列表或字典传递给函数。以下是一个示例，展示了如何使用参数解包：
def print_numbers(a, b, c):
print(a, b, c)
numbers = [1, 2, 3]
print_numbers(*numbers) # Output: 1 2 3
在这个示例中，*numbers 将列表 numbers 解包为函数参数。
参数解包的作用
参数解包使得函数调用更加灵活，可以方便地传递多个参数。以下是一个示例，展示了如何使用 进行关键字参数解包：
def print_info(name, age, city):
print(f"Name: {name}, Age: {age}, City: {city}")
info = {"name": "Alice", "age": 30, "city": "New York"}
print_info(info) # Output: Name: Alice, Age: 30, City: New York
在这个示例中，info 将字典 info 解包为函数参数。
十四、函数的闭包
定义闭包
闭包是指在函数内部定义的函数可以引用其外部作用域的变量。以下是一个示例，展示了如何定义闭包：
def outer_function(msg):
def inner_function():
print(msg)
return inner_function
closure = outer_function("Hello, World!")
closure() # Output: Hello, World!
在这个示例中，inner_function 是一个闭包，可以引用 outer_function 的参数 msg。
闭包的作用
闭包可以用于创建带有状态的函数或延迟计算。以下是一个示例，展示了如何使用闭包创建带有状态的函数：
def make_counter():
count = 0
def counter():
nonlocal count
count += 1
return count
return counter
counter = make_counter()
print(counter()) # Output: 1
print(counter()) # Output: 2
print(counter()) # Output: 3
在这个示例中，counter 函数是一个闭包，可以引用 make_counter 的变量 count。
十五、函数的高阶函数
定义高阶函数
高阶函数是指接受函数作为参数或返回函数的函数。以下是一个示例，展示了如何定义高阶函数：
def apply_function(func, value):
return func(value)
def square(x):
return x * x
相关问答FAQs：
如何在Python中创建一个简单的函数？
在Python中创建一个函数非常简单。使用def关键字开始，接着是函数名称和参数列表。以下是一个基本的示例：
def greet(name):
return f"Hello, {name}!"
调用该函数的方法是直接使用函数名并传入参数，例如：greet("Alice")，这将返回"Hello, Alice!"。
在Python中如何传递参数给函数？
函数可以通过位置参数、关键字参数和默认参数来接收输入。位置参数是最常见的方式，按照定义时的顺序传递。关键字参数允许你在调用函数时指定参数的名称，便于提高代码的可读性。默认参数则为参数设定一个默认值，如果调用时未传入该参数，函数将使用默认值。例如：
def add(x, y=10):
return x + y
调用add(5)将返回15，因为y使用了默认值。
如何在Python函数中返回多个值？
Python函数可以通过元组、列表或字典来返回多个值。返回多个值时，使用逗号分隔。例如：
def calculate(a, b):
return a + b, a - b, a * b
调用calculate(5, 3)将返回一个元组(8, 2, 15)，可以通过解包来分别获取这些值。
