别让代码愁白头发！15 个 Python 函数拯救你的开发生活

在 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

输出：

你好, 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

输出：

年龄: 30, 城市: 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.num2
else:
    result = args.num1 - args.num2

print(f"结果: {result}")

运行示例：

python script.py 10 5 --operation subtract

输出：

结果: 5

使用场景

命令行工具开发：如脚本自动化、系统管理任务、文件处理脚本等，方便通过命令行传递参数。数据处理脚本：通过不同的参数，处理不同的数据文件或数据源。脚本调试与测试：通过简单的命令行参数可以快速切换脚本的行为（例如详细模式、测试模式等）。

注意事项

自动生成帮助信息：argparse 会根据你定义的参数自动生成帮助信息，帮助用户了解如何使用脚本。参数类型：支持多种类型的参数，包括字符串、整数、布尔值、列表等。参数验证：argparse 可以自动验证参数的类型和合法性，确保输入有效。

4. collections.Counter - 计数器类

功能介绍

Counter 是 collections 模块中的一个字典子类，主要用于计数，统计可迭代对象中每个元素出现的次数。它将元素作为字典的键，次数作为值，并且提供了多个方便的计数操作方法。

使用示例

1、统计字符串中字符的频率：

from collections import Counter
text = "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 + counter2
print(result)  # 输出: Counter({'a': 4, 'b': 3})

result = counter1 - counter2
print(result)  # 输出: Counter({'a': 2})

使用场景

统计字符或词频：分析文本中字符或单词的频率。计数元素出现的次数：如统计购物车中物品数量、游戏中的分数等。找出最常见的元素：从一组数据中快速找出最常出现的元素。

注意事项

负数计数会被保留，但在使用 most_common 等方法时不会显示。可以使用 +、-、&、| 等操作符对多个 Counter 对象进行加减或并集交集操作。

5. collections.defaultdict - 带默认值的字典

功能介绍

defaultdict 是 Python collections 模块中的一个子类，提供了一个带默认值的字典。当你访问一个不存在的键时，defaultdict 不会抛出 KeyError，而是会根据提供的工厂函数自动生成默认值。这使得在处理字典时无需手动检查键是否存在，减少代码中的冗余检查。

使用示例

1、创建一个带默认值的字典：

from collections import defaultdict

# 默认值为0
dd = defaultdict(int)
dd['a'] += 1
print(dd)  # 输出: defaultdict(<class 'int'>, {'a': 1})

2、按字符统计字符串中字符出现的次数：

text = "hello world"
char_count = defaultdict(int)
for char in text:
    char_count[char] += 1
print(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'] += 1
print(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

@dataclass
class Person:
    name: str
    age: int

person = Person(name="Alice", age=30)
print(person)  # 输出: Person(name='Alice', age=30)

2、设置默认值：

@dataclass
class Person:
    name: str
    age: int = 25  # 默认年龄为25

person = Person(name="Bob")
print(person)  # 输出: Person(name='Bob', age=25)

3、生成对象比较方法：

@dataclass
class 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 dataclass
from typing import List

@dataclass
class 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))

输出：

354224848179261915075

在上面的例子中，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

输出：

3
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'])

输出：

John

通过 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'))  # 输出: 2024
print(match.group('month'))  # 输出: 09
print(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 = 0
for 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 random
data = [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 np
data = 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_DNS
name = "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_URL
name = "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

体验地址：引迈 - JNPF快速开发平台_低代码开发平台_零代码开发平台_流程设计器_表单引擎_工作流引擎_软件架构