Python on Aminiam's Blog

Notes for Pandas

Wed, 09 Sep 2026 11:30:40 +0800

Pandas Basics

Here we import numpy, pandas as:

1
2


import numpy as np
import pandas as pd

Basic data structures in pandas

pandas provides two types of classes fro handling data:

Series: a one-dimansional labeled array holding data of any type, such as integers, strings, Python objects, etc.
DataFrame: a two-dimensional data structure that holds data like a two-dimension array or a table with rows and columns.

Object creation

Creating a Series by passing a list of values, letting pandas create a default RangeIndex

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


>>> import numpy as np
>>> import pandas as pd
>>> s = pd.Series([1, 3, 5, np.nan, 6, 8])
>>> s
0 1.0
1 3.0
2 5.0
3 NaN
4 6.0
5 8.0
dtype: float64

Creating a DataFrame by passing a NumPy array with a datetime index using date_range() and labeled columns:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


>>> dates = pd.date_range("20260909", periods=6)
>>> dates
DatetimeIndex(['2026-09-09', '2026-09-10', '2026-09-11', '2026-09-12',
 '2026-09-13', '2026-09-14'],
 dtype='datetime64[ns]', freq='D')
>>> df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list("ABCD"))
>>> df
 A B C D
2026-09-09 0.956212 0.496608 1.031761 0.439333
2026-09-10 -0.283260 0.644414 -0.352740 -0.617138
2026-09-11 0.667249 1.570810 -1.711173 1.114610
2026-09-12 -0.324996 -0.441097 0.821568 -0.425018
2026-09-13 0.981316 0.504753 1.098882 0.498294
2026-09-14 0.433741 0.992282 -0.737600 1.621099

Notes for Matplotlib

Sat, 05 Sep 2026 10:13:30 +0800

Pyplot Basics

Introduction to pyplot

matplotlib.pyplot is a collection of functions that make matplotlib work like MATLAB. Each pyplot function makes some change to a figure: e.e., creates a figure, creates a plotting area in a figure, plots some lines in a plotting area, decorates the plot with labels, etc.

In matplotlib.pyplot various states are preserved across function calls, so that it keeps track of things like the current figure and plotting area, and the plotting functions are directed to the current Axes (please note that we user uppercase Axes to refter to the Axes concept, which is a central part of a figure and not only the plural of axis).

1
2
3
4


import matplotlib.pyplot as plt
plt.plot([1, 3, 3, 4])
plt.ylabel('some numbers')
plt.show()

If your provide a single list or array to plot, matplotlib assumes it i a sequence of y values, and automatically generates the x values for you. Since python ranges start with 0, the default x vector has the same length as y but starts with 0; there fore, the x data are [0, 1, 2, 3].

plot is a versatile function, and will take an arbitrary number of arguments. For example, to plot x versus y, you can write:

1

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])

Formatting the style of you plot

For every x, y pair of arguments, there is an optional third argument which is the format string that indicates the color and line type of the plot. The letters and symbols of the format string are from MATLAB, and you concatenate a color string with a line style string. The default format string is ‘b-’, which is a solid blue line. For example, to plot the above with red circles, you would issue.

1
2
3


plt.plot([1, 2, 3, 4], [1, 4, 9, 16], 'ro')
plt.axis((0, 6, 0, 20))
plt.show()

The axis function in the example above takes a list of [xmin, xmax, ymin, ymax] and specifies the viewport of the Axes.

Generally, you will use numpy arrays.

1
2
3
4
5
6


import numpy as np
# evenly sampled time at 200ms intervals
t = np.arange(0., 5., 0.2)
# red dashes, blue squares and green triangles
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
plt.show()

Plot with keyword strings

There are some instances where you have data in a format theat lets you access particular variables with strings. For example, with strctured arrays or pandas.DataFrame.

Matplotlib allows you to provide such an object with the data keyword argument. I fprovided, the you may generate plots with the strings corresponding to these variables.

1
2
3
4
5
6
7
8
9


data = {'a': np.arange(50),
 'c': np.random.randint(0, 50, 50),
 'd': np.random.randn(50)}
data['b'] = data['a'] + 10 * np.random.randn(50)
data['d'] = np.abs(data['d']) * 100
plt.scatter('a', 'b', c='c', s='d', data=data)
plt.xlabel('entry a')
plt.ylabel('entry b')
plt.show()

Plotting with categorical variables

It is also possible to create a plot using categorical variables. Matplotlib allows you to pass categorical variables directly to many plotting functions. For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


names = ['group_a', 'group_b', 'group_c']
values = [1, 10, 100]
plt.figure(figsize=(9, 3))
plt.subplot(131)
plt.bar(names, values)
plt.subplot(132)
plt.scatter(names, values)
plt.subplot(133)
plt.plot(names, values)
plt.suptitle('Categorical Plotting')
plt.show()

Controlling line properties

Lines have many attributes that you can set: linewidth, dash style, antialiased, etc. There are several ways to set line properties:

Use keyword arguments

1

plt.plot(x, y, linewidth=2.0)

Use the setter methods of a Line2D instance. plot returns a list of Line2D objects; e.g., line1, line2 = plot(x1, y1, x2, y2). In the code below we will suppose that we have only one line so that the list returned is of length 1. We use tuple unpacking with line, to get the first element of that list:

1
2


line, = plt.plot(x, y, '-')
line.set_antialiased(False) # turn off antialiasing

Use setp. The example below uses a MATLAB-style function to set multiple properties on a list of lines. setp works transparently with a list of objects or a single object. You can either use python keyword arguments or MATLAB-style string/value pairs:

1
2
3
4
5


lines = plt.plot(x1, y1, x2, y2)
# use keyword arguments
plt.setp(lines, color='r', linewidth=2.0)
# or MATLAB style string value pairs
plt.setp(lines, 'color', 'r', 'linewidth', 2.0)

Working with multiple figures and Axes

MATLAB, and pyplot, have the concept of the current figure and the current Axes. All plotting functions apply to the current Axes. The gunction gca returns the current figure (A matplotlib.axes.Axes instance), and gcf returns the current figure (a matplotlib.figure.Figure instance). Normally, you don’t have to worry about this, becase it is all taken care of behind the scenes. Below is a script to create two subplots.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def f(t):
 return np.exp(-t) * np.cos(2 * np.pi * t)
t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)
plt.figure()
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')
plt.subplot(212)
plt.plot(t2, np.cos(2 * np.pi * t2), 'r--')
plt.show()

The figure call here is optional because a figure will be created if none exists, just as an Axes will be created (equivalent to an explicit subplot() call) if none exists. The subplot call specifies numrows, numcols, plot_number where plot_number ranges from 1 to numrowsnumcols. The commas in the subplot call are optional if numrowsnumcols<10. So subplot(211) is identical to subplot(2, 1, 1).

1
2
3
4
5


plt.subplot(
 [nrows](n rows of plots will be created),
 [ncols](n cols of plots will be created),
 [index](start from 1, L2R, T2B)
)

You can create an arbitrary number of subplots and Axes. If you want to place an Axes manually, i.e., not on a rectangular grid, use axes, which allows you to specify the location as axes([left, bottom, width, height]) where all values are in fractional (0 to 1) coordinates. See Axes Demo for an example of placing Axes manually and Multiple subplots for an example with lots of subplots.

You can create multiple figures by using multiple figure calls with an increasing figure number. Of course, each figure can contain as many Axes and subplots as your heart desires:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


import matplotlib.pyplot as plt
plt.figure(1) # the first figure
plt.subplot(211) # the first subplot in the first figure
plt.plot([1, 2, 3])
plt.subplot(212) # the second subplot in the first figure
plt.plot([4, 5, 6])

plt.figure(2) # a second figure
plt.plot([4, 5, 6]) # creates a subplot() by default

plt.figure(1) # first figure current;
 # subplot(212) still current
plt.subplot(211) # make subplot(211) in the first figure
 # current
plt.title('Easy as 1, 2, 3') # subplot 211 title

You can clear the current figure with clf and the current Axes with cla. If you find it annoying that states (specifically the current image, figure and Axes) are being maintained for you behind the scenes, don’t despair: this is just a thin stateful wrapper around an object-oriented API, which you can use instead (see Artist tutorial)

If you are making lots of figures, you need to be aware of one more thing: the memory required for a figure is not completely released until the figure is explicitly closed with close. Deleting all references to the figure, and/or using the window manager to kill the window in which the figure appears on the screen, is not enough, because pyplot maintains internal references until close is called.

Working with text

text can be used to add text in an arbitrary location, and xlabel, ylabel and title are used to add text in the indicated locations.

1
2
3


mu, sigma = 100, 15
x = mu + sigma * np.random.randn(10000)
# the histogram // TODO from here

MATLAB format string

1

plt.plot(x, y, fmt)

here:

1

fmt = '[marker][line][color]'

Marker styles

Code	Marker	Meaning
`.`	point	small dot
`o`	circle	○
`s`	square	□
`^`	triangle up	△
`v`	triangle down	▽
`<`	triangle left
`>`	triangle right
`*`	star	★
`+`	plus	+
`x`	cross	×
`D`	diamond	◇

Line styles

Code	Style	Appearance
`-`	solid	━━━━━
`--`	dashed	- - - -
`-.`	dash-dot	-·-·-
`:`	dotted	·····

Colour codes

Code	Colour	Example
`b`	blue	`'b'`
`g`	green	`'g'`
`r`	red	`'r'`
`c`	cyan	`'c'`
`m`	magenta	`'m'`
`y`	yellow	`'y'`
`k`	black	`'k'`
`w`	white	`'w'`

序列解包

1

line, = plt.plot(x, y, '-')

plt.plot()返回一个列表，其中包含所绘制的line2D对象（即使只有一条线，也是长度为$1$的列表）

line,是一个单元素元组（逗号作为必须的标识符），它要求右侧的可迭代对象恰好有一个元素

解包过程将列表中的唯一一个line2D对象提取出来，赋值给line

等价于：

1

line = plt.plot(x, y, '-')[0]

MCM 常用方法 Python 版

Wed, 02 Sep 2026 21:35:33 +0800

層次分析法 AHP（Analytic Hierarchy Process）

問題背景

決策目標涉及多個難以統一量綱衡量的因素時，需要有一種方法把專家的主管判斷轉化爲客觀權重。

與其直接問某因素的權重，不如讓專家兩兩比較“A比B”重要多少倍。

兩兩比較的結果構成判斷矩陣$(A_{ij}) _ {n\times n}$，其中$a_{ij}$表示因素$i$相對於$j$的重要程度，採用如下標度法：

標度	含義
1	同等重要
3	稍微重要
5	明顯重要
7	強烈重要
9	極端重要
2,4,6,8	中間值

性質

矩陣滿足互反性：$a_{ij}a_{ji}=1$，對角線$a_{ii}=1$

若專家的判斷具有完全一致性，則存在權重向量$(\omega)_n$使得：

$$ a_{ij} = \frac{\omega_i}{\omega_j} $$

此時矩陣$A$可以寫成列向量與行向量的乘積形式。

下面證明權重向量就是特徵向量：

$$ (A\omega)_i=\sum_j{a_{ij}\omega_j}=n\omega_i\space\square $$

現實中專家判斷難免有偏差，矩陣不完全已知，但可以證明此時最大的特徵值$\lambda_{max}\ge n$，且當$\lambda_{max}$越接近$n$，矩陣一致性越好。於是去最大特徵值對應的特徵向量，歸一化後作爲權重。

一致性檢驗

定義一致性指標：

$$ CI=\frac{\lambda_{max}-n}{n-1} $$

再用隨機一致性指標$RI$（查表可知，反映隨機矩陣的平均$CI$）做歸一化：

$$ CR=\frac{CI}{RI} $$

當$CR<0.1$認爲矩陣一致性可以接受。

Python實現

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


import numpy as np

def ahp_analysis(A):
 n = A.shape[0]
 eigvals, eigvecs = np.linalg.eig(A) # 計算特徵值和特徵向量
 max_idx = np.argmax(eigvals.real) # 數值計算可能有小虛部，並找到最大特徵值位置
 lambda_max = eigvals[max_idx].real # 提取最大特徵值
 w = eigvecs[:, max_idx].real # 提取對應特徵向量
 weights = w / w.sum() # 歸一化
 # 一致性檢驗：
 CI = (lambda_max - n) / (n - 1)
 RI_table = {1:0, 2:0, 3:0.58, 4:0.90, 5:1.12, 6:1.24, 7:1.32, 9:1.41}
 RI = RI_table[n]
 CR = CI / RI
 # return
 return weights, CR

 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


>>> import numpy as np
>>> A = np.array([[1, 3, 1.0 / 3.0], [1.0 / 3.0, 1\
, 1.0 / 5.0], [3, 5, 1]])
>>> n = A.shape[0]
>>> eigvals, eigvecs = np.linalg.eig(A)
>>> print(eigvals)
[ 3.03851109+0.j -0.01925555+0.34153419j -0.01925555-0.34153419j]
>>> print(eigvecs)
[[ 0.37147738+0.j 0.18573869-0.32170885j 0.18573869+0.32170885j]
 [ 0.1506267 +0.j 0.07531335+0.13044655j 0.07531335-0.13044655j]
 [ 0.916142 +0.j -0.916142 +0.j -0.916142 -0.j ]]
>>> max_idx = np.argmax(eigvals.real)
>>> print(max_idx)
0
>>> lambda_max = eigvals[max_idx].real
>>> print(lambda_max)
3.0385110905581696
>>> w = eigvecs[:, max_idx].real
>>> print(w)
[0.37147738 0.1506267 0.916142 ]
>>> weights = w / w.sum()
>>> print(weights)
[0.25828499 0.10472943 0.63698557]
>>> CI = (lambda_max - n) / (n - 1)
>>> print(CI)
0.019255545279084796
>>> RI_table = {1:0, 2:0, 3:0.58, 4:0.90, 5:1.12, \
6:1.24, 7:1.32, 9:1.41}
>>> RI = RI_table[n]
>>> CR = CI / RI
>>> print(CR)
0.033199215998422064

1

np.argmax(...) // 找到數組中最大值的索引位置

TOPSIS法（逼近理想解排序法）

TOPSIS (Tecnique for Order Preference by Similarity to Ideal Solution)

一個好的方案，應該離最優解情況最近，同時離最差情況最遠。

性質

設有$m$個評價對象，$n$個指標，決策矩陣爲$X=(x_{ij})_{m\times n}$。

正向化：若指標是“越小越好”型，先轉化爲“越大越好”型，常用取倒數或者$max-x$的方式
歸一化（消除兩綱影響），常用向量歸一化：$\displaystyle z_{ij}=\frac{x_{ij}}{\sqrt{\sum_{i=1}^m{x_{ij}^2}}}$。
加權（結合AHP或熵權法得到的權重$\omega_j$）：$v_{ij}=\omega_j z_{ij}$。
確定正負理想解：$Z^+=(\max_iv_{i1},\cdots,\max_iv_{in}$，$Z^+=(\min_iv_{i1},\cdots,\min_iv_{in}$
計算歐氏距離與貼近度：
$$ D_i^+=\sqrt{\sum_j{(v_{ij}-Z_j^+)^2}} $$$$ D_i^-=\sqrt{\sum_j{(v_{ij}-Z_j^-)^2}} $$$$ C_i=\frac{D_i^-}{D_i^++D_i^-}\in[0,1] $$

顯然$C_i$越接近$1$，該方案越優。

Python實現

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


import numpy as np

def topsis(data, weights, indicator_types):
 X = data.astype(float) # 將數據強制轉化成float
 m, n = X.shape
 # 1. 正向化（如果是極小性，則翻轉）
 for j in range(n):
 if indicator_types[j] == 'min':
 X[:, j] = np.max(X[:, j]) - (X[:, j])
 # 2. 向量歸一化（按列歸一化）
 norm-factor = np.sqrt(np.sum(X**2, axis=0)) # axis=0是列，1是行
 Z = X / norm_factor # 廣播
 # 3. 加權
 V = Z * weights # 區別@，這裏是對應元素相乘
 # 4. 正負理想解
 Z_pos = V.max(axis=0)
 Z_neg = V.min(axis=0)
 # 5. 計算歐氏距離
 D_pos = np.sqrt(np.sum((V - Z_pos)**2, axis=1))
 D_neg = np.sqrt(np.sum((V - Z_neg)**2, axis=1))
 # 6. 貼近度
 C = D_neg / (D_pos + D_neg + 1e-8)
 # return
 return C

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


>>> import numpy as np
>>> data = np.array([[5, 5, 10], [8, 8, 5]])
>>> weights = [0.25828499, 0.10472943, 0.63698557]
>>> X = data.astype(float)
>>> m, n = X.shape
>>> norm_factor = np.sqrt(np.sum(X**2,axis=0))
>>> Z = X / norm_factor
>>> V = Z * weights
>>> Z_pos = V.max(axis=0)
>>> Z_neg = V.min(axis=0)
>>> D_pos = np.sqrt(np.sum((V - Z_pos)**2, axis=1)\
)
>>> D_neg = np.sqrt(np.sum((V - Z_neg)**2, axis=1)\
)
>>> C = D_neg / (D_pos + D_neg + 1e-8)
>>> print(C)
[0.76270391 0.23729606]

最小二乘擬合與迴歸

性質

設擬合模型爲$\hat{y}=P_k(x)=\sum_i\beta_ix^k$，定義殘差平方和：

$$ S(\beta) = \sum_i(y_i-\hat{y}_i)^2 $$

最小二乘法的目標是找到使$S(\beta)$最小的參數$\beta$。

推導正規方程：將模型寫作$y=X\beta+\varepsilon$，其中$X$是範德蒙德矩陣（每行爲：$[1,x_i,x_i^2,\cdots,x_i^k]$），展開$S(\beta)$：

$$ S(\beta)=(y-X\beta)^T(y-X\beta)=y^Ty-2\beta^TX^Ty+\beta^TX^TX\beta $$

對$\beta$求梯度並令其爲零：

$$ \frac{\partial S}{\partial\beta}=-2X^Ty+2X^TX\beta=0 $$

解得正規方程：

$$ X^TX\beta=X^Ty $$

當$X$列滿秩時，$\beta=(X^TX)^{-1}X^Ty$

證明其最優性（高斯-馬爾可夫定理，BLUE）：略

Python實現

 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


import numpy as np

class LinearRegression:
 def __init__(self):
 self.coef_ = None
 self.intercept_ = None
 self.r2_ = None

 def fit(self, X, y):
 # X: （樣本數，特徵數），y: （樣本數，）
 # 構造增廣矩陣：在X左邊加一列1，用來計算解決
 X_design = np.c_[np.ones(X.shape[0]), X]
 
 beta = np.linalg.inv(X_design.T @ X_design) @ X_design.T @ y
 self.intercept_ = beta[0]
 self.coef_ = beta[1:]
 
 y_pred = self.predict(X)
 ss_res = np.sum((y - y_pred)**2)
 ss_tot = np.sum((y - np.mean(y))**2)
 self.r2_ = 1 - ss_res / ss_tot
 
 return self
 
 def predict(self, X):
 return X @ self.coef_ + self.intercept_

 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


import numpy as np

# 一维数组（形状: (3,) ）
a1 = np.array([1, 2, 3])
b1 = np.array([4, 5, 6])

# 二维数组（形状: (2, 2) ）
a2 = np.array([[1, 2], 
 [3, 4]])
b2 = np.array([[5, 6], 
 [7, 8]])
# 第一部分：按列左右拼接 (Horizontal / 增加列数)
# np.hstack —— 对一维数组：保持一维，直接延长（拼接元素）
res_hstack_1d = np.hstack((a1, b1))
# 输出: [1 2 3 4 5 6] (6,)

# np.c_ —— 对一维数组：转成列向量，形成二维矩阵（增加列数）
# 相当于把 a1 和 b1 看作两列特征，形状从 (3,) + (3,) -> (3, 2)
res_c_1d = np.c_[a1, b1]
# 输出: [[1 4] (3, 2)
# [2 5]
# [3 6]]

# np.column_stack —— 和 np.c_ 效果完全一样（一维数组当列处理）
res_col_stack = np.column_stack((a1, b1))
print(f"column_stack 一维结果: \n{res_col_stack}, 形状: {res_col_stack.shape}")

# 针对二维数组：hstack、c_、concatenate(axis=1) 三者等价
res_hstack_2d = np.hstack((a2, b2))
res_c_2d = np.c_[a2, b2]
res_concat_axis1 = np.concatenate((a2, b2), axis=1) # axis=1 代表列方向
{res_hstack_2d.shape}")
# 输出: [[1 2 5 6] (2, 4)
# [3 4 7 8]]

# 不要对一维数组用 concatenate(axis=1)，因为一维没有 axis=1 维度

# np.vstack —— 对一维数组：转成行向量，上下堆叠（增加行数）
# 相当于把 a1 和 b1 看作两行样本，形状从 (3,) + (3,) -> (2, 3)
res_vstack_1d = np.vstack((a1, b1))
# 输出: [[1 2 3] (2, 3)
# [4 5 6]]

# np.r_ —— 对一维数组：直接合并延长（和 vstack 不同！r_ 对一维是延长）
# r_ 对一维数组的行为是“合并元素”，类似 hstack（特殊）
res_r_1d = np.r_[a1, b1]
# 输出: [1 2 3 4 5 6] (6,)

# 针对二维数组：vstack、r_、concatenate(axis=0) 三者等价
res_vstack_2d = np.vstack((a2, b2))
res_r_2d = np.r_[a2, b2]
res_concat_axis0 = np.concatenate((a2, b2), axis=0) # axis=0行方向（默认值）
# 输出: [[1 2] (4, 2)
# [3 4]
# [5 6]
# [7 8]]

# np.row_stack —— np.vstack 的别名
res_row_stack = np.row_stack((a2, b2))

# 增加新维度拼接 (np.stack)
# np.stack 会在指定位置创建一个新的维
res_stack_axis0 = np.stack((a1, b1), axis=0) # 新维度在第0层（第0轴变成2）
res_stack_axis1 = np.stack((a1, b1), axis=1) # 新维度在第1层（第1轴变成2）
# 输出: [[1 2 3] (2, 3)
# [4 5 6]]
# 输出: [[1 4] (3, 2)
# [2 5]
# [3 6]]

1
2
3


X.T # 转置
np.linalg.inv() # 求逆
x.reshape(-1, 1) # 将一维数组变成二维列向量。`-1`表示自动计算行数

Note for Numpy

Mon, 31 Aug 2026 19:27:00 +0800

Very Basics

The basics

NumPy’s array class is called ndarray.

Properties:

ndarray.ndim: dimansions/axes of the arrary.
ndarray.shape: $(x, y, z, t, \cdots) : tuple?$
ndarray.size: the total number of elements of the array.
ndarray.dtype: ?
ndarray.itemsize: ?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


>>> import numpy as np
>>> a = np.arange(15).reshape(3, 5)
>>> a
array([[ 0, 1, 2, 3, 4],
 [ 5, 6, 7, 8, 9],
 [10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim
2
>>> a.dtype.name
'int64'
>>> a.itemsize
8
>>> a.size
15
>>> type(a)
<class 'numpy.ndarray'>
>>> b = np.array([6, 7, 8])
>>> b
array([6, 7, 8])
>>> type(b)
<class 'numpy.ndarray'>

Array creation

using array():

1
2
3
4


>>> import numpy as np
>>> a = np.arrary([2, 3, 4])
>>> a
array([2, 3, 4])

the type of the array can also be explicitly specified at creation time:

1

>>> c = np.array([[1, 2], [3, 4]], dtype=np.complex128)

Often, the elements of an array are originally unknown, but its size is known. Hence, NumPy offers several functions to create arrays with initial placeholder content. These minimize the necessity of growing arrays, an expensive operation.
the function zeros() creates an array full of zeros, while ones() ones.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


>>> np.zeros((3, 4))
array([[0., 0., 0., 0.],
 [0., 0., 0., 0.],
 [0., 0., 0., 0.]])
>>> np.ones((2, 3, 4), dtype=np.int16)
array([[[1, 1, 1, 1],
 [1, 1, 1, 1],
 [1, 1, 1, 1]],

 [[1, 1, 1, 1],
 [1, 1, 1, 1],
 [1, 1, 1, 1]]], dtype=int16)
>>> np.empty((2, 3)) 
array([[3.73603959e-262, 6.02658058e-154, 6.55490914e-260], # may vary
 [5.30498948e-313, 3.14673309e-307, 1.00000000e+000]])

a sequence of numbers ($arange(m, n, step)([m,n))$):

1
2


>>> np.arange(10, 30, 5)
array([10, 15, 20, 25])

linespace(begin, end, count)$[\text{begin},\space \text{end}]$

1
2
3
4
5
6


x = np.linspace(0, 2, 10)
array(
 [0. , 0.22222222, 0.44444444,
 0.66666667, 0.88888889, 1.11111111, 
 1.33333333, 1.55555556, 1.77777778, 2. ]
 )

Printing arrays

print(nparray)

Basic operations

Arithmetic operators on arrays apply elementwise. A new array is created and filled with the result.

elementwise product:

1

A * B

matrix product:

1

A @ B

When operating with arrays of different types, the type of the resulting array corresponds to the more general or precise one (a behavior known as upcasting).

Universal functions

NumPy provides familiar mathematical functions such as $\sin,\space\cos$, and $\text{exp}$. In NumPy, these are called “universal functions”(ufunc). Within NumPy, these functions operate elementwise on an array, producing an array as output.

1
2
3
4
5


>>> B = np.arange(3)
>>> B
array([0, 1, 2])
>>> np.exp(B)
array([1. , 2.71828183, 7.3890561 ])

Indexing, slicing and iterating

One-dimensional arrays can be indexed, sliced and iterated over, much like lists and other Python sequences.

 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


>>> a = np.arange(10)**3
>>> a
array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])
>>> a[2]
8
>>> a[2:5]
array([ 8, 27, 64])
>>> # equivalent to a[0:6:2] = 1000;
>>> # from start to position 6, exclusive, set every 2nd element to 1000
>>> a[:6:2] = 1000
>>> a
array([1000, 1, 1000, 27, 1000, 125, 216, 343, 512, 729])
>>> a[::-1] # reversed a
array([ 729, 512, 343, 216, 125, 1000, 27, 1000, 1, 1000])
>>> for i in a:
... print(i**(1 / 3.))
...
9.999999999999998 # may vary
1.0
9.999999999999998
3.0
9.999999999999998
4.999999999999999
5.999999999999999
6.999999999999999
7.999999999999999
8.999999999999998

Multidimensional arrays can have one index per axis. Thesse indices are given in a tuple separated by commas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


>>> def f(x, y):
... return 10 * x + y
...
>>> b = np.fromfuction(f, (5, 4), dtype=np.int_)
>>> b
array([[ 0, 1, 2, 3],
 [10, 11, 12, 13],
 [20, 21, 22, 23],
 [30, 31, 32, 33],
 [40, 41, 42, 43]])
>>> b[2, 3]
23
>>> b[0:5, 1] # each row in the second column of b
array([ 1, 11, 21, 31, 41])
>>> b[:, 1] # equivalent to the previous example
array([ 1, 11, 21, 31, 41])
>>> b[1:3, :] # each column in the second and third row of b
array([[10, 11, 12, 13],
 [20, 21, 22, 23]])

… (skip) (more ways to get a slice)

Shape manipulation

Changing the shape of an array

An array has a shape given by the number o felements along each axis:

1
2
3
4
5
6
7


>>> a = np.floor(10 * rg.random((3, 4)))
>>> a
array([[3., 7., 3., 4.],
 [1., 4., 2., 2.],
 [7., 2., 4., 9.]])
>>> a.shape
(3, 4)

The shape of an array can be changed with various commands. Note that the following three commands all return a modified array, but do not change the original array:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


>>> a.ravel() # returns the flattened array
array([3., 7., 3., 4., 1., 4., 2., 2., 7., 2., 4., 9.])
>>> a.reshape(6, 2) # returns the array with a modified shape
array([[3., 7.],
 [3., 4.],
 [1., 4.],
 [2., 2.],
 [7., 2.],
 [4., 9.]])
>>> a.T # returns the array, transposed
array([[3., 1., 7.],
 [7., 4., 2.],
 [3., 2., 4.],
 [4., 2., 9.]])

By the way: of `np.random`

init the seed:

1

>>> np.random.seed(int(hashlib.sha256("Aminiam".encode()).hexdigest(), 16) % (2**32))

print:

1
2
3
4


>>> print(np.random.random((3,3)))
[[0.59908781 0.55341069 0.73192068]
 [0.61572755 0.97373193 0.27759232]
 [0.53090874 0.57221723 0.63055102]]

By the way: of `random`

1
2
3
4


>>> import random as rd
>>> rd.seed(10086)
>>> rd.random()
0.043562757723543566

View or shallow copy

View() method creates a new array object that looks at the same data.

1
2
3
4
5
6
7


>>> c = a.view()
>>> c is a
False
>>> c.base is a
True
>>> c.flags.owndata
False

Slicing an array returns a view of it.

1
2


>>> s = a[:, 1:3]
s[:] = 10 # s[:]is a view of `s`. Note the difference between `s=10` and `s[:]=10`

Deep copy

The copy() method makes a complete copy f the array and its data.

1
2
3


>>> d = a.copy()
>>> d is a
False

Sometimes copy() should be called after slicing if the original array is not required anymore. For example, suppose a is a huge intermediate result and the final result b only contains a small fraction of a, a deep copy should be made when constructing b with slicing.

Less basic

Broadcasting rules

Broadcasting allows universal functions to deal in a meaningful way with inputs that do not have exactly the same shape.

The first rule of broadcasting is that if all input arrays do not have the same number of dimensions, a “1” will be repeatedly prepended to the shapes of the smaller arrays until all the arrays have the same number of dimensions.

The second rule of broadcasting ensures that arrays with a size of 1 along a particular dimension act as if the had the size of the array with the largest shape along that dimension. The value of the array element is assumed to be the same along that dimension for the “broadcast” array.

After application of the broadcasting rules, the sizes of all arrays must match.

Advanced indexing and index tricks

Indexing with arrays of indices

Note for Python

Mon, 31 Aug 2026 19:27:00 +0800

本體語法

自定義輸出行爲：

方法一：

1
2


import sys
sys.stdout.write("Hello!\n")

方法二：

1
2


def printf(string : str):
 print(string, end='', sep='')

自定義讀入行爲：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


>>> import sys
>>> line = sys.stdin.read()
Hello World!
>>> # line = "Hello World!\n"
>>> line = sys.stdin.readline().rstrip('\n')
Hello World!
>>> # line = "Hello World!"
>>> char = sys.stdin.read(1)
Hello World!
>>> # char = 'H'
>>> all_content = sys.stdin.read()
>>> # read to EOF (suitable for pipe)
>>> for line in sys.stdin:
... print(repr(line)) # to print '\n' explicitly cuz `line` has '\n' surfix

<str>.title() 以首字母大寫返回每一個單詞，<str>.upper()大寫，<str>.lower()小寫
+拼接str
\t製表符
<str>.lstrip(), <str>.rstrip(), <str>.strip()，返回str左右兩端空格，不修改，修改另存儲爲<str> = <str>.strip()
""字符串可以換行，''字符串不可換行
print(a, b)的默認行爲是a,<space>b\n
str拼接需強轉<strA> + str(10086) + <strB>
3 / 2 = 1, 3.0 / 2.0 = 1.5, 3.0 / 2 = 1.5, 3 / 2.0 = 1.5
列表[elementA, elementB, ...]
<list>.append()尾插，<list>.insert(N)索引處插入，索引及右右移一位，<list>.del(N)刪除索引，<list>.pop()彈出隊尾，<list>.pop(N)彈出索引
<list>.remove()根據值刪除元素
<list>.sort()永久排序，<list>.sort(reverse=True)逆序，<list>.sorted()返回臨時排序
<list>.reverse()永久翻轉
<list>.len()長度
for element in list:按引用訪問
range(a,b,c)：$[a,b)(step = c)$
切片<list>[a:b]：$[a,b)$
<listA> = <listB>複製引用

Shallow copy:

1
2
3
4
5
6


import copy
a = [1, 2, [3, 4]]
b = a.copy()
b = a[:]
b = list(a)
b = copy.copy(a)

頂層元素修改不影響，修改嵌套的可變對象（比如a[2].append(5)）b也會改變

Deep copy:

1
2


a = [1, 2, [3, 4]]
b = copy.deepcopy(a)

tuple：(elementA, elementB)，不可以修改元組的元素，但是可以重新定義整個元組（修改元組變量）
not > and > or, ==, !=, >/<(=)

位運算：

運算	名稱
`&`	按位與
`\|`	按位或
`~`	按位非
`^`	按位抑或
`<<` / `>>`	左右位移

位運算 > 比較運算 > 邏輯運算
檢查元素是否在list中：element (not) in <list, array, tuple> ，返回True / False
if-elif-else
檢查列表是否爲空：if <list>，不爲空True，空False（It says this is Pytholic?）
字典：{key : value, key : value, ...}，按key訪問<dict>[key]，添加元素<dict.[new_key] = element，創建空字典dict = {}，刪除元素del <dict>[key]
遍歷字典：for key, value in dict
遍歷字典所有鍵：for key in dict.keys()
遍歷字典所有值：for value in dict.values()
默認值同cpp全部放右側
沒有函數重載
函數傳遞整數、浮點、字符串、元組傳遞地址但是修改時會另外創建新對象，列表、字典、集合傳遞地址，修改時會直接修改元素
禁止函數修改列表：將列表的副本傳遞給函數：func(<list>[:])（潛copy）

傳遞任意數量的實參：

1
2
3
4
5
6
7


>>> def func(*args):
... print(args)
...
>>> func('A')
('A',)
>>> func('B', 'C', 'D')
('B', 'C', 'D')

傳遞任意數量的關鍵字實參：

1
2
3
4
5


>>> def func(**args):
... profile = {}
... for key, value in args:
... dict[key] = value
... return dict

將函數存儲在模塊中：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# ./a.py
def func_1():
 return # or `return None`
# ./package/b.py
def func_2():
 return
# ./package/__init__.py
# ./main.py
import a
import package.b

子目錄相對導入：

1
2
3
4
5
6
7
8
9


- PROJETC
- main.py
- c.py
- package
 |- a.py
 |- b.py
# b.py
import .a
import ..c

from module import function
from module import function as func

類：

1
2
3
4
5
6
7


class cls():
 """description"""
 def __init__(a, b):
 	self.a = a
 self.b = b
 def func(self):
 return

繼承：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class A():
 def __init__(a, b):
 self.a = a
 self.b = b
 def func():
 print("A")
 return
class B():
 def __init__(a, b, c):
 super().__init__(a, b)
 self.c = c
 def func(): # super().func() is overrided
 super().func()
 print("B")
 return

讀取文件：

1
2


# hello.txt
Hello World!

1
2
3


with open('hello.txt') as file_object:
 contents = file_object.read()
 print(contents)

1

Hello World!

關鍵字with在不需要訪問文件後將其關閉，也可使用open(), close()来控制儘管這是不推薦的
文件訪問的路徑爲當前相對路徑
逐行讀取：
1 2 3

with open('hello.txt') as file_obj: for line in file_obj: print(line)
這樣會多出空行，因爲line的結尾有換行符，寫爲：print(line.rstrip())即可（？）
創建一個包含文件各行內容的列表（只能在with內訪問文件對象，那麼在with外需要訪問的時候就需要用列表拷貝一份
1 2 3 4

with open('Hello.txt') as f: lines = f.readlines() for line in lines: print(line.rstrip())

寫入文件：

1
2


with open("Bye.txt", 'w') as f:
 f.write("Bye World!")

讀取：'r'，寫入：'w'，追加：'a'

如果寫入的文件不存在，Python 將自動創建它
write()默認不寫入\n
異常（神了，我cpp都沒學異常）

存儲數據（使用json）（JavaScript Object Notation）

使用json.dump(), json.load()：

1
2
3
4


import json
numbers = [1, 0, 0, 8, 6]
with open('data.json', 'w') as f:
 json.dump(numbers, f)

1
2
3
4


import json
with open('data.json') as f:
 numbers = json.load(f)
print(numbers)

列表推导式：

1

list[expr for var in iteratable_obj]

1

a = [x for x in range(5)]

等价于：

1
2
3


a = []
for x in range(5):
 a.append(x)

约定：for _ in range iteratable_object表示不关心循环变量

1

[0] * 3 == [0] + [0] + [0] == [0, 0, 0]

列表相加表示拼接列表

因此创建一个$m\times n$的数组只需要：

1

a = [[0] * n for _ in range(m)]

或者这样定义：

1
2
3


def matrix(m, n, val=0):
 return [val * n for _ in range(m)]
a = matrix(3, 4, 1)

判断值是否在dict中：
1 2

if value in dict.values(): pass

標準庫

math

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


from math import *
sqrt(16) == 4.0
floor(3.3) == 3
cell(3.3) == 4
gcd(12, 18) == 6
lcm(4, 6) == 12
log(8, 2) == 3.0
log2(8) == 3.0
pi == 3.1415926...
inf == ∞

还有一些常见函数直接隶属Python：

1
2
3
4
5
6


abs(-3) == 3
pow(2, 3) == 8.0
round(3.14159, 2) = 3.14
min()
max()
sum([1, 2, 3])

random

1
2
3
4
5
6
7
8


from random import *
random() # float in [0, 1)
randint(1, 10) # random integer in [1, 10] # note that it's right closed
randrange(10) # 0 ~ 9 # note that it's right open
choice([0, 1, 2]) # choose from randomly
shuffle(a) # shuffle randomly
sample(a, 3) # get a random sample of 3
seed(10086) # set seed

time

1
2
3


from time import *
t = time() # get UNIX timestamp
print(t)

time a programme

1
2
3
4
5


start = time.perf_counter()
for i in range(1000000):
 pass
end = time.perf_counter()
print(end - start) # seconds

sleep：

1

sleep(1) # sleep for 1s

datetime

1
2
3
4
5
6
7


import datetime
now = datetime.now()
print(now)
print(now.year)
print(now.month)
print(now.day)
print(now.hour)

1
2
3
4
5


2026-09-02 08:43:21.310003
2026
9
2
8

同样还有：now.minute, now.second

创建时间：

1

dt = datetime.datetime(2026, 9, 2, 22, 30)

时间差：

1
2


now = datetime.datetime.now()
tomorrow = now + timedelta(days=1)

格式化：

1

now.strftime("%Y-%m-%d %H:%M:%S")

解析字符串：

1
2
3
4


datetime.strptime(
	"2026-09-02 08:50:29",
 "%Y-%m-%d %H-%M-%S"
)

collections

`deque`

1
2
3
4
5
6


from collections import deque
q = deque([1, 2, 3])
q.append(4)
q.appendleft(0)
q.pop()
q.popleft()

`Counter`

统计元素出现次数：

1
2
3
4


from collections import Counter
cnt = Counter("hello")
print(cnt)
print(cnt["l"])

`defaultdict`

1
2
3
4
5


from collections import defaultdict
d = defaultdict(list)
d["a"].append(1)
d["a"].append(2)
d["b"].append(3)

普通dict访问不存在的key会报错，defaultdict可以自动创建默认值

比如计数：

1
2
3


cnt = defaultdict(int)
for x in [1, 2, 2, 3]:
 cnt[x] += 1

`itertools`

迭代器工具

排列：

1
2
3


>>> from itertools import permutations
>>> list(permutations([1, 2, 3]))
[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

组合：

1
2
3


>>> from itertools import combinations
>>> list(combinations([1, 2, 3, 4], 2))
[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

笛卡儿积：

1
2
3


>>> from itertools import product
>>> list(product([0, 1], repeat=3))
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]

其他：

1
2
3
4


itertools.chain(...)
itertools.accumulate(...)
itertools.repeat(...)
itertools.count(...)

`heapq`

堆（默认小根堆）

`bisect`

在有序序列中二分

`functools`

函数工具，最常见是缓存：

1
2
3
4
5
6
7


from functools import cache

@cache
def f(n):
 if n <= 1:
 return n
 return f(n - 1) + f(n - 2)

@cache会自动缓存函数结果

operator

操作函数：

1
2


from operator import add
add(2, 3)

常用于排序：

1
2
3
4
5
6
7


from operator import itemgetter
a = [
	("A", 20),
	("B", 18),
	("C", 22)
]
a.sort(key=temgetter(1))

`string`

字符串常量

1
2
3
4


import string
string.ascii_lowercase # abcdefghijklmnopqrstuvwxyz
string.ascii_uppercase # ABCDEFGHIJKLMNOPQRSTUVWXYZ
string.digits # 0123456789

`re`

正则表达式

`os`

操作系统

获取当前目录：

1
2


import os
os.getcwd()

查看文件：

1

os.listdir(".")

创建目录：

1

os.mkdir("hello")

环境变量：

1

os.environ["PATH"]

尽管现代 Python 更推荐用pathlib处理路径

`pathlib`

文件路径

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


>>> from pathlib import Path
>>> p = Path("data/test.txt")
>>> print(p.exists())
True
>>> print(p.name)
test.txt
>>> print(p.stem)
test
>>> print(p.suffix)
.txt

创建路径：

1

p = Path("data") / "test.txt"

遍历文件：

1
2


for p in Path(".").glob("*.py"):
 print(p)

递归查找：

1

Path(".").rglob("*.py")

`sys`

Python 运行环境

命令行参数：

1
2


import sys
print(sys.argv)

标准输入：

1

input = sys.stdin.readline

标准输出：

1

print("Hello", file=sys.stdout)

退出程序：

1

sys.exit()

运行外部程序：

1
2


import subprocess
subprocess.run(["git", "status"])

`copy`

浅复制：copy.copy()，深复制：copy.deepcopy()

Python on Aminiam's Blog

Notes for Pandas

Pandas Basics

Basic data structures in pandas

Object creation

Notes for Matplotlib

Pyplot Basics

Introduction to pyplot

Formatting the style of you plot

Plot with keyword strings

Plotting with categorical variables

Controlling line properties

Working with multiple figures and Axes

Working with text

MATLAB format string

Marker styles

Line styles

Colour codes

序列解包

MCM 常用方法 Python 版

層次分析法 AHP（Analytic Hierarchy Process）

問題背景

性質

一致性檢驗

Python實現

TOPSIS法（逼近理想解排序法）

性質

Python實現

最小二乘擬合與迴歸

性質

Python實現

Note for Numpy

Very Basics

The basics

Array creation

Printing arrays

Basic operations

Universal functions

Indexing, slicing and iterating

Shape manipulation

Changing the shape of an array

By the way: of np.random

By the way: of random

View or shallow copy

Deep copy

Less basic

Broadcasting rules

Advanced indexing and index tricks

Indexing with arrays of indices

Note for Python

本體語法

標準庫

math

random

time

datetime

collections

deque

Counter

defaultdict

itertools

heapq

bisect

functools

operator

string

re

os

pathlib

sys

copy

By the way: of `np.random`

By the way: of `random`

`deque`

`Counter`

`defaultdict`

`itertools`

`heapq`

`bisect`

`functools`

`string`

`re`

`os`

`pathlib`

`sys`

`copy`