1. 装饰器
装饰器是 Python 的一种高阶函数，它可以在不修改函数内部代码的情况下，给函数增加额外的功能。
案例：记录函数执行时间的装饰器
import time
def timing_decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"Function {func.__name__} took {end_time - start_time:.6f} seconds to execute.")
return result
return wrapper
@timing_decorator
def my_function():
time.sleep(1) # 模拟耗时操作
print("Function executed.")
my_function()
效果图
2. 迭代器
迭代器是一个可以记住遍历位置的对象，它可以从头到尾访问数据集合的元素。
案例：使用迭代器遍历列表
my_list = [1, 2, 3, 4, 5] my_iter = iter(my_list) print(next(my_iter)) # 输出: 1 print(next(my_iter)) # 输出: 2 # ... 可以继续调用 next() 直到 StopIteration 异常
效果图
3. 生成器
生成器是一种特殊的迭代器，它使用 yield 关键字来产生值，并且只在需要时计算下一个值，这可以节省内存。
案例：生成斐波那契数列的生成器
def fibonacci(n): a, b = 0, 1 while a < n: yield a a, b = b, a + b # 使用生成器 for num in fibonacci(10): print(num)
效果图
4. 高阶函数
高阶函数是接受函数作为参数或返回函数作为结果的函数。
案例：高阶函数实现函数映射
def apply_func(func, lst): return [func(x) for x in lst] def square(x): return x ** 2 numbers = [1, 2, 3, 4, 5] squared_numbers = apply_func(square, numbers) print(squared_numbers) # 输出: [1, 4, 9, 16, 25]
效果图
5. 匿名函数
匿名函数（lambda 函数）是没有名称的简短函数。
案例：使用匿名函数对列表进行排序
my_list = [(1, 'a'), (2, 'c'), (3, 'b')] my_list.sort(key=lambda x: x[1]) # 根据元组的第二个元素排序 print(my_list) # 输出: [(1, 'a'), (3, 'b'), (2, 'c')]
效果图
6. 偏函数
偏函数是固定了某些参数的新函数，返回一个新函数，这个新函数可以调用原函数，且原函数的某些参数值始终不变。
案例：使用偏函数设置默认参数
from functools import partial
def greet(name, greeting="Hello"):
print(f"{greeting}, {name}!")
greet_with_hi = partial(greet, greeting="Hi")
greet_with_hi("Alice") # 输出: Hi, Alice!
效果图
7. 切片
切片用于在序列类型（如列表、元组、字符串）上选择一段连续的元素。
案例：使用切片选择字符串中的一部分
s = "Hello, World!" substring = s[7:12] # 选择索引7到11的字符（不包括12） print(substring) # 输出: World
效果图
8. 列表解析式
列表解析式是一种简洁创建列表的方式。
案例：使用列表解析式创建平方数列表
numbers = [1, 2, 3, 4, 5] squares = [x**2 for x in numbers] print(squares) # 输出: [1, 4, 9, 16, 25]
效果图
9 元组拆包
元组拆包是将元组中的元素分别赋值给不同的变量。这在处理返回多个值的函数或接收多个值的函数参数时非常有用。
案例：交换两个变量的值
a, b = 1, 2
print(f"Before swap: a = {a}, b = {b}")
# 使用元组拆包交换值
a, b = b, a
print(f"After swap: a = {a}, b = {b}") # 输出: After swap: a = 2, b = 1
效果图
10 多进程
多进程是指操作系统中同时运行多个进程，每个进程都拥有独立的内存空间和系统资源。Python的multiprocessing模块支持多进程编程。
案例：使用多进程计算平方数
from multiprocessing import Process
def square(n):
print(f"The square of {n} is {n**2}")
if __name__ == "__main__":
processes = []
for i in range(5):
p = Process(target=square, args=(i,))
processes.append(p)
p.start()
for p in processes:
p.join() # 等待所有进程完成
效果图
11 进程通信
进程通信是指在不同进程之间传递信息或数据。Python的multiprocessing模块提供了Queue、Pipe等方式来实现进程间通信。
案例：使用Queue进行进程通信
from multiprocessing import Process, Queue
def worker(q):
result = q.get() # 从队列中获取任务
print(f"Processing {result}")
q.put(result * 2) # 将处理结果放回队列
if __name__ == "__main__":
q = Queue()
q.put(10) # 向队列中添加任务
p = Process(target=worker, args=(q,))
p.start()
p.join()
result = q.get() # 从队列中获取处理结果
print(f"Result: {result}") # 输出: Result: 20
效果图
12 进程锁
进程锁用于同步多个进程对共享资源的访问，以避免竞态条件。multiprocessing模块提供了Lock来实现进程锁。
案例：使用进程锁保护共享资源
from multiprocessing import Process, Lock, Value
def increment(lock, counter, n):
for _ in range(n):
with lock: # 使用with语句自动管理锁
counter.value += 1
if __name__ == "__main__":
lock = Lock()
counter = Value('i', 0) # 创建一个共享整数计数器
processes = []
for _ in range(10):
p = Process(target=increment, args=(lock, counter, 1000))
processes.append(p)
p.start()
for p in processes:
p.join()
print(f"Final counter value: {counter.value}") # 输出应该接近10000
效果图
13 进程池
进程池用于限制同时运行的进程数量，这对于管理系统资源非常有用。multiprocessing.Pool类提供了进程池的实现。
案例：使用进程池计算平方数列表
from multiprocessing import Pool def square(n): return n ** 2 if __name__ == "__main__": with Pool(processes=4) as pool: # 创建一个包含4个进程的进程池 numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] results = pool.map(square, numbers) # 使用进程池计算平方数 print(results) # 输出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
效果图
14 多线程
多线程是指在同一个进程中运行多个线程，共享进程的内存空间和系统资源。Python的threading模块支持多线程编程。
案例：使用多线程打印数字
import threading
import time
# 打印奇数的线程函数
def print_odd_numbers():
for i in range(1, 6, 2):
time.sleep(0.5) # 模拟耗时操作
print(i)
# 打印偶数的线程函数
def print_even_numbers():
for i in range(2, 6, 2):
time.sleep(0.5) # 模拟耗时操作
print(i)
# 创建线程
odd_thread = threading.Thread(target=print_odd_numbers)
even_thread = threading.Thread(target=print_even_numbers)
# 启动线程
odd_thread.start()
even_thread.start()
# 等待线程结束
odd_thread.join()
even_thread.join()
print("All threads have finished.")
效果图
15 os模块
简单介绍： os模块提供了很多与操作系统交互的功能，如文件操作、目录操作、环境变量获取等。它允许Python程序执行系统相关的操作，如创建和删除文件、读取环境变量等。
案例：列出当前目录下的所有文件和文件夹
import os
# 列出当前目录下的所有文件和文件夹
for item in os.listdir('.'):
print(item)
效果图
17 datetime模块
简单介绍： datetime模块提供了日期和时间的类，用于解析、格式化、操作日期和时间。该模块中的datetime类可以表示一个具体的日期和时间，支持加减运算以及日期时间的比较等。
案例：获取当前日期和时间，并计算一天后的日期
from datetime import datetime, timedelta
# 获取当前日期和时间
now = datetime.now()
print("Current date and time:", now)
# 计算一天后的日期
one_day_later = now + timedelta(days=1)
print("Date one day later:", one_day_later)
效果图
18 time模块
简单介绍： time模块主要用于处理时间，如获取当前时间戳、将时间戳转换为格式化字符串等。它还提供了程序控制的功能，如sleep用于让程序暂停执行一段时间。
案例：获取当前时间戳，并转换为格式化字符串
import time
# 获取当前时间戳
timestamp = time.time()
print("Current timestamp:", timestamp)
# 将时间戳转换为格式化字符串
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timestamp))
print("Formatted time:", formatted_time)
效果图
19 base64模块
简单介绍： base64模块提供了Base64编码和解码的功能，通常用于在文本数据中表示、传输、存储二进制数据。它常用于电子邮件的传输编码，以及在XML中存储复杂数据。
案例：对字符串进行Base64编码和解码
import base64
# 对字符串进行Base64编码
encoded_str = base64.b64encode(b"Hello, World!")
print("Encoded string:", encoded_str)
# 对Base64编码的字符串进行解码
decoded_str = base64.b64decode(encoded_str)
print("Decoded string:", decoded_str.decode('utf-8'))
效果图
20 copy模块
简单介绍： copy模块提供了浅拷贝和深拷贝的功能，用于复制对象。浅拷贝只复制对象本身，而不复制对象内部的子对象；深拷贝则递归地复制对象及其所有子对象。
案例：使用浅拷贝和深拷贝复制列表
import copy
# 原始列表
original_list = [1, [2, 3], 4]
# 浅拷贝列表
shallow_copy_list = copy.copy(original_list)
print("Shallow copy:", shallow_copy_list)
# 修改浅拷贝列表中的子列表，原始列表也会受到影响
shallow_copy_list[1].append(5)
print("Original list after shallow copy modification:", original_list)
# 深拷贝列表
deep_copy_list = copy.deepcopy(original_list)
print("Deep copy:", deep_copy_list)
# 修改深拷贝列表中的子列表，原始列表不会受到影响
deep_copy_list[1].append(6)
print("Original list after deep copy modification:", original_list)
效果图
21 collections模块
简单介绍： collections模块提供了一些特殊的容器数据类型，它们为常见的数据结构提供了更高级别的接口，如namedtuple（具有名称的元组）、deque（双端队列）、Counter（计数器）、OrderedDict（有序字典）和defaultdict（带有默认值的字典）等。
案例：OrderedDict是一个字典子类，它保持元素被插入时的顺序。
from collections import OrderedDict # 创建一个OrderedDict对象 od = OrderedDict() # 添加键值对 od['first'] = 1 od['second'] = 2 od['third'] = 3 # 遍历OrderedDict，保持插入顺序 for key, value in od.items(): print(key, value) # 输出: # first 1 # second 2 # third 3
效果图
