函数的特殊参数
# /前的参数只能是位置参数，*后面的只能是关键字参数，之间的不限参数类型
def func(a, b, /, c, *, d, e):
print(a, b, c, d, e)
func(1, 2, 3, d=4, e=5)
func(1, 2, c=3, d=4, e=5) # a,b不能以关键字形式传参，d,e只能以关键字参数传参
# 可变参数*args
def func(*args):
print(type(args))
print(*args)
func(1, 2) # 输出的内容为 <class 'tuple'> ，通过元组的格式进行存储
# 可变参数*kwargs
def func(**kwargs):
print(type(kwargs))
print(kwargs)
func(a=1 , b=2) # 输出的内容为 <class 'dict'> ，通过字典的格式进行存储
# 参数解包
def func(a, b, c):
print(a, b, c)
args = [1, 2, 3]
func(*args) # 解包列表
args = (1, 2, 3)
func(*args) # 解包元组
s = "hello"
func(*s) # 解包字符串，将字符串的每个字符作为单独的参数传递
d = {'a': 1, 'b': 2, 'c': 3}
func(*d.values()) # 解包字典的值 1, 2, 3
def func(a, b, *c):
print(a, b, c)
args = [1, 2, 3, 4, 5]
func(*args) # 1, 2, (3, 4, 5)
def func(a, b, c, d):
print(a, b, c, d)
args = [1, 2, 3, 4, 5]
func(args[0], *args[1:]) # 1, 2, 3, 4
闭包
# 闭包是一个函数和它所引用的环境组合的一个整体。在Python中，闭包通常是在一个函数内定义另一个函数，并且这个内部函数引用了外部函数中的变量。
def outer_func(x):
def inner_func(y):
return x * y
return inner_func
my_closure = outer_func(5)
result = my_closure(7)
print(result) # 输出: 35
装饰器
# 定义一个装饰器函数来计算函数执行时间
def timer(func):
def wrapper(*args, **kwargs):
start_time = time.perf_counter()
result = func(*args, **kwargs)
end_time = time.perf_counter()
execution_time = end_time - start_time
print(f"函数 {func.__name__} 执行耗时: {execution_time} 秒")
return result
return wrapper
# 使用装饰器
@timer # 等同于 example = timer(example)
def example():
time.sleep(1)
print("这是一个示例函数。")
# 调用被装饰的函数
example()
LEGB规则(变量作用域)
# Local（局部）作用域示例
def my_function():
x = 10
print(x)
my_function() # 输出结果为 10
print(x) # 报错，x未定义
# Enclosing（嵌套）作用域示例
def outer_function():
x = 10
def inner_function():
print(x)
inner_function() # 输出结果为 10
outer_function()
# Global（全局）作用域示例
x = 10
def my_function():
print(x)
my_function() # 输出结果为 10
print(x) # 输出结果为 10
# Built-in（内建）作用域示例
print("Hello, World!") # 输出结果为 Hello, World!
# LEGB规则的应用示例
x = 10
def outer_function():
x = 20
def inner_function():
nonlocal x
x = 30
print("Inner function:", x)
inner_function()
print("Outer function:", x)
outer_function()
print("Global:", x)
Lambda表达式
# Python 中的lambda表达式是一种定义匿名函数的方式，它允许你创建简洁的、没有名字的函数。
lambda arguments: expression
# arguments 是函数的参数列表，可以包含多个参数，也可以不包含参数。
# expression 是函数体，可以是任意的表达式。
# Lambda表达式的返回值是一个函数对象，可以将其赋值给一个变量，并通过变量来调用该函数。
# 以下是一些使用lambda表达式的例子：
# 定义一个求两数之和的函数：add = lambda x, y: x + y
# 定义一个比较两个数大小的函数：mx = lambda n1, n2: n1 if n1 > n2 else n2
# 使用map函数将列表中的每个元素都平方：squares = list(map(lambda x: x**2, lst))
# 使用filter函数过滤出列表中的偶数：evens = list(filter(lambda x: x % 2 == 0, lst))
# 使用reduce函数计算列表中所有元素的和：total = reduce(lambda x, y: x + y, lst)
生成器
def fibonacci(n): # 定义一个斐波那契数列的生成器函数
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # 创建一个生成器实例，生成10个数字
while True:
try:
print(next(f), end=" ")
except StopIteration:
break
生成器表达式
# 使用列表推导式生成一个平方列表
squares = [x**2 for x in range(10)]
print(squares) # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 使用生成器表达式替代列表推导式以节省内存
squares_gen = (x**2 for x in range(10))
print(list(squares_gen)) # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 生成器迭代
squares_gen = (x**2 for x in range(10))
while True:
try:
print(next(squares_gen), end=" ")
except StopIteration:
break
递归
# 在使用递归时，必须有一个明确的退出条件，否则，递归将无限进行下去，最终导致栈溢出错误
# 计算阶乘
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
print(factorial(5)) # 输出: 120
# 求斐波那契数列
def fibonacci(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(10)) # 输出: 55
# 排列组合
def perm(lst, n):
if n == 1:
return [lst]
else:
l = []
for i in range(len(lst)):
t = lst[:i] + lst[i+1:]
p = perm(t, n-1)
for j in p:
l.append(lst[i:i+1] + j)
return l
lst = [1, 2, 3]
print(perm(lst, len(lst))) # 输出: [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
# 搜索树的深度
def depth(node):
if node is None:
return 0
else:
return 1 + max(depth(node.left), depth(node.right))
高阶函数
# reduce函数累积运算
from functools import reduce
# 定义一个加法函数
def add(x, y):
return x + y
# 使用reduce来累加列表中的数字
numbers = [1, 2, 3, 4, 5]
result = reduce(add, numbers)
print(result) # 输出15
# 偏函数partial函数将一个或多个参数预设为特定值
from functools import partial
# 一个简单的函数，用于将两个数字相乘并返回结果
def multiply(x, y):
return x * y
# 使用partial创建一个新函数，预设y的值为2
double = partial(multiply, y=2)
# 当调用double时，只需要提供一个x参数
result = double(3) # 相当于multiply(3, 2)
print(result) # 输出: 6
# warps装饰器保留原函数的元信息
import functools
def my_decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
# 在调用函数之前可以添加操作
result = func(*args, **kwargs)
# 在调用函数之后可以添加操作
return result
return wrapper
@my_decorator
def my_function():
"""这是一个测试函数"""
print("Hello, World!")
print(my_function.__name__) # 输出: my_function
print(my_function.__doc__) # 输出: 这是一个测试函数
# 如果我们不使用functools.wraps，那么执行上述代码，将会输出：
wrapper
None