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

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

功能介紹

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

使用示例

檢查列表中的所有數(shù)字是否為正數(shù)：

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

使用場景

驗(yàn)證數(shù)據(jù)完整性：確保所有數(shù)據(jù)項(xiàng)都符合特定條件。
條件檢查：在執(zhí)行操作之前驗(yàn)證數(shù)據(jù)的有效性。

2.any- 檢查是否有元素滿足條件

功能介紹

any函數(shù)用于檢查一個(gè)可迭代對象（如列表、元組等）中是否有至少一個(gè)元素滿足給定的條件。如果有任意一個(gè)元素為 True，則返回 True，否則返回 False。如果可迭代對象為空，則返回 False。

使用示例

檢查列表中是否有大于 10 的數(shù)字：

numbers = [1, 5, 8, 12]
result = any(num > 10 for num in numbers)
print(result)  # 輸出: True

檢查字符串是否包含某個(gè)字符：

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

使用場景

條件檢查：當(dāng)你希望在一組數(shù)據(jù)中驗(yàn)證是否至少有一個(gè)元素滿足某個(gè)條件時(shí)，any 是一個(gè)非常高效的工具。例如，檢查用戶輸入是否符合某些標(biāo)準(zhǔn)，或者列表中是否存在滿足特定條件的值。

users = ['admin', 'guest', 'user1']
if any(user == 'admin' for user in users):
    print("Admin is present")

數(shù)據(jù)驗(yàn)證：在處理表單或數(shù)據(jù)庫時(shí)，檢查是否有數(shù)據(jù)字段為空或無效。

fields = {'name': 'John', 'email': '', 'age': 30}
if any(value == '' for value in fields.values()):
    print("Some fields are empty!")

快速篩選數(shù)據(jù)：例如，在數(shù)據(jù)分析中快速查看是否有不符合條件的數(shù)據(jù)項(xiàng)。

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!")

注意事項(xiàng)

any會(huì)在遇到第一個(gè)為True的元素時(shí)立即返回，而不會(huì)繼續(xù)檢查剩余的元素，因此在性能方面具有優(yōu)勢。
any通常與生成器表達(dá)式一起使用，使其能夠處理大型數(shù)據(jù)集而不消耗過多內(nèi)存。
any和all是一對非常實(shí)用的布爾函數(shù)，能夠快速簡化許多條件檢查的代碼邏輯。

3.argparse- 處理命令行參數(shù)

功能介紹

argparse模塊用于編寫用戶友好的命令行接口。它允許你定義腳本可以接收的參數(shù)，并自動(dòng)生成幫助信息。通過命令行傳遞參數(shù)可以讓你的程序更加靈活和易于使用，尤其是在需要傳遞多種不同參數(shù)的腳本中。

使用示例

處理基本的命令行參數(shù)：

import argparse

parser = argparse.ArgumentParser(description="這是一個(gè)演示腳本")
parser.add_argument('--name', type=str, help='輸入你的名字')
args = parser.parse_args()

print(f"你好, {args.name}!")

運(yùn)行示例：

python script.py --name Alice

輸出：

你好, Alice!

設(shè)置默認(rèn)值和必選參數(shù)：

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}")

運(yùn)行示例：

python script.py --age 30 --city Beijing

輸出：

年齡: 30, 城市: Beijing

支持布爾值參數(shù)：

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--verbose', action='store_true', help='是否輸出詳細(xì)信息')
args = parser.parse_args()

if args.verbose:
    print("詳細(xì)模式已開啟")
else:
    print("默認(rèn)模式")

運(yùn)行示例：

python script.py --verbose

輸出：

詳細(xì)模式已開啟

處理多個(gè)命令行參數(shù)：

import argparse

parser = argparse.ArgumentParser(description="計(jì)算器程序")
parser.add_argument('num1', type=int, help="第一個(gè)數(shù)字")
parser.add_argument('num2', type=int, help="第二個(gè)數(shù)字")
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"結(jié)果: {result}")

運(yùn)行示例：

python script.py 10 5 --operation subtract

輸出：

結(jié)果: 5

使用場景

命令行工具開發(fā)：如腳本自動(dòng)化、系統(tǒng)管理任務(wù)、文件處理腳本等，方便通過命令行傳遞參數(shù)。
數(shù)據(jù)處理腳本：通過不同的參數(shù)，處理不同的數(shù)據(jù)文件或數(shù)據(jù)源。
腳本調(diào)試與測試：通過簡單的命令行參數(shù)可以快速切換腳本的行為（例如詳細(xì)模式、測試模式等）。

注意事項(xiàng)

自動(dòng)生成幫助信息：argparse 會(huì)根據(jù)你定義的參數(shù)自動(dòng)生成幫助信息，幫助用戶了解如何使用腳本。
參數(shù)類型：支持多種類型的參數(shù)，包括字符串、整數(shù)、布爾值、列表等。
參數(shù)驗(yàn)證：argparse 可以自動(dòng)驗(yàn)證參數(shù)的類型和合法性，確保輸入有效。

4.collections.Counter- 計(jì)數(shù)器類

功能介紹

Counter是collections模塊中的一個(gè)字典子類，主要用于計(jì)數(shù)，統(tǒng)計(jì)可迭代對象中每個(gè)元素出現(xiàn)的次數(shù)。它將元素作為字典的鍵，次數(shù)作為值，并且提供了多個(gè)方便的計(jì)數(shù)操作方法。

使用示例

統(tǒng)計(jì)字符串中字符的頻率：

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})

統(tǒng)計(jì)列表中元素的出現(xiàn)次數(shù)：

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

更新計(jì)數(shù)器：

counter.update(['banana', 'orange', 'apple'])
print(counter)  # 輸出: Counter({'apple': 4, 'banana': 3, 'orange': 2})

計(jì)數(shù)器的加減操作：

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})

使用場景

統(tǒng)計(jì)字符或詞頻：分析文本中字符或單詞的頻率。
計(jì)數(shù)元素出現(xiàn)的次數(shù)：如統(tǒng)計(jì)購物車中物品數(shù)量、游戲中的分?jǐn)?shù)等。
找出最常見的元素：從一組數(shù)據(jù)中快速找出最常出現(xiàn)的元素。

注意事項(xiàng)

負(fù)數(shù)計(jì)數(shù)會(huì)被保留，但在使用 most_common 等方法時(shí)不會(huì)顯示。
可以使用 +、-、&、| 等操作符對多個(gè) Counter 對象進(jìn)行加減或并集交集操作。

5.collections.defaultdict- 帶默認(rèn)值的字典

功能介紹

defaultdict是 Pythoncollections模塊中的一個(gè)子類，提供了一個(gè)帶默認(rèn)值的字典。當(dāng)你訪問一個(gè)不存在的鍵時(shí)，defaultdict不會(huì)拋出KeyError，而是會(huì)根據(jù)提供的工廠函數(shù)自動(dòng)生成默認(rèn)值。這使得在處理字典時(shí)無需手動(dòng)檢查鍵是否存在，減少代碼中的冗余檢查。

使用示例

創(chuàng)建一個(gè)帶默認(rèn)值的字典：

from collections import defaultdict

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

按字符統(tǒng)計(jì)字符串中字符出現(xiàn)的次數(shù)：

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})

將列表中的元素按長度進(jìn)行分組：

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

自定義默認(rèn)工廠函數(shù)：

def default_value():
    return "default_value"

dd = defaultdict(default_value)
print(dd["nonexistent_key"])  # 輸出: "default_value"

嵌套使用 defaultdict：

# 創(chuàng)建一個(gè)嵌套的默認(rèn)字典
nested_dict = defaultdict(lambda: defaultdict(int))
nested_dict['key1']['subkey'] += 1
print(nested_dict)  # 輸出: defaultdict( at 0x...>, {'key1': defaultdict(, {'subkey': 1})})

使用場景

避免手動(dòng)檢查鍵是否存在：在處理計(jì)數(shù)或聚合操作時(shí)，避免頻繁進(jìn)行鍵存在性檢查。
統(tǒng)計(jì)數(shù)據(jù)：如統(tǒng)計(jì)字符出現(xiàn)次數(shù)、單詞長度分組、計(jì)數(shù)等。
簡化嵌套結(jié)構(gòu)：使用嵌套 defaultdict 可以創(chuàng)建多層字典結(jié)構(gòu)，避免逐層初始化。

注意事項(xiàng)

defaultdict 的默認(rèn)值是通過工廠函數(shù)生成的，因此每次訪問缺失鍵時(shí)都會(huì)調(diào)用這個(gè)工廠函數(shù)。
小心使用帶副作用的工廠函數(shù)，如文件操作、網(wǎng)絡(luò)請求等，因?yàn)檫@些操作會(huì)在訪問不存在的鍵時(shí)被觸發(fā)。

6.dataclasses.dataclass- 輕量級數(shù)據(jù)類

功能介紹

dataclass是 Python 3.7 引入的一個(gè)裝飾器，用于簡化數(shù)據(jù)類的創(chuàng)建。它可以自動(dòng)生成類的初始化方法 (__init__)、表示方法 (__repr__) 等，還可以對比對象的相等性 (__eq__)，從而減少手動(dòng)編寫樣板代碼。

使用示例

創(chuàng)建一個(gè)簡單的數(shù)據(jù)類：

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

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

設(shè)置默認(rèn)值：

@dataclass
class Person:
    name: str
    age: int = 25  # 默認(rèn)年齡為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

凍結(jié)數(shù)據(jù)類（禁止修改屬性）：

@dataclass(frozen=True)
class Person:
    name: str
    age: int

person = Person(name="Alice", age=30)
# person.age = 31  # 這行代碼會(huì)拋出錯(cuò)誤：FrozenInstanceError

處理復(fù)雜的數(shù)據(jù)類型：

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

使用場景

簡化數(shù)據(jù)類的定義：避免手動(dòng)編寫init、repr、eq等方法，減少冗余代碼。
創(chuàng)建不可變對象：通過凍結(jié)類屬性實(shí)現(xiàn)不可變性（類似于 namedtuple 的行為）。
數(shù)據(jù)封裝：在應(yīng)用中使用數(shù)據(jù)類封裝業(yè)務(wù)邏輯和數(shù)據(jù)結(jié)構(gòu)，如定義用戶、商品、訂單等類。

注意事項(xiàng)

數(shù)據(jù)類可以通過設(shè)置 frozen=True 讓屬性不可變，這使得數(shù)據(jù)類的實(shí)例更接近于 namedtuple。
可以通過 field() 函數(shù)為類屬性提供更靈活的控制，例如設(shè)置默認(rèn)值、排除某些字段不進(jìn)行比較等。

7.datetime- 處理日期和時(shí)間

功能介紹

datetime模塊提供了操作日期和時(shí)間的強(qiáng)大工具。它允許你獲取當(dāng)前日期時(shí)間、進(jìn)行時(shí)間運(yùn)算、格式化日期時(shí)間字符串等。這個(gè)模塊是處理時(shí)間相關(guān)任務(wù)的首選，非常適合需要追蹤、計(jì)算或展示時(shí)間的場景。

datetime主要有幾個(gè)核心對象：

datetime.datetime: 表示日期和時(shí)間的組合。

datetime.date: 僅表示日期（年、月、日）。

datetime.time: 僅表示時(shí)間（時(shí)、分、秒）。

datetime.timedelta: 用于時(shí)間差運(yùn)算。

使用示例

獲取當(dāng)前日期和時(shí)間：

from datetime import datetime

now = datetime.now()
print(f"當(dāng)前時(shí)間: {now}")

輸出：

當(dāng)前時(shí)間: 2024-09-07 1518.123456

格式化日期和時(shí)間：

from datetime import datetime

now = datetime.now()
formatted_time = now.strftime("%Y-%m-%d %H:%M:%S")
print(f"格式化后的時(shí)間: {formatted_time}")

輸出：

格式化后的時(shí)間: 2024-09-07 1518

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

解析日期字符串：

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用于根據(jù)指定格式將字符串轉(zhuǎn)換為日期時(shí)間對象。
4.計(jì)算時(shí)間差：

from datetime import datetime, timedelta

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

輸出：

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

timedelta對象用于表示兩個(gè)日期或時(shí)間之間的差值，可以進(jìn)行加減法運(yùn)算。
5.獲取日期部分或時(shí)間部分：

from datetime import datetime

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

輸出：

當(dāng)前日期: 2024-09-07
當(dāng)前時(shí)間: 1518.123456

使用場景

日志記錄：自動(dòng)生成時(shí)間戳，用于記錄系統(tǒng)操作、錯(cuò)誤報(bào)告等。
定時(shí)任務(wù)：設(shè)置延遲、時(shí)間間隔的操作，例如自動(dòng)備份系統(tǒng)。
數(shù)據(jù)處理：對包含時(shí)間戳的數(shù)據(jù)進(jìn)行操作，如分析時(shí)間序列數(shù)據(jù)或時(shí)間范圍過濾。
時(shí)間運(yùn)算：例如計(jì)算某個(gè)日期之前或之后的天數(shù)、小時(shí)數(shù)等。

注意事項(xiàng)

datetime.now() 獲取當(dāng)前時(shí)間時(shí)精確到微秒。如果不需要微秒，可以使用 .replace(microsecond=0) 來忽略。
timedelta 可以進(jìn)行時(shí)間運(yùn)算，但對于時(shí)區(qū)計(jì)算，需要結(jié)合 pytz 模塊進(jìn)行更復(fù)雜的時(shí)區(qū)管理。

8.functools.lru_cache- 緩存函數(shù)結(jié)果，提升性能

功能介紹

functools.lru_cache是一個(gè)非常有用的裝飾器，它可以緩存函數(shù)的結(jié)果，從而避免對相同輸入的重復(fù)計(jì)算，提升程序的性能。它適用于那些具有重復(fù)計(jì)算特性且結(jié)果可以被重用的函數(shù)，特別是在遞歸或大量重復(fù)調(diào)用的場景下表現(xiàn)尤為出色。

lru_cache中的 "LRU" 是 "Least Recently Used" 的縮寫，意思是當(dāng)緩存達(dá)到指定容量時(shí)，最久未使用的緩存條目將被清除。

使用示例

遞歸斐波那契數(shù)列計(jì)算（使用緩存）：

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 通過緩存前面的計(jì)算結(jié)果，大大提高了遞歸斐波那契數(shù)列的效率。如果沒有緩存，每次遞歸都會(huì)重復(fù)計(jì)算之前的結(jié)果，效率極低。maxsize 參數(shù)指定了緩存的大小。

指定緩存大小：

@lru_cache(maxsize=32)  # 緩存最近32個(gè)調(diào)用結(jié)果
def compute(x):
    # 假設(shè)這是一個(gè)很耗時(shí)的函數(shù)
    return x * x

for i in range(40):
    print(compute(i))

print(compute.cache_info())  # 查看緩存的狀態(tài)

輸出：

CacheInfo(hits=0, misses=40, maxsize=32, currsize=32)

cache_info() 方法可以用來查看緩存的命中次數(shù)（hits）、未命中次數(shù)（misses）、緩存最大容量（maxsize）以及當(dāng)前緩存的條目數(shù)（currsize）。

清除緩存：

fibonacci.cache_clear()  # 清除緩存
print(fibonacci.cache_info())  # 輸出緩存信息，確認(rèn)緩存已被清除

cache_clear() 方法可以手動(dòng)清空緩存，適用于需要重置緩存的情況。

處理復(fù)雜計(jì)算：

@lru_cache(maxsize=100)
def slow_function(x, y):
    # 模擬耗時(shí)計(jì)算
    import time
    time.sleep(2)
    return x + y

# 第一次調(diào)用會(huì)等待2秒
print(slow_function(1, 2))  # 輸出: 3

# 第二次調(diào)用將直接使用緩存的結(jié)果，幾乎瞬時(shí)完成
print(slow_function(1, 2))  # 輸出: 3

輸出：

3
3

通過緩存結(jié)果，第二次調(diào)用相同參數(shù)時(shí)可以節(jié)省大量時(shí)間。

使用場景

遞歸算法優(yōu)化：如斐波那契數(shù)列、動(dòng)態(tài)規(guī)劃問題等，需要重復(fù)計(jì)算的函數(shù)調(diào)用。
處理復(fù)雜計(jì)算：對于需要大量重復(fù)計(jì)算的函數(shù)，通過緩存結(jié)果可以大大提高性能，如 Web 請求的處理、數(shù)據(jù)庫查詢結(jié)果的緩存等。
函數(shù)調(diào)用優(yōu)化：在處理相同輸入時(shí)，可以避免重復(fù)計(jì)算或耗時(shí)操作。

注意事項(xiàng)

緩存大小管理：maxsize 參數(shù)控制緩存的最大容量，合理設(shè)置該值可以在性能與內(nèi)存使用之間找到平衡。如果設(shè)置為 None，則緩存大小無限。
避免緩存不必要的數(shù)據(jù)：對于一些參數(shù)變化較多的函數(shù)，緩存可能會(huì)占用大量內(nèi)存，應(yīng)慎重使用 lru_cache。
緩存失效策略：lru_cache 使用的是最近最少使用 (LRU) 策略來移除舊的緩存項(xiàng)，因此不會(huì)一直保留所有的緩存結(jié)果。

9.itertools.chain- 將多個(gè)可迭代對象串聯(lián)起來

功能介紹

itertools.chain是itertools模塊中的一個(gè)函數(shù)，它可以將多個(gè)可迭代對象（如列表、元組、集合等）“串聯(lián)”成一個(gè)單一的迭代器。這樣你可以在遍歷多個(gè)可迭代對象時(shí)無需嵌套循環(huán)，從而簡化代碼結(jié)構(gòu)。

使用示例

串聯(lián)多個(gè)列表：

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]

串聯(lián)不同類型的可迭代對象：

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]

串聯(lián)多個(gè)字符串：

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]

使用場景

合并多個(gè)數(shù)據(jù)源：當(dāng)你需要遍歷多個(gè)可迭代對象時(shí)，使用 chain 可以避免多層循環(huán)。
合并嵌套列表：使用 chain.from_iterable 可以展平嵌套的可迭代對象，方便處理嵌套結(jié)構(gòu)的數(shù)據(jù)。
簡化代碼：如果需要對多個(gè)列表、生成器等進(jìn)行統(tǒng)一操作，chain 可以減少冗余代碼并提高代碼的可讀性。

注意事項(xiàng)

itertools.chain 是一個(gè)迭代器，不會(huì)立刻生成結(jié)果，直到你真正遍歷它。因此對于超大數(shù)據(jù)集，chain 的性能更優(yōu)，因?yàn)樗粫?huì)一次性加載所有數(shù)據(jù)到內(nèi)存中。
如果需要串聯(lián)嵌套可迭代對象，推薦使用 chain.from_iterable，而不是嵌套 chain 函數(shù)調(diào)用。

10.json- 處理JSON數(shù)據(jù)的好幫手

功能介紹

json模塊是 Python 用來解析、生成和操作 JSON（JavaScript Object Notation）數(shù)據(jù)的內(nèi)建模塊。JSON 是一種輕量級的數(shù)據(jù)交換格式，廣泛用于 Web 應(yīng)用程序與服務(wù)器之間的數(shù)據(jù)通信。通過json模塊，Python 可以方便地將 JSON 格式的字符串解析為 Python 對象，或?qū)?Python 對象序列化為 JSON 格式的字符串。

常用的函數(shù)包括：

json.dumps(): 將 Python 對象轉(zhuǎn)換為 JSON 字符串。

json.loads(): 將 JSON 字符串解析為 Python 對象。

json.dump(): 將 Python 對象寫入文件，保存為 JSON 格式。

json.load(): 從文件讀取 JSON 數(shù)據(jù)并轉(zhuǎn)換為 Python 對象。

使用示例

將 Python 對象轉(zhuǎn)換為 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 轉(zhuǎn)換為了 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 字典，然后可以訪問其中的數(shù)據(jù)。
3.將 JSON 數(shù)據(jù)寫入文件：

import json

data = {'name': 'Alice', 'age': 25, 'city': 'London'}
with open('data.json', 'w') as file:
    json.dump(data, file)

結(jié)果：這段代碼會(huì)在當(dāng)前目錄下生成一個(gè) data.json 文件，內(nèi)容為：

{
    "name": "Alice",
    "age": 25,
    "city": "London"
}

從文件讀取 JSON 數(shù)據(jù)：

import json

with open('data.json', 'r') as file:
    data = json.load(file)
print(data)

輸出：

{'name': 'Alice', 'age': 25, 'city': 'London'}

通過 json.load() 函數(shù)，我們從文件中讀取并解析了 JSON 數(shù)據(jù)。

自定義 JSON 序列化和反序列化：
有時(shí)候，JSON 不支持某些 Python 對象（如日期時(shí)間），我們可以自定義序列化方法：

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 參數(shù)可用于處理 JSON 默認(rèn)不支持的對象類型。

使用場景

Web 開發(fā)：將數(shù)據(jù)以 JSON 格式在前端和后端之間傳輸，例如從 API 獲取數(shù)據(jù)時(shí)常用 JSON 格式。
配置文件：許多應(yīng)用程序使用 JSON 文件來存儲配置數(shù)據(jù)。
日志記錄：將系統(tǒng)操作日志保存為 JSON 格式，便于分析和處理。
數(shù)據(jù)序列化：用于保存和共享 Python 數(shù)據(jù)結(jié)構(gòu)，如保存爬蟲數(shù)據(jù)、機(jī)器學(xué)習(xí)模型參數(shù)等。

注意事項(xiàng)

JSON 的數(shù)據(jù)類型限制：JSON 支持的數(shù)據(jù)類型包括字符串、數(shù)字、布爾值、數(shù)組、對象和 null，不支持復(fù)雜的 Python 對象（如類實(shí)例、函數(shù)等）。
UTF-8 編碼：json 模塊默認(rèn)使用 UTF-8 編碼，因此可以很好地處理國際化字符。
避免重復(fù)數(shù)據(jù)的寫入：使用 json.dump() 時(shí)，一定要小心文件的打開模式，確保不會(huì)覆蓋重要數(shù)據(jù)。

11.pickle- 序列化和反序列化對象

功能介紹

pickle是 Python 標(biāo)準(zhǔn)庫中的一個(gè)模塊，用于將 Python 對象序列化為字節(jié)流，或?qū)⒆止?jié)流反序列化為原始對象。這使得對象可以存儲到文件中或者在網(wǎng)絡(luò)上傳輸。pickle支持幾乎所有的 Python 對象，包括復(fù)雜的數(shù)據(jù)結(jié)構(gòu)和自定義對象。

使用示例

將對象序列化到文件：

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'}

將對象序列化為字節(jié)流：

import pickle

data = [1, 2, 3, {'a': 'A', 'b': 'B'}]

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

從字節(jié)流反序列化對象：

import pickle

byte_stream = b'x80x04x95x1cx00x00x00x00x00x00x00x8cx04listx94x8cx04x00x00x00x00x00x00x00x8cx03intx94x8cx04x00x00x00x00x00x00x00x8cx03dictx94x8cx03x00x00x00x00x00x00x00x8cx01ax94x8cx01Ax94x8cx01bx94x8cx01Bx94x87x94x00x00x00x00x00x00x00'

# 反序列化字節(jié)流為對象
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)

使用場景

持久化數(shù)據(jù)：將數(shù)據(jù)存儲到文件中，方便在程序重啟后恢復(fù)。
對象傳輸：在網(wǎng)絡(luò)通信中傳輸 Python 對象，尤其是在分布式系統(tǒng)中。
數(shù)據(jù)緩存：將計(jì)算結(jié)果緩存到文件中，以便下次快速加載。

注意事項(xiàng)

安全性：反序列化數(shù)據(jù)時(shí)需謹(jǐn)慎，因?yàn)?pickle 可以執(zhí)行任意代碼，可能導(dǎo)致安全風(fēng)險(xiǎn)。盡量避免從不可信來源加載數(shù)據(jù)。
兼容性：不同版本的 Python 可能不完全兼容 pickle 數(shù)據(jù)，特別是在使用不同 Python 版本時(shí)。
性能：序列化和反序列化大對象時(shí)，性能可能會(huì)受到影響，可以考慮使用其他序列化格式（如 JSON）作為替代。

12.pprint- 格式化打印數(shù)據(jù)結(jié)構(gòu)

功能介紹

pprint是 Python 標(biāo)準(zhǔn)庫中的一個(gè)模塊，提供了格式化打印復(fù)雜數(shù)據(jù)結(jié)構(gòu)的功能。它可以將嵌套的數(shù)據(jù)結(jié)構(gòu)（如字典、列表、元組等）以更易讀的格式輸出，幫助開發(fā)者更好地調(diào)試和查看數(shù)據(jù)。

使用示例

打印嵌套的字典：

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]

打印帶有自定義縮進(jìn)的字典：

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)

使用場景

調(diào)試復(fù)雜數(shù)據(jù)結(jié)構(gòu)：在調(diào)試程序時(shí)，使用 pprint 可以更清晰地查看復(fù)雜的嵌套數(shù)據(jù)結(jié)構(gòu)。
數(shù)據(jù)分析：打印大型數(shù)據(jù)集合時(shí)，格式化輸出有助于快速理解數(shù)據(jù)內(nèi)容和結(jié)構(gòu)。
日志記錄：在記錄日志時(shí)，使用 pprint 可以使數(shù)據(jù)更易讀，幫助分析問題。

注意事項(xiàng)

pprint 適用于較為復(fù)雜的數(shù)據(jù)結(jié)構(gòu)，簡單的數(shù)據(jù)結(jié)構(gòu)使用普通的 print 更為高效。
調(diào)整 indent 和 width 參數(shù)可以控制輸出的格式和可讀性，根據(jù)具體需求選擇合適的設(shè)置。

13.re- 正則表達(dá)式處理利器

功能介紹

re模塊是 Python 中用來處理正則表達(dá)式的模塊，提供了強(qiáng)大的字符串匹配、查找、替換等功能。正則表達(dá)式是一種匹配字符串的模式，通過特定的規(guī)則，可以用于處理復(fù)雜的文本操作，比如提取數(shù)據(jù)、驗(yàn)證輸入格式等。

常用的函數(shù)包括：

re.match(): 從字符串的開頭進(jìn)行匹配。

re.search(): 在整個(gè)字符串中搜索第一個(gè)匹配項(xiàng)。

re.findall(): 找到所有與正則表達(dá)式匹配的子串。

re.sub(): 使用另一個(gè)字符串替換匹配到的部分。

re.split(): 根據(jù)正則表達(dá)式分割字符串。

使用示例

簡單匹配：

import re

pattern = r'd+'  # 匹配一個(gè)或多個(gè)數(shù)字
result = re.match(pattern, '123abc')
print(result.group())  # 輸出: 123

re.match 函數(shù)從字符串的開頭開始匹配。上例中匹配到了字符串開頭的數(shù)字 123。

查找字符串中的第一個(gè)匹配項(xiàng)：

result = re.search(r'[a-z]+', '123abc456')
print(result.group())  # 輸出: abc

re.search 在整個(gè)字符串中搜索，返回第一個(gè)符合模式的子串。
3.查找所有匹配項(xiàng)：

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 使用 # 替換所有匹配的數(shù)字部分。
5.根據(jù)正則表達(dá)式分割字符串：

result = re.split(r'd+', 'abc123def456ghi')
print(result)  # 輸出: ['abc', 'def', 'ghi']

re.split 按照正則表達(dá)式中的數(shù)字進(jìn)行分割，結(jié)果是一個(gè)列表。
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

命名組可以給每個(gè)匹配的子串起名字，從而方便后續(xù)的提取。

使用場景

表單驗(yàn)證：驗(yàn)證電子郵件、電話號碼、郵政編碼等格式。

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

數(shù)據(jù)提取：從文本中提取特定格式的數(shù)據(jù)，例如日期、時(shí)間、金額等。

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

日志分析：分析系統(tǒng)日志，提取時(shí)間戳、IP 地址、錯(cuò)誤信息等。

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

字符串替換和格式化：通過模式匹配，快速進(jìn)行復(fù)雜的文本替換或格式化。

text = 'User ID: 1234, Date: 2024-09-07'
new_text = re.sub(r'd+', '[ID]', text)
print(new_text)  # 輸出: User ID: [ID], Date: [ID]

注意事項(xiàng)

貪婪與非貪婪匹配：默認(rèn)情況下，正則表達(dá)式是貪婪的，會(huì)盡可能多地匹配字符。可以通過 ? 實(shí)現(xiàn)非貪婪匹配，例如 r'<.?>'。
避免過于復(fù)雜的正則：雖然正則表達(dá)式功能強(qiáng)大，但復(fù)雜的表達(dá)式可能難以維護(hù)，建議保持簡潔。
轉(zhuǎn)義字符：某些字符在正則表達(dá)式中有特殊含義（如 .、、+ 等），使用它們時(shí)需要通過 進(jìn)行轉(zhuǎn)義。

14.timeit.timeit- 測量代碼執(zhí)行時(shí)間

功能介紹

timeit.timeit是 Python 標(biāo)準(zhǔn)庫中的一個(gè)函數(shù)，用于精確測量小段代碼的執(zhí)行時(shí)間。它特別適合用于性能測試，能夠準(zhǔn)確地計(jì)算出代碼塊的運(yùn)行時(shí)間，并提供有關(guān)代碼執(zhí)行效率的有價(jià)值信息。

使用示例

測量簡單代碼的執(zhí)行時(shí)間：

import timeit

# 測量一行代碼的執(zhí)行時(shí)間
execution_time = timeit.timeit('x = sum(range(100))', number=10000)
print(f"Execution time: {execution_time} seconds")

測量函數(shù)的執(zhí)行時(shí)間：

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測量代碼塊的執(zhí)行時(shí)間：

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代碼的執(zhí)行時(shí)間：

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

測量代碼性能的復(fù)雜場景：

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

使用場景

性能分析：評估代碼段或函數(shù)的性能，找出潛在的性能瓶頸。
優(yōu)化代碼：通過測量不同算法或?qū)崿F(xiàn)的執(zhí)行時(shí)間，選擇最優(yōu)的解決方案。
比較不同實(shí)現(xiàn)：在對比不同的實(shí)現(xiàn)方式時(shí)，使用 timeit 可以提供準(zhǔn)確的執(zhí)行時(shí)間數(shù)據(jù)。

注意事項(xiàng)

測量粒度：timeit 主要用于測量小段代碼的性能，測量時(shí)間過長的代碼段可能需要調(diào)整 number 參數(shù)。
環(huán)境一致性：為了獲得準(zhǔn)確的性能測試結(jié)果，確保測量代碼在相同的環(huán)境和條件下運(yùn)行。
測量多次：建議運(yùn)行多次測量以獲得更穩(wěn)定的結(jié)果，避免偶發(fā)性的性能波動(dòng)。

15.uuid- 生成唯一標(biāo)識符

功能介紹

uuid是 Python 標(biāo)準(zhǔn)庫中的一個(gè)模塊，用于生成全球唯一標(biāo)識符（UUID）。UUID 是一種標(biāo)準(zhǔn)格式的標(biāo)識符，廣泛用于需要唯一標(biāo)識的場景，如數(shù)據(jù)庫主鍵、分布式系統(tǒng)中的對象標(biāo)識等。uuid模塊支持多種生成 UUID 的方法，包括基于時(shí)間、隨機(jī)數(shù)和哈希值等方式。

使用示例

生成一個(gè)基于時(shí)間的 UUID：

import uuid

uuid1 = uuid.uuid1()
print(f"UUID1: {uuid1}")

輸出：
UUID1: 123e4567-e89b-12d3-a456-426614174000

生成一個(gè)基于隨機(jī)數(shù)的 UUID：

import uuid

uuid4 = uuid.uuid4()
print(f"UUID4: {uuid4}")

輸出：

UUID4: 9d6d8a0a-1e2b-4f8c-8c0d-15e16529d37e

生成一個(gè)基于名稱的 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

生成一個(gè)基于 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 轉(zhuǎn)換為字符串：

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

使用場景

唯一標(biāo)識符：生成唯一的標(biāo)識符用于數(shù)據(jù)庫主鍵、會(huì)話標(biāo)識、文件名等。
分布式系統(tǒng)：在分布式系統(tǒng)中生成唯一的 ID，以確保不同節(jié)點(diǎn)生成的標(biāo)識符不會(huì)重復(fù)。
數(shù)據(jù)追蹤：生成唯一的標(biāo)識符用于跟蹤數(shù)據(jù)或?qū)ο蟮纳芷冢缭谌罩居涗浿袠?biāo)識事件。

注意事項(xiàng)

UUID 的版本：uuid 模塊提供了不同版本的 UUID（如 UUID1、UUID4、UUID3 和 UUID5），選擇適合的版本根據(jù)實(shí)際需求。
性能考慮：對于大量生成 UUID 的應(yīng)用，考慮選擇合適的 UUID 版本來優(yōu)化性能。例如，UUID4 基于隨機(jī)數(shù)，生成速度較快，但可能會(huì)有沖突風(fēng)險(xiǎn)；UUID1 基于時(shí)間和節(jié)點(diǎn)信息，生成速度較慢，但唯一性更高。
格式一致性：UUID 在不同應(yīng)用和系統(tǒng)之間傳遞時(shí)，需要確保格式一致，通常使用標(biāo)準(zhǔn)的字符串格式進(jìn)行傳遞。

鏈接：https://www.cnblogs.com/Sunzz/p/18402025