Python调用自己写的函数非常简单、只需要定义函数并在需要的地方调用它、函数的定义使用def关键字、函数调用时使用函数名加小括号。
比如在Python中，你可以这样定义一个简单的函数：
def greet(name):
print(f"Hello, {name}!")
然后在代码的其他部分调用它：
greet("Alice")
这一段代码会输出Hello, Alice!。定义函数时，需要注意以下几点：函数名应具有描述性、以便于理解其功能；函数参数可以有默认值、以提高函数的灵活性；函数可以有返回值、通过return关键字返回。
一、定义函数的基础知识
在Python中，定义函数的基本语法如下：
def function_name(parameters):
"""docstring"""
statement(s)
1、函数名和参数
函数名可以由字母、数字和下划线组成，但不能以数字开头。参数是可选的，函数可以有多个参数，也可以没有参数。例如：
def add(a, b):
return a + b
这个函数add接收两个参数a和b，并返回它们的和。
2、函数体
函数体包含函数执行的代码块。代码块的缩进必须一致，一般使用四个空格。函数体可以包含任意数量的语句。
3、文档字符串
文档字符串（docstring）是函数的注释，用于描述函数的用途和用法。它放在函数定义的第一行，通常用三重引号（"""）括起来。例如：
def greet(name):
"""Print a greeting message to the given name."""
print(f"Hello, {name}!")
二、调用函数
调用函数时，只需使用函数名加上小括号，并传入必要的参数。例如：
result = add(3, 5)
print(result) # 输出: 8
1、位置参数
位置参数是最常见的参数类型，按顺序传递给函数。例如：
def multiply(a, b):
return a * b
print(multiply(4, 5)) # 输出: 20
2、关键字参数
关键字参数通过参数名传递给函数，可以不按顺序。例如：
def greet(name, message):
print(f"{message}, {name}!")
greet(message="Good morning", name="Alice") # 输出: Good morning, Alice!
3、默认参数
默认参数在定义函数时指定默认值，如果调用时未传入参数，则使用默认值。例如：
def greet(name, message="Hello"):
print(f"{message}, {name}!")
greet("Alice") # 输出: Hello, Alice!
greet("Bob", "Good evening") # 输出: Good evening, Bob!
三、返回值
函数可以使用return语句返回一个值，如果没有return语句，函数返回None。例如：
def add(a, b):
return a + b
result = add(3, 5)
print(result) # 输出: 8
函数也可以返回多个值，返回的多个值会被打包成一个元组。例如：
def get_coordinates():
return 10, 20
x, y = get_coordinates()
print(x, y) # 输出: 10 20
四、局部变量和全局变量
1、局部变量
局部变量是在函数内部定义的变量，只能在该函数内部访问。例如：
def increment(x):
y = x + 1
return y
print(increment(5)) # 输出: 6
print(y) # 报错：NameError: name 'y' is not defined
2、全局变量
全局变量是在函数外部定义的变量，可以在整个程序中访问。例如：
z = 10
def increment(x):
return x + z
print(increment(5)) # 输出: 15
如果需要在函数内部修改全局变量，需要使用global关键字声明。例如：
z = 10
def increment_global():
global z
z += 1
increment_global()
print(z) # 输出: 11
五、嵌套函数和闭包
1、嵌套函数
嵌套函数是指在一个函数内部定义另一个函数。例如：
def outer_function():
def inner_function():
print("This is the inner function")
inner_function()
outer_function()
输出: This is the inner function
2、闭包
闭包是一个函数对象，即使在外部函数已经返回的情况下，仍然能够访问外部函数的变量。例如：
def outer_function(x):
def inner_function(y):
return x + y
return inner_function
closure = outer_function(10)
print(closure(5)) # 输出: 15
六、递归函数
递归函数是指函数调用自身。递归函数必须有一个终止条件，否则会无限递归下去。例如，计算阶乘的递归函数：
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1)
print(factorial(5)) # 输出: 120
七、匿名函数（lambda 函数）
匿名函数是没有名字的函数，使用lambda关键字定义。匿名函数可以接受任意数量的参数，但只能有一个表达式。例如：
add = lambda a, b: a + b
print(add(3, 5)) # 输出: 8
匿名函数常用于需要一个简单函数但不想命名的场景，例如在map、filter和sorted等函数中使用。例如：
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x 2, numbers)
print(list(squared)) # 输出: [1, 4, 9, 16, 25]
八、函数参数的解包
Python支持在函数调用时使用*和运算符进行参数解包。这使得传递列表或字典作为函数参数变得更加方便。
1、使用*解包列表
可以使用*运算符将列表的元素作为位置参数传递给函数。例如：
def add(a, b):
return a + b
numbers = [3, 5]
result = add(*numbers)
print(result) # 输出: 8
2、使用</strong>解包字典
可以使用运算符将字典的键值对作为关键字参数传递给函数。例如：
def greet(name, message):
print(f"{message}, {name}!")
info = {"name": "Alice", "message": "Good morning"}
greet(info) # 输出: Good morning, Alice!
九、高阶函数
高阶函数是指可以接受其他函数作为参数或返回一个函数的函数。例如：
1、接受函数作为参数
def apply_function(func, value):
return func(value)
def square(x):
return x 2
print(apply_function(square, 5)) # 输出: 25
2、返回一个函数
def create_multiplier(factor):
def multiplier(number):
return number * factor
return multiplier
double = create_multiplier(2)
print(double(5)) # 输出: 10
十、装饰器
装饰器是高阶函数的一种，用于在不修改原函数代码的情况下，扩展或修改函数的行为。使用@符号应用装饰器。例如：
1、定义装饰器
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
2、应用装饰器
@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.
装饰器也可以带参数，例如：
def repeat(n):
def decorator(func):
def wrapper(*args, kwargs):
for _ in range(n):
func(*args, kwargs)
return wrapper
return decorator
@repeat(3)
def say_hello():
print("Hello!")
say_hello()
输出:
Hello!
Hello!
Hello!
十一、函数注解
函数注解用于为函数的参数和返回值添加类型提示。虽然注解不会影响函数的运行，但可以提高代码的可读性和可维护性。例如：
def add(a: int, b: int) -> int:
return a + b
print(add(3, 5)) # 输出: 8
可以使用__annotations__属性查看函数的注解：
print(add.__annotations__)
输出: {'a': <class 'int'>, 'b': <class 'int'>, 'return': <class 'int'>}
十二、函数式编程
Python支持函数式编程范式，例如使用map、filter和reduce等函数处理数据。
1、map函数
map函数用于将一个函数应用到一个可迭代对象的每个元素，并返回一个迭代器。例如：
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x 2, numbers)
print(list(squared)) # 输出: [1, 4, 9, 16, 25]
2、filter函数
filter函数用于过滤掉不符合条件的元素，并返回一个迭代器。例如：
numbers = [1, 2, 3, 4, 5]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers)) # 输出: [2, 4]
3、reduce函数
reduce函数用于将一个二元函数累积地应用到一个可迭代对象的元素，并返回一个单一值。例如：
from functools import reduce
numbers = [1, 2, 3, 4, 5]
sum_of_numbers = reduce(lambda x, y: x + y, numbers)
print(sum_of_numbers) # 输出: 15
十三、生成器函数
生成器函数使用yield语句生成一个值序列，每次调用生成器时，它会从上次yield语句处继续执行。例如：
def countdown(n):
while n > 0:
yield n
n -= 1
for number in countdown(5):
print(number)
输出:
5
4
3
2
1
生成器函数与普通函数的区别在于，它们返回一个生成器对象而不是单个值。生成器对象是一个迭代器，可以在需要时生成值。
十四、模块和包中的函数
在实际开发中，函数通常存放在模块和包中，以便于组织和重用代码。例如，假设有一个名为math_utils.py的模块，包含以下函数：
# math_utils.py
def add(a, b):
return a + b
def subtract(a, b):
return a - b
可以在另一个脚本中导入并使用这些函数：
# main.py
from math_utils import add, subtract
print(add(3, 5)) # 输出: 8
print(subtract(10, 3)) # 输出: 7
包是包含多个模块的目录，通常包含一个__init__.py文件。可以通过包组织相关的模块。例如，假设有一个名为math_package的包，包含以下文件结构：
math_package/
__init__.py
arithmetic.py
geometry.py
其中，arithmetic.py包含以下函数：
# arithmetic.py
def add(a, b):
return a + b
def subtract(a, b):
return a - b
geometry.py包含以下函数：
# geometry.py
def area_of_circle(radius):
import math
return math.pi * radius 2
def perimeter_of_circle(radius):
import math
return 2 * math.pi * radius
可以在另一个脚本中导入并使用这些函数：
# main.py
from math_package.arithmetic import add, subtract
from math_package.geometry import area_of_circle, perimeter_of_circle
print(add(3, 5)) # 输出: 8
print(subtract(10, 3)) # 输出: 7
print(area_of_circle(5)) # 输出: 78.53981633974483
print(perimeter_of_circle(5)) # 输出: 31.41592653589793
十五、单元测试
单元测试用于验证函数的正确性。Python标准库提供了unittest模块，用于编写和运行单元测试。例如：
import unittest
from math_utils import add, subtract
class TestMathUtils(unittest.TestCase):
def test_add(self):
self.assertEqual(add(3, 5), 8)
self.assertEqual(add(-1, 1), 0)
def test_subtract(self):
self.assertEqual(subtract(10, 3), 7)
self.assertEqual(subtract(5, 5), 0)
if __name__ == "__main__":
unittest.main()
运行以上代码将执行测试用例，并报告测试结果。
十六、文档化函数
良好的文档对函数的使用和维护至关重要。Python的docstring用于为函数添加文档说明。可以使用工具如Sphinx生成函数的文档。例如：
def add(a: int, b: int) -> int:
"""
Add two integers and return the result.
:param a: The first integer.
:param b: The second integer.
:return: The sum of the two integers.
"""
return a + b
十七、性能优化
在编写函数时，性能优化是一个重要考虑因素。以下是一些常见的性能优化技巧：
1、减少不必要的计算
避免在循环中进行重复计算。例如：
# 不推荐
def calculate_squares(numbers):
result = []
for number in numbers:
result.append(number 2)
return result
推荐
def calculate_squares(numbers):
return [number 2 for number in numbers]
2、使用生成器
生成器比列表更节省内存，因为它们按需生成值。例如：
# 不推荐
def get_squares(numbers):
return [number 2 for number in numbers]
推荐
def get_squares(numbers):
for number in numbers:
yield number 2
3、使用内置函数和库
Python的内置函数和标准库通常经过高度优化，比自己实现的代码更高效。例如：
# 不推荐
def factorial(n):
result = 1
for i in range(1, n + 1):
result *= i
return result
推荐
import math
def factorial(n):
return math.factorial(n)
十八、函数的可读性和维护性
编写易于阅读和维护的函数是良好的编程实践。以下是一些建议：
1、函数应具有单一职责
每个函数应只做一件事，并且应有一个明确的职责。例如：
# 不推荐
def process_data(data):
clean_data = clean(data)
transformed_data = transform(clean_data)
save(transformed_data)
推荐
def clean_data(data):
# 清理数据
pass
def transform_data(data):
# 转换数据
pass
def save_data(data):
# 保存数据
pass
2、函数名应具有描述性
函数名应描述函数的功能，以便于理解。例如：
# 不推荐
def process(a, b):
return a + b
推荐
def add(a, b):
return a + b
3、适当使用注释和文档字符串
注释和文档字符串可以帮助理解函数的用途和实现。例如：
相关问答FAQs：
如何在Python中定义一个函数并调用它？
在Python中，定义一个函数非常简单。使用def关键字来开始定义，并为函数命名。函数体需要缩进。例如：
def my_function():
print("Hello, World!")
调用这个函数只需使用它的名称加上括号：
my_function()
可以在函数中传递参数吗？如何实现？
是的，您可以在定义函数时指定参数，这样调用时可以向函数传递不同的值。例如：
def greet(name):
print(f"Hello, {name}!")
调用函数时传入参数：
greet("Alice")
输出将会是“Hello, Alice!”。
如何在函数中返回值，而不是直接打印？
在函数中，您可以使用return语句来返回值，而不是使用print()。这样您可以在调用函数后处理返回的结果。示例代码如下：
def add(a, b):
return a + b
调用函数并保存返回值：
result = add(5, 3)
print(result) # 输出8
这种方式使得函数更加灵活和实用。
