在 Python 世界里，有一些寶藏函數(shù)和模塊，它們可以讓你編程更輕松、代碼更高效。這篇文章將帶你一一認識這些神器，讓你的開發(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

使用場景

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

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

功能介紹

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

使用示例

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

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

使用場景

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

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

數(shù)據(jù)驗證：在處理表單或數(shù)據(jù)庫時，檢查是否有數(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ù)項。

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

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

功能介紹

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

使用示例

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

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!

設(shè)置默認值和必選參數(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}")

運行示例：

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

輸出：

年齡: 30, 城市: Beijing

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

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

輸出：

詳細模式已開啟

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

import argparse

parser = argparse.ArgumentParser(description="計算器程序")
parser.add_argument('num1', type=int, help="第一個數(shù)字")
parser.add_argument('num2', type=int, help="第二個數(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}")

運行示例：

python script.py 10 5 --operation subtract

輸出：

結(jié)果: 5

使用場景

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

注意事項

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

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

功能介紹

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

使用示例

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

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)計列表中元素的出現(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)]

更新計數(shù)器：

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

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

注意事項

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

5.collections.defaultdict- 帶默認值的字典

功能介紹

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

使用示例

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

from collections import defaultdict

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

按字符統(tǒng)計字符串中字符出現(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})

將列表中的元素按長度進行分組：

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

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

def default_value():
    return "default_value"

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

嵌套使用 defaultdict：

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

使用場景

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

注意事項

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

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

功能介紹

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

使用示例

創(chuàng)建一個簡單的數(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è)置默認值：

@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

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

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

person = Person(name="Alice", age=30)
# person.age = 31  # 這行代碼會拋出錯誤：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ù)類的定義：避免手動編寫init、repr、eq等方法，減少冗余代碼。
創(chuàng)建不可變對象：通過凍結(jié)類屬性實現(xiàn)不可變性（類似于 namedtuple 的行為）。
數(shù)據(jù)封裝：在應(yīng)用中使用數(shù)據(jù)類封裝業(yè)務(wù)邏輯和數(shù)據(jù)結(jié)構(gòu)，如定義用戶、商品、訂單等類。

注意事項

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

7.datetime- 處理日期和時間

功能介紹

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

datetime主要有幾個核心對象：

datetime.datetime: 表示日期和時間的組合。

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

datetime.time: 僅表示時間（時、分、秒）。

datetime.timedelta: 用于時間差運算。

使用示例

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

from datetime import datetime

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

輸出：

當(dāng)前時間: 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 用于根據(jù)指定格式將日期時間對象轉(zhuǎn)換為字符串。常見格式說明：
%Y: 四位數(shù)的年份，如 2024
%m: 兩位數(shù)的月份，如 09
%d: 兩位數(shù)的日期，如 07
%H: 兩位數(shù)的小時，24 小時制
%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)換為日期時間對象。
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"當(dāng)前日期: {now.date()}")
print(f"當(dāng)前時間: {now.time()}")

輸出：

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

使用場景

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

注意事項

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

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

功能介紹

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

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

使用示例

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

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

指定緩存大小：

@lru_cache(maxsize=32)  # 緩存最近32個調(diào)用結(jié)果
def compute(x):
    # 假設(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())  # 輸出緩存信息，確認緩存已被清除

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

處理復(fù)雜計算：

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

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

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

輸出：

3
3

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

使用場景

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

注意事項

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

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

功能介紹

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

使用示例

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

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)多個字符串：

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]

使用場景

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

注意事項

itertools.chain 是一個迭代器，不會立刻生成結(jié)果，直到你真正遍歷它。因此對于超大數(shù)據(jù)集，chain 的性能更優(yōu)，因為它不會一次性加載所有數(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é)果：這段代碼會在當(dāng)前目錄下生成一個 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 序列化和反序列化：
有時候，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 參數(shù)可用于處理 JSON 默認不支持的對象類型。

使用場景

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

注意事項

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

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

功能介紹

pickle是 Python 標(biāo)準庫中的一個模塊，用于將 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ù)緩存：將計算結(jié)果緩存到文件中，以便下次快速加載。

注意事項

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

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

功能介紹

pprint是 Python 標(biāo)準庫中的一個模塊，提供了格式化打印復(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]

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

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

注意事項

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

13.re- 正則表達式處理利器

功能介紹

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

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

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

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

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

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

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

使用示例

簡單匹配：

import re

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

re.match 函數(shù)從字符串的開頭開始匹配。上例中匹配到了字符串開頭的數(shù)字 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 使用 # 替換所有匹配的數(shù)字部分。
5.根據(jù)正則表達式分割字符串：

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

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

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

使用場景

表單驗證：驗證電子郵件、電話號碼、郵政編碼等格式。

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ù)，例如日期、時間、金額等。

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)日志，提取時間戳、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

字符串替換和格式化：通過模式匹配，快速進行復(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àn)非貪婪匹配，例如 r'<.?>'。
避免過于復(fù)雜的正則：雖然正則表達式功能強大，但復(fù)雜的表達式可能難以維護，建議保持簡潔。
轉(zhuǎn)義字符：某些字符在正則表達式中有特殊含義（如 .、、+ 等），使用它們時需要通過 進行轉(zhuǎn)義。

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

功能介紹

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

使用示例

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

import timeit

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

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

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í)行時間：

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í)行時間：

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í)行時間，選擇最優(yōu)的解決方案。
比較不同實現(xiàn)：在對比不同的實現(xiàn)方式時，使用 timeit 可以提供準確的執(zhí)行時間數(shù)據(jù)。

注意事項

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

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

功能介紹

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

使用示例

生成一個基于時間的 UUID：

import uuid

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

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

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

注意事項

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

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