在 Python 世界里，有一些寶藏函數和模塊，它們可以讓你編程更輕松、代碼更高效。這篇文章將帶你一一認識這些神器，讓你的開發生活瞬間輕松不少！

1.all- 檢查所有元素是否滿足條件

功能介紹

all函數用于檢查可迭代對象中的所有元素是否都滿足給定的條件。如果可迭代對象為空，則返回True。

使用示例

檢查列表中的所有數字是否為正數：

numbers = [1, 2, 3, 4]
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 = [1, 5, 8, 12]
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 = [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模塊用于編寫用戶友好的命令行接口。它允許你定義腳本可以接收的參數，并自動生成幫助信息。通過命令行傳遞參數可以讓你的程序更加靈活和易于使用，尤其是在需要傳遞多種不同參數的腳本中。

使用示例

處理基本的命令行參數：

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是 Pythoncollections模塊中的一個子類，提供了一個帶默認值的字典。當你訪問一個不存在的鍵時，defaultdict不會拋出KeyError，而是會根據提供的工廠函數自動生成默認值。這使得在處理字典時無需手動檢查鍵是否存在，減少代碼中的冗余檢查。

使用示例

創建一個帶默認值的字典：

from collections import defaultdict

# 默認值為0
dd = defaultdict(int)
dd['a'] += 1
print(dd)  # 輸出: defaultdict(, {'a': 1})

按字符統計字符串中字符出現的次數：

text = "hello world"
char_count = defaultdict(int)
for char in text:
    char_count[char] += 1
print(char_count)  # 輸出: defaultdict(, {'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[len(word)].append(word)
print(word_groups)  # 輸出: defaultdict(, {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( at 0x...>, {'key1': defaultdict(, {'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[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: 用于時間差運算。

使用示例

獲取當前日期和時間：

from datetime import datetime

now = datetime.now()
print(f"當前時間: {now}")

輸出：

當前時間: 2024-09-07 1518.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 1518

strftime 用于根據指定格式將日期時間對象轉換為字符串。常見格式說明：
%Y: 四位數的年份，如 2024
%m: 兩位數的月份，如 09
%d: 兩位數的日期，如 07
%H: 兩位數的小時，24 小時制
%M: 兩位數的分鐘
%S: 兩位數的秒

解析日期字符串：

from datetime import datetime

date_str = "2024-09-07 1518"
date_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print(f"解析后的日期對象: {date_obj}")

輸出：

解析后的日期對象: 2024-09-07 1518

strptime用于根據指定格式將字符串轉換為日期時間對象。
4.計算時間差：

from datetime import datetime, timedelta

now = datetime.now()
future = now + timedelta(days=10)
print(f"10天后的日期: {future}")

輸出：

10天后的日期: 2024-09-17 1518.123456

timedelta對象用于表示兩個日期或時間之間的差值，可以進行加減法運算。
5.獲取日期部分或時間部分：

from datetime import datetime

now = datetime.now()
print(f"當前日期: {now.date()}")
print(f"當前時間: {now.time()}")

輸出：

當前日期: 2024-09-07
當前時間: 1518.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 = [1, 2, 3]
list2 = [4, 5, 6]
result = list(chain(list1, list2))
print(result)  # 輸出: [1, 2, 3, 4, 5, 6]

串聯不同類型的可迭代對象：

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]

串聯多個字符串：

str1 = "ABC"
str2 = "DEF"
result = list(chain(str1, str2))
print(result)  # 輸出: ['A', 'B', 'C', 'D', 'E', 'F']

合并多層嵌套的迭代器：

nested_list = [[1, 2], [3, 4], [5, 6]]
result = list(chain.from_iterable(nested_list))
print(result)  # 輸出: [1, 2, 3, 4, 5, 6]

處理生成器：

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 對象。

使用示例

將 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-07T1518.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 = [1, 2, 3, {'a': 'A', 'b': 'B'}]

# 序列化對象為字節流
byte_stream = pickle.dumps(data)
print(byte_stream)

從字節流反序列化對象：

import pickle

byte_stream = b'x80x04x95x1cx00x00x00x00x00x00x00x8cx04listx94x8cx04x00x00x00x00x00x00x00x8cx03intx94x8cx04x00x00x00x00x00x00x00x8cx03dictx94x8cx03x00x00x00x00x00x00x00x8cx01ax94x8cx01Ax94x8cx01bx94x8cx01Bx94x87x94x00x00x00x00x00x00x00'

# 反序列化字節流為對象
data = pickle.loads(byte_stream)
print(data)  # 輸出: [1, 2, 3, {'a': 'A', 'b': 'B'}]

序列化自定義對象：

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, 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]

打印帶有自定義縮進的字典：

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, 33, 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'[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'(?Pd{4})-(?Pd{2})-(?Pd{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 = '[email protected]'
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/202455: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 標準庫中的一個函數，用于精確測量小段代碼的執行時間。它特別適合用于性能測試，能夠準確地計算出代碼塊的運行時間，并提供有關代碼執行效率的有價值信息。

使用示例

測量簡單代碼的執行時間：

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 = [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")

測量代碼性能的復雜場景：

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