在 Python 世界里，有一些宝藏函数和模块，它们可以让你编程更轻松、代码更高效。这篇文章将带你一一认识这些神器，让你的开发生活瞬间轻松不少！
1. all - 检查所有元素是否满足条件
功能介绍
all 函数用于检查可迭代对象中的所有元素是否都满足给定的条件。如果可迭代对象为空，则返回 True。
使用示例
1、检查列表中的所有数字是否为正数：
numbers = [1, 2, 3, 4]result = all(num > 0 for num in numbers)print(result) # 输出: True
复制代码
2、检查字符串中的所有字符是否为字母：
text = "Hello"result = all(char.isalpha() for char in text)print(result) # 输出: True
复制代码
3、检查字典中所有值是否大于 10：
data = {'a': 11, 'b': 12, 'c': 9}result = all(value > 10 for value in data.values())print(result) # 输出: False
复制代码
使用场景
验证数据完整性：确保所有数据项都符合特定条件。条件检查：在执行操作之前验证数据的有效性。
复制代码
2.any - 检查是否有元素满足条件
功能介绍
any函数用于检查一个可迭代对象（如列表、元组等）中是否有至少一个元素满足给定的条件。如果有任意一个元素为 True，则返回 True，否则返回 False。如果可迭代对象为空，则返回 False。
使用示例
1、检查列表中是否有大于 10 的数字：
numbers = [1, 5, 8, 12]result = any(num > 10 for num in numbers)print(result) # 输出: True
复制代码
2、检查字符串是否包含某个字符：
text = "hello"result = any(char == 'h' for char in text)print(result) # 输出: True
复制代码
3、检查字典中是否有值为 None：
data = {'name': 'Alice', 'age': None, 'location': 'NY'}result = any(value is None for value in data.values())print(result) # 输出: True
复制代码
4、检查元组中是否包含非零元素：
tup = (0, 0, 1, 0)result = any(tup)print(result) # 输出: True
复制代码
使用场景
条件检查：当你希望在一组数据中验证是否至少有一个元素满足某个条件时，any 是一个非常高效的工具。例如，检查用户输入是否符合某些标准，或者列表中是否存在满足特定条件的值。
users = ['admin', 'guest', 'user1']if any(user == 'admin' for user in users): print("Admin is present")
复制代码
数据验证：在处理表单或数据库时，检查是否有数据字段为空或无效。
fields = {'name': 'John', 'email': '', 'age': 30}if any(value == '' for value in fields.values()): print("Some fields are empty!")
复制代码
快速筛选数据：例如，在数据分析中快速查看是否有不符合条件的数据项。
data_points = [3.2, 5.6, 0.0, -1.2, 4.8]if any(x < 0 for x in data_points): print("Negative data point found!")
复制代码
注意事项
any 会在遇到第一个为 True 的元素时立即返回，而不会继续检查剩余的元素，因此在性能方面具有优势。any 通常与生成器表达式一起使用，使其能够处理大型数据集而不消耗过多内存。any 和 all 是一对非常实用的布尔函数，能够快速简化许多条件检查的代码逻辑。
3. argparse - 处理命令行参数
功能介绍
argparse 模块用于编写用户友好的命令行接口。它允许你定义脚本可以接收的参数，并自动生成帮助信息。通过命令行传递参数可以让你的程序更加灵活和易于使用，尤其是在需要传递多种不同参数的脚本中。
使用示例
1、处理基本的命令行参数：
import argparse
parser = argparse.ArgumentParser(description="这是一个演示脚本")parser.add_argument('--name', type=str, help='输入你的名字')args = parser.parse_args()
print(f"你好, {args.name}!")
复制代码
运行示例：
python script.py --name Alice
复制代码
输出：
2、设置默认值和必选参数：
import argparse
parser = argparse.ArgumentParser()parser.add_argument('--age', type=int, required=True, help='输入你的年龄')parser.add_argument('--city', type=str, default='Unknown', help='输入你所在的城市')args = parser.parse_args()
print(f"年龄: {args.age}, 城市: {args.city}")
复制代码
运行示例：
python script.py --age 30 --city Beijing
复制代码
输出：
3、支持布尔值参数：
import argparse
parser = argparse.ArgumentParser()parser.add_argument('--verbose', action='store_true', help='是否输出详细信息')args = parser.parse_args()
if args.verbose: print("详细模式已开启")else: print("默认模式")
复制代码
运行示例：
python script.py --verbose
复制代码
输出：
4、处理多个命令行参数：
import argparse
parser = argparse.ArgumentParser(description="计算器程序")parser.add_argument('num1', type=int, help="第一个数字")parser.add_argument('num2', type=int, help="第二个数字")parser.add_argument('--operation', type=str, default='add', choices=['add', 'subtract'], help="选择操作类型：加法或减法")args = parser.parse_args()
if args.operation == 'add': result = args.num1 + args.num2else: result = args.num1 - args.num2
print(f"结果: {result}")
复制代码
运行示例：
python script.py 10 5 --operation subtract
复制代码
输出：
使用场景
命令行工具开发：如脚本自动化、系统管理任务、文件处理脚本等，方便通过命令行传递参数。数据处理脚本：通过不同的参数，处理不同的数据文件或数据源。脚本调试与测试：通过简单的命令行参数可以快速切换脚本的行为（例如详细模式、测试模式等）。
注意事项
自动生成帮助信息：argparse 会根据你定义的参数自动生成帮助信息，帮助用户了解如何使用脚本。参数类型：支持多种类型的参数，包括字符串、整数、布尔值、列表等。参数验证：argparse 可以自动验证参数的类型和合法性，确保输入有效。
4. collections.Counter - 计数器类
功能介绍
Counter 是 collections 模块中的一个字典子类，主要用于计数，统计可迭代对象中每个元素出现的次数。它将元素作为字典的键，次数作为值，并且提供了多个方便的计数操作方法。
使用示例
1、统计字符串中字符的频率：
from collections import Countertext = "hello world"counter = Counter(text)print(counter) # 输出: Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
复制代码
2、统计列表中元素的出现次数：
items = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']counter = Counter(items)print(counter) # 输出: Counter({'apple': 3, 'banana': 2, 'orange': 1})
复制代码
3、找出最常见的元素：
counter = Counter(items)most_common = counter.most_common(2)print(most_common) # 输出: [('apple', 3), ('banana', 2)]
复制代码
4、更新计数器：
counter.update(['banana', 'orange', 'apple'])print(counter) # 输出: Counter({'apple': 4, 'banana': 3, 'orange': 2})
复制代码
5、计数器的加减操作：
counter1 = Counter(a=3, b=1)counter2 = Counter(a=1, b=2)result = counter1 + counter2print(result) # 输出: Counter({'a': 4, 'b': 3})
result = counter1 - counter2print(result) # 输出: Counter({'a': 2})
复制代码
使用场景
统计字符或词频：分析文本中字符或单词的频率。计数元素出现的次数：如统计购物车中物品数量、游戏中的分数等。找出最常见的元素：从一组数据中快速找出最常出现的元素。
注意事项
负数计数会被保留，但在使用 most_common 等方法时不会显示。可以使用 +、-、&、| 等操作符对多个 Counter 对象进行加减或并集交集操作。
5. collections.defaultdict - 带默认值的字典
功能介绍
defaultdict 是 Python collections 模块中的一个子类，提供了一个带默认值的字典。当你访问一个不存在的键时，defaultdict 不会抛出 KeyError，而是会根据提供的工厂函数自动生成默认值。这使得在处理字典时无需手动检查键是否存在，减少代码中的冗余检查。
使用示例
1、创建一个带默认值的字典：
from collections import defaultdict
# 默认值为0dd = defaultdict(int)dd['a'] += 1print(dd) # 输出: defaultdict(<class 'int'>, {'a': 1})
复制代码
2、按字符统计字符串中字符出现的次数：
text = "hello world"char_count = defaultdict(int)for char in text: char_count[char] += 1print(char_count) # 输出: defaultdict(<class 'int'>, {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
复制代码
3、将列表中的元素按长度进行分组：
words = ["apple", "banana", "pear", "kiwi", "grape"]word_groups = defaultdict(list)for word in words: word_groups[len(word)].append(word)print(word_groups) # 输出: defaultdict(<class 'list'>, {5: ['apple', 'pear', 'grape'], 6: ['banana'], 4: ['kiwi']})
复制代码
4、自定义默认工厂函数：
def default_value(): return "default_value"
dd = defaultdict(default_value)print(dd["nonexistent_key"]) # 输出: "default_value"
复制代码
5、嵌套使用 defaultdict：
# 创建一个嵌套的默认字典nested_dict = defaultdict(lambda: defaultdict(int))nested_dict['key1']['subkey'] += 1print(nested_dict) # 输出: defaultdict(<function <lambda> at 0x...>, {'key1': defaultdict(<class 'int'>, {'subkey': 1})})
复制代码
使用场景
避免手动检查键是否存在：在处理计数或聚合操作时，避免频繁进行键存在性检查。统计数据：如统计字符出现次数、单词长度分组、计数等。简化嵌套结构：使用嵌套 defaultdict 可以创建多层字典结构，避免逐层初始化。
注意事项
defaultdict 的默认值是通过工厂函数生成的，因此每次访问缺失键时都会调用这个工厂函数。小心使用带副作用的工厂函数，如文件操作、网络请求等，因为这些操作会在访问不存在的键时被触发。
6. dataclasses.dataclass - 轻量级数据类
功能介绍
dataclass 是 Python 3.7 引入的一个装饰器，用于简化数据类的创建。它可以自动生成类的初始化方法 (__init__)、表示方法 (__repr__) 等，还可以对比对象的相等性 (__eq__)，从而减少手动编写样板代码。
使用示例
1、创建一个简单的数据类：
from dataclasses import dataclass
@dataclassclass Person: name: str age: int
person = Person(name="Alice", age=30)print(person) # 输出: Person(name='Alice', age=30)
复制代码
2、设置默认值：
@dataclassclass Person: name: str age: int = 25 # 默认年龄为25
person = Person(name="Bob")print(person) # 输出: Person(name='Bob', age=25)
复制代码
3、生成对象比较方法：
@dataclassclass Person: name: str age: int
person1 = Person(name="Alice", age=30)person2 = Person(name="Alice", age=30)print(person1 == person2) # 输出: True
复制代码
4、冻结数据类（禁止修改属性）：
@dataclass(frozen=True)class Person: name: str age: int
person = Person(name="Alice", age=30)# person.age = 31 # 这行代码会抛出错误：FrozenInstanceError
复制代码
5、处理复杂的数据类型：
from dataclasses import dataclassfrom typing import List
@dataclassclass Team: name: str members: List[str]
team = Team(name="Developers", members=["Alice", "Bob", "Charlie"])print(team) # 输出: Team(name='Developers', members=['Alice', 'Bob', 'Charlie'])
复制代码
使用场景
简化数据类的定义：避免手动编写 init、repr、eq 等方法，减少冗余代码。创建不可变对象：通过冻结类属性实现不可变性（类似于 namedtuple 的行为）。数据封装：在应用中使用数据类封装业务逻辑和数据结构，如定义用户、商品、订单等类。
注意事项
数据类可以通过设置 frozen=True 让属性不可变，这使得数据类的实例更接近于 namedtuple。可以通过 field() 函数为类属性提供更灵活的控制，例如设置默认值、排除某些字段不进行比较等。
7. datetime - 处理日期和时间
功能介绍
datetime 模块提供了操作日期和时间的强大工具。它允许你获取当前日期时间、进行时间运算、格式化日期时间字符串等。这个模块是处理时间相关任务的首选，非常适合需要追踪、计算或展示时间的场景。
datetime 主要有几个核心对象：
datetime.datetime: 表示日期和时间的组合。
datetime.date: 仅表示日期（年、月、日）。
datetime.time: 仅表示时间（时、分、秒）。
datetime.timedelta: 用于时间差运算。
使用示例
1、获取当前日期和时间：
from datetime import datetime
now = datetime.now()print(f"当前时间: {now}")
复制代码
输出：
当前时间: 2024-09-07 15:32:18.123456
复制代码
2、格式化日期和时间：
from datetime import datetime
now = datetime.now()formatted_time = now.strftime("%Y-%m-%d %H:%M:%S")print(f"格式化后的时间: {formatted_time}")
复制代码
输出：
格式化后的时间: 2024-09-07 15:32:18
复制代码
strftime 用于根据指定格式将日期时间对象转换为字符串。常见格式说明：
%Y: 四位数的年份，如 2024
%m: 两位数的月份，如 09
%d: 两位数的日期，如 07
%H: 两位数的小时，24 小时制
%M: 两位数的分钟
%S: 两位数的秒
3、解析日期字符串：
from datetime import datetime
date_str = "2024-09-07 15:32:18"date_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")print(f"解析后的日期对象: {date_obj}")
复制代码
输出：
解析后的日期对象: 2024-09-07 15:32:18
复制代码
strptime 用于根据指定格式将字符串转换为日期时间对象。
4、计算时间差：
from datetime import datetime, timedelta
now = datetime.now()future = now + timedelta(days=10)print(f"10天后的日期: {future}")
复制代码
输出：
10天后的日期: 2024-09-17 15:32:18.123456
复制代码
timedelta 对象用于表示两个日期或时间之间的差值，可以进行加减法运算。
5、 获取日期部分或时间部分：
from datetime import datetime
now = datetime.now()print(f"当前日期: {now.date()}")print(f"当前时间: {now.time()}")
复制代码
输出：
当前日期: 2024-09-07当前时间: 15:32:18.123456
复制代码
使用场景
日志记录：自动生成时间戳，用于记录系统操作、错误报告等。定时任务：设置延迟、时间间隔的操作，例如自动备份系统。数据处理：对包含时间戳的数据进行操作，如分析时间序列数据或时间范围过滤。时间运算：例如计算某个日期之前或之后的天数、小时数等。
注意事项
datetime.now() 获取当前时间时精确到微秒。如果不需要微秒，可以使用 .replace(microsecond=0) 来忽略。timedelta 可以进行时间运算，但对于时区计算，需要结合 pytz 模块进行更复杂的时区管理。
8. functools.lru_cache - 缓存函数结果，提升性能
功能介绍
functools.lru_cache 是一个非常有用的装饰器，它可以缓存函数的结果，从而避免对相同输入的重复计算，提升程序的性能。它适用于那些具有重复计算特性且结果可以被重用的函数，特别是在递归或大量重复调用的场景下表现尤为出色。
lru_cache 中的 "LRU" 是 "Least Recently Used" 的缩写，意思是当缓存达到指定容量时，最久未使用的缓存条目将被清除。
使用示例
1、递归斐波那契数列计算（使用缓存）：
from functools import lru_cache
@lru_cache(maxsize=128)def fibonacci(n): if n < 2: return n return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(100))
复制代码
输出：
在上面的例子中，lru_cache 通过缓存前面的计算结果，大大提高了递归斐波那契数列的效率。如果没有缓存，每次递归都会重复计算之前的结果，效率极低。maxsize 参数指定了缓存的大小。
2、指定缓存大小：@lru_cache(maxsize=32) # 缓存最近32个调用结果 def compute(x): # 假设这是一个很耗时的函数 return x * x for i in range(40): print(compute(i)) print(compute.cache_info()) # 查看缓存的状态
输出：
CacheInfo(hits=0, misses=40, maxsize=32, currsize=32)
复制代码
cache_info() 方法可以用来查看缓存的命中次数（hits）、未命中次数（misses）、缓存最大容量（maxsize）以及当前缓存的条目数（currsize）。
4、清除缓存：fibonacci.cache_clear() # 清除缓存 print(fibonacci.cache_info()) # 输出缓存信息，确认缓存已被清除
cache_clear() 方法可以手动清空缓存，适用于需要重置缓存的情况。
5、处理复杂计算：@lru_cache(maxsize=100) def slow_function(x, y): # 模拟耗时计算 import time time.sleep(2) return x + y # 第一次调用会等待2秒 print(slow_function(1, 2)) # 输出: 3 # 第二次调用将直接使用缓存的结果，几乎瞬时完成 print(slow_function(1, 2)) # 输出: 3
输出：
通过缓存结果，第二次调用相同参数时可以节省大量时间。
使用场景
递归算法优化：如斐波那契数列、动态规划问题等，需要重复计算的函数调用。处理复杂计算：对于需要大量重复计算的函数，通过缓存结果可以大大提高性能，如 Web 请求的处理、数据库查询结果的缓存等。函数调用优化：在处理相同输入时，可以避免重复计算或耗时操作。
注意事项
缓存大小管理：maxsize 参数控制缓存的最大容量，合理设置该值可以在性能与内存使用之间找到平衡。如果设置为 None，则缓存大小无限。避免缓存不必要的数据：对于一些参数变化较多的函数，缓存可能会占用大量内存，应慎重使用 lru_cache。缓存失效策略：lru_cache 使用的是最近最少使用 (LRU) 策略来移除旧的缓存项，因此不会一直保留所有的缓存结果。
9. itertools.chain - 将多个可迭代对象串联起来
功能介绍
itertools.chain 是 itertools 模块中的一个函数，它可以将多个可迭代对象（如列表、元组、集合等）“串联”成一个单一的迭代器。这样你可以在遍历多个可迭代对象时无需嵌套循环，从而简化代码结构。
使用示例
1、串联多个列表：
from itertools import chain
list1 = [1, 2, 3]list2 = [4, 5, 6]result = list(chain(list1, list2))print(result) # 输出: [1, 2, 3, 4, 5, 6]
复制代码
2、串联不同类型的可迭代对象：
list1 = [1, 2, 3]tuple1 = (4, 5, 6)set1 = {7, 8, 9}result = list(chain(list1, tuple1, set1))print(result) # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]
复制代码
3、串联多个字符串：
str1 = "ABC"str2 = "DEF"result = list(chain(str1, str2))print(result) # 输出: ['A', 'B', 'C', 'D', 'E', 'F']
复制代码
4、合并多层嵌套的迭代器：
nested_list = [[1, 2], [3, 4], [5, 6]]result = list(chain.from_iterable(nested_list))print(result) # 输出: [1, 2, 3, 4, 5, 6]
复制代码
5、处理生成器：
def generator1(): yield 1 yield 2
def generator2(): yield 3 yield 4
result = list(chain(generator1(), generator2()))print(result) # 输出: [1, 2, 3, 4]
复制代码
使用场景
合并多个数据源：当你需要遍历多个可迭代对象时，使用 chain 可以避免多层循环。合并嵌套列表：使用 chain.from_iterable 可以展平嵌套的可迭代对象，方便处理嵌套结构的数据。简化代码：如果需要对多个列表、生成器等进行统一操作，chain 可以减少冗余代码并提高代码的可读性。
注意事项
itertools.chain 是一个迭代器，不会立刻生成结果，直到你真正遍历它。因此对于超大数据集，chain 的性能更优，因为它不会一次性加载所有数据到内存中。如果需要串联嵌套可迭代对象，推荐使用 chain.from_iterable，而不是嵌套 chain 函数调用。
10. json - 处理 JSON 数据的好帮手
功能介绍
json 模块是 Python 用来解析、生成和操作 JSON（JavaScript Object Notation）数据的内建模块。JSON 是一种轻量级的数据交换格式，广泛用于 Web 应用程序与服务器之间的数据通信。通过 json 模块，Python 可以方便地将 JSON 格式的字符串解析为 Python 对象，或将 Python 对象序列化为 JSON 格式的字符串。
常用的函数包括：
json.dumps(): 将 Python 对象转换为 JSON 字符串。
json.loads(): 将 JSON 字符串解析为 Python 对象。
json.dump(): 将 Python 对象写入文件，保存为 JSON 格式。
json.load(): 从文件读取 JSON 数据并转换为 Python 对象。
使用示例
1、将 Python 对象转换为 JSON 字符串：import json data = {'name': 'John', 'age': 30, 'city': 'New York'} json_str = json.dumps(data) print(json_str)
输出：
{"name": "John", "age": 30, "city": "New York"}
复制代码
这里将 Python 字典 data 转换为了 JSON 格式的字符串。
2、 将 JSON 字符串解析为 Python 对象：
json_str = '{"name": "John", "age": 30, "city": "New York"}'data = json.loads(json_str)print(data['name'])
复制代码
输出：
通过 json.loads()，我们将 JSON 字符串解析回 Python 字典，然后可以访问其中的数据。
3、将 JSON 数据写入文件：
import json
data = {'name': 'Alice', 'age': 25, 'city': 'London'}with open('data.json', 'w') as file: json.dump(data, file)
复制代码
结果： 这段代码会在当前目录下生成一个 data.json 文件，内容为：
{ "name": "Alice", "age": 25, "city": "London"}
复制代码
4、从文件读取 JSON 数据：
import json with open('data.json', 'r') as file: data = json.load(file) print(data)
输出：
{'name': 'Alice', 'age': 25, 'city': 'London'}
复制代码
通过 json.load() 函数，我们从文件中读取并解析了 JSON 数据。
5、自定义 JSON 序列化和反序列化：有时候，JSON 不支持某些 Python 对象（如日期时间），我们可以自定义序列化方法：
import json from datetime import datetime def datetime_serializer(obj): if isinstance(obj, datetime): return obj.isoformat() raise TypeError("Type not serializable") data = {'name': 'Bob', 'timestamp': datetime.now()} json_str = json.dumps(data, default=datetime_serializer) print(json_str)
输出：
{"name": "Bob", "timestamp": "2024-09-07T15:32:18.123456"}
复制代码
自定义 default 参数可用于处理 JSON 默认不支持的对象类型。
使用场景
Web 开发：将数据以 JSON 格式在前端和后端之间传输，例如从 API 获取数据时常用 JSON 格式。配置文件：许多应用程序使用 JSON 文件来存储配置数据。日志记录：将系统操作日志保存为 JSON 格式，便于分析和处理。数据序列化：用于保存和共享 Python 数据结构，如保存爬虫数据、机器学习模型参数等。
注意事项
JSON 的数据类型限制：JSON 支持的数据类型包括字符串、数字、布尔值、数组、对象和 null，不支持复杂的 Python 对象（如类实例、函数等）。UTF-8 编码：json 模块默认使用 UTF-8 编码，因此可以很好地处理国际化字符。避免重复数据的写入：使用 json.dump() 时，一定要小心文件的打开模式，确保不会覆盖重要数据。
11. pickle - 序列化和反序列化对象
功能介绍
pickle 是 Python 标准库中的一个模块，用于将 Python 对象序列化为字节流，或将字节流反序列化为原始对象。这使得对象可以存储到文件中或者在网络上传输。pickle 支持几乎所有的 Python 对象，包括复杂的数据结构和自定义对象。
使用示例
1、将对象序列化到文件：
import pickle
data = {'name': 'Alice', 'age': 30, 'city': 'Wonderland'}
# 将对象序列化并写入文件with open('data.pkl', 'wb') as file: pickle.dump(data, file)
复制代码
2、从文件反序列化对象：
import pickle
# 从文件读取并反序列化对象with open('data.pkl', 'rb') as file: data = pickle.load(file)print(data) # 输出: {'name': 'Alice', 'age': 30, 'city': 'Wonderland'}
复制代码
3、将对象序列化为字节流：
import pickle
data = [1, 2, 3, {'a': 'A', 'b': 'B'}]
# 序列化对象为字节流byte_stream = pickle.dumps(data)print(byte_stream)
复制代码
4、从字节流反序列化对象：
import pickle
byte_stream = b'\x80\x04\x95\x1c\x00\x00\x00\x00\x00\x00\x00\x8c\x04list\x94\x8c\x04\x00\x00\x00\x00\x00\x00\x00\x8c\x03int\x94\x8c\x04\x00\x00\x00\x00\x00\x00\x00\x8c\x03dict\x94\x8c\x03\x00\x00\x00\x00\x00\x00\x00\x8c\x01a\x94\x8c\x01A\x94\x8c\x01b\x94\x8c\x01B\x94\x87\x94\x00\x00\x00\x00\x00\x00\x00'
# 反序列化字节流为对象data = pickle.loads(byte_stream)print(data) # 输出: [1, 2, 3, {'a': 'A', 'b': 'B'}]
复制代码
5、序列化自定义对象：
import pickle
class Person: def __init__(self, name, age): self.name = name self.age = age
def __repr__(self): return f"Person(name={self.name}, age={self.age})"
person = Person("Bob", 25)
# 将自定义对象序列化到文件with open('person.pkl', 'wb') as file: pickle.dump(person, file)
# 从文件反序列化自定义对象with open('person.pkl', 'rb') as file: loaded_person = pickle.load(file)print(loaded_person) # 输出: Person(name=Bob, age=25)
复制代码
使用场景
持久化数据：将数据存储到文件中，方便在程序重启后恢复。对象传输：在网络通信中传输 Python 对象，尤其是在分布式系统中。数据缓存：将计算结果缓存到文件中，以便下次快速加载。
注意事项
安全性：反序列化数据时需谨慎，因为 pickle 可以执行任意代码，可能导致安全风险。尽量避免从不可信来源加载数据。兼容性：不同版本的 Python 可能不完全兼容 pickle 数据，特别是在使用不同 Python 版本时。性能：序列化和反序列化大对象时，性能可能会受到影响，可以考虑使用其他序列化格式（如 JSON）作为替代。
12. pprint - 格式化打印数据结构
功能介绍
pprint 是 Python 标准库中的一个模块，提供了格式化打印复杂数据结构的功能。它可以将嵌套的数据结构（如字典、列表、元组等）以更易读的格式输出，帮助开发者更好地调试和查看数据。
使用示例
1、打印嵌套的字典：
from pprint import pprint
data = { 'name': 'Alice', 'age': 30, 'address': { 'street': '123 Main St', 'city': 'Wonderland' }, 'hobbies': ['reading', 'hiking', 'coding']}pprint(data)
复制代码
输出：
{'address': {'city': 'Wonderland', 'street': '123 Main St'},'age': 30,'hobbies': ['reading', 'hiking', 'coding'],'name': 'Alice'}
复制代码
2、打印长列表：
from pprint import pprint
long_list = list(range(100))pprint(long_list)
复制代码
输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19,20, 21, 22, 23, 24, 25, 26, 27, 28, 29,30, 31, 32, 33, 34, 35, 36, 37, 38, 39,40, 41, 42, 43, 44, 45, 46, 47, 48, 49,50, 51, 52, 53, 54, 55, 56, 57, 58, 59,60, 61, 62, 63, 64, 65, 66, 67, 68, 69,70, 71, 72, 73, 74, 75, 76, 77, 78, 79,80, 81, 82, 83, 84, 85, 86, 87, 88, 89,90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
复制代码
3、打印带有自定义缩进的字典 ：
from pprint import pprint
data = { 'name': 'Bob', 'age': 25, 'address': { 'street': '456 Elm St', 'city': 'Metropolis' }, 'hobbies': ['cycling', 'cooking', 'traveling']}pprint(data, indent=2)
复制代码
输出：
{'name': 'Bob','age': 25,'address': {'street': '456 Elm St', 'city': 'Metropolis'},'hobbies': ['cycling', 'cooking', 'traveling']}
复制代码
4、打印带有自定义宽度的列表：
from pprint import pprint
data = list(range(50))pprint(data, width=40)
复制代码
输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19,20, 21, 22, 23, 24, 25, 26, 27, 28, 29,30, 31, 32, 33, 34, 35, 36, 37, 38, 39,40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
复制代码
5、使用 pprint 打印自定义对象：
from pprint import pprint
class Person: def __init__(self, name, age, address): self.name = name self.age = age self.address = address
def __repr__(self): return f"Person(name={self.name}, age={self.age}, address={self.address})"
person = Person("Charlie", 40, "789 Maple St")pprint(person)
复制代码
输出：
Person(name=Charlie, age=40, address=789 Maple St)
复制代码
使用场景
调试复杂数据结构：在调试程序时，使用 pprint 可以更清晰地查看复杂的嵌套数据结构。数据分析：打印大型数据集合时，格式化输出有助于快速理解数据内容和结构。日志记录：在记录日志时，使用 pprint 可以使数据更易读，帮助分析问题。
注意事项
pprint 适用于较为复杂的数据结构，简单的数据结构使用普通的 print 更为高效。调整 indent 和 width 参数可以控制输出的格式和可读性，根据具体需求选择合适的设置。
13. re - 正则表达式处理利器
功能介绍
re 模块是 Python 中用来处理正则表达式的模块，提供了强大的字符串匹配、查找、替换等功能。正则表达式是一种匹配字符串的模式，通过特定的规则，可以用于处理复杂的文本操作，比如提取数据、验证输入格式等。
常用的函数包括：
re.match(): 从字符串的开头进行匹配。
re.search(): 在整个字符串中搜索第一个匹配项。
re.findall(): 找到所有与正则表达式匹配的子串。
re.sub(): 使用另一个字符串替换匹配到的部分。
re.split(): 根据正则表达式分割字符串。
使用示例
1、简单匹配：
import re
pattern = r'\d+' # 匹配一个或多个数字result = re.match(pattern, '123abc')print(result.group()) # 输出: 123
复制代码
re.match 函数从字符串的开头开始匹配。上例中匹配到了字符串开头的数字 123。
2、查找字符串中的第一个匹配项：
result = re.search(r'[a-z]+', '123abc456')print(result.group()) # 输出: abc
复制代码
re.search 在整个字符串中搜索，返回第一个符合模式的子串。
3、 查找所有匹配项：
result = re.findall(r'\d+', '123abc456def789')print(result) # 输出: ['123', '456', '789']
复制代码
re.findall 返回所有与模式匹配的部分，以列表形式给出。
4、 替换匹配到的字符串：
result = re.sub(r'\d+', '#', '123abc456')print(result) # 输出: #abc#
复制代码
re.sub 使用 # 替换所有匹配的数字部分。
5、 根据正则表达式分割字符串：
result = re.split(r'\d+', 'abc123def456ghi')print(result) # 输出: ['abc', 'def', 'ghi']
复制代码
re.split 按照正则表达式中的数字进行分割，结果是一个列表。
6、 使用命名组提取特定信息：
pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'match = re.search(pattern, 'Date: 2024-09-07')print(match.group('year')) # 输出: 2024print(match.group('month')) # 输出: 09print(match.group('day')) # 输出: 07
复制代码
命名组可以给每个匹配的子串起名字，从而方便后续的提取。
使用场景
表单验证：验证电子邮件、电话号码、邮政编码等格式。
email = 'example@domain.com'pattern = r'^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$'if re.match(pattern, email): print("Valid email")else: print("Invalid email")
复制代码
数据提取：从文本中提取特定格式的数据，例如日期、时间、金额等。
text = 'Total cost is $123.45, and date is 2024-09-07.'cost = re.search(r'\$\d+\.\d{2}', text).group()print(cost) # 输出: $123.45
复制代码
日志分析：分析系统日志，提取时间戳、IP 地址、错误信息等。
log = '192.168.0.1 - - [07/Sep/2024:14:55:36] "GET /index.html HTTP/1.1" 200 2326'ip = re.search(r'\d+\.\d+\.\d+\.\d+', log).group()print(ip) # 输出: 192.168.0.1
复制代码
字符串替换和格式化：通过模式匹配，快速进行复杂的文本替换或格式化。
text = 'User ID: 1234, Date: 2024-09-07'new_text = re.sub(r'\d+', '[ID]', text)print(new_text) # 输出: User ID: [ID], Date: [ID]
复制代码
注意事项
贪婪与非贪婪匹配：默认情况下，正则表达式是贪婪的，会尽可能多地匹配字符。可以通过 ? 实现非贪婪匹配，例如 r'<.?>'。避免过于复杂的正则：虽然正则表达式功能强大，但复杂的表达式可能难以维护，建议保持简洁。转义字符：某些字符在正则表达式中有特殊含义（如 .、、+ 等），使用它们时需要通过 \ 进行转义。
14. timeit.timeit - 测量代码执行时间
功能介绍
timeit.timeit 是 Python 标准库中的一个函数，用于精确测量小段代码的执行时间。它特别适合用于性能测试，能够准确地计算出代码块的运行时间，并提供有关代码执行效率的有价值信息。
使用示例
1、测量简单代码的执行时间：
import timeit
# 测量一行代码的执行时间execution_time = timeit.timeit('x = sum(range(100))', number=10000)print(f"Execution time: {execution_time} seconds")
复制代码
2、测量函数的执行时间：
import timeit
def test_function(): return sum(range(100))
execution_time = timeit.timeit(test_function, number=10000)print(f"Execution time: {execution_time} seconds")
复制代码
3、使用 timeit 测量代码块的执行时间：
import timeit
code_to_test = '''result = 0for i in range(1000): result += i'''
execution_time = timeit.timeit(code_to_test, number=1000)print(f"Execution time: {execution_time} seconds")
复制代码
4、使用 timeit 测量带有 setup 代码的执行时间：
import timeit
setup_code = '''import randomdata = [random.randint(1, 100) for _ in range(1000)]'''
test_code = '''sorted_data = sorted(data)'''
execution_time = timeit.timeit(test_code, setup=setup_code, number=1000)print(f"Execution time: {execution_time} seconds")
复制代码
5、测量代码性能的复杂场景：
import timeit
setup_code = '''import numpy as npdata = np.random.rand(1000)'''
test_code = '''mean_value = np.mean(data)'''
execution_time = timeit.timeit(test_code, setup=setup_code, number=1000)print(f"Execution time: {execution_time} seconds")
复制代码
使用场景
性能分析：评估代码段或函数的性能，找出潜在的性能瓶颈。优化代码：通过测量不同算法或实现的执行时间，选择最优的解决方案。比较不同实现：在对比不同的实现方式时，使用 timeit 可以提供准确的执行时间数据。
注意事项
测量粒度：timeit 主要用于测量小段代码的性能，测量时间过长的代码段可能需要调整 number 参数。环境一致性：为了获得准确的性能测试结果，确保测量代码在相同的环境和条件下运行。测量多次：建议运行多次测量以获得更稳定的结果，避免偶发性的性能波动。
15. uuid - 生成唯一标识符
功能介绍
uuid 是 Python 标准库中的一个模块，用于生成全球唯一标识符（UUID）。UUID 是一种标准格式的标识符，广泛用于需要唯一标识的场景，如数据库主键、分布式系统中的对象标识等。uuid 模块支持多种生成 UUID 的方法，包括基于时间、随机数和哈希值等方式。
使用示例
1、生成一个基于时间的 UUID：
import uuid
uuid1 = uuid.uuid1()print(f"UUID1: {uuid1}"
复制代码
输出：UUID1: 123e4567-e89b-12d3-a456-426614174000
2、生成一个基于随机数的 UUID：
import uuid
uuid4 = uuid.uuid4()print(f"UUID4: {uuid4}")
复制代码
输出：
UUID4: 9d6d8a0a-1e2b-4f8c-8c0d-15e16529d37e
复制代码
3、生成一个基于名称的 UUID：
import uuid
namespace = uuid.NAMESPACE_DNSname = "example.com"uuid3 = uuid.uuid3(namespace, name)print(f"UUID3: {uuid3}")
复制代码
输出：
UUID3: 5d5c4b37-1c73-3b3d-bc8c-616c98a6a3d3
复制代码
4、生成一个基于 SHA-1 哈希值的 UUID：
import uuid
namespace = uuid.NAMESPACE_URLname = "http://example.com"uuid5 = uuid.uuid5(namespace, name)print(f"UUID5: {uuid5}")
复制代码
输出：
UUID5: 9b3f7e1d-f9b0-5d8b-9141-fb8b571f4f67
复制代码
5、将 UUID 转换为字符串：
import uuid
uuid_obj = uuid.uuid4()uuid_str = str(uuid_obj)print(f"UUID as string: {uuid_str}")
复制代码
输出：
UUID as string: 2d5b44b8-4a0f-4f3d-a2b4-3c6e1f7f6a3b
复制代码
使用场景
唯一标识符：生成唯一的标识符用于数据库主键、会话标识、文件名等。分布式系统：在分布式系统中生成唯一的 ID，以确保不同节点生成的标识符不会重复。数据追踪：生成唯一的标识符用于跟踪数据或对象的生命周期，例如在日志记录中标识事件。
注意事项
UUID 的版本：uuid 模块提供了不同版本的 UUID（如 UUID1、UUID4、UUID3 和 UUID5），选择适合的版本根据实际需求。性能考虑：对于大量生成 UUID 的应用，考虑选择合适的 UUID 版本来优化性能。例如，UUID4 基于随机数，生成速度较快，但可能会有冲突风险；UUID1 基于时间和节点信息，生成速度较慢，但唯一性更高。格式一致性：UUID 在不同应用和系统之间传递时，需要确保格式一致，通常使用标准的字符串格式进行传递。
文章转载自：Sunzz
原文链接：https://www.cnblogs.com/Sunzz/p/18402025
体验地址：http://www.jnpfsoft.com/?from=infoq
评论