前言

此系列筆記是撥珠自己的學習筆記，自用為主，學習建議移步其他大佬的專門教程。

math庫

Python 的?math?庫是標準庫之一，提供了大量數學運算相關的函數，適用于基礎數學計算、科學計算等場景。下面詳細介紹其使用方法及常用功能：

1. 庫的調用

math?是 Python 內置標準庫，無需額外安裝，直接通過?import?語句導入即可使用：

import math  # 導入整個庫
# 或只導入需要的函數（推薦，減少內存占用）
from math import ceil, floor, factorial, comb, pow, sqrt, gcd, sin, cos, log, exp

2. 常用功能及示例

（1）向上取整與向下取整

• math.ceil(x)：向上取整，返回大于等于?x?的最小整數
• math.floor(x)：向下取整，返回小于等于?x?的最大整數

import mathprint(math.ceil(3.2))   # 輸出：4
print(math.ceil(-2.8))  # 輸出：-2（向上取整靠近0）
print(math.floor(3.8))  # 輸出：3
print(math.floor(-2.1)) # 輸出：-3（向下取整遠離0）

（2）階乘

• math.factorial(n)：返回非負整數?n?的階乘（n! = 1×2×...×n），n=0?時返回 1

import mathprint(math.factorial(5))  # 輸出：120（5! = 5×4×3×2×1）
print(math.factorial(0))  # 輸出：1（0! 定義為1）

（3）組合數

• math.comb(n, k)：返回從?n?個元素中選擇?k?個元素的組合數（C(n,k) = n!/(k!·(n-k)!)），要求?n ≥ k ≥ 0

import mathprint(math.comb(5, 2))  # 輸出：10（從5個中選2個的組合數）
print(math.comb(10, 3)) # 輸出：120

（4）指數與對數

• math.exp(x)：返回自然指數?e^x（e≈2.718）
• math.log(x[, base])：返回以?base?為底?x?的對數，默認底為?e（自然對數）
• math.log10(x)：返回以 10 為底?x?的對數（常用對數）

import mathprint(math.exp(1))       # 輸出：2.71828...（e^1）
print(math.log(math.e))  # 輸出：1.0（自然對數 ln(e)）
print(math.log(8, 2))    # 輸出：3.0（以2為底8的對數）
print(math.log10(100))   # 輸出：2.0（lg(100)）

（5）冪運算與開方

• math.pow(x, y)：返回?x?的?y?次冪（x^y），與內置?**?運算符類似，但返回浮點數
• math.sqrt(x)：返回?x?的平方根（√x），要求?x ≥ 0

import mathprint(math.pow(2, 3))  # 輸出：8.0（2^3）
print(math.sqrt(25))   # 輸出：5.0（√25）
print(math.sqrt(2))    # 輸出：1.4142...（√2）

（6）最大公約數（GCD）

math.gcd(a, b)：返回兩個非負整數?a?和?b?的最大公約數，a?和?b?不能同時為 0

import mathprint(math.gcd(12, 18))  # 輸出：6（12和18的最大公約數）
print(math.gcd(7, 5))    # 輸出：1（7和5互質）

（7）三角函數

math?庫的三角函數默認使用弧度制，需注意角度與弧度的轉換（math.radians(x)?可將角度轉為弧度）：

• 正弦：math.sin(x)
• 余弦：math.cos(x)
• 正切：math.tan(x)
• 反三角函數：math.asin(x)、math.acos(x)、math.atan(x)

import math# 計算30度的正弦值（先轉弧度）
angle = 30
radian = math.radians(angle)
print(math.sin(radian))  # 輸出：0.5（sin(30°)=0.5）print(math.cos(math.pi)) # 輸出：-1.0（cos(π) = -1）

collections庫

counter：計數器

基本用法

（1）導入?Counter

from collections import Counter

（2）創建?Counter?對象

可以傳入可迭代對象（如列表、元組、字符串等）來初始化：

# 統計列表中元素的出現次數
nums = [1, 2, 3, 2, 1, 3, 3, 4]
count = Counter(nums)
print(count)  # 輸出：Counter({3: 3, 1: 2, 2: 2, 4: 1})# 統計字符串中字符的出現次數
s = "hello world"
count_char = Counter(s)
print(count_char)  # 輸出：Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

（3）獲取元素的計數

通過鍵訪問，類似字典：

count = Counter([1, 2, 3, 2, 1, 3, 3, 4])
print(count[3])  # 輸出：3（數字3出現了3次）
print(count[5])  # 輸出：0（不存在的元素默認計數為0）

counter可以直接統計列表中元素出現的次數

回顧
輸入一段文本（一組數據），統計每個字符出現次數

#讀入文本
s = input()#統計數據
C = {}
for i in s:C[i] = C.get(i, 0) + 1#打印結果
for x, y in C.items():print("{} : {}".format(x, y))

常用函數

1. 設初值（初始化方式）

除了傳入可迭代對象，Counter?還支持多種初始化方式：

• 空初始化：創建空的?Counter，后續通過鍵值對添加

  from collections import Counter
  c = Counter()  # 空Counter
  c['a'] = 2
  c['b'] = 3
  print(c)  # Counter({'b': 3, 'a': 2})
  

• 字典初始化：通過鍵值對字典直接初始化

  c = Counter({'a': 5, 'b': 2, 'c': 3})
  print(c)  # Counter({'a': 5, 'b': 2, 'c': 3})
  

• 關鍵字參數初始化：通過關鍵字參數指定計數

  c = Counter(a=3, b=1, c=2)
  print(c)  # Counter({'a': 3, 'c': 2, 'b': 1})
  

2. 核心方法詳解

（1）most_common(k)

• 功能：返回包含前?k?個出現次數最多元素的列表，每個元素是?(元素, 計數)?的元組。

• 若?k?大于元素總數，返回所有元素；若?k=None，返回所有元素（按計數降序）。

• 若多個元素計數相同，順序不固定（取決于插入順序）。

  c = Counter('abracadabra')  # 統計字符串中字符
  print(c.most_common(3))  # 前3個最常見元素
  # 輸出：[('a', 5), ('b', 2), ('r', 2)]print(c.most_common())   # 所有元素按計數排序
  # 輸出：[('a', 5), ('b', 2), ('r', 2), ('c', 1), ('d', 1)]
  

（2）elements()

• 功能：返回一個迭代器，包含所有元素，每個元素重復的次數等于其計數（計數≤0 的元素會被忽略）。此方法可應用于把counter變回一個列表。

• 元素順序與插入順序一致，適合將計數結果還原為原始元素序列。

  c = Counter(a=3, b=2, c=0, d=-1)
  elements = list(c.elements())  # 轉換為列表
  print(elements)  # ['a', 'a', 'a', 'b', 'b']（忽略c和d，因計數≤0）
  

（3）clear()

• 功能：清空?Counter?中的所有元素和計數，使其變為空對象。

  c = Counter(a=2, b=3)
  c.clear()
  print(c)  # Counter()（空對象）
  

3. 與字典類似的功能

Counter?是?dict?的子類，因此支持大多數字典的操作：

• 訪問 / 修改計數：通過鍵直接操作，不存在的鍵默認計數為 0

  c = Counter(a=2, b=3)
  print(c['a'])  # 2（訪問計數）
  c['a'] += 1    # 修改計數
  print(c['a'])  # 3
  print(c['c'])  # 0（不存在的鍵默認返回0）
  

• 獲取鍵 / 值 / 鍵值對：keys()、values()、items()

  c = Counter(a=2, b=3)
  print(list(c.keys()))    # ['a', 'b']
  print(list(c.values()))  # [2, 3]
  print(list(c.items()))   # [('a', 2), ('b', 3)]
  

• 刪除元素：del?關鍵字

  c = Counter(a=2, b=3)
  del c['a']  # 刪除鍵'a'
  print(c)    # Counter({'b': 3})
  

• 檢查鍵是否存在：in?關鍵字

  c = Counter(a=2)
  print('a' in c)  # True
  print('b' in c)  # False
  

4. 數學運算

Counter?支持多種集合類數學運算，方便對兩個計數結果進行合并、求差等操作（僅保留計數為正的元素）：

• 加法（+）：合并兩個?Counter，相同元素的計數相加

  c1 = Counter(a=2, b=3)
  c2 = Counter(a=1, c=4)
  print(c1 + c2)  # Counter({'c': 4, 'b': 3, 'a': 3})
  

• 減法（-）：求差集，相同元素的計數相減（結果只保留計數 > 0 的元素）

  c1 = Counter(a=5, b=3)
  c2 = Counter(a=2, b=1, c=4)
  print(c1 - c2)  # Counter({'a': 3, 'b': 2})（5-2=3，3-1=2，忽略c）
  

• 交集（&）：取兩個?Counter?中相同元素的最小計數

  c1 = Counter(a=3, b=2, c=1)
  c2 = Counter(a=2, b=4, d=5)
  print(c1 & c2)  # Counter({'a': 2, 'b': 2})（取a的min(3,2)，b的min(2,4)）
  

• 并集（|）：取兩個?Counter?中相同元素的最大計數

  c1 = Counter(a=3, b=2, c=1)
  c2 = Counter(a=2, b=4, d=5)
  print(c1 | c2)  # Counter({'b': 4, 'd': 5, 'a': 3, 'c': 1})（取a的max(3,2)，b的max(2,4)）
  

• 負數（-c）：返回計數取負的?Counter（但通常結合其他運算使用）

  c = Counter(a=2, b=3)
  print(-c)  # Counter({'a': -2, 'b': -3})
  

deque雙端隊列（與列表非常類似）

關鍵特性補充：

• maxlen?是初始化時的固定屬性，例如?deque([1,2], maxlen=3)?創建的隊列最多容納 3 個元素，新增元素時會自動移除另一端的舊元素。
• reverse()?和?rotate()?均為原地操作，直接修改原隊列，不會返回新隊列。
• copy()?為淺拷貝，若隊列中包含可變對象（如列表），修改拷貝隊列中的可變對象會影響原隊列。

defaultdict:有默認值的字典

即使一開始key不存在也不會報錯

1. 基本用法

（1）導入?defaultdict

from collections import defaultdict

（2）創建?defaultdict?對象

需要指定一個默認值工廠函數（如?int、list、str?等），當訪問不存在的鍵時，會自動調用該函數生成默認值。

# 示例1：默認值為0（用int作為工廠函數）
d = defaultdict(int)
d['a'] += 1  # 鍵'a'不存在時，自動初始化為0，再+1
print(d['a'])  # 輸出：1
print(d['b'])  # 鍵'b'不存在，返回默認值0# 示例2：默認值為空列表（用list作為工廠函數）
d = defaultdict(list)
d[' fruits'].append('apple')  # 鍵'fruits'自動初始化為空列表，再添加元素
print(d['fruits'])  # 輸出：['apple']
print(d['vegetables'])  # 鍵不存在，返回空列表[]

2. 常用默認值類型

3. 與普通字典的區別

• 普通字典訪問不存在的鍵會報錯：

  normal_dict = {}
  print(normal_dict['key'])  # 拋出 KeyError: 'key'
  

• defaultdict?會自動生成默認值：

  d = defaultdict(str)
  print(d['key'])  # 輸出空字符串 ''（無報錯）
  

4. 典型應用場景

（1）統計元素出現次數

from collections import defaultdictwords = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
count = defaultdict(int)  # 默認值0for word in words:count[word] += 1  # 直接累加，無需判斷鍵是否存在print(dict(count))  # 轉換為普通字典：{'apple': 3, 'banana': 2, 'orange': 1}

（2）按 key 分組元素

from collections import defaultdictpairs = [('fruit', 'apple'), ('vegetable', 'carrot'), ('fruit', 'banana')]
groups = defaultdict(list)  # 默認值為空列表for key, value in pairs:groups[key].append(value)  # 自動按key分組print(dict(groups))  # {'fruit': ['apple', 'banana'], 'vegetable': ['carrot']}

heapq堆

heapq?是 Python 標準庫中用于實現堆（heap）?操作的模塊，主要提供了基于最小堆的一系列功能，可用于實現優先級隊列等場景。堆是一種特殊的完全二叉樹，其中最小堆的父節點值始終小于等于子節點值。

上面的叫父親節點，左邊的叫左兒子，右邊的叫右兒子，二叉樹一個節點最多有兩叉，而且一定要兩個兒子都填滿才會往下填。

1. 基本用法

（1）導入模塊

import heapq

（2）核心操作

• 創建堆：通過?heapq.heapify(list)?將列表原地轉換為最小堆（時間復雜度 O (n)）。

  nums = [3, 1, 4, 2]
  heapq.heapify(nums)  # 轉換為最小堆
  print(nums)  # 輸出：[1, 2, 4, 3]（堆的內部存儲結構）
  

• 添加元素：heapq.heappush(heap, item)?向堆中添加元素，并維持堆結構。

  heap = []
  heapq.heappush(heap, 3)
  heapq.heappush(heap, 1)
  heapq.heappush(heap, 2)
  print(heap)  # 輸出：[1, 3, 2]（始終保持最小元素在堆頂）
  

• 彈出最小元素：heapq.heappop(heap)?移除并返回堆中最小的元素（堆頂），自動調整堆結構。

  print(heapq.heappop(heap))  # 輸出：1
  print(heap)  # 輸出：[2, 3]（剩余元素重新構成最小堆）
  

2. 常用功能

• 獲取最小元素（不彈出）：直接訪問堆的第一個元素?heap[0]。

  print(heap[0])  # 輸出：2（當前堆頂元素）
  

• 合并多個有序序列：heapq.merge(*iterables)?合并多個有序迭代器，返回一個生成器（需手動轉換為列表）。

  list1 = [1, 3, 5]
  list2 = [2, 4, 6]
  merged = heapq.merge(list1, list2)
  print(list(merged))  # 輸出：[1, 2, 3, 4, 5, 6]
  

• 獲取前 n 個最大 / 小元素：

  • heapq.nlargest(n, iterable)：返回迭代器中最大的 n 個元素。
  • heapq.nsmallest(n, iterable)：返回迭代器中最小的 n 個元素。

  nums = [5, 2, 9, 1, 5, 6]
  print(heapq.nlargest(3, nums))  # 輸出：[9, 6, 5]
  print(heapq.nsmallest(3, nums)) # 輸出：[1, 2, 5]

堆其實就是一個特殊的列表，它最常用的功能就是找到列表中的最小值。

functool函數工具中的partial

functools.partial?是 Python 中?functools?模塊提供的一個實用工具，用于固定函數的部分參數，生成一個新的簡化版函數（偏函數）。它可以減少函數調用時需要傳入的參數數量，提高代碼復用性。

1. 基本用法

（1）導入?partial

from functools import partial

（2）核心功能：固定參數

假設有一個需要多個參數的函數，使用?partial?可以固定其中一部分參數，生成一個只需傳入剩余參數的新函數。

def multiply(x, y):return x * y# 固定第一個參數 x=2，生成新函數 double
double = partial(multiply, 2)
print(double(3))  # 等價于 multiply(2, 3) → 輸出 6
print(double(5))  # 等價于 multiply(2, 5) → 輸出 10# 固定第二個參數 y=3，生成新函數 triple
triple = partial(multiply, y=3)
print(triple(4))  # 等價于 multiply(4, 3) → 輸出 12

2. 適用場景

• 簡化重復調用：當函數需要頻繁以相同參數調用時，用?partial?固定重復參數，減少代碼冗余。

  import requests
  from functools import partial# 固定請求方法為 GET，生成簡化的 get 請求函數
  get = partial(requests.request, 'GET')
  # 調用時只需傳入 URL
  response = get('https://www.example.com')
  

• 適配函數參數：當需要將一個多參數函數作為回調函數（通常要求參數更少）時，用?partial?適配參數數量。

  from functools import partialdef greet(greeting, name):print(f"{greeting}, {name}!")# 固定 greeting="Hello"，生成適配單參數的回調函數
  hello_greet = partial(greet, "Hello")
  # 回調場景中只需傳入 name
  names = ["Alice", "Bob"]
  for name in names:hello_greet(name)  # 輸出：Hello, Alice! / Hello, Bob!
  

1. 位置固定：按原函數參數順序固定值（不寫參數名），新參數自動補在后面。
   例：def add(x,y,z): return x+y+z
add10 = partial(add, 10)?→ 固定?x=10，調用?add10(2,3)?等價于?add(10,2,3)。

2. 參數固定：用?參數名=值?固定特定參數（不依賴順序），新參數傳未固定的部分。
   例：add_y20 = partial(add, y=20)?→ 固定?y=20，調用?add_y20(1,3)?等價于?add(1,20,3)。

3. 關鍵特性

• partial?生成的新函數可以像原函數一樣被調用，且支持傳入額外參數（會補充在固定參數之后）。
• 若固定參數時指定了關鍵字參數（如?partial(func, y=3)），調用新函數時不能再用位置參數重復傳入，避免沖突。

intertools迭代器工具

itertools?是 Python 用于高效循環的工具庫，提供了三類常用迭代器：

1. 無限迭代器

可無限生成元素，需手動終止（如用?break），常用 3 個：

2. 有限迭代器

處理有限可迭代對象，返回新的迭代器，常用：

accumulate在前綴和的使用中有大用

itertools.accumulate?是用于累積計算的迭代器，它對可迭代對象（如列表、元組）中的元素進行連續操作，返回每一步的累積結果，默認是累加，也可自定義運算邏輯。

基本用法

1. 語法

itertools.accumulate(iterable, func=None)

• iterable：需要處理的可迭代對象（如列表、range 等）

• func：可選參數，指定累積運算的函數（默認是?operator.add，即加法）

2. 默認行為（累加）

不指定?func?時，默認對元素依次求和：

from itertools import accumulatenums = [1, 2, 3, 4]
result = accumulate(nums)
print(list(result))  # 輸出：[1, 3, 6, 10]
# 計算過程：1 → 1+2=3 → 3+3=6 → 6+4=10

3. 自定義運算（通過?func?參數）

指定?func?可以實現其他累積邏輯（如乘法、最大值等）：

from itertools import accumulate
import operator# 累乘（用 operator.mul）
nums = [1, 2, 3, 4]
product = accumulate(nums, func=operator.mul)
print(list(product))  # 輸出：[1, 2, 6, 24]
# 計算過程：1 → 1×2=2 → 2×3=6 → 6×4=24# 累積取最大值（用 max 函數）
nums = [3, 1, 4, 2]
max_accum = accumulate(nums, func=max)
print(list(max_accum))  # 輸出：[3, 3, 4, 4]
# 計算過程：3 → max(3,1)=3 → max(3,4)=4 → max(4,2)=4

4. 處理非數字類型

只要?func?支持對應類型的運算，也可處理其他數據（如字符串拼接）：

from itertools import accumulatewords = ["a", "b", "c"]
str_accum = accumulate(words, func=lambda x, y: x + y)
print(list(str_accum))  # 輸出：['a', 'ab', 'abc']

關鍵特點

• 惰性計算：只在需要時生成結果，節省內存（尤其適合大數據）。

• 長度不變：返回的迭代器長度與原可迭代對象一致（第?i?個元素是前?i+1?個元素的累積結果）。

• 依賴順序：累積結果與元素順序相關（如?[1,2]?和?[2,1]?的累加結果不同）。

accumulate?非常適合需要 “逐步記錄中間結果” 的場景，如累計求和、累計乘積、歷史最大值追蹤等，避免手動寫循環累加的冗余代碼。

3. 排列組合迭代器

生成元素的排列或組合，適用于數學計算：