生活在水面的鱼 发表于 2024-9-8 00:11:30

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

在 Python 世界里,有一些宝藏函数和模块,它们可以让你编程更轻松、代码更高效。这篇文章将带你一一认识这些神器,让你的开发生活瞬间轻松不少!

1. all - 检查所有元素是否满足条件

功能介绍

all 函数用于检查可迭代对象中的所有元素是否都满足给定的条件。如果可迭代对象为空,则返回 True。
使用示例


[*]检查列表中的所有数字是否为正数:numbers =
result = all(num > 0 for num in numbers)
print(result)# 输出: True
[*]检查字符串中的所有字符是否为字母:text = "Hello"
result = all(char.isalpha() for char in text)
print(result)# 输出: True
[*]检查字典中所有值是否大于 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。
使用示例


[*]检查列表中是否有大于 10 的数字:
numbers =
result = any(num > 10 for num in numbers)
print(result)# 输出: True
[*]检查字符串是否包含某个字符:
text = "hello"
result = any(char == 'h' for char in text)
print(result)# 输出: True
[*]检查字典中是否有值为 None:
data = {'name': 'Alice', 'age': None, 'location': 'NY'}
result = any(value is None for value in data.values())
print(result)# 输出: True
[*]检查元组中是否包含非零元素:
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 =
if any(x < 0 for x in data_points):
    print("Negative data point found!")注意事项

any 会在遇到第一个为 True 的元素时立即返回,而不会继续检查剩余的元素,因此在性能方面具有优势。
any 通常与生成器表达式一起使用,使其能够处理大型数据集而不消耗过多内存。
any 和 all 是一对非常实用的布尔函数,能够快速简化许多条件检查的代码逻辑。
3. argparse - 处理命令行参数

功能介绍

argparse 模块用于编写用户友好的命令行接口。它允许你定义脚本可以接收的参数,并自动生成帮助信息。通过命令行传递参数可以让你的程序更加灵活和易于使用,尤其是在需要传递多种不同参数的脚本中。
使用示例


[*]处理基本的命令行参数: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!
[*]设置默认值和必选参数: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
[*]支持布尔值参数: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输出:
详细模式已开启
[*]处理多个命令行参数: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 模块中的一个字典子类,主要用于计数,统计可迭代对象中每个元素出现的次数。它将元素作为字典的键,次数作为值,并且提供了多个方便的计数操作方法。
使用示例


[*]统计字符串中字符的频率:
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})
[*]统计列表中元素的出现次数:
items = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
counter = Counter(items)
print(counter)# 输出: Counter({'apple': 3, 'banana': 2, 'orange': 1})
[*]找出最常见的元素:
counter = Counter(items)
most_common = counter.most_common(2)
print(most_common)# 输出: [('apple', 3), ('banana', 2)]
[*]更新计数器:
counter.update(['banana', 'orange', 'apple'])
print(counter)# 输出: Counter({'apple': 4, 'banana': 3, 'orange': 2})
[*]计数器的加减操作:
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,而是会根据提供的工厂函数自动生成默认值。这使得在处理字典时无需手动检查键是否存在,减少代码中的冗余检查。
使用示例


[*]创建一个带默认值的字典:
from collections import defaultdict

# 默认值为0
dd = defaultdict(int)
dd['a'] += 1
print(dd)# 输出: defaultdict(<class 'int'>, {'a': 1})
[*]按字符统计字符串中字符出现的次数:
text = "hello world"
char_count = defaultdict(int)
for char in text:
    char_count += 1
print(char_count)# 输出: defaultdict(<class 'int'>, {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
[*]将列表中的元素按长度进行分组:
words = ["apple", "banana", "pear", "kiwi", "grape"]
word_groups = defaultdict(list)
for word in words:
    word_groups.append(word)
print(word_groups)# 输出: defaultdict(<class 'list'>, {5: ['apple', 'pear', 'grape'], 6: ['banana'], 4: ['kiwi']})
[*]自定义默认工厂函数:
def default_value():
    return "default_value"

dd = defaultdict(default_value)
print(dd["nonexistent_key"])# 输出: "default_value"
[*]嵌套使用 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__),从而减少手动编写样板代码。
使用示例


[*]创建一个简单的数据类:
from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

person = Person(name="Alice", age=30)
print(person)# 输出: Person(name='Alice', age=30)
[*]设置默认值:
@dataclass
class Person:
    name: str
    age: int = 25# 默认年龄为25

person = Person(name="Bob")
print(person)# 输出: Person(name='Bob', age=25)
[*]生成对象比较方法:
@dataclass
class Person:
    name: str
    age: int

person1 = Person(name="Alice", age=30)
person2 = Person(name="Alice", age=30)
print(person1 == person2)# 输出: True
[*]冻结数据类(禁止修改属性):
@dataclass(frozen=True)
class Person:
    name: str
    age: int

person = Person(name="Alice", age=30)
# person.age = 31# 这行代码会抛出错误:FrozenInstanceError
[*]处理复杂的数据类型:
from dataclasses import dataclass
from typing import List

@dataclass
class Team:
    name: str
    members: List

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: 用于时间差运算。
使用示例


[*]获取当前日期和时间:from datetime import datetime

now = datetime.now()
print(f"当前时间: {now}")
输出:
当前时间: 2024-09-07 15:32:18.123456
[*]格式化日期和时间: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:18strftime 用于根据指定格式将日期时间对象转换为字符串。常见格式说明:
%Y: 四位数的年份,如 2024
%m: 两位数的月份,如 09
%d: 两位数的日期,如 07
%H: 两位数的小时,24 小时制
%M: 两位数的分钟
%S: 两位数的秒

[*]解析日期字符串: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:18strptime 用于根据指定格式将字符串转换为日期时间对象。
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.123456timedelta 对象用于表示两个日期或时间之间的差值,可以进行加减法运算。
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" 的缩写,意思是当缓存达到指定容量时,最久未使用的缓存条目将被清除。
使用示例


[*]递归斐波那契数列计算(使用缓存):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 参数指定了缓存的大小。

[*]指定缓存大小:@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)。

[*]清除缓存:fibonacci.cache_clear()# 清除缓存
print(fibonacci.cache_info())# 输出缓存信息,确认缓存已被清除
cache_clear() 方法可以手动清空缓存,适用于需要重置缓存的情况。

[*]处理复杂计算:@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 模块中的一个函数,它可以将多个可迭代对象(如列表、元组、集合等)“串联”成一个单一的迭代器。这样你可以在遍历多个可迭代对象时无需嵌套循环,从而简化代码结构。
使用示例


[*]串联多个列表:
from itertools import chain

list1 =
list2 =
result = list(chain(list1, list2))
print(result)# 输出:
[*]串联不同类型的可迭代对象:
list1 =
tuple1 = (4, 5, 6)
set1 = {7, 8, 9}
result = list(chain(list1, tuple1, set1))
print(result)# 输出:
[*]串联多个字符串:
str1 = "ABC"
str2 = "DEF"
result = list(chain(str1, str2))
print(result)# 输出: ['A', 'B', 'C', 'D', 'E', 'F']
[*]合并多层嵌套的迭代器:
nested_list = [, , ]
result = list(chain.from_iterable(nested_list))
print(result)# 输出:
[*]处理生成器:
def generator1():
    yield 1
    yield 2

def generator2():
    yield 3
    yield 4

result = list(chain(generator1(), generator2()))
print(result)# 输出:
使用场景

合并多个数据源:当你需要遍历多个可迭代对象时,使用 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 对象。
使用示例


[*]将 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"
}
[*]从文件读取 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 数据。

[*]自定义 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 对象,包括复杂的数据结构和自定义对象。
使用示例


[*]将对象序列化到文件:
import pickle

data = {'name': 'Alice', 'age': 30, 'city': 'Wonderland'}

# 将对象序列化并写入文件
with open('data.pkl', 'wb') as file:
    pickle.dump(data, file)
[*]从文件反序列化对象:
import pickle

# 从文件读取并反序列化对象
with open('data.pkl', 'rb') as file:
    data = pickle.load(file)
print(data)# 输出: {'name': 'Alice', 'age': 30, 'city': 'Wonderland'}
[*]将对象序列化为字节流:
import pickle

data =

# 序列化对象为字节流
byte_stream = pickle.dumps(data)
print(byte_stream)
[*]从字节流反序列化对象:
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)# 输出:
[*]序列化自定义对象:
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 标准库中的一个模块,提供了格式化打印复杂数据结构的功能。它可以将嵌套的数据结构(如字典、列表、元组等)以更易读的格式输出,帮助开发者更好地调试和查看数据。
使用示例


[*]打印嵌套的字典: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'}
[*]打印长列表: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, 3
3, 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]
[*]打印带有自定义缩进的字典 :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']}
[*]打印带有自定义宽度的列表: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, 3
3, 34, 35, 36, 37, 38, 39,40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
[*]使用 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(): 根据正则表达式分割字符串。
使用示例


[*]简单匹配:import re

pattern = r'\d+'# 匹配一个或多个数字
result = re.match(pattern, '123abc')
print(result.group())# 输出: 123
re.match 函数从字符串的开头开始匹配。上例中匹配到了字符串开头的数字 123。

[*]查找字符串中的第一个匹配项:result = re.search(r'+', '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+@+?\.{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 - - "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+', '', text)
print(new_text)# 输出: User ID: , Date: 注意事项

贪婪与非贪婪匹配:默认情况下,正则表达式是贪婪的,会尽可能多地匹配字符。可以通过 ? 实现非贪婪匹配,例如 r''。
避免过于复杂的正则:虽然正则表达式功能强大,但复杂的表达式可能难以维护,建议保持简洁。
转义字符:某些字符在正则表达式中有特殊含义(如 .、</em>、+ 等),使用它们时需要通过 \ 进行转义。
14. timeit.timeit - 测量代码执行时间

功能介绍

timeit.timeit 是 Python 标准库中的一个函数,用于精确测量小段代码的执行时间。它特别适合用于性能测试,能够准确地计算出代码块的运行时间,并提供有关代码执行效率的有价值信息。
使用示例


[*]测量简单代码的执行时间:
import timeit

# 测量一行代码的执行时间
execution_time = timeit.timeit('x = sum(range(100))', number=10000)
print(f"Execution time: {execution_time} seconds")
[*]测量函数的执行时间:
import timeit

def test_function():
    return sum(range(100))

execution_time = timeit.timeit(test_function, number=10000)
print(f"Execution time: {execution_time} seconds")
[*]使用 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")
[*]使用 timeit 测量带有 setup 代码的执行时间:
import timeit

setup_code = '''
import random
data =
'''

test_code = '''
sorted_data = sorted(data)
'''

execution_time = timeit.timeit(test_code, setup=setup_code, number=1000)
print(f"Execution time: {execution_time} seconds")
[*]测量代码性能的复杂场景:
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 的方法,包括基于时间、随机数和哈希值等方式。
使用示例


[*]生成一个基于时间的 UUID:import uuid

uuid1 = uuid.uuid1()
print(f"UUID1: {uuid1}")
输出:
UUID1: 123e4567-e89b-12d3-a456-426614174000

[*]生成一个基于随机数的 UUID:import uuid

uuid4 = uuid.uuid4()
print(f"UUID4: {uuid4}")
输出:
UUID4: 9d6d8a0a-1e2b-4f8c-8c0d-15e16529d37e
[*]生成一个基于名称的 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
[*]生成一个基于 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
[*]将 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 在不同应用和系统之间传递时,需要确保格式一致,通常使用标准的字符串格式进行传递。

来源:https://www.cnblogs.com/Sunzz/p/18402025
免责声明:由于采集信息均来自互联网,如果侵犯了您的权益,请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容,谢谢合作!
页: [1]
查看完整版本: 别让代码愁白头发!15 个 Python 函数拯救你的开发生活