一、數字類型
1.1 數字類型的組成
1.1.1 整數
（1）十進制，二進制0b，八進制0o，十六進制0x
print(16 == 0b10000 == 0o20 == 0x10)
# 輸出：True
（2）十進制轉其他進制
a = bin(16)
b = oct(16)
c = hex(16)
print(a, b, c)
# 輸出：0b10000 0o20 0x10
注意：上述輸出結果為字符串類型
print(a == b == c)
# 輸出：False
print(type(a), type(b), type(c))
# 輸出：<class 'str'> <class 'str'> <class 'str'>
（3）其他進制轉十進制
l = int(a, 2)
m = int(b, 8)
n = int(c, 16)
print(l, m, n)
# 輸出：16 16 16
1.1.2 浮點數
（1）不確定小數問題
print((0.1 + 0.2) == 0.3)
# 輸出：False
print(0.1 + 0.2)
# 輸出：0.30000000000000004
（2）計算機采用二進制小數表示浮點數的小數部分
注意：
- 部分小數不能用二進制小數完全表示
- 通常情況，不影響計算精度
- 四舍五入可獲得精確解
a = 0.1 + 0.7
print(a)
# 輸出：0.7999999999999999b = round(a, 1)
print(b)
# 輸出：0.8
print(b == 0.8)
# 輸出：True
1.1.3 復數
（1）j or J
print(3+4j)
# 輸出：(3+4j)
print(3+4J)
# 輸出：(3+4j)
（2）若虛部系數為1，則需要顯式寫出
print(3+J)
# 輸出：NameError: name 'J' is not defined
print(3+1j)
# 輸出：(3+1j)
1.2 數字類型的運算操作符
1.2.1 加減乘除
print((1+2-3*4) / 5)
# 輸出：-1.8
1.2.2 取反
x = 3
print(-x)
# 輸出：-3
1.2.3 乘方
print(2**3)
# 輸出：8
1.2.4 整數商和模
print(11 // 2)
# 輸出：5
print(11 % 2)
# 輸出：2
注意：
- 整數和浮點數的運算結果為浮點數
- 除法的運算結果為浮點數
print(1+2.5)
# 輸出：3.5
print(5/2)
# 輸出：2.5
print(4.0/2)
# 輸出：2.0
1.3 整數類型的運算操作函數
1.3.1 絕對值——abs()
print(abs(-3))
# 輸出：3
print(abs(3+4j)) # 對復數，執行求模運算
# 輸出：5.0
1.3.2 冪次方——pow(x, n)
print(pow(2, 3)) # 執行 2**3
# 輸出：8
print(pow(2, 3, 4)) # 執行 2^3%4
# 輸出：0
1.3.3 四舍五入——round(x, n)
a = 314.159
print(round(a)) # 默認整數
# 輸出：314
print(round(a, 2)) # 四舍五入保留兩位小數
# 輸出：314.16
print(round(a, 8)) # 位數不足時，無需補足
# 輸出：314.159
print(round(a, -2)) # 四舍五入保留100的倍數
# 輸出：300.0
1.3.4 整數商和模——divmod(x, y)
print(divmod(9, 2))
# 輸出：(4, 1)
# 返回二元元組：(9//2, 9%2)
1.3.5 序列最大值/最小值——max(), min()
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("max：", max(lst))
# 輸出：max： 10
print("min：", min(lst))
# 輸出：min： 1
1.3.6 求和——sum()
print(sum((1, 3, 5, 7, 9)))
# 輸出：25
1.3.7 科學計算庫
（1）math
import math# 1.冪運算
print("2 的 3 次方:", math.pow(2, 3))
# 輸出：2 的 3 次方: 8.0# --------------------------------------------------# 2.對數運算
print("log(100, 10):", math.log(100, 10)) # 以 10 為底 100 的對數
# 輸出：log(100, 10): 2.0
print("自然對數 log(e):", math.log(math.e)) # 自然對數
# 輸出：自然對數 log(e): 1.0# --------------------------------------------------# 3.平方根
print("sqrt(16):", math.sqrt(16))
# 輸出：sqrt(16): 4.0# --------------------------------------------------# 4.角度轉弧度
angle_in_degrees = 45
angle_in_radians = math.radians(angle_in_degrees)# --------------------------------------------------# 5.正弦、余弦、正切
print(f"{angle_in_degrees} 度的正弦值: {math.sin(angle_in_radians)}")
# 輸出：45 度的正弦值: 0.7071067811865476
print(f"{angle_in_degrees} 度的余弦值: {math.cos(angle_in_radians)}")
# 輸出：45 度的余弦值: 0.7071067811865476
print(f"{angle_in_degrees} 度的正切值: {math.tan(angle_in_radians)}")
# 輸出：45 度的正切值: 0.9999999999999999# --------------------------------------------------# 6.反三角函數
print("arcsin(0.7071):", math.degrees(math.asin(0.7071))) # 結果轉換為角度
# 輸出：arcsin(0.7071): 44.99945053347443# --------------------------------------------------# 7.雙曲正弦、雙曲余弦、雙曲正切
x = 1
print(f"x={x} 的雙曲正弦值: {math.sinh(x)}")
# 輸出：x=1 的雙曲正弦值: 1.1752011936438014
print(f"x={x} 的雙曲余弦值: {math.cosh(x)}")
# 輸出：x=1 的雙曲余弦值: 1.5430806348152437
print(f"x={x} 的雙曲正切值: {math.tanh(x)}")
# 輸出：x=1 的雙曲正切值: 0.7615941559557649# --------------------------------------------------# 8.階乘
n = 5
print(f"{n} 的階乘: {math.factorial(n)}")
# 輸出：5 的階乘: 120# --------------------------------------------------# 9.伽馬函數
print("gamma(3):", math.gamma(3)) # gamma(n) = (n-1)!
# 輸出：gamma(3): 2.0# --------------------------------------------------# 10.常數
print("π:", math.pi)
# 輸出：π: 3.141592653589793
print("e:", math.e)
# 輸出：e: 2.718281828459045
（2）scipy
- Optimize (優化)：提供了多種優化算法，包括最小化(最大化)函數、曲線擬合等
from scipy import optimize
import numpy as npdef f(x):return x**2 + 10 * np.sin(x)# 使用 minimize 方法尋找函數最小值
result = optimize.minimize(f, 0)
print("找到的最小值點:", result.x)
# 輸出：找到的最小值點: [-1.30644012]
- Integrate (積分和微分方程求解)：提供了多種數值積分方法以及 ODE 求解器
from scipy import integrate# 定義被積函數
def integrand(x):return np.exp(-x**2)# 計算積分
result, _ = integrate.quad(integrand, -np.inf, np.inf)
print("積分結果:", result)
# 輸出：積分結果: 1.7724538509055159
- Linalg (線性代數)：擴展了 NumPy 的線性代數能力，提供了更多高級功能
from scipy import linalg
import numpy as np# 創建兩個隨機矩陣
A = np.random.randn(3, 3)
B = np.random.randn(3, 1)# 解線性方程 Ax = B
solution = linalg.solve(A, B)
print("Ax=B 的解:", solution)
# 輸出：Ax=B 的解: [[-0.07803842]
# [ 0.23422888]
# [ 0.19536865]
# ]
- Signal (信號處理)：提供了一系列工具用于信號處理，如濾波、卷積等
from scipy import signal
import numpy as np
import matplotlib.pyplot as pltplt.rcParams['font.sans-serif'] = ['SimHei'] # 使用黑體或其他中文字體
plt.rcParams['axes.unicode_minus'] = False # 解決負號 '-' 顯示為方塊的問題# 創建一個簡單的正弦波信號
t = np.linspace(0, 1, 500)
x = np.sin(2 * np.pi * 3 * t) + 0.5 * np.random.randn(t.size)# 設計一個低通濾波器并應用到信號上
b, a = signal.butter(3, 0.05)
filtered_x = signal.filtfilt(b, a, x)plt.plot(t, x, label='原始信號')
plt.plot(t, filtered_x, label='過濾后的信號')
plt.legend()
plt.show()
結果：
- Stats (統計分布和函數)：提供了廣泛的統計分布模型和統計測試
from scipy import stats
import numpy as np# 生成一組隨機數據
data = np.random.normal(loc=0, scale=1, size=1000)# 計算描述性統計量
mean = np.mean(data)
median = np.median(data)
mode = stats.mode(data) # 需要注意的是，對于連續分布的數據，模式可能不適用或需要進行分箱處理
std_dev = np.std(data)print(f"Mean: {mean}, Median: {median}, Standard Deviation: {std_dev}")
# 輸出：Mean: 0.035383601211682034, Median: 0.06455716819180869, Standard Deviation: 0.9858768770120637
（3）numpy
import numpy as np# 1.創建數組
# 從列表創建一維數組
a = np.array([1, 2, 3])
print("一維數組:", a)
# 輸出：一維數組: [1 2 3]# 從列表創建二維數組
b = np.array([[1, 2], [3, 4]])
print("二維數組:\n", b)
# 輸出：二維數組:
# [[1 2]
# [3 4]]# 使用內置函數創建特定形狀的數組
c = np.zeros((3, 3)) # 創建一個3x3的零矩陣
print("零矩陣:\n", c)
# 輸出：零矩陣:
# [[0. 0. 0.]
# [0. 0. 0.]
# [0. 0. 0.]]# --------------------------------------------------# 2.數組操作
# 數組的形狀和大小
print("數組b的形狀:", b.shape)
# 輸出：數組b的形狀: (2, 2)
print("數組b的維度:", b.ndim)
# 輸出：數組b的維度: 2
print("數組b的元素總數:", b.size)
# 輸出：數組b的元素總數: 4# 數組重塑
d = b.reshape(1, 4) # 將二維數組b重塑為1行4列的一維數組
print("重塑后的數組:\n", d)
# 輸出：重塑后的數組:
# [[1 2 3 4]]# --------------------------------------------------# 3.廣播機制
e = np.array([1, 2, 3])
f = np.array([2, 2, 2])# 利用廣播機制進行加法運算
g = e + f
print("廣播加法結果:", g)
# 輸出：廣播加法結果: [3 4 5]# 標量與數組的加法
h = e + 2
print("標量加法結果:", h)
# 輸出：標量加法結果: [3 4 5]# --------------------------------------------------# 4.線性代數運算
i = np.array([[1, 2], [3, 4]])
j = np.array([[5, 6], [7, 8]])# 矩陣乘法
k = np.dot(i, j)
print("矩陣乘法結果:\n", k)
# 輸出：矩陣乘法結果:
# [[19 22]
# [43 50]]# 計算行列式
det_i = np.linalg.det(i)
print("行列式i:", det_i)
# 輸出：行列式i: -2.0000000000000004# --------------------------------------------------# 5.傅里葉變換
signal = np.array([0, 1, 0, 1])
fourier = np.fft.fft(signal)
print("傅里葉變換結果:", fourier)
# 輸出：傅里葉變換結果: [ 2.+0.j 0.+0.j -2.+0.j 0.+0.j]# --------------------------------------------------# 6.隨機數生成
# 生成標準正態分布的隨機數
random_numbers = np.random.randn(5)
print("隨機數:", random_numbers)
# 輸出：隨機數: [ 0.91515599 -0.74805686 0.90227149 0.2376813 2.70840746]# 生成指定范圍內的整數隨機數
random_integers = np.random.randint(0, 10, size=5)
print("整數隨機數:", random_integers)
# 輸出：整數隨機數: [7 0 4 7 7]
二、字符串類型
2.1 字符串的表達
print("hello", 'world')
# 輸出：hello world
2.1.1 雙中有單
print("I'm a test")
# 輸出：I'm a test
2.1.2 單中有雙
print('I am a "test"')
# 輸出：I am a "test"
2.1.3 雙中有雙/單中有單
print('I\'m a test')
# 輸出：I'm a test
2.1.4 轉移符用來換行繼續輸入
st = "py\
thon"
print(st)
# 輸出：python
2.2 字符串的性質
2.2.1 字符串的索引——變量名[位置編號]
s = "my name is <NAME>"# 正向索引
print(s[0])
# 輸出：m
print(s[3])
# 輸出：n
print(s[9])
# 輸出：s# 反向索引
print(s[-1])
# 輸出：>
print(s[-2])
# 輸出：E
print(s[-6])
# 輸出：<
2.2.2 字符串的切片——變量名[開始位置:結束位置:切片間隔]
print(s[0:6])
# 輸出：my nam
print(s[0:6:2])
# 輸出：m a
print(s[:6]) # 開始位置為0時，可省略
# 輸出：my nam
print(s[:]) # 結束位置省略時，則表示取到最后一個字符
# 輸出：my name is <NAME>
print(s[-3:]) # 也可以使用反向索引
# 輸出：ME>
print(s[-1:-9:-1]) # 反向切片
# 輸出：>EMAN< s
2.3 字符串的操作符
2.3.1 字符串的拼接
a = "my name "
b = "is Tom"
print(a + b)
# 輸出：my name is Tom
2.3.2 字符串的成倍復制
c = a+b
print(c)
# 輸出：my name is Tom
print(c*3)
# 輸出：my name is Tommy name is Tommy name is Tom
2.3.3 字符串的成員運算
- 子集 in 全集——任何一個連續的切片都是原字符串的子集
singers = "Tom, Tina, Time"
print("Tom" in singers)
# 輸出：True
- for 字符 in 字符串——遍歷字符串
for s in "python":print(s)
# 輸出：p
# y
# t
# h
# o
# n
2.4 字符串的處理函數
2.4.1 字符串的長度——len()
s = "python"
print(len(s))
# 輸出：6
2.4.2 字符編碼
- 定義：將字符（字母、數字、符號等）映射為計算機可以處理的二進制數
- 特點：
??（1）每個單一字符對應一個唯一的不可重復的二進制編碼
??（2）Python中使用Unicode編碼
（1）字符轉Unicode碼——ord(字符)
print(ord("1"))
# 輸出：49
print(ord("a"))
# 輸出：97
print(ord("."))
# 輸出：46
print(ord("中"))
# 輸出：20013
（2）Unicode碼轉字符——chr(Unicode碼)
print(chr(1000))
# 輸出：8
print(chr(1010))
# 輸出：c
print(chr(12345))
# 輸出：?
2.5 字符串的處理方法
特點：
??1. 返回的結果為一個列表
??2. 原字符串不變
2.5.1 字符串的分割——字符串.split(分割字符)
st = "my name is Tom"
st_lst = st.split(" ")
print(st)
# 輸出：my name is Tom
print(st_lst)
# 輸出：['my', 'name', 'is', 'Tom']
2.5.2 字符串的聚合——“聚合字符”.join(可迭代數據類型)
可迭代類型：
??1. 列表（list）：有序的、可變的數據集合
??2. 元組（tuple）：有序的、不可變的數據集合
??3. 字符串（str）：字符的有序集合，也是不可變的
??4. 字典（dict）：鍵值對的無序集合，迭代時默認遍歷鍵
??5. 集合（set）：無序且不重復元素的集合
words = ["Hello", "world", "from", "Python"]
sentence = " ".join(words)
print(sentence)
# 輸出: Hello world from Pythonnumbers = [1, 2, 3]
joined_numbers = " - ".join(str(n) for n in numbers)
print(joined_numbers)
# 輸出: 1 - 2 - 3
2.5.3 刪除兩端待定字符——字符串.strip(刪除字符)
s = "------my name is Tom------"
print(s.strip("-"))
# 輸出：my name is Tom
print(s.rstrip("-"))
# 輸出：------my name is Tom
print(s.lstrip("-"))
# 輸出：my name is Tom------
print(s)
# 輸出：------my name is Tom------st = " my name is Tom "
print(st.strip(" ")) # strip()從兩側開始搜索，遇到指定字符則刪除，遇到非指定字符則停止
# 輸出：my name is Tom
2.5.4 字符串的替換——字符串.replace(“被替換”, “替換成”)
s = "my name is Tom"
s1 = s.replace("Tom", "Time")
print(s1)
# 輸出：my name is Time
2.5.5 字符串的字母大小寫
s = "pyThon"
print(s.upper()) # 全部大寫
# 輸出：PYTHON
print(s.lower()) # 全部小寫
# 輸出：python
print(s.capitalize()) # 字符串首字母大寫
# 輸出：Python
print(s.title()) # 單詞首字母大寫
# 輸出：Python
print(s.swapcase()) # 大小寫轉寫
# 輸出：PYtHON
三、布爾類型
3.1 作為邏輯運算的結果
a = 3
print(a > 1)
# 輸出：True
print(a == 3)
# 輸出：True
print(a < 2)
# 輸出：False
print(any([False, 1, 0, None]))
# 輸出：True
print(all([False, 1, 0, None]))
# 輸出：False
3.2 作為指示條件
m = 3
while True:n = eval(input("請輸入一個正整數："))if m == n:print("猜對啦！")elif m > n:print("猜小了。")else:print("猜大了。")
3.3 作為掩碼
import numpy as np
x = np.array([[1, 3, 2, 5, 7]])
print(x > 3)
# 輸出：[[False False False True True]]
print(x[x > 3])
# 輸出：[5 7]
四、類型判別與轉換
4.1 類型判別
4.1.1 type(變量)
age = 20
print(type(age))
# 輸出：<class 'int'>
4.1.2 isinstance(變量, 預測類型)
print(isinstance(age, int))
# 輸出：True
print(isinstance(age, float))
# 輸出：False
print(isinstance(age, object))
# 輸出：True
4.1.3 字符串的檢查方法
（1）數字組成——字符串.isdigit()
# 數字組成--字符串.isdigit()
age = "20"
age1 = "18 歲"
print(age.isdigit())
# 輸出：True
print(age1.isdigit())
# 輸出：False
（2）字母組成——字符串.isalpha()
name = "Tom"
print(age.isalpha())
# 輸出：False
print(name.isalpha())
# 輸出：True
（3）數字和字母組成——字符串.isalnum()
print("Tom2025".isalnum()) # 一般用于判斷用戶名是否合法
# 輸出：True
4.2 類型轉換
4.2.1 數字轉字符串——str(數字類型)
age = 20
print("my age is " + str(age))
# 輸出：my age is 20
4.2.2 字符串轉數字
s1 = "20"
s2 = "21.5"
print(int(s1))
# 輸出：20
print(float(s2))
# 輸出：21.5
print(eval(s1))
# 輸出：20
print(eval(s2))
# 輸出：21.5
微語錄：書上說，天下沒有不散的宴席。不要怕，書上還說了，人生何處不相逢。
