SM.MS图片资源下载 posts/43947/ SM.MS是个不错的图床工具，上传的图片资源虽然不能批量一键下载，但官方还是提供了一个获取图片列表的API：https://sm.ms/api/v2/upload_history，header中只需要提供一个Authorization认证码即可，好长时间没写python了，想练练手，就不用API了

之前爬取需要登陆的网站我都是通过Selenium完成，尝试换个姿势，通过requests.Session实现？首先分析下SM.MS网站的登陆流程：

使用fiddler抓包查看表单请求内容：

唯一的障碍点其实就是g-recaptcha-response字段值的获取（我本想通过execjs模块执行JS代码），sm.ms通过<script src="https://recaptcha.google.cn/recaptcha/api.js?render=6LdArYchAAAAADs9BJEP0Ud-MpC54mNN90Bp0BvK"></script>获得了一个grecaptcha对象，然后调用grecaptcha.execute()得到了g-recaptcha-response字段值，然而execjs主要是一个在非浏览器环境中执行JS代码的工具，因此涉及到浏览器特有对象（如window、document）的代码在这个环境下通常是无法正常工作的

好吧，姿势更换失败，还是只能通过selenium(+chrome)爬取SM.MS图片数据了，但是为了尽量寻求较优的实现方案，我只会用selenium完成登陆操作，之后就可以拿到网站cookie，再用requests库携cookie请求个人图片资源列表、下载图片数据，毕竟如果是做大规模图片爬取的话，使用selenium速度实在太慢了，肯定得用并发URL请求下载资源，而且很多境外服务器一次网络请求都有可能是以秒为单位，单线程下载不得等到地老天荒啊，对于python来说，爬虫属于网络IO密集型任务，因此直接用线程模块即可或者上线程池

其实要确定请求头参数有个更好的办法，直接F12找到网络请求链接右键Copy as cURL（还可以顺便cmd执行一下看看能否成功）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
curl "https://sm.ms/home/picture" ^
  -v ^
  -H "authority: sm.ms" ^
  -H "accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7" ^
  -H "accept-language: zh-CN,zh;q=0.9" ^
  -H "cookie: PHPSESSID=xxx; smms=yyy" ^
  -H "sec-ch-ua: ^\^"Not_A Brand^\^";v=^\^"8^\^", ^\^"Chromium^\^";v=^\^"120^\^", ^\^"Google Chrome^\^";v=^\^"120^\^"" ^
  -H "sec-ch-ua-mobile: ?0" ^
  -H "sec-ch-ua-platform: ^\^"Windows^\^"" ^
  -H "sec-fetch-dest: document" ^
  -H "sec-fetch-mode: navigate" ^
  -H "sec-fetch-site: none" ^
  -H "sec-fetch-user: ?1" ^
  -H "upgrade-insecure-requests: 1" ^
  -H "user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" ^
  --compressed

执行request.get(url, cookie)报错：OpenSSL.SSL.Error: [(‘SSL routines’, ‘ssl3_get_server_certificate’, ‘certificate verify failed’)]，意思是对于sm.ms服务器发过来的证书验证失败了，解决办法就是在get方法中传递verify参数以指定用于验证的CA根证书，从sm.ms网站下载用于验证的根证书（链），crt格式，然后用XCA转换为单个pem格式证书：

获取到所有图片资源的URL列表，就可以通过get请求下载二进制图片了，经过一系列操作，我得到了一个用字典构建的图片数据库db，其键值对定义如下：<img_unique_key : [img_name, url, size, upload_date, download_flag, local_path]>，其中download_flag指示其是否已被下载到本地，只有为否的图片url才需要提交给线程池通过request执行下载，local_path是图片的本地下载路径。通过线程池下载实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
urls = {k:v[1] for k,v in db.items() if v[-2]==False} #find all pictures not downloaded
def download_url(url, timeout):
    r = requests.get(url, timeout=timeout)
    if r.ok:
        return r.content
    return None
with concurrent.futures.ThreadPoolExecutor(max_workers=36) as workers:
    future_download = {workers.submit(download_url, url, timeout=6):key for key,url in urls.items()}
    for task in as_completed(future_download):
        img_key = future_download(task)
        try:
            img_byte = task.result()
        except Exception as e:
            print(f'Error: download {db[img_key][1]} failed for {e}')
            continue
        if img_byte is None:
            continue
        db[img_key][-2] = True
        save_img_to_local(img_byte, local_path)
        db[img_key][-1] = local_path
save_db_to_local(db)

最后我又将图片数据库db导出为一个简易html页面：

完整代码见github仓库smms_download，支持增量更新

]]> Python 爬虫 Pytorch入门教程 posts/35908/ 反向传播

简单介绍一下BP算法：

  • 给定一个输入xx（列向量），前向传播得到预测值hW,b(x)h_{W,b}(x)，其中W,bW,b是网络参数
  • 根据标签值yy与预测值的误差（此处以均方误差为例）对网络参数进行更新，该过程是从后向前的，称为反向传播
    图1. 反向传播示例（黑色箭头代表前向传播，红色箭头代表反向传播
详细推导

相关符号定义：

  • 网络的总层数设为nln_l，那么倒数第二层就是第nl−1n_l-1层，网络层数ll取值范围为[1,nl][1,n_l]，特别的，第11层为输入层，第nln_l层为输出层
  • 网络权重和偏置(W,b):=(W1,b1,W2,b2,...,Wnl−1,bnl−1)(W,b):=(W^1,b^1,W^2,b^2,...,W^{n_l-1},b^{n_l-1})，设Wi,jlW_{i,j}^l表示第ll层的第jj个节点与第l+1l+1层的第ii个节点之间的连接权重值，bilb_i^l表示第l+1l+1层的第ii个节点的偏置项
  • 记zilz_i^l为第ll层的第ii个节点的输入加权和（zil=∑j=1Sl−1(Wijl−1ajl−1)+bil−1z_i^{l}=\sum\limits_{j=1}^{S_{l-1}}(W_{ij}^{l-1}a_j^{l-1})+b_i^{l-1}），记aila_i^l为第ll层的第ii个节点的激活输出
  • 记SlS_l为第ll层的节点数

以第ll层为例，其输入是al−1∈RSl−1×1a^{l-1}\in R^{S_{l-1}\times 1}，该层的权重矩阵为Wl−1=[W11l−1W21l−1⋯WSl,1l−1W12l−1W22l−1⋯WSl,2l−1⋮⋮⋱⋮W1,Sl−1l−1W2,Sl−1l−1⋯WSl,Sl−1l−1]∈RSl−1×SlW^{l-1}=\begin{bmatrix}W_{11}^{l-1}&W_{21}^{l-1}&\cdots&W_{S_l,1}^{l-1}\\W_{12}^{l-1}&W_{22}^{l-1}&\cdots&W_{S_l,2}^{l-1}\\\vdots&\vdots&\ddots&\vdots\\W_{1,S_{l-1}}^{l-1}&W_{2,S_{l-1}}^{l-1}&\cdots&W_{S_l,S_{l-1}}^{l-1}\end{bmatrix}\in R^{S_{l-1}\times S_l}，偏置项为bl−1∈RSl×1b^{l-1}\in R^{S_l\times 1}，于是第ll层的输出为al=σ(zl)=σ((Wl−1)Tal−1+bl−1)∈RSl×1a^l=\sigma(z^l)=\sigma((W^{l-1})^Ta^{l-1}+b^{l-1})\in R^{S_l\times 1}，其中σ(⋅)\sigma(·)为激活函数。事实上，要求损失函数L=12∥hW,b(x)−y∥2L=\frac{1}{2}\|h_{W,b}(x)-y\|^2对权重的偏导，核心是计算其对zz（任意节点的输入加权和）的偏导，这又分为两种情况，一是输出层，二是非输出层，就是简单的链式求导：

  • 输出层
    ∂L∂zinl=∂∂zinl(12∑j=1Snl(ajnl−yj)2)=(ainl−yi)∂ainl∂zinl=(ainl−yi)σ′(zinl)\frac{\partial L}{\partial z_i^{n_l}}=\frac{\partial}{\partial z_i^{n_l}}(\frac{1}{2}\sum\limits_{j=1}^{S_{n_l}}(a_j^{n_l}-y_j)^2)=(a_i^{n_l}-y_i)\frac{\partial a_i^{n_l}}{\partial z_i^{n_l}}=(a_i^{n_l}-y_i)\sigma^{\prime}(z_i^{n_l})
  • 非输出层
    以倒数第二层为例，∂L∂zinl−1=∂L∂z1nl∂z1nl∂zinl−1+...+∂L∂zSnlnl∂zSnlnl∂zinl−1=∑j=1Snl(∂L∂zjnl∂zjnl∂zinl−1)=∑j=1Snl(∂L∂zjnlWjinl−1σ′(zinl−1))\frac{\partial L}{\partial z_i^{n_l-1}}=\frac{\partial L}{\partial z_1^{n_l}}\frac{\partial z_1^{n_l}}{\partial z_i^{n_l-1}}+...+\frac{\partial L}{\partial z_{S_{n_l}}^{n_l}}\frac{\partial z_{S_{n_l}}^{n_l}}{\partial z_i^{n_l-1}}=\sum\limits_{j=1}^{S_{n_l}}(\frac{\partial L}{\partial z_j^{n_l}}\frac{\partial z_j^{n_l}}{\partial z_i^{n_l-1}})=\sum\limits_{j=1}^{S_{n_l}}(\frac{\partial L}{\partial z_j^{n_l}}W_{ji}^{n_l-1}\sigma^{\prime}(z_i^{n_l-1}))，其中zjnl=Wj1nl−1σ(z1nl−1)+...+Wj,Snl−1nl−1σ(zSnl−1nl−1)+bjnl−1z_j^{n_l}=W_{j1}^{n_l-1}\sigma(z_1^{n_l-1})+...+W_{j,S_{n_l-1}}^{n_l-1}\sigma(z_{S_{n_l-1}}^{n_l-1})+b_j^{n_l-1}。一般的，对任意非输出层ll（l∈{2,...,nl−1}l\in \{2,...,n_l-1\}），有∂L∂zil=∑j=1Sl+1(∂L∂zjl+1Wjil)σ′(zil)\frac{\partial L}{\partial z_i^l}=\sum\limits_{j=1}^{S_{l+1}}(\frac{\partial L}{\partial z_j^{l+1}}W_{ji}^{l})\sigma^{\prime}(z_i^l)（这就是图1反向传播的原理）

现在可以轻松求解∂L∂Wijl=∂L∂zil+1∂zil+1∂Wijl=∂L∂zil+1ajl\frac{\partial L}{\partial W_{ij}^l}=\frac{\partial L}{\partial z_i^{l+1}}\frac{\partial z_i^{l+1}}{\partial W_{ij}^l}=\frac{\partial L}{\partial z_i^{l+1}}a_j^l，以及∂L∂bil=∂L∂zil+1∂zil+1∂bil=∂L∂zil+11\frac{\partial L}{\partial b_i^l}=\frac{\partial L}{\partial z_i^{l+1}}\frac{\partial z_i^{l+1}}{\partial b_i^l}=\frac{\partial L}{\partial z_i^{l+1}}1

以上全部改写为矩阵形式，有：
∂L∂znl=(anl−y)⊙σ′(znl)∈RSnl×1\frac{\partial L}{\partial z^{n_l}}=(a^{n_l}-y)\odot\sigma^{\prime}(z^{n_l})\in R^{S_{n_l}\times 1}（⊙\odot表示逐元素乘法），∂L∂znl−1=(Wnl−1∂L∂znl)⊙σ′(znl−1)∈RSnl−1×1\frac{\partial L}{\partial z^{n_l-1}}=(W^{n_l-1}\frac{\partial L}{\partial z^{n_l}})\odot\sigma^{\prime}(z^{n_l-1})\in R^{S_{n_l-1}\times 1}，…，∂L∂zl=(Wl∂L∂zl+1)⊙σ′(zl)∈RSl×1\frac{\partial L}{\partial z^l}=(W^l\frac{\partial L}{\partial z^{l+1}})\odot\sigma^{\prime}(z^l)\in R^{S_l\times 1}（l=1,...,nl−1l=1,...,n_l-1）

进一步，有：∂L∂Wl=[∂L∂W11l∂L∂W21l⋯∂L∂WSl+1,1l∂L∂W12l∂L∂W22l⋯∂L∂WSl+1,2l⋮⋮⋱⋮∂L∂W1,Sll∂L∂W2,Sll⋯∂L∂WSl+1,Sll]=[∂L∂z1l+1a1l∂L∂z2l+1a1l⋯∂L∂zSl+1l+1a1l∂L∂z1l+1a2l∂L∂z2l+1a2l⋯∂L∂zSl+1l+1a2l⋮⋮⋱⋮∂L∂z1l+1aSll∂L∂z2l+1aSll⋯∂L∂zSl+1l+1aSll]=al(∂L∂zl+1)T∈RSl×Sl+1\frac{\partial L}{\partial W^l}=\begin{bmatrix}\frac{\partial L}{\partial W_{11}^{l}}&\frac{\partial L}{\partial W_{21}^{l}}&\cdots&\frac{\partial L}{\partial W_{S_{l+1},1}^{l}}\\\frac{\partial L}{\partial W_{12}^{l}}&\frac{\partial L}{\partial W_{22}^{l}}&\cdots&\frac{\partial L}{\partial W_{S_{l+1},2}^{l}}\\\vdots&\vdots&\ddots&\vdots\\\frac{\partial L}{\partial W_{1,S_{l}}^{l}}&\frac{\partial L}{\partial W_{2,S_{l}}^{l}}&\cdots&\frac{\partial L}{\partial W_{S_{l+1},S_{l}}^{l}}\end{bmatrix}=\begin{bmatrix}\frac{\partial L}{\partial z_{1}^{l+1}}a_{1}^l&\frac{\partial L}{\partial z_{2}^{l+1}}a_{1}^l&\cdots&\frac{\partial L}{\partial z_{S_{l+1}}^{l+1}}a_{1}^l\\\frac{\partial L}{\partial z_{1}^{l+1}}a_{2}^l&\frac{\partial L}{\partial z_{2}^{l+1}}a_{2}^l&\cdots&\frac{\partial L}{\partial z_{S_{l+1}}^{l+1}}a_{2}^l\\\vdots&\vdots&\ddots&\vdots\\\frac{\partial L}{\partial z_{1}^{l+1}}a_{S_l}^l&\frac{\partial L}{\partial z_{2}^{l+1}}a_{S_l}^l&\cdots&\frac{\partial L}{\partial z_{S_{l+1}}^{l+1}}a_{S_l}^l\end{bmatrix}=a^l(\frac{\partial L}{\partial z^{l+1}})^T\in R^{S_l\times S_{l+1}}，∂L∂bl=∂L∂zl+1∈RSl+1×1\frac{\partial L}{\partial b^l}=\frac{\partial L}{\partial z^{l+1}}\in R^{S_{l+1}\times 1}

Pytorch标量对矩阵求导

举个例子，∂tr(AXBX)∂X=ATXTBT+BTXTAT\frac{\partial tr(AXBX)}{\partial X}=A^TX^TB^T+B^TX^TA^T（该解析解可根据“矩阵求导术”得出）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> import torch as pt
>>> X=pt.arange(12,dtype=pt.float32).view(3,4) #要使X支持求导，必须为浮点类型
>>> _=X.requires_grad_(True) #置requires_grad为True（表示可导），于是X上的梯度更新将累积到grad属性中
>>> A=pt.rand(4,3) #rand()的默认类型就是float32
>>> B=pt.rand(4,3)
>>> out=pt.trace(A.mm(X).mm(B).mm(X)) #out是一个复合函数，默认只会计算对叶子节点的导数，中间节点需要手动定义，譬如AX=A.mm(X)
>>> out.backward() #只要任意叶子节点（此处就是X,A,B）的requires_grad为True，则out也为True，执行一遍反向传播后，将可以得出out对X的偏导（存放在X.grad属性中）
>>> X.grad #由于梯度会累加，可以执行X.grad.data.zero_()对梯度清零
tensor([[35.3752, 34.2365,  9.8990, 22.8047],
        [31.8588, 32.2588,  8.7556, 17.3359],
        [24.6398, 21.3645,  6.5890, 17.4973]])
>>> pt.t(A).mm(pt.t(X)).mm(pt.t(B))+pt.t(B).mm(pt.t(X)).mm(pt.t(A)) #验证偏导是否计算正确（AᵀXᵀBᵀ+BᵀXᵀAᵀ），正确
tensor([[35.3752, 34.2365,  9.8990, 22.8047],
        [31.8587, 32.2588,  8.7556, 17.3359],
        [24.6398, 21.3645,  6.5890, 17.4973]], grad_fn=<AddBackward0>)

线性回归模型

简要回顾：

线性回归预测模型定义为y^=w1x1+w2x2+...+wnxn+b\hat{y}=w_1x_1+w_2x_2+...+w_nx_n+b，其中w=[w1,...,wn]T,bw=[w_1,...,w_n]^T,b为模型参数，分别称为权重和偏置项，x=[x1,...,xn]Tx=[x_1,...,x_n]^T为单个样本数据。对于有mm个样本的批量数据，其（预测模型）矩阵表示形式为：Y^=wTX+b\hat{Y}=w^TX+b（注意这边我们直接对一个向量和一个标量相加，发生广播），其中X=[x(1),...,x(m)]X=[x^{(1)},...,x^{(m)}]，Y^=[y^(1),...,y^(m)]\hat{Y}=[\hat{y}^{(1)},...,\hat{y}^{(m)}]，相应的，记真实值Y=[y(1),...,y(m)]Y=[y^{(1)},...,y^{(m)}]。假设我们使用均方误差（预测值与真实值差的平方）作为单样本（第ii个样本）损失函数：l(w,b)(i)=12(y^(i)−y(i))2l_{(w,b)}^{(i)}=\frac{1}{2}(\hat{y}^{(i)}-y^{(i)})^2，而对mm个批量数据，我们用所有这些样本的平方误差和的均值作为总体损失：L(w,b)=1m∑i=1ml(w,b)(i)L_{(w,b)}=\frac{1}{m}\sum\limits_{i=1}^ml_{(w,b)}^{(i)}，接下来要做的就是学习一组模型参数以最小化总体损失：w∗,b∗=arg⁡min⁡w,bL(w,b)=arg⁡min⁡w,b12m∥Y^−Y∥22w^*,b^*=\arg\min\limits_{w,b}L_{(w,b)}=\arg\min\limits_{w,b}\frac{1}{2m}\|\hat{Y}-Y\|_2^2，具体的，使用梯度下降算法更新参数以最小化损失：{w←w−r∂L(w,b)∂wb←b−r∂L(w,b)∂b\begin{cases}w\leftarrow w-r\frac{\partial L_{(w,b)}}{\partial w} \\ b\leftarrow b-r\frac{\partial L_{(w,b)}}{\partial b}\end{cases}（其中rr是学习率）

图2. 线性回归是一个单层（感知器）神经网络[3]

编程实现（核心步骤）：

  1. 定义网络模型
    定义网络的前向传播过程，并返回模型预测值，此处就是wTX+bw^TX+b
  2. 定义损失函数
    损失函数用于衡量预测值与真实值的误差，此处使用的是均方误差，即12m∥(wTX+b)−Y∥2\frac{1}{2m}\|(w^TX+b)-Y\|^2
  3. 定义优化算法
    最常用且最简单的就是梯度下降算法，其他还有改进的Adam等，我们知道偏导数保存在张量对象的grad属性中（记得反向传播前清零），梯度下降要做的就是用模型参数减去这些导数值，然后将结果作为参数的新值

假设真实权重为w=[2,3.4]Tw=[2,3.4]^T，偏置为b=4.2b=4.2，生成一组数据：Y=wTX+b+ϵY=w^TX+b+\epsilon，其中ϵ\epsilon为服从均值0、标准差0.01的正态分布的随机误差项：

1
2
3
4
5
6
7
8
### 生成数据
import numpy as np
true_w=np.array([[2],[3.4]])
true_b=np.array([4.2])
samples_num=1000 #自定义样本数量
X=np.random.randn(len(true_w),samples_num)
Y=true_w.T@X+true_b
Y+=np.random.normal(0,0.01,size=Y.shape)

（三维）可视化数据：

1
2
3
4
5
6
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
ax=Axes3D(plt.gcf())
data=np.vstack((X,Y))
ax.scatter(*data)
plt.show()
图3. 准备的训练数据

在上述“核心步骤”中已经解释过了，直接看代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
### 定义线性回归模型
import torch as pt
def linear_regress(X,w,b):
    return pt.t(w).mm(X)+b #其实就是前向传播计算式

### 定义损失函数
def square_loss(Y_hat,Y):
    return pt.sum((Y_hat-Y)**2/2) #注意我们没有在这里除以m（批量尺寸），而会在梯度下降时做，方便写代码

### 定义梯度下降算法
def sgd(params,learn_rate,batch_size):
    for param in params:
        param.data-=(learn_rate*param.grad/batch_size)

在开始训练前还要准备一些东西：训练数据的批量（batch）数据生成器、模型参数的初始化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
### 将ndarray对象转换为Tensor对象以供后续使用
X=pt.from_numpy(X).to(pt.float32) #注意from_numpy是共享内存的
Y=pt.from_numpy(Y).to(pt.float32)

### 批量读取数据的函数
def data_iter(X,Y,batch_size):
    n=X.shape[1]
    ind=np.arange(n)
    np.random.shuffle(ind)
    for i in range(0,n,batch_size):
        j=pt.LongTensor(ind[i:min(i+batch_size,n)]) #最后一次可能不足一个batch
        yield  X.index_select(1,j),Y.index_select(1,j) #tensor.index_select(1,索引序列)表示沿张量的1轴索引元素

### 初始化模型参数
def init_params():
    w=pt.tensor(np.random.normal(0,0.01,(X.shape[0],1)),dtype=pt.float32)
    b=pt.zeros(1,dtype=pt.float32)
    w.requires_grad_(requires_grad=True)
    b.requires_grad_(requires_grad=True)
    return w,b

开始训练：

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
num_epoches=5 #自定义迭代周期
learn_rate=0.03 #自定义学习率
batch_size=10 #自定义批量大小
w,b=init_params()
for epoch in range(num_epoches):
    for mini_X,mini_Y in data_iter(X,Y,batch_size): #小批量随机梯度下降算法
        mini_Y_hat=linear_regress(mini_X,w,b) #前向传播计算预测值
        loss=square_loss(mini_Y_hat,mini_Y) #计算损失值
        loss.backward() #计算损失对参数的偏导数
        sgd((w,b),learn_rate,batch_size) #根据梯度下降算法更新网络参数
        _=w.grad.data.zero_() #梯度清零，防止累加
        _=b.grad.data.zero_()
    #计算当前epoch的损失（损失应该是递减的），理论上，当参数接近正确值时，损失也将接近0
    print('epoch=%d,loss=%f'%(epoch+1,square_loss(linear_regress(X,w,b),Y))) #这里直接输出loss拉倒了
print('-'*22)
print('w:',w.data) #观察神经网络拟合出的参数
print('b:',b.data)

'''OUTPUT
epoch=1,loss=32.869465
epoch=2,loss=0.122995
epoch=3,loss=0.054227
epoch=4,loss=0.054130
epoch=5,loss=0.054148
----------------------
w: tensor([[2.0000],
        [3.3990]])
b: tensor([4.1995])
'''

比较简单，直接看代码：

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
import torch as pt
import numpy as np

### 生成训练数据
def gen_data(true_w,true_b,samples_num):
    '''参数：真实的权重（列向量），偏置（标量），训练数据个数（列代表样本）。Ndarray对象
       返回：训练数据（dxn），值（标签，1xn）。Tensor/float32对象'''
    X=np.random.randn(len(true_w),samples_num)
    Y=true_w.T@X+true_b
    Y+=np.random.normal(0,0.01,size=Y.shape)
    return pt.from_numpy(X).to(pt.float32),pt.from_numpy(Y).to(pt.float32)
    
### 利用torch.utils.data工具包迭代产生小批量数据
import torch.utils.data as Data
def data_iter(features,labels,batch_size): #需要注意的是，features的形状为(n,d)，labels的形状为(n,k)，其中d为输入层节点数
    #（样本维数），k为输出层节点数
    #将训练数据的特征和标签组合
    dataset = Data.TensorDataset(features, labels)
    #随机小批量迭代生成器
    iteration=Data.DataLoader(dataset, batch_size, shuffle=True)
    return iteration
    
### 定义线性回归模型
import torch.nn as nn
linearNet=lambda input_num: nn.Sequential(nn.Linear(input_num,1))

### 定义损失函数，均方差损失
loss=nn.MSELoss()

### 定义优化算法，使用随机梯度下降
import torch.optim as optim
optimize=lambda params,lr:optim.SGD(params,lr=lr)

### 训练模型
from torch.nn import init
epoches=10
true_w=np.array([[2],[3.4]])
true_b=4.2
samples_num=1000
batch_size=10
train_X,train_Y=gen_data(true_w,true_b,samples_num)
net=linearNet(len(true_w))
_=init.normal_(net[0].weight, mean=0, std=0.01) #初始化模型参数，权重服从标准正态分布。net[0].weight/net[0].bias表示查看第一层网络的权重和偏置
_=init.constant_(net[0].bias, val=0) #后缀_表示原址修改，偏置设为0
opt=optimize(net.parameters(),0.01) #通过net.parameters()返回的生成器查看所有可学习参数
for epoch in range(epoches):
    for mini_X,mini_Y in data_iter(pt.t(train_X),pt.t(train_Y),batch_size):
        out=net(mini_X) #前向传播（需要注意的是，nn.Linear计算表达式为Xw^T+b，由于X的行为样本，所以输出结果会是一个列向量，
                        #我通常都是写成w^TX+b，其中X列为样本数据，所以输出结果是一个行向量）
        l=loss(out,mini_Y.view(-1,1)) #计算损失
        l.backward() #反向传播求偏导
        opt.step() #执行优化，更新网络参数
        net.zero_grad() #清空导数
    print('epoch=%d,loss=%f'%(epoch+1,l.item()))
print('-'*21)
print(net[0].weight.data)
print(net[0].bias.data)

'''OUTPUT
epoch=1,loss=0.395253
epoch=2,loss=0.015482
epoch=3,loss=0.000321
epoch=4,loss=0.000112
epoch=5,loss=0.000151
epoch=6,loss=0.000066
epoch=7,loss=0.000070
epoch=8,loss=0.000097
epoch=9,loss=0.000113
epoch=10,loss=0.000144
---------------------
tensor([[2.0000, 3.3993]])
tensor([4.2006])
'''

Softmax分类模型

简要回顾（注意从本段开始，我会稍稍规范化latex公式的书写，会用大写和加粗来区别表示标量xx、向量x\mathbf{x}和矩阵X\mathbf{X}，之前写的就算了，懒得改了）：

介绍Softmax（多）分类模型之前先介绍一下Logistic（二）分类模型，Logistic分类模型的目的在于找到一个超平面wx+b=0\mathbf{w}\mathbf{x}+b=0，其中w=[w1,...,wn]∈R1×n\mathbf{w}=[w_1,...,w_n]\in R^{1\times n}，x=[x1,...,xn]T∈Rn×1\mathbf{x}=[x_1,...,x_n]^T\in R^{n\times 1}，b∈Rb\in R，用于在nn维空间中分割两种不同类别（用符号yy来标记）的数据，分别记为正类（类别1，y=1y=1）和负类（类别0，y=0y=0）。现给出Logistic分类预测模型：y^=hw,b(x)=σ(wx+b)\hat{y}=h_{\mathbf{w},b}(\mathbf{x})=\sigma(\mathbf{w}\mathbf{x}+b)，其中σ(x)=11+e−x\sigma(x)=\frac{1}{1+e^{-x}}，有σ′(x)=σ(x)(1−σ(x))\sigma^{\prime}(x)=\sigma(x)(1-\sigma(x))，由σ(⋅)\sigma(·)函数的值域范围（[0,1][0,1]区间），我们将模型预测结果y^\hat{y}视为“样本x\mathbf{x}属于正类的概率值P(y=1∣x,w,b)P(y=1|\mathbf{x},\mathbf{w},b)”，则1−y^1-\hat{y}为样本x\mathbf{x}属于负类的概率，因此样本x\mathbf{x}属于类别y={1,0}y=\{1,0\}的概率为P(y∣x,w,b)=σ(wx+b)y(1−σ(wx+b))1−yP(y|\mathbf{x},\mathbf{w},b)=\sigma(\mathbf{w}\mathbf{x}+b)^{y}(1-\sigma(\mathbf{w}\mathbf{x}+b))^{1-y}（可视作单样本的目标函数，要最大化之），要求该问题中的未知参数w\mathbf{w}和bb，可以采用极大似然法对其进行估计，也就是未知参数取多少时，样本取观测值的概率最大，设训练集总计有mm个样本{(x(1),y(1)),(x(2),y(2)),...,(x(m),y(m))}\{(\mathbf{x}^{(1)},y^{(1)}),(\mathbf{x}^{(2)},y^{(2)}),...,(\mathbf{x}^{(m)},y^{(m)})\}，则其似然函数为（也就是总体目标函数，仍要最大化之）：Lw,b′=∏i=1mP(y(i)∣x(i),w,b)=∏i=1m[hw,b(x(i))y(i)(1−hw,b(x(i)))1−y(i)]L_{\mathbf{w},b}^{'}=\prod\limits_{i=1}^m P(y^{(i)}|\mathbf{x^{(i)}},\mathbf{w},b)=\prod\limits_{i=1}^m[h_{\mathbf{w},b}(\mathbf{x}^{(i)})^{y^{(i)}}(1-h_{\mathbf{w},b}(\mathbf{x}^{(i)}))^{1-y^{(i)}}]，然后再取对数和负数，转换为极小值问题，由此得到我们所熟知的损失函数形式：Lw,b=−1mln⁡Lw,b′=−1m∑i=1m[y(i)ln⁡(hw,b(x(i)))+(1−y(i))ln⁡(1−hw,b(x(i)))]=−1m∑i=1m[y(i)ln⁡(y^(i))+(1−y(i))ln⁡(1−y^(i))]L_{\mathbf{w},b}=-\frac{1}{m}\ln L_{\mathbf{w},b}^{'}=-\frac{1}{m}\sum\limits_{i=1}^m[y^{(i)}\ln(h_{\mathbf{w},b}(\mathbf{x}^{(i)}))+(1-y^{(i)})\ln(1-h_{\mathbf{w},b}(\mathbf{x}^{(i)}))]=-\frac{1}{m}\sum\limits_{i=1}^m[y^{(i)}\ln(\hat{y}^{(i)})+(1-y^{(i)})\ln(1-\hat{y}^{(i)})]（某些地方还会看到另一种写法，若记f(x)=wx+bf(\mathbf{x})=\mathbf{w}\mathbf{x}+b，代入损失函数中可得：Lw,b=1m∑i=1m[y(i)ln⁡(1+e−f(x(i)))+(1−y(i))ln⁡(1+ef(x(i)))]=1m∑i=1mln⁡(1+e(−1)y(i)f(x(i)))L_{\mathbf{w},b}=\frac{1}{m}\sum\limits_{i=1}^m[y^{(i)}\ln(1+e^{-f(\mathbf{x}^{(i)})})+(1-y^{(i)})\ln(1+e^{f(\mathbf{x}^{(i)})})]=\frac{1}{m}\sum\limits_{i=1}^m\ln(1+e^{(-1)^{y^{(i)}}f(\mathbf{x}^{(i)})})，如果正负类别标签你不是记作11或00，而是11或−1-1，那么损失将写为Lw,b=1m∑i=1mln⁡(1+e−y(i)f(x(i)))L_{\mathbf{w},b}=\frac{1}{m}\sum\limits_{i=1}^m\ln(1+e^{-y^{(i)}f(\mathbf{x}^{(i)})})）

图4. Softmax多分类模型是一个单层（感知器）神经网络[3]

Softmax（多）分类是Logistic（二）分类的一个推广，或者说后者是前者的一个特例。和线性回归模型相比，Softmax也是一个单层神经网络，只不过输出层有多个节点（等于类别数）并且加了一个sigmoid激活函数。相比于二分类寻找单个超平面，多分类会寻找多个超平面用于分割多种（大于2）不同的类别：w1x+b1=0\mathbf{w}_1\mathbf{x}+b_1=0、w2x+b2=0\mathbf{w}_2\mathbf{x}+b_2=0、…，为了方便推导，我们将超平面wx+b=0\mathbf{w}\mathbf{x}+b=0中的参数部分合起来（本节推导参考[2]），记θ=[b,w]T∈R(n+1)×1\boldsymbol{\theta}=[b,\mathbf{w}]^T\in R^{(n+1)\times 1}，x=[1,x1,...,xn]∈R(n+1)×1\mathbf{x}=[1,x_1,...,x_n]\in R^{(n+1)\times 1}，于是超平面变为θTx=0\boldsymbol{\theta}^T\mathbf{x}=0，假设是kk分类，全部未知参数记作Θ=[θ1,θ2,...,θk]∈R(n+1)×k\Theta=[\boldsymbol{\theta}_1,\boldsymbol{\theta}_2,...,\boldsymbol{\theta}_k]\in R^{(n+1)\times k}，现给出Softmax分类预测模型：y^=hΘ(x)=softmax(ΘTx)∈Rk×1\hat{\mathbf{y}}=h_\Theta(\mathbf{x})=\textbf{softmax}(\Theta^T\mathbf{x})\in R^{k\times 1}，其中softmax(x)=exp⁡(x)∑exp⁡(x)\textbf{softmax}(\mathbf{x})=\frac{\exp(\mathbf{x})}{\sum\exp(\mathbf{x})}（分母表示向量元素求和），其批量（mm个样本）损失函数直接参照二分类，有LΘ=−1m∑i=1m∑j=1kyj(i)ln⁡(y^j(i))L_\Theta=-\frac{1}{m}\sum\limits_{i=1}^m\sum\limits_{j=1}^k\mathbf{y}_j^{(i)}\ln(\hat{\mathbf{y}}_j^{(i)})，其中y(i)\mathbf{y}^{(i)}是样本x(i)\mathbf{x}^{(i)}所属标量类别y(i)y^{(i)}的one-hot编码向量）

Softmax（多）分类是Logistic（二）分类的一个推广，或者说后者是前者的一个特例。和线性回归模型相比，Softmax也是一个单层神经网络，只不过输出层有多个节点（等于类别数）并且加了一个sigmoid激活函数。相比于二分类寻找单个超平面，多分类会寻找多个超平面用于分割多种（大于2）不同的类别：w1x+b1=0\mathbf{w}_1\mathbf{x}+b_1=0、w2x+b2=0\mathbf{w}_2\mathbf{x}+b_2=0、…，为了方便推导，我们将超平面wx+b=0\mathbf{w}\mathbf{x}+b=0中的参数部分合起来（本节推导参考[2]，下面将纠正其中损失函数求偏导部分的一个因符号混乱引发的错误），记θ=[b,w]T∈R(n+1)×1\boldsymbol{\theta}=[b,\mathbf{w}]^T\in R^{(n+1)\times 1}，x=[1,x1,...,xn]∈R(n+1)×1\mathbf{x}=[1,x_1,...,x_n]\in R^{(n+1)\times 1}，于是超平面变为θTx=0\boldsymbol{\theta}^T\mathbf{x}=0，假设是kk分类，全部未知参数记作Θ=[θ1,θ2,...,θk]∈R(n+1)×k\Theta=[\boldsymbol{\theta}_1,\boldsymbol{\theta}_2,...,\boldsymbol{\theta}_k]\in R^{(n+1)\times k}，现给出Softmax分类预测模型：y^=hΘ(x)=1∑i=1keθiTx[eθ1Txeθ2Tx⋮eθkTx]=softmax(ΘTx)≡[P(y=1∣x,Θ)P(y=2∣x,Θ)⋮P(y=k∣x,Θ)]∈Rk×1\hat{\mathbf{y}}=h_\Theta(\mathbf{x})=\frac{1}{\sum\limits_{i=1}^ke^{\boldsymbol{\theta}_i^T\mathbf{x}}}\begin{bmatrix}e^{\boldsymbol{\theta}_1^T\mathbf{x}}\\e^{\boldsymbol{\theta}_2^T\mathbf{x}}\\\vdots\\e^{\boldsymbol{\theta}_k^T\mathbf{x}}\end{bmatrix}=\textbf{softmax}(\Theta^T\mathbf{x})\equiv \begin{bmatrix}P(y=1|\mathbf{x},\Theta)\\P(y=2|\mathbf{x},\Theta)\\\vdots\\P(y=k|\mathbf{x},\Theta)\end{bmatrix}\in R^{k\times 1}，其中softmax(x)=exp⁡(x)∑exp⁡(x)\textbf{softmax}(\mathbf{x})=\frac{\exp(\mathbf{x})}{\sum\exp(\mathbf{x})}（分母表示向量元素求和）

和Logistic分类的联系：假设k=2k=2，则hΘ(x)=[eθ1Txeθ1Tx+eθ2Txeθ2Txeθ1Tx+eθ2Tx]=[11+e(θ2−θ1)Tx≡v1−v]h_\Theta(\mathbf{x})=\begin{bmatrix}\frac{e^{\boldsymbol{\theta}_1^T\mathbf{x}}}{e^{\boldsymbol{\theta}_1^T\mathbf{x}}+e^{\boldsymbol{\theta}_2^T\mathbf{x}}}\\\frac{e^{\boldsymbol{\theta}_2^T\mathbf{x}}}{e^{\boldsymbol{\theta}_1^T\mathbf{x}}+e^{\boldsymbol{\theta}_2^T\mathbf{x}}}\end{bmatrix}=\begin{bmatrix}\frac{1}{1+e^{(\boldsymbol{\theta}_2-\boldsymbol{\theta}_1)^T\mathbf{x}}}\equiv v\\1-v\end{bmatrix}，其中vv不就是σ((θ2−θ1)Tx)\sigma((\boldsymbol{\theta}_2-\boldsymbol{\theta}_1)^T\mathbf{x})么，这正是Logistic分类预测模型的表达形式

至于Softmax分类模型的损失函数，对于mm个批量数据，直接仿照Logistic分类，给出总体损失函数：LΘ=−1m∑i=1m∑j=1k[I{y(i)=j}ln⁡eθjTx(i)∑l=1keθlTx(i)]L_\Theta=-\frac{1}{m}\sum\limits_{i=1}^m\sum\limits_{j=1}^k[I\{y^{(i)}=j\}\ln\frac{e^{\boldsymbol{\theta}_j^T\mathbf{x}^{(i)}}}{\sum\limits_{l=1}^ke^{\boldsymbol{\theta}_l^T\mathbf{x}^{(i)}}}]，其中II为指示函数，I{condition}={1,if condition is true0,if condition is falseI\{\text{condition}\}=\begin{cases}1,\text{if condition is true}\\0,\text{if condition is false}\end{cases}

参考书[2]错误纠正

对书中P29求导部分的更正：
∇θqLΘ=−1m∑i=1m∑j=1k[I{y(i)=j}∂∂θq(ln⁡eθjTx(i)∑l=1keθlTx(i))]\nabla_{\boldsymbol{\theta}_q}^{L_\Theta}=-\frac{1}{m}\sum\limits_{i=1}^m\sum\limits_{j=1}^k[I\{y^{(i)}=j\}\frac{\partial}{\partial \boldsymbol{\theta}_q}(\ln\frac{e^{\boldsymbol{\theta}_j^T\mathbf{x}^{(i)}}}{\sum\limits_{l=1}^ke^{\boldsymbol{\theta}_l^T\mathbf{x}^{(i)}}})]，由ln⁡\ln函数求导规则ddxln⁡(u)=1ududx\frac{d}{dx}\ln(u)=\frac{1}{u}\frac{du}{dx}以及分数求导(uv)′=u′v−uv′v2(\frac{u}{v})^{\prime}=\frac{u^{\prime}v-uv^{\prime}}{v^2}以及∂eθjTx(i)∂θq={eθjTx(i)x(i),q=j0,q≠j=eθjTx(i)I{q=j}x(i)\frac{\partial e^{\boldsymbol{\theta}_j^T\mathbf{x}^{(i)}}}{\partial \boldsymbol{\theta}_q}=\begin{cases}e^{\boldsymbol{\theta}_j^T\mathbf{x}^{(i)}}\mathbf{x}^{(i)},q=j\\0,q\ne j\end{cases}=e^{\boldsymbol{\theta}_j^T\mathbf{x}^{(i)}}I\{q=j\}\mathbf{x}^{(i)}，∇θqLΘ=−1m∑i=1m∑j=1k[I{y(i)=j}∑l=1keθlTx(i)eθjTx(i)eθjTx(i)I{q=j}x(i)∑l=1keθlTx(i)−eθjTx(i)x(i)eθqTx(i)(∑l=1keθlTx(i))2]=−1m∑i=1m∑j=1k[I{y(i)=j}I{q=j}∑l=1keθlTx(i)−eθqTx(i)∑l=1keθlTx(i)x(i)]=−1m∑i=1m[I{q=y(i)}∑l=1keθlTx(i)−eθqTx(i)∑l=1keθlTx(i)x(i)]=−1m∑i=1m[(I{y(i)=q}−P(y=q∣x(i),Θ))x(i)]\nabla_{\boldsymbol{\theta}_q}^{L_\Theta}=-\frac{1}{m}\sum\limits_{i=1}^m\sum\limits_{j=1}^k[I\{y^{(i)}=j\}\frac{\sum\limits_{l=1}^ke^{\boldsymbol{\theta}_l^T\mathbf{x}^{(i)}}}{e^{\boldsymbol{\theta}_j^T\mathbf{x}^{(i)}}}\frac{e^{\boldsymbol{\theta}_j^T\mathbf{x}^{(i)}}I\{q=j\}\mathbf{x}^{(i)}\sum\limits_{l=1}^ke^{\boldsymbol{\theta}_l^T\mathbf{x}^{(i)}}-e^{\boldsymbol{\theta}_j^T\mathbf{x}^{(i)}}\mathbf{x}^{(i)}e^{\boldsymbol{\theta}_q^T\mathbf{x}^{(i)}}}{(\sum\limits_{l=1}^ke^{\boldsymbol{\theta}_l^T\mathbf{x}^{(i)}})^2}]=-\frac{1}{m}\sum\limits_{i=1}^m\sum\limits_{j=1}^k[I\{y^{(i)}=j\}\frac{I\{q=j\}\sum\limits_{l=1}^ke^{\boldsymbol{\theta}_l^T\mathbf{x}^{(i)}}-e^{\boldsymbol{\theta}_q^T\mathbf{x}^{(i)}}}{\sum\limits_{l=1}^ke^{\boldsymbol{\theta}_l^T\mathbf{x}^{(i)}}}\mathbf{x}^{(i)}]=-\frac{1}{m}\sum\limits_{i=1}^m[\frac{I\{q=y^{(i)}\}\sum\limits_{l=1}^ke^{\boldsymbol{\theta}_l^T\mathbf{x}^{(i)}}-e^{\boldsymbol{\theta}_q^T\mathbf{x}^{(i)}}}{\sum\limits_{l=1}^ke^{\boldsymbol{\theta}_l^T\mathbf{x}^{(i)}}}\mathbf{x}^{(i)}]=-\frac{1}{m}\sum\limits_{i=1}^m[(I\{y^{(i)}=q\}-P(y=q|\mathbf{x}^{(i)},\Theta))\mathbf{x}^{(i)}]

上述给出的Softmax分类模型的损失其实就是所谓的交叉熵损失，下面给出简洁且常见的表示形式，对于单样本，其kk分类预测值为y^\hat{\mathbf{y}}，真实值为y\mathbf{y}（所属标量类别yy经one-hot编码所得向量），于是有交叉熵损失：lΘ=−∑i=1kyiln⁡(y^i)l_\Theta=-\sum\limits_{i=1}^k\mathbf{y}_i\ln(\hat{\mathbf{y}}_i)，对于mm个批量数据的总体交叉熵损失，求和取平均得到LΘ=−1m∑i=1m∑j=1kyj(i)ln⁡(y^j(i))=−1m∑i=1m(y(i))Tln⁡(y^(i))=−1mtr([y(1),...,y(m)]T[ln⁡(y^(1)),...,ln⁡(y^(m))])L_\Theta=-\frac{1}{m}\sum\limits_{i=1}^m\sum\limits_{j=1}^k\mathbf{y}_j^{(i)}\ln(\hat{\mathbf{y}}_j^{(i)})=-\frac{1}{m}\sum\limits_{i=1}^m(\mathbf{y}^{(i)})^T\ln(\hat{\mathbf{y}}^{(i)})=-\frac{1}{m}tr([\mathbf{y}^{(1)},...,\mathbf{y}^{(m)}]^T[\ln(\hat{\mathbf{y}}^{(1)}),...,\ln(\hat{\mathbf{y}}^{(m)})])，通过最小化该损失函数，可以使样本的预测概率分布y^(i)\hat{\mathbf{y}}^{(i)}尽可能接近真实的标签概率分布y(i)\mathbf{y}^{(i)}，其中i∈{1,...,m}i\in \{1,...,m\}（某些地方还会看到另一种写法，若记f(x)=ΘTxf(\mathbf{x})=\Theta^T\mathbf{x}，称为“logit”，代入损失函数中可得：LΘ=−1m∑i=1m∑j=1kyj(i)ln⁡(ef(x(i))j∑l=1kef(x(i))l)L_\Theta=-\frac{1}{m}\sum\limits_{i=1}^m\sum\limits_{j=1}^k\mathbf{y}_j^{(i)}\ln(\frac{e^{f(\mathbf{x}^{(i)})_j}}{\sum_{l=1}^ke^{f(\mathbf{x}^{(i)})_l}})，由于y(i)\mathbf{y}^{(i)}是标量类别y(i)y^{(i)}的one-hot编码，因此y(i)\mathbf{y}^{(i)}只有在第y(i)y^{(i)}个下标位置处值为1，其余皆为0，因此损失函数继续等于1m∑i=1mln⁡(1+∑l=1,l≠y(i)kef(x(i))lef(x(i))y(i))\frac{1}{m}\sum\limits_{i=1}^m\ln(1+\frac{\sum_{l=1,l\ne y^{(i)}}^ke^{f(\mathbf{x}^{(i)})_l}}{e^{f(\mathbf{x}^{(i)})_{y^{(i)}}}})）

编程实现：

和线性回归示例一样，需要定义网络模型、定义损失函数、定义优化算法三大步骤。（批量mm个训练数据X∈Rd×m\mathbf{X}\in R^{d\times m}，且为kk分类）前向传播：Y^k×m=softmax(Wd×kTXd×m+Bk×1)\hat{\mathbf{Y}}_{k\times m}=\textbf{softmax}(\mathbf{W}_{d\times k}^T\mathbf{X}_{d\times m}+\mathbf{B}_{k\times 1})（上面给出了softmax\textbf{softmax}函数的定义，处理的向量，此处虽然接收的一个矩阵，但是是逐列分别计算的），损失函数：LW,B=−1mtr(Yk×mTln⁡(Y^k×m))L_{W,B}=-\frac{1}{m}tr(\mathbf{Y}_{k\times m}^T\ln(\hat{\mathbf{Y}}_{k\times m}))，优化算法：小批量随机梯度下降

首先通过torchvision.datasets模块获取Fashion-MNIST图像分类数据集，并利用transforms.ToTensor()函数将所有图像数据（numpy对象，[0−255][0-255]的Uint8类型）转换成Tensor张量对象，且数值为介于[0.0−1.0][0.0-1.0]的torch.float32类型：

1
2
3
4
5
6
7
8
9
10
11
12
13
import torchvision
import torchvision.transforms as transforms

mnist_train = torchvision.datasets.FashionMNIST(root='./data/FashionMNIST', train=True, download=True, transform=transforms.ToTensor())
mnist_test = torchvision.datasets.FashionMNIST(root='./data/FashionMNIST', train=False, download=True, transform=transforms.ToTensor())
print(len(mnist_train),len(mnist_test))
feature,label=mnist_train[0] #通过下标索引第一个训练图像
print(feature.shape,label) #需要注意的是，类别是标量数据，后面训练的时候我再转换成one-hot编码形式

'''OUTPUT
60000 10000
torch.Size([1, 28, 28]) 9
'''

训练集和测试集中的每个类别的图像数分别为6,000和1,000，统共10个类别，为t-shirt（T恤）、trouser（裤子）、pullover（套衫）、dress（连衣裙）、coat（外套）、sandal（凉鞋）、shirt（衬衫）、sneaker（运动鞋）、bag（包）和ankle boot（短靴），因此总计有70,000张图像。图像数据的形状为(c,h,w)，三个符号分别代表通道数、高度、宽度，根据上述输出可知，此处图像是单通道的

可视化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import matplotlib.pyplot as plt

def get_fashion_mnist_labels(labels):
    text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat',
                   'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
    return [text_labels[int(i)] for i in labels]

# 定义一个可以在一行里画出多张图像和对应标签的函数
def show_fashion_mnist(images,labels):
    for i in range(len(images)):
        ax=plt.subplot(1,len(images),i+1)
        plt.imshow(np.squeeze(images[i].numpy()).reshape(28,28),cmap='gray')
        plt.xlabel(get_fashion_mnist_labels([labels[i]])[0])
        plt.xticks([])
        plt.yticks([])
    plt.show()
    
X, y = [], []
for i in range(5):
    X.append(mnist_train[i][0])
    y.append(mnist_train[i][1])
show_fashion_mnist(X,y)
图5. Fashion-MNIST数据集图例

首先定义前向传播时要用到的softmax函数：

1
2
3
def softmax(WX):
    WX=WX.exp()
    return WX/WX.sum()

再定义模型、损失和优化函数：

1
2
3
4
5
6
7
8
9
10
11
12
### 定义网络模型
def softmax_classify(X,W,B):
    return softmax(pt.t(W).mm(X)+B)

### 定义损失函数
def cross_loss(Y_hat,Y):
    return -pt.trace(pt.t(Y).mm(pt.log(Y_hat))) #注意这里并未除以m（批量数），我们会在更新参数的时候再做，同线性回归示例
    
### 定义优化算法
def sgd(params,learn_rate,batch_sise): #同线性回归示例
    for param in params:
        param.data-=(learn_rate*param.grad/batch_size)

在训练前还要准备一些东西：批量数据生成器、one-hot编码以及参数初始化：

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 time

#批量读取数据。mnist_train对象是torch.utils.data.Dataset的子类，所以我们可以将其传入torch.utils.data.DataLoader来创建一个读取小批量数据样本的DataLoader实例。PyTorch的DataLoader一个很好的功能是允许使用多进程来加速数据读取，这里我们通过参数num_workers来设置4个进程读取数据
batch_size = 256 #自定义批量尺寸
num_workers = 4 #0则表示不用额外的进程来加速读取数据
train_iter = pt.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers) #定义批量数据迭代器
test_iter = pt.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)
#此处查看读取一遍训练数据需要的时间（作为对比，num_workers=0需4.64s，num_workers=4需要1.99s）
start = time.time()
for X, y in train_iter:
    continue
print('%.2f sec' % (time.time() - start))

# labels转换为one-hot编码
def to_onehot(labels,N): #N为类别数（labels中标签标量取值范围应为[0,N-1]）
    return (pt.arange(N).view(N,1)==labels).to(pt.float32) #形状为(N,len(labels))

### 初始化模型参数
def init_params(d,k): #d是图像样本展开后的维度，也就是输入层的节点数量，k是分类数，即输出层节点数量
    W=pt.tensor(np.random.normal(0,0.01,(d,k)),dtype=pt.float32)
    B=pt.zeros(k,1,dtype=pt.float32)
    W.requires_grad_(requires_grad=True)
    B.requires_grad_(requires_grad=True)
    return W,B

为了评判模型在测试集上的性能，在每一轮epoch结束后都会计算预测准确率，对于批量测试数据，网络的输出Y^\hat{\mathbf{Y}}是一个矩阵，每一列代表其中一个样本的预测概率分布，其中最大值所在位置就是预测的类别，同时已知的测试集真实值标签Y\mathbf{Y}，和Y^\hat{\mathbf{Y}}是一个同形矩阵，含义一样，每一列都是其中一个样本的one-hot编码，于是精度计算代码就是(Y^.argmax(dim=0)==Y.argmax(dim=0)).mean()(\hat{\mathbf{Y}}.argmax(dim=0)==\mathbf{Y}.argmax(dim=0)).mean()：

1
2
3
4
5
6
7
8
9
10
11
#计算单个批次数据的精确率
def acc(Y_hat,Y):
    return (Y_hat.argmax(dim=0)==Y.argmax(dim=0)).float().mean().item()

#计算多个批次数据的精确率
def calc_accuracy(data_iter, net_with_wb):
    acc_sum, n = 0.0, 0
    for X, y in data_iter:
        acc_sum += (net_with_wb(pt.t(X.view(-1,784))).argmax(dim=0)==y).float().sum().item()
        n += len(y)
    return acc_sum / n

开始训练：

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
from functools import partial

### 训练过程
start_time=time.time()
epoches=10 #自定义迭代周期
learn_rate=0.1 #自定义学习率
W,B=init_params(784,10) #784是图像一维化展开后的长度
for epoch in range(epoches):
    for mini_samples,mini_labels in train_iter:
        mini_X=pt.t(mini_samples.view(-1,784)) #将小批量训练数据转换到(d,batch_size)二维形状
        mini_Y=to_onehot(mini_labels,10) #将标签向量转换成one-hot编码
        mini_Y_hat=softmax_classify(mini_X,W,B) #前向传播
        loss=cross_loss(mini_Y_hat,mini_Y) #得到损失
        loss.backward() #反向传播求偏导
        sgd((W,B),learn_rate,batch_size) #根据偏导以及梯度下降算法更新网络参数
        _=W.grad.data.zero_()
        _=B.grad.data.zero_()
    print('epoch=%d,train_loss=%f,test_accuracy=%f'%(epoch+1,loss.data.item(),calc_accuracy(test_iter,partial(softmax_classify,W=W,B=B))))
print('Time: %f'%(time.time()-start_time))

'''OUTPUT
epoch=1,train_loss=513.109375,test_accuracy=0.795100
epoch=2,train_loss=505.963837,test_accuracy=0.811600
epoch=3,train_loss=506.121246,test_accuracy=0.819600
epoch=4,train_loss=499.465485,test_accuracy=0.821300
epoch=5,train_loss=491.453918,test_accuracy=0.823300
epoch=6,train_loss=500.663055,test_accuracy=0.826000
epoch=7,train_loss=496.945709,test_accuracy=0.820800
epoch=8,train_loss=493.426422,test_accuracy=0.830900
epoch=9,train_loss=493.445496,test_accuracy=0.829300
epoch=10,train_loss=494.146027,test_accuracy=0.825700
Time: 33.636117
'''

编写预测函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
### 预测函数
def predict(images,true_labels):
    t=pt.cat(images,0)
    t=t.view(t.shape[0],-1)
    y=softmax_classify(pt.t(t),W,B).argmax(dim=0)
    print('预测结果:')
    show_fashion_mnist(images,y)
    print('真实标签:',get_fashion_mnist_labels(true_labels))

X, y = [], []
for i in pt.randint(0,10000,(8,)):
    X.append(mnist_test[i][0])
    y.append(mnist_test[i][1])
predict(X,y)

比较简单，直接看代码：

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
import torch as pt
import numpy as np

### 一些参数设置
batch_size=128
num_inputs=784
num_outputs=10

### 获取fashion-mnist训练数据以及小批量生成器
train_iter,test_iter=load_data_fashion_mnist(batch_size,root='./data/FashionMNIST') #注意迭代产生的训练样本的形状为(batch_size,1,h,w)，标签形状为(batch_size,)

### 定义网络模型，定义展开层和线性层而无需定义softmax层（因为pytorch的softmax交叉熵损失nn.CrossEntropyLoss完成了这一步）
import torch.nn as nn
net=nn.Sequential(FlattenLayer(),nn.Linear(num_inputs,num_outputs))

### 定义损失函数
#分开定义softmax运算和交叉熵损失函数可能会造成数值不稳定。因此，PyTorch提供了一个包括softmax运算和交叉熵损失计算的函数。它的数值稳定性更好
loss=nn.CrossEntropyLoss()

### 定义优化算法
optimizer=pt.optim.SGD(net.parameters(), lr=0.1)

### 训练
from torch.nn import init
_=init.normal_(net[1].weight, mean=0, std=0.01) #初始化权重
_=init.constant_(net[1].bias, val=0)
num_epochs = 5
train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, None, None, optimizer)

上述代码用到了几个别人写好的功能函数（后面还会用到，写在d2l.py中，作为模块调用）：

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 torch
import torchvision
import sys

def load_data_fashion_mnist(batch_size, resize=None, root='~/Datasets/FashionMNIST'):
    """Download the fashion mnist dataset and then load into memory."""
    trans = []
    if resize:
        trans.append(torchvision.transforms.Resize(size=resize))
    trans.append(torchvision.transforms.ToTensor())
    
    transform = torchvision.transforms.Compose(trans)
    mnist_train = torchvision.datasets.FashionMNIST(root=root, train=True, download=True, transform=transform)
    mnist_test = torchvision.datasets.FashionMNIST(root=root, train=False, download=True, transform=transform)
    if sys.platform.startswith('win'):
        num_workers = 4  # 0表示不用额外的进程来加速读取数据
    else:
        num_workers = 6
    train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers)
    test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)
 
    return train_iter, test_iter

class FlattenLayer(torch.nn.Module):
    def __init__(self):
        super(FlattenLayer, self).__init__()
    def forward(self, x): # x shape: (batch, *, *, ...)
        return x.view(x.shape[0], -1)

def sgd(params, lr, batch_size):
    # 为了和原书保持一致，这里除以了batch_size，但是应该是不用除的，因为一般用PyTorch计算loss时就默认已经
    # 沿batch维求了平均了。
    for param in params:
        param.data -= lr * param.grad / batch_size # 注意这里更改param时用的param.data

def evaluate_accuracy_ch3(data_iter, net):
    acc_sum, n = 0.0, 0
    for X, y in data_iter:
        acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
        n += y.shape[0]
    return acc_sum / n

def train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size,
              params=None, lr=None, optimizer=None):
    for epoch in range(num_epochs):
        train_l_sum, train_acc_sum, n = 0.0, 0.0, 0
        for X, y in train_iter:
            y_hat = net(X)
            l = loss(y_hat, y).sum()
            
            # 梯度清零
            if optimizer is not None:
                optimizer.zero_grad()
            elif params is not None and params[0].grad is not None:
                for param in params:
                    param.grad.data.zero_()
            
            l.backward()
            if optimizer is None:
                sgd(params, lr, batch_size)
            else:
                optimizer.step()  # “softmax回归的简洁实现”一节将用到
            
            train_l_sum += l.item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
            n += y.shape[0]
        test_acc = evaluate_accuracy_ch3(test_iter, net)
        print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f'
              % (epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc))

MLP多层感知器

简要回顾：

图6. 由单个隐层构成的多层感知器[3]

和线性回归、Softmax多分类相比，MLP增加了隐藏层的概念（实现了对输入空间的非线性映射+输出层线性判别分析）。给定批量nn个数据，对于任意第ll层节点，有Zl=(Wl−1)TAl−1+Bl\mathbf{Z}^l=(\mathbf{W}^{l-1})^T\mathbf{A}^{l-1}+\mathbf{B}^l，Al=σ(Zl)\mathbf{A}^{l}=\sigma(\mathbf{Z}^l)，其中Al−1∈RSl−1×n\mathbf{A}^{l-1}\in R^{S_{l-1}\times n}为上一层的输出、当前层的输入，Bl∈RSl×1\mathbf{B}^l\in R^{S_l\times 1}为当前层偏置（广播为形状Sl×nS_l\times n），Zl∈RSl×n\mathbf{Z}^l\in R^{S_l\times n}为当前层的输入加权和，Wl−1∈RSl−1×Sl\mathbf{W}^{l-1}\in R^{S_{l-1}\times S_l}的第ii列代表第l−1l-1层所有节点和第ll层第ii个节点的连线权重，Al∈RSl×n\mathbf{A}^l\in R^{S_l\times n}为当前层的输出，SlS_l为第ll层节点数，σ(⋅)\sigma(·)为激活函数，包括但不限于Sigmoid函数（sigmoid(x)=11+exp(−x)sigmoid(x)=\frac{1}{1+exp(-x)}）、ReLU函数（relu(x)=max(x,0)relu(x)=max(x,0)）以及Tanh函数（tanh(x)=1−exp(−2x)1+exp(−2x)tanh(x)=\frac{1-exp(-2x)}{1+exp(-2x)}）

图7. 常见激活函数

编程实现：
以单隐层为例，模型总计三层，第一层是输入层，第二层是隐藏层，第三层是输出层，由于是多分类问题，所以第三层后面还要接一个Softmax层，注意pytorch为了数值稳定性（具体我也不清楚），前向传播时最后的输出并不会执行Softmax运算，而是留到计算交叉熵损失的时候再算（torch.nn.CrossEntropyLoss()），由于torch.utils.data.DataLoader迭代产生的批量样本数据的形状是(batch_size,dim)，前述计算式中则是基于相反的形状，所以为了适用于已经定义好的d2l.train_ch3()等方法，我稍稍修改了该单隐层网络的前向传播计算式：Zn×S22=Xn×S1WS1×S21+B1×S22\mathbf{Z}_{n\times S_2}^2=\mathbf{X}_{n\times S_1}\mathbf{W}_{S_1\times S_2}^1+\mathbf{B}_{1\times S_2}^2，An×S22=σ(Zn×S22)\mathbf{A}_{n\times S_2}^2=\sigma(\mathbf{Z}_{n\times S_2}^2)，Zn×S33=An×S22WS2×S32+B1×S33\mathbf{Z}_{n\times S_3}^3=\mathbf{A}_{n\times S_2}^2\mathbf{W}_{S2\times S_3}^2+\mathbf{B}_{1\times S_3}^3，Y^=softmax(Zn×S33)\hat{\mathbf{Y}}=\sout{\textbf{softmax}}(\mathbf{Z}_{n\times S_3}^3)

仍使用Fashion-MNIST数据集，同Softmax多分类

首先定义激活函数，作为网络中的激活层：

1
2
3
4
5
6
7
8
### 定义激活函数
import torch as pt
def sigmoid(Z):
    return 1/(1+pt.exp(-Z))
def relu(Z):
    return pt.max(Z,other=pt.Tensor([0.0])) #尽管ReLU并不完全处处可导，但是从实验看pytorch的自动求偏导机制并不会因此出错
def tanh(Z):
    return (1-pt.exp(-2*Z))/(1+pt.exp(-2*Z))

优化函数当然还是简单的随机梯度下降，而将要调用的训练方法d2l.train_ch3()中已经定义了SGD过程：

1
2
3
4
5
6
7
8
### 定义网络模型
def MLP_1(X,W1,W2,B1,B2,activate):
    X=X.view((-1,784)) #注意fashion-mnist的批量数据形状为(batch_size,1,28,28)，形状重塑为(batch_sise,784)
    return activate(X.mm(W1)+B1).mm(W2)+B2

### 定义损失函数
import torch.nn as nn
loss=nn.CrossEntropyLoss() #为了得到更好的数值稳定性，我们直接使用PyTorch提供的包括softmax运算和交叉熵损失计算的函数

训练前还是先准备数据生成器并作参数初始化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
### 获取fashion-mnist训练数据以及小批量生成器
import d2l
batch_size=256
train_iter,test_iter=d2l.load_data_fashion_mnist(batch_size,root='./data/FashionMNIST')

### 初始化模型参数
num_inputs=784 #输入层节点数
num_hiddens=256 #隐层节点数
num_outputs=10 #输出层节点数
W1 = pt.tensor(np.random.normal(0, 0.01, (num_inputs, num_hiddens)), dtype=pt.float)
B1 = pt.zeros(num_hiddens, dtype=pt.float)
W2 = pt.tensor(np.random.normal(0, 0.01, (num_hiddens, num_outputs)), dtype=pt.float)
B2 = pt.zeros(num_outputs, dtype=pt.float)
#设置权重/偏置参数可导
params = [W1, B1, W2, B2]
for param in params:
    _=param.requires_grad_(requires_grad=True)

开始训练：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
### 训练
from functools import partial
num_epochs = 5
lr = 100.0 #注意交叉熵中已经除以了batch_size，而sgd中又除以batch_size，所以这边学习率设大一点以抵消其中一个除法
net = partial(MLP_1,W1=W1,W2=W2,B1=B1,B2=B2,activate=relu)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, params, lr)

'''OUTPUT
epoch 1, loss 0.0030, train acc 0.709, test acc 0.737
epoch 2, loss 0.0019, train acc 0.824, test acc 0.787
epoch 3, loss 0.0017, train acc 0.845, test acc 0.795
epoch 4, loss 0.0016, train acc 0.855, test acc 0.854
epoch 5, loss 0.0015, train acc 0.864, test acc 0.816
'''

train_iter,test_iter,loss都复用自前面的代码，此处简洁实现只要重新定义网络部分即可：

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
### 定义模型
num_inputs, num_outputs, num_hiddens = 784, 10, 256
net=nn.Sequential(
    d2l.FlattenLayer(),
    nn.Linear(num_inputs,num_hiddens),
    nn.ReLU(),
    nn.Linear(num_hiddens,num_outputs)
)
#初始化模型参数
from torch.nn import init
for params in net.parameters():
    _=init.normal_(params, mean=0, std=0.01)

### 定义损失函数、优化算法并训练模型
optimizer = pt.optim.SGD(net.parameters(), lr=0.5) #优化算法
num_epochs = 5
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, None, None, optimizer)

'''OUTPUT
epoch 1, loss 0.0030, train acc 0.708, test acc 0.700
epoch 2, loss 0.0019, train acc 0.821, test acc 0.745
epoch 3, loss 0.0017, train acc 0.842, test acc 0.829
epoch 4, loss 0.0015, train acc 0.856, test acc 0.858
epoch 5, loss 0.0014, train acc 0.865, test acc 0.846
'''

[1] Pytorch模型训练实用教程
[2] Python机器学习算法 赵志勇 著
[3] 动手学深度学习 PyTorch版
[4] 从最优化的角度看待Softmax损失函数

]]> 深度学习 DL基础 Pytorch Python基础 - 面向对象编程 posts/22901/

📚 文档目录
🎃 类型和对象 - 🎈 程序结构与函数编程 - 🎏 面向对象编程

📚 文档目录
🎃 类型和对象 - 🎈 程序结构与函数编程 - 🎏 面向对象编程

类

类定义了一组属性，包括变量（指类变量，为所有实例共享）、方法（有三种类型，实例方法、静态方法和类方法）以及由@property支持的特性（需要计算的属性），使用class语句可以创建类对象（注意区分“类对象”和“类实例”），类可以充当一个命名空间，与模块很类似，类的实例是以函数形式调用类对象来创建的（类名后加小括号），然后将创建的实例传递给类的__init__()方法，__init__()方法的参数包括新创建的实例self和用于初始化实例的一些其他参数（可以缺省），注意__init__()只能返回None，可以在其中将一些初始化参数绑定在self对象上作为实例属性，之后可以通过属性名和.运算符访问到实例的这些属性（任意对象都有一个__dict__字典属性，当然也有特例，存储了所有通过obj.property=value方式动态绑定在对象上的属性），在访问属性时，首先会检查实例，如果不知道该属性的任何信息，则会对实例的类进行搜索，如果还没有，会继续搜索其父类，直到没有更多的基类可供搜索

继承是一种创建新类的机制，目的是专门使用或修改现有类的行为，原始类称为基类或超类，新类称为派生类或子类，通过继承创建类时（可以有多个基类，即多继承，否则叫单继承），所创建的类将继承其基类定义中的属性（注意继承的是类属性而不会继承基类的任何实例的绑定属性），且派生类可以重新定义任何这些属性并添加自己的新属性。子类如果没有定义自己的__init__()方法，实例化子类的时候将会自动调用父类的初始化函数（__new__()也一样），反之，则不会调用，除非手动执行super().__init__()（不建议通过父类类名调用__init__()方法），关于多重继承时的属性查找，会按照MRO顺序（第一章节已经谈过这个问题）依序搜索基类

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
class Dog:
    def __init__(self,name):
        self.name=name
    
class WorkDog(Dog): #工作狗
    allnum=0
    
    def __init__(self,name,identity): #工作狗除了姓名，还具有编制identity，当前全部注册的工作狗数量由allnum类属性记录
        self.__class__.allnum+=1 #千万不能写成self.allnum+=1或者WorkDog.allnum+=1，如果没有派生类的话，后者才正确，前者将会创建一个与类属性allnum同名的实例绑定属性（但若类定义allnum是一个可变对象的话，则又不会新创建实例绑定属性，除非写成self.allnum=self.allnum+1的形式，因为+=对可变对象来说是一个原址操作，示例参见https://github.com/leisurelicht/wtfpython-cn#-class-attributes-and-instance-attributes%E7%B1%BB%E5%B1%9E%E6%80%A7%E5%92%8C%E5%AE%9E%E4%BE%8B%E5%B1%9E%E6%80%A7），数值将总是为1，但是在访问该类属性的时候，总是可以写成self.allnum，因为实例上找不到，会自动到类中寻找
        self.identity=identity
        super().__init__(name) #自定义__init__()后，除非手动调用父类初始化方法，否则不会自动调用，在单继承情况下写成Dog.__init__(self,name)也没问题，但是多继承就不一定了，因此总是建议采用super方式，而且后者形式更加简约，super()（python3中等价于super(WorkDog,self)）返回super对象（相当于父类但不是原始父类，是绑定了实例self的bound super object，且多继承的时候返回的还可能是兄弟类，具体参见第一章节所提到的钻石继承），不同于其他通过类访问实例方法（返回非绑定方法，只有通过实例访问实例方法才返回绑定方法）的情况，此处返回的也是“绑定方法”，即绑定了self参数的父类__init__()方法，因此调用时不需要再传入self参数
    
    def work(self): #一个公开的未实现的接口，子类应重载之
        pass
    
    def __del__(self):
        self.__class__.allnum-=1

class ArmyDog(WorkDog):
    def work(self):
        print(f'{self.name}({self.identity})在追击敌人')

class DrugDog(WorkDog):
    def work(self):
        print(f'{self.name}({self.identity})在追查毒品')

class SuperDog(DrugDog,ArmyDog):
    def __init__(self,name,identity):
        self.__class__.allnum=0 #访问SuperDog.allnum时会在基类（ArmyDog或DrugDog）中查找，可能已经非零了
        super().__init__(name,identity)
    
    pass

army_dog_1=ArmyDog('Cherry',id('Cherry')) #ArmyDog直接继承了父类的__init__()方法，初始化ArmyDog类实例的时候会自动调用之
army_dog_2=ArmyDog('Black',id('Black'))

print(army_dog_2.__dict__) #{'identity': 1761656222920, 'name': 'Black'} #通过__dict__实例属性字典查找用户绑定在实例上的所有属性
army_dog_2_ref=army_dog_2 #对army_dog_2所指向的对象引用计数+1，于是当前引用数总计为2

drug_dog_1=DrugDog('HelloKit',id('HelloKit'))
drug_dog_2=DrugDog('Jack',id('Jack'))
drug_dog_3=DrugDog('Pig',id('Pig'))

del army_dog_2 #del语句看似是“删除对象”，准确说其实是对象引用计数-1，且del语句并不会立即执行__del__()方法，只有在对象的引用计数降为0的时候才会执行，这时候对象才会真的从内存中删除
print(ArmyDog.allnum) #2 #写成army_dog_1.allnum也正确，但是语义不明，因为allnum明明是一个类属性，通过实例访问会让人误以为是实例属性
print(DrugDog.allnum) #3
del army_dog_2_ref
print(ArmyDog.allnum) #1

drug_dog_2.work() #Jack(2607617062368)在追查毒品

super_dog_1=SuperDog('Hero',id('Hero'))
print(super_dog_1.__class__.mro()) #[<class '__main__.SuperDog'>, <class '__main__.DrugDog'>, <class '__main__.ArmyDog'>, <class '__main__.WorkDog'>, <class '__main__.Dog'>, <class 'object'>]
super_dog_1.work() #Hero(2359695357632)在追查毒品 #SuperDog并未实现自己的work()方法，因此在属性查找时，会顺着MRO列表依次在“基类”中寻找，MRO列表中位于SuperDog之后的正是DrugDog，而DrugDog类确实定义了自己的work()方法，所以属性查找到此结束，就是它

def work(self):
    print(f'{self.name}({self.identity})在追击敌人，同时在追查毒品')
    
SuperDog.work=work #给类动态绑定属性方法，且默认是实例方法，相当于你一开始在定义SuperDog的地方写了work()方法
super_dog_1.work() #Hero(1559184520896)在追击敌人，同时在追查毒品

@classmethod
def print_allnum(cls):
    print(f'{cls}类总数量为{cls.allnum}')
    
SuperDog.print_allnum=print_allnum #给类对象动态绑定类方法，同理静态方法也可以
SuperDog.print_allnum() #<class '__main__.SuperDog'>类总数量为1 #也可以通过实例调用类方法，super_dog_1.print_allnum()

通常你可以为类实例动态绑定任意数量的任意属性，当你要限制此行为时，或者当一个类需要创建大量实例要节省内存时，可以设置__slots__类属性声明实例可动态绑定的属性范围，一旦定义__slots__，类实例就不再有__dict__属性，且类中不能再定义与__slots__列表中同名的类属性：

1
2
3
4
5
6
7
8
9
10
11
12
13
class student:
    __slots__=('name','score')
    #name='xxx' #ValueError: 'name' in __slots__ conflicts with class variable #类中不能再定义出现在__slots__列表中的属性
    pass
    
s=student()
s.name='dy'
s.score=8.0
#s.sex='female' #AttributeError: 'student' object has no attribute 'sex' #无法为实例动态绑定非__slots__列表属性
#print(s.__dict__) #AttributeError: 'student' object has no attribute '__dict__' #定义__slots__类属性的类实例不再有__dict__属性字典

student.school='nuist' #__slots__不会限制类本身可动态绑定属性的范围
print(student.__dict__) #{'__module__': '__main__', '__slots__': ('name', 'score'), 'name': <member 'name' of 'student' objects>, 'score': <member 'score' of 'student' objects>, '__doc__': None, 'school': 'nuist'} #注意看类的__dict__中有了name和score两个属性，这也是为什么上面在类中定义同名属性name时会发生冲突

在实际使用中，__slots__不是作为一种安全特性，虽然定义了__slots__的类不再依赖__dict__字典进行实例属性的存储和查找，从而达到隐藏实例动态绑定的属性的目的，但是并没有对属性访问本身增加任何控制，其主要目的还是对内存和性能的优化，使用__slots__的类实例不再使用字典来存储实例绑定属性，它会使用基于数组的更加紧密的数据结构，在创建大量对象的程序中，使用__slots__可以显著减少内存占用和执行时间（直接通过数组内存地址偏移访问__slots__中定义的属性比通过__dict__字典进行属性查找要快），但是也会带来一些需要注意的问题，1）__slots__无法被继承，每个子类都要重新定义一遍，如果忘记这一点，子类的执行速度将比没有使用__slots__时更慢，2）实例只能动态绑定那些在__slots__列表中出现的属性，极大影响了程序的灵活性，3）实例不能被弱引用，除非将'__weakref__'放进__slots__

关于上述第一点，子类如果没有重新定义__slots__，动态绑定将不受限制，重新定义时如果和基类一致，可以直接赋一个空值__slots__=()，也可以在基类的基础上进行增补，但无法删除

1
2
3
4
5
6
7
8
class graduate(student):
    __slots__=('sex') #一个笔误，之前以为__slots__必须是一个列表，此处等同于：__slots__='sex'，当前子类graduate的__slots__在基类基础上扩展，属性范围限制在['name','score','sex']
    
g=graduate()
g.name='dy'
g.score=25
g.sex='female'
print(g.sex)

关于第三点，弱引用的问题，定义了__slots__的类实例无法被弱引用，因为此时不仅是类实例的__dict__属性被禁用，__weakref__属性也被禁用，__weakref__属性是干嘛的？假设对对象进行弱引用，那么创建的弱引用将存储在对象的__weakref__属性中，因此解决办法就是将'__weakref__'放进__slots__列表中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class graduate(student):
    __slots__=('sex','__weakref__')

import weakref

g=graduate()
print(g.__weakref__) #None #此时还没有弱引用
ref=weakref.ref(g) #如果没有将'__weakref__'放到__slots__中，则报错：TypeError: cannot create weak reference to 'graduate' object
print(g.__weakref__) #<weakref at 0x000002595C39C4F8; to 'graduate' at 0x000002595C60CDC8>

g.name='muggle'
g.score=25
g.sex='female'

print(f'{ref().name},{ref().sex},{ref().score}') #muggle,female,25 #调用弱引用将获取被弱引用的原始对象
弱引用

weakref模块允许用户创建对对象的弱引用（weak reference），相比于普通的引用（为了和“弱引用”这一名词对应，在官方文档中明确有strong reference“强引用”一说）来说，只要存在任何一个对对象的强引用（即引用计数大于1，注意弱引用不计在内，要删除某个强引用，使用del语句，引用计数减一），这个对象就不会被垃圾收集器销毁，而当引用计数为0时（没有强引用），无论还有多少弱引用，那么它将会被垃圾收集器收回。在对象未被销毁之前，可以通过弱引用访问到对象，否则只能得到None

weakref运行在“观察者模式”，当我们创建一个对对象的弱引用，意味着对该对象进行观察，当对象被回收，观察者将立即得到一个反馈并执行回调函数，假设存在的话。另外并非所有对象都可以创建弱引用，可以创建弱引用的对象包括类实例、函数对象、实例方法、集合、冰冻集合、文件对象、生成器、类对象、sockets、数组、队列（deque）、正则表达式对象（regular expression pattern）以及code对象，而列表和字典是不能直接支持弱引用的：

1
2
3
4
5
6
>>> import weakref
>>> a=[1,2,3]
>>> wr=weakref.ref(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot create weak reference to 'list' object

通过子类化列表或字典可以增加这样的支持：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import weakref
class new_list(list):
    pass

def callback(ref):
    if ref is wr:
        print('列表对象[1,2,3]被回收')

a=new_list([1,2,3])
wr=weakref.ref(a,callback)
del a

'''OUTPUT
列表对象[1,2,3]被回收
'''

但是像元组和整型，即使子类化也不能支持弱引用。在上述示例中，通过weakref.ref()创建了一个弱引用对象，可以像调用函数那样调用它以获取被引用的对象（因为弱引用类实现了__call__()方法），称之为referent，如果referent不再存活，调用将返回None，因此如果你要测试一个referent是否存活，可以使用逻辑表达式ref() is not None（其中ref是一个弱引用对象）

简单介绍weakref模块的类或方法：

  • class weakref.ref(obj[, callback])（创建对对象的弱引用）
    参数obj是被弱引用的原始对象（被称为referent），callback是回调函数，当obj引用计数减为0被当作垃圾回收清理的时候，会自动调用该函数，且传入该弱引用作为唯一参数，可以创建多个弱引用，当referent被回收的时候，会根据弱引用创建的时间由近及远地逐个执行回调函数，假设定义了的话

    假设referent是可哈希的，弱引用对象也是可哈希的，即使referent被销毁，弱引用对象仍能维持其哈希值，但是如果你在referent被销毁之后才第一次计算弱引用对象的哈希值，将导致TypeError

    弱引用对象支持等值测试（==），但是不支持排序，不同弱引用之间的等值关系等同于各自对应的referent之间的等值关系（举个例子，假设有两个不同对象满足a==b，且wra是对a的弱引用，wrb是对b的弱引用，那么立即推，wra==wrb是成立的，若其中一方的referent被销毁，则不再相等），特别的，对同一对象所创建的不同弱引用总是等值的（创建弱引用时所传入的回调函数参数不影响等值测试的结果，但会影响is判断的结果），示例：

    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
    import weakref
    class A:
        def __init__(self,name):
            self.name=name
        def __hash__(self):
            return hash(self.name)
        def __eq__(self,another):
            if self.name==another.name:
                return True
            return False

    a=A('msy')
    b=A('msy')
    wra=weakref.ref(a)
    wrb=weakref.ref(b)
    print(a==b,wra==wrb)

    print(hash(wra))
    del b
    #print(hash(wrb)) #TypeError: weak object has gone away
    print(wra==wrb) #False

    def callback(ref):
        pass
    wra2=weakref.ref(a,callable)
    print(wra==wra2,wra is wra2) #True False
    wra3=weakref.ref(a)
    print(wra==wra2,wra is wra3) #True True

  • weakref.proxy(obj[, callback])（创建对对象的代理）
    代理对象是不可哈希的（无论referent可不可哈希），这阻止了将其用于字典的键，和weakref.ref()一样，支持回调，代理和弱引用的显著的区别是，1）要从弱引用获取referent，你需要使用()调用这个弱引用对象，但是代理不需要，使用代理对象就如同使用对象本身一样，2）当referent销毁后，弱引用调用会返回None，而访问代理则导致ReferenceError：

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

    a={1,2,3}
    wr=weakref.ref(a)

    def callback(ref):
        print('删除对象')

    proxy=weakref.proxy(a,callback)

    print(wr()) #{1, 2, 3}
    print(repr(proxy))
    print(proxy) #{1, 2, 3}

    proxy.add(4)
    print(proxy) #{1, 2, 3, 4}

    del a #对象a的引用计数降为0后，自动调用代理的回调函数，输出：删除对象

    print(wr()) #None
    print(proxy) #ReferenceError: weakly-referenced object no longer exists

  • weakref.getweakrefcount(obj)（返回对象obj的全部弱引用以及代理数量）

  • weakref.getweakrefs(obj)（返回对象obj的全部弱引用和代理对象，以列表返回）

  • class weakref.WeakMethod(method)（创建对绑定方法的弱引用）
    假设你有一个类实例a，f是实例方法，要对a.f创建弱引用，使用WeakMethod(a.f)即可，而标准弱引用对象构造办法（ref(a.f)()将返回None）无法做到这一点，因为a.f返回的是一个全新的“绑定了实例的方法”，其引用计数为0，如果一定要使用标准弱引用对象构造办法，只要将a.f赋给一个变量即可（使引用计数非0），因为WeakMethod是ref的子类，因此要获取被弱引用的原始绑定方法对象，也是通过()进行调用来获取：

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

    class A:
        def f(self):
            print('实例方法')
        
        @classmethod
        def cf(cls):
            print('类方法')
            
        @staticmethod
        def sf():
            print('静态方法')

    a=A()
    m1=weakref.WeakMethod(a.f) #替换成WeakMethod(a.cf)也可以，但是替换成WeakMethod(a.sf)不行，因为a.sf返回的是非绑定方法
    m1()()

    print(weakref.ref(a.f)()) #None
    t=a.f #替换成a.sf或a.cf都可以
    m2=weakref.ref(t)
    m2()()

  • class weakref.finalize(obj, func, *args, **kwargs)
    创建一个可通过()调用的finalizer对象（finalize类的__call__()方法体即是执行func(*args,**kwargs)），当referent对象obj的引用计数降为0时将自动触发调用，另外在程序结束时也总会调用这些finalizer对象（调用顺序和这些对象的创建顺序相反，对比ref(obj,callback)，程序结束时则不会调用callback()，除非在程序中手动执行del语句降低引用计数为0），除非其atexit属性被设置为False，finalizer一旦被调用一次将“死亡”，若调用一个死亡了的finalizer，将返回None（另请注意func、args和kwargs不能直接或间接对obj存在任何引用，否则会导致obj不能被回收，特别的，func不能是obj的实例绑定方法）：

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

    class A:
        pass

    def callback():
        print('回收')
        return 888

    a=A()
    t=weakref.finalize(a,callback)
    print(t())
    print(t()) #1、如果替换这两行为del a，输出结果一致，2、如果注释掉这两行，将先后输出"OVER"和"回收"
    print('OVER')

    '''OUTPUT
    回收
    888
    None
    OVER
    '''

    finalizer对象的属性、方法：

    • __call__()
      当finalizer对象存活时调用__call__()将返回func(*args,**kwargs)的结果，并在此之后宣判其死亡，当finalizer对象死亡时调用__call__()将返回None
    • detach()
      当finalizer对象存活时调用detach()将返回(obj, func, args, kwargs)元组，并在此之后宣判其死亡，当finalizer对象死亡时调用detach()将返回None
    • peek()
      同detach()，但是调用后不会导致finalizer对象死亡
    • alive
      判断finalizer对象是否存活
    • atexit
      一个可写的布尔属性，默认值为True，且只有atexit属性为True的finalizer对象才会被触发调用

  • weakref.ReferenceType（返回弱引用对象的类型<class 'weakref'>）

  • weakref.ProxyType（返回不可调用对象的弱代理的类型<class 'weakproxy'>）

  • weakref.CallableProxyType（返回可调用对象的弱代理的类型<class 'weakcallableproxy'>）

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

    s=set() #不可调用对象

    t1=weakref.proxy(s)
    print(type(t1))
    print(isinstance(t1,weakref.ProxyType))

    def f(): #可调用对象
        pass

    t2=weakref.proxy(f)
    print(type(t2))
    print(isinstance(t2,weakref.CallableProxyType))

    '''OUTPUT
    <class 'weakproxy'>
    True
    <class 'weakcallableproxy'>
    True
    '''

  • weakref.ProxyTypes（返回全部代理类型，即(<class 'weakproxy'>, <class 'weakcallableproxy'>)）

弱引用的主要用途是实现持有大量“大”对象（指占用内存大）的高速缓存或映射，以往由于对象作为高速缓存或映射的条目被引用，导致用户使用完后无法使用del将这些对象的引用计数降为0（只要高速缓存或映射还存在），从而浪费大量空间，为此weakref模块提供了WeakKeyDictionary和WeakValueDictionary用来解决该问题

  • class weakref.WeakKeyDictionary([dict])
    该字典中的键是弱引用的，当外部不存在对某键的强引用时，会自动删除字典中此键对应的条目，另外WeakKeyDictionary对象拥有一个额外的方法keyrefs()，其返回全部弱引用的键的列表
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    import weakref
    class A:
        pass

    d=weakref.WeakKeyDictionary()
    d[A()]=1
    print(list(d.keys())) #[] #弱字典中空无一物，原因在于"d[A()]=1"中的键"A()"的引用计数为0，它随即被删除

    a=A()
    d[a]=1 #键"a"存在外部引用：a=A()，其引用计数为1
    print(list(d.keys())) #[<__main__.A object at 0x000001FA6AB16EB8>]
    print(d[a]) #1
    del a #del使"a"的引用计数减1，变为0
    print(list(d.keys())) #[]
    #print(d[a]) #NameError: name 'a' is not defined
  • class weakref.WeakValueDictionary([dict])
    该字典中键的值是弱引用的，当外部不存在对某键值的强引用时，会自动删除此字典中该键值对应的条目，另外WeakValueDictionary对象拥有一个额外的方法valuerefs()，其返回全部弱引用的值的列表

除了“弱字典”，模块还提供了“弱集合”class weakref.WeakSet([elements])，当弱集合中的某个元素的引用计数降低为0时，将自动从弱集合中删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import weakref
class A:
    pass
s=weakref.WeakSet()
a=A()
b=A()
s.add(a)
s.add(b)
print(list(s))
del a
print(list(s))

'''OUTPUT
[<__main__.A object at 0x0000019127A1D588>, <__main__.A object at 0x0000019127A1D160>]
[<__main__.A object at 0x0000019127A1D588>]
'''

Python中无法为类声明私有类型的属性，声明私有类型的目的是阻止子类继承该属性，并且只能在类定义中访问私有属性，在类外任何地方都无法直接通过属性名访问它。一种变通是python内部会对类定义中所有以__双下划线开头且不超过一个下划线结尾（这样命名的属性就被认为是“私有属性”）的属性进行名字转换，具体的，在原始属性名前加上“_类名”，譬如：类Foo的“私有属性”__spam被替换为_Foo__spam，使得子类无法通过原始属性名访问它，python把这种技术叫做“name mangling”（属性名轧压机制），示例：

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
class A(object):
    def __init__(self):
        self.__private()
        self.public()
    def __private(self):
        print('A.__private()')
    def public(self):
        print('A.public()')

class B(A):
    # def __init__(self): #此处写不写都一样，因为没有实现__init__方法时，本就会自动调用父类的__init__方法
    #     super(B,self).__init__() #或者A.__init__(self)
    def __private(self):
        print('B.__private()')
    def public(self):
        print('B.public()')
        
a=A()
b=B()

'''OUTPUT
A.__private()
A.public()
A.__private()
B.public()
'''

输出倒数第二行为什么是A.__private()而不是B.__private()（上述示例既展示了python中“私有属性”的工作方式，也展示其愚蠢，为了纠正，应这样实现B的初始化函数：self.__private();self.public()，而不是偷懒直接调用父类的初始化函数），不急，先来看看属性名轧压机制是否真的工作了：

1
2
3
4
5
6
7
8
9
>>> a.__private()
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-2-cc12b64d1d3b> in <module>()
----> 1 a.__private()

AttributeError: 'A' object has no attribute '__private'
>>> a._A__private()
A.__private()

对象a确实访问不到原始的属性方法__private了，名字已经转变为_A__private，实际上解释器在遇到类定义语句时，会首先修改这些“私有”属性的名字，即在内存中的类定义如下（在类定义外动态绑定的双下划线属性名不会被轧压）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class A(object):
    def __init__(self):
        self._A__private() #修改1
        self.public()
    def _A__private(self): #修改2
        print('A.__private()')
    def public(self):
        print('A.public()')
        
class B(A):
    def _B__private(self): #修改3
        print('B.__private()')
    def public(self):
        print('B.public()')

现在可以回答上述问题了，当实例化B类时，会调用父类A类的初始化函数，并传入B类实例，记作b，于是在__init__()中将先后执行b._A__private()和b.public()，真相大白

另外经常遇到以_单下划线开头的变量名（实际上是以任何数量下划线开头的变量，仅习惯上以单下划线打头），如果位于模块级别，在from module import *时是无法导入的（可以预防错误，因为这种方式导入的变量很容易导致“覆盖”，即“命名空间污染”），如果要设置from module import *所允许导入的变量，可以使用__all__指定

__new__()是一个静态方法，通用的定义为__new__(cls,*args,**kwargs)（第一个参数cls表示要实例化的类，你总是需要手动传递它），其中*args和**kwargs接收的参数与传递给__init__()的参数相同，注意__new__()是唯一可以编写在创建实例之前执行的代码的地方，其必须有返回值，返回的是创建的实例对象，一般调用父类或object类的__new__()方法来创建，如果返回值不是当前类的实例那么__init__()函数将不会被调用

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
class A:
    def __new__(cls,*args,**kwargs): #__new__和__init__方法的参数除第一个参数(cls或self)外必须完全一致
        ret=super(A,cls).__new__(cls)
        print(f'Return of __new__(): {ret}')
        return ret
        
    def __init__(self,*args,**kwargs):
        print(f'Init A {self} with {args} and {kwargs}')
        pass
        
class B:
    def __new__(cls):
        return A.__new__(A) #事实上__new__方法可以生产非当前类的其他任意类的实例对象，这表示__new__方法拥有决定实例对象所属类型的绝对权力，但此时__init__方法则不再被自动调用
        
    def __init__(self):
        print('Init B')

a=A('Hello,','muggledy')
b=B()
print('-'*10)
b.__init__()

'''OUTPUT
Return of __new__(): <__main__.A object at 0x0000013B40CFB4A8>
Init A <__main__.A object at 0x0000013B40CFB4A8> with ('Hello,', 'muggledy') and {}
Return of __new__(): <__main__.A object at 0x0000013B40CFB518>
----------
Init A <__main__.A object at 0x0000013B40CFB518> with () and {}
'''

__new__方法可用于当你继承一些不可变的类型时（如int、str、tuple），提供给你一个自定义这些类的实例化过程的途径，譬如你要继承int类型实现一个永远为正数的整型，由于是不可变对象，显然你无法在实例创建之后（如__init__()中）进行任何修改：

1
2
3
4
5
6
class PositiveInteger(int):
    def __new__(cls,value):
        return super(PositiveInteger,cls).__new__(cls,abs(value))

i=PositiveInteger(-3)
print(i) #3

还可以用来实现“单例”，具体后面再说

所谓元类，就是创建类对象本身的类，我们在创建类实例的时候，是通过类名加括号（括号中是初始化参数）的方式，又知道“类的类”是type类型，可想而知类对象是通过type(...)形式创建的，现给定一个类定义，解释器究竟做了什么呢？譬如：

1
2
3
4
5
class Foo(object):
    ...
    def func(self):
        pass
    ...

解释器扫描完这一段内容后，可以得到类名class_name、继承的基类bases以及类主体class_body三个内容：

1
2
3
4
5
6
7
8
9
class_name='Foo'
bases=(object,)
class_body= \
'''\
...
def func(self):
    pass
...
'''

然后在局部空间class_dict={}中执行类主体：exec(class_body,globals(),class_dict)，最后使用默认元类也就是type类创建类对象：Foo=type(class_name,bases,class_dict)

除了使用默认的type类创建类对象，还可以继承type类，也就是自定义元类，通过重载__new__()或__init__()来进一步控制用户自定义类的定义内容（如果是修改类定义的话，应该在__new__()中类对象创建之前修改，如果是一些检查逻辑如类属性值是否合法等，则在类对象创建后再检查也不迟，即放在__init__()中），看个示例，已知有一个factory类，现要求其只能有三个属性，名称name、地址location以及业务business，其实就是添加一个类属性__slots__（注意类对象创建后，再添加类属性__slots__是没效果的，必须写在类定义中）：

1
2
3
4
5
6
7
8
9
10
11
class MyMetaCls(type): #自定义元类
    def __new__(cls,class_name,bases,class_dict):
        class_dict['__slots__']=['name','location','business']
        return type.__new__(cls,class_name,bases,class_dict)

class factory(metaclass=MyMetaCls):
    def __init__(self,name,location,business):
        self.name,self.location,self.business=name,location,business
    
f=factory(name='中石化',location='西北',business='中国能源供给')
f.xxx='xxx' #AttributeError: 'factory' object has no attribute 'xxx'

如上，要设置元类，只需要在基类元组中提供metaclass关键字参数，或者在类定义中指定__metaclass__属性。尽管使用元类可以显著改变用户定义的类的行为和语义，但在使用元类时，不应使类的工作方式和其文档描述相距甚远，这会使得用户对代码感到困惑

属性访问控制

在类定义中，所有方法默认都是在实例上操作的，特点是总是存在一个名为self（当然名称可以自定义）的位置参数，在通过实例访问这些方法属性时，譬如obj.method（obj是某一类实例，method是类中定义的普通实例方法），python会利用“特性”（特殊属性）机制来进行访问控制，事实上，用户得到的不是原始函数对象method，而是会得到所谓的“绑定方法”，绑定方法类似于偏函数（obj.method返回的相当于是partial(method,self=obj)），其中self参数已经填入，保存在绑定方法的执行环境中，但是其他参数仍需在调用该（绑定）方法时提供（其实你也可以通过类调用实例方法，不过这时候你就需要手动传入实例对象了，如cls.method(obj,...)，cls为obj的所属类，省略号省略了方法可能存在的其他参数），这种绑定方法是由在后台执行的特性函数静默创建的，你还可以手动指定其他两种特性函数分别用于创建静态方法和类方法，静态方法是一种普通函数，但是位于类定义的命名空间中，要定义静态方法，可使用@staticmethod装饰器，譬如：

1
2
3
4
class Foo:
    @staticmethod
    def add(x,y):
        return x+y

不同于实例方法，静态方法属性访问返回的就是原始的函数对象而非绑定方法，且既可以通过类也可以通过实例来调用静态方法。如果在编写类时需要采用很多不同的方式来创建新实例，而类中只能由一个__init__()方法，可以使用静态方法，替代的创建函数通常按如下形式定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import time
class Date:
    def __init__(self,year,month,day):
        self.year,self.month,self.day=year,month,day
        
    @staticmethod
    def now():
        t=time.localtime()
        return Date(t.tm_year,t.tm_mon,t.tm_mday)
        
    @staticmethod
    def tomorrow():
        t=time.localtime(time.time()+86400)
        return Date(t.tm_year,t.tm_mon,t.tm_mday)
        
    def __str__(self):
        return f'{self.year}-{self.month}-{self.day}'
        
print(Date(1967,4,9)) #1967-4-9
print(Date.now()) #2021-5-18
print(Date.tomorrow()) #2021-5-19

类方法是将类本身作为对象进行操作的方法，类方法使用@classmethod装饰器，与实例方法不同在于，类方法定义的第一个参数通常命名为cls，且将类本身作为第一个参数进行传递，譬如：

1
2
3
4
5
6
7
8
9
10
class Times:
    factor=1
    @classmethod
    def mul(cls,x):
        return cls.factor*x
        
class TwoTimes(Times):
    factor=2
    
print(TwoTimes.mul(4)) #8

类似于实例方法的属性访问，类方法属性访问同样返回绑定方法，因此上述示例中TwoTimes.mul返回的相当于partial(mul,cls=TwoTimes)，且类方法也能通过实例调用，譬如t=TwoTimes();t.mul(4)，其中t.mul返回的相当于partial(mul,cls=t.__class__)

在之前的Date类示例中我们使用静态方法实现多个创建函数，假设有一个子类EuroDate继承它以输出欧洲日期格式，但是你会发现结果不符合预期：

1
2
3
4
5
class EuroDate(Date):
    def __str__(self):
        return f'{self.day:02d}/{self.month:02d}/{self.year}'

print(EuroDate.now()) #2021-5-18

输出之所以还是旧格式，这是因为EuroDate.now()返回的是一个Date对象，应采用类方法实现创建函数来避免该错误：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import time
class Date:
    def __init__(self,year,month,day):
        self.year,self.month,self.day=year,month,day
        
    @classmethod
    def now(cls):
        t=time.localtime()
        return cls(t.tm_year,t.tm_mon,t.tm_mday)
        
    @classmethod
    def tomorrow(cls):
        t=time.localtime(time.time()+86400)
        return cls(t.tm_year,t.tm_mon,t.tm_mday)
        
    def __str__(self):
        return f'{self.year}-{self.month}-{self.day}'
        
class EuroDate(Date):
    def __str__(self):
        return f'{self.day:02d}/{self.month:02d}/{self.year}'
        
print(EuroDate.now()) #18/05/2021

通常，访问实例或类属性时，会返回所存储的相关值，由@property特性支持的属性，可以在访问时经过计算得到返回值，譬如：

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

class Circle:
    def __init__(self,radius):
        self.radius=radius
    
    @property
    def area(self):
        return math.pi*self.radius**2
        
    @property
    def perimeter(self):
        return 2*math.pi*self.radius
        
c=Circle(4)
print(f'半径：{c.radius}，周长：{c.perimeter}，面积：{c.area}') #半径：4，周长：25.132741228718345，面积：50.26548245743669
#c.area=8 #AttributeError: can't set attribute #当前area“属性”仅仅是只读的，除非设置setter方法，具体见下

上述示例中，计算面积的area()实例方法和计算周长的perimeter()实例方法，通过装饰器@property修饰后，支持以简单属性的形式访问（不需要加()调用），用户很难发现正在“计算”一个属性，除非在试图重新定义该属性时生成了错误消息（AttributeError异常），这种特性使用方式遵循所谓的统一访问原则，你不需要费力了解何时添加额外的()所带来的不必要的混淆

事实上，该特性还可以拦截操作，以设置和删除属性，这是通过向特性附加setter和deleter操作来实现的，譬如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class student:
    def __init__(self,name):
        self.name=name
        
    @property
    def score(self):
        return self.__score #将值实际存储在其他名称中，通常是在加两个下划线前缀，即“私有属性”中，但是注意“私有属性”其实也直接暴露在外，而且易于辨识，你可以通过访问实例的__dict__看到它，可以定义__slots__来禁用__dict__，但是你依旧无法阻止通过setattr(...)的方式进行非法赋值
        
    @score.setter
    def score(self,score):
        if score>=0 and score<=100:
            self.__score=score
        else:
            raise ValueError('score must between 0 ~ 100!')

s=student('zj')
s.score=99 #如果设置的数值大于100，将导致错误，因为我们利用特性进行了相关的访问控制
print(s.name,s.score) #zj 99

print(s.__dict__) #{'name': 'zj', '_student__score': 99}

s.__sex='female' #只有在类定义中绑定的以双下划线打头的实例属性被认为是“私有属性”并被倾轧，在类定义外动态绑定的则不会被认为是私有属性，也不会被倾轧
print(s.__dict__) #{'name': 'zj', '_student__score': 99, '__sex': 'female'}

在上述示例中，首先使用@property装饰器将相关方法score()转变成了只读属性，后面的@score.setter装饰器将其他方法与score属性上的设置操作相关联，这个“其他方法”的名称应该与原始特性的名称完全匹配

使用@property特性后，对属性的访问将由一系列用户定义的get、set和delete函数控制，这种属性控制方式可以由“描述符”进一步推广，描述符就是一个表示属性值的对象，凡是实现__get__()、__set__()和__delete__()方法的就是描述符，注意描述符只能在类级别上进行实例化，当你通过实例访问一个描述符对象时，会自动调用描述符的__get__()、__set__()或__delete__()，并总是传入实例作为参数之一

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
class movie(object):
    def __init__(self,title,score,ratings):
        self.title=title
        self.score=score
        self.ratings=ratings
        
    @property
    def score(self):
        return self._score
        
    @score.setter
    def score(self,newValue):
        if newValue<0 or newValue>10:
            raise ValueError("movie's score can't be negative or greater than 10")
        else:
            self._score=newValue
            
    @property
    def ratings(self):
        return self._ratings
        
    @ratings.setter
    def ratings(self,newValue):
        if newValue<0 or newValue>10:
            raise ValueError("movie's ratings can't be negative or greater than 10")
        else:
            self._ratings=newValue
            
m=movie('后天',7.5,3)

上述示例中定义了一个通过@property进行属性访问控制的电影类，可以看到score和ratings两个属性拥有相同的访问控制，从而导致上述代码有较高的重复率，而描述符的访问控制可以被多个属性重复利用，需要注意的是你总是应该通过实例而非类名访问描述符，示例如下：

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
from weakref import WeakKeyDictionary

class descriptor:
    def __init__(self,default):
        self.default=default
        self.data=WeakKeyDictionary() #由于描述符是定义在类层级的，因此对于类的所有实例都是可访问的，所以我们定义一个字典，存储类的所有实例及其属性值
        
    def __get__(self,instance,owner): #在访问movie实例m的score属性时，会被解释器解释为m.__class__.score.__get__(m,m.__class__)
        #print(owner) #<class '__main__.movie'>
        if instance==None: #如果通过类访问描述符，传入的实例将为None，此时返回描述符对象本身，该操作是通用操作，该设置允许我们能够获取到在类层级定义的描述符对象本身
            return self
        return self.data.get(instance,self.default)
        
    def __set__(self,instance,value):
        if value<0 or value>10:
            raise ValueError("movie's score or ratings can't be negative or greater than 10")
        self.data[instance]=value
        
class movie:
    score=descriptor(0)
    ratings=descriptor(0)
    
    def __init__(self,title,score,ratings):
        self.title=title
        self.score=score #注意千万不能通过类名访问描述符对象，譬如movie.score=score，这将导致类的score属性从一个描述符对象转变为一个数值对象，因为这不会触发调用描述符的__set__()方法，不过print(movie.score)还是会触发调用描述符的__get__()方法的，只是此时传入__get__()的instance实例对象是None
        self.ratings=ratings

m1=movie('后天',7.5,3)
print(m1.score,m1.ratings) #7.5 3
#m2=movie('后天',7.5,-3) #ValueError: movie's score or ratings can't be negative or greater than 10

#m1.score=-1 #ValueError: movie's score or ratings can't be negative or greater than 10
movie.score.data[m1]=-1 #在这种基于“实例-属性值”字典实现的描述符下其实你还是可以绕过描述符的访问控制实现非法赋值
print(m1.score) #-1

当访问实例属性的时候，obj.x总是调用__getattribute__()方法（因此你也可以通过重载__getattributr__()进行最简单的属性访问控制，在这种情况下，不要忘记调用父类的__getattributr__()方法以防属性查找失败，所以不太建议这么做），其行为是，1）检查类中是否有同名的数据描述符对象，如果有，则自动变形为obj.__class__.__dict__['x'].__get__(obj,obj.__class__)，否则，2）检查实例字典，即在实例的__dict__中查找，找到则返回，否则，3）检查类字典，即在obj.__class__.__dict__中查找，找到则返回，如果是同名的非数据描述符，则还会自动变形，否则，4）按照MRO顺序依次检查基类字典，如果还找不到，则检查obj所在类是否定义了__getattr__()方法，有则返回__getattr__()的调用结果，否则抛出AttributeError

当访问实例属性并进行赋值的时候，obj.x=value总是调用__setattr__()方法，其行为是，1）如果类中有同名的数据描述符对象，则自动变形为obj.__class__.__dict__['x'].__set__(obj,value)，否则，2）在实例的字典__dict__中查找，有则修改相应的键值，没有则将属性x直接绑定在实例上，即__dict__.update({'x':value})（del obj.x语句将触发调用__delattr__()方法，和obj.x=value触发调用__setattr__()类似，只不过其默认行为是删除obj的__dict__中存储的键值，除非请求的属性正好是一个描述符对象，此时将会执行obj.__class__.__dict__['x'].__delete__(obj)，如果实例字典中没有该属性，则抛出AttributeError）

注：实现了__set__()和__get__()方法的描述符类被称为数据描述符，如果只实现了__get__()方法，则称为非数据描述符

上面的描述符示例中采用字典存储所有的实例和属性值，但如果实例是不可哈希对象呢，为此我们还可以直接将属性值绑定到实例（的__dict__）上面：

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
class descriptor:
    def __init__(self,label,default):
        self.label=label
        self.default=default
        
    def __get__(self,instance,owner):
        if instance==None:
            return self
        return instance.__dict__.get(self.label,self.default)
        
    def __set__(self,instance,value):
        if value<0 or value>10:
            raise ValueError("movie's score or ratings can't be negative or greater than 10")
        instance.__dict__[self.label]=value

class movie:
    score=descriptor('score',0) #不同名也行，但这就重蹈@property的覆辙了，譬如名称改为'_score'，此时通过“obj.score=非法值”自然会受到访问控制，但是“obj._score=非法值”则不受保护
    ratings=descriptor('ratings',0)
    
    def __init__(self,title,score,ratings):
        self.title=title
        self.score=score
        self.ratings=ratings

m1=movie('后天',7.5,3)
print(m1.score,m1.ratings) #7.5 3
try:
    m1.score=-10
except Exception as e:
    print(e)
    
print(m1.__dict__) #{'title': '后天', 'score': 7.5, 'ratings': 3}

m1.__dict__['score']=-1000 #在这种情况下你可以通过直接修改实例字典来绕过描述符的访问控制，唉，有完美的解决方案吗
print(m1.score) #-1000

上述在类层级定义描述符的时候需要手动传入属性名称字符串，score=descriptor('score',0)，这不太方便，为了隐藏该细节，可以借助元类，使得定义变回score=descriptor(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
class descriptor:
    def __init__(self,default,label=None): #此处参数定义要稍稍修改
        self.label=label
        self.default=default
        
    def __get__(self,instance,owner):
        if instance==None:
            return self
        return instance.__dict__.get(self.label,self.default)
        
    def __set__(self,instance,value):
        if value<0 or value>10:
            raise ValueError("movie's score or ratings can't be negative or greater than 10")
        instance.__dict__[self.label]=value
        
    def __delete__(self,instance): #__delete__()不太常用，主要用来使实例（描述符）属性不可删除，但是你不能在__del__()方法中通过抛出异常阻止对象的删除
        raise AttributeError('Can\'t delete this attribute!')

class addLabelMeta(type):
    def __new__(cls,name,bases,local_dict):
        for k,v in local_dict.items():
            if isinstance(v,descriptor):
                v.label=k
        return super(cls,cls).__new__(cls,name,bases,local_dict)

class movie(metaclass=addLabelMeta):
    score=descriptor(0)
    ratings=descriptor(0)
    
    def __init__(self,title,score,ratings):
        self.title=title
        self.score=score
        self.ratings=ratings

m1=movie('后天',7.5,3)
print(m1.score,m1.ratings) #7.5 3
try:
    m1.score=-10
except Exception as e:
    print(e)
    
print(m1.__dict__) #{'title': '后天', 'score': 7.5, 'ratings': 3}

try:
    del m1.score
except Exception as e:
    print(e)
    
print(m1.score) #7.5

未完待续…

[1] Python参考手册 第4版 修订版 [美] 大卫·M.比兹利（David M.Beazley）著，谢俊，杨越，高伟 译
[2] 绑定方法与非绑定方法

]]> 计算机基础 编程语言 Python Python基础 - 程序结构与函数编程 posts/176/

📚 文档目录
🎃 类型和对象 - 🎈 程序结构与函数编程 - 🎏 面向对象编程

程序结构与执行

Python程序由一些语句序列组成，这些语句包括变量赋值、函数定义、类和模块导入等，加载源文件时，解释器始终顺序执行每条语句，直到再无语句可以执行，这种执行模式同样适用于作为主程序运行的文件和通过import加载的库文件

条件语句可由if以及可省的elif、else子句构成

在一些编程语言中存在switch语句，譬如C语言中实现成绩等级判断：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
int main(){
  int a;
  printf("Input your score:");
  scanf("%d",&a);
  switch(a/10){
    case 10:
    case 9: printf("\nA"); break;
    case 8: printf("\nB"); break;
    case 7: printf("\nC"); break;
    default:printf("\nD");
  }
  return 0;
}

Python中没有switch关键字，可以通过以下方式替代实现：

  1. 利用字典实现：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    switch={
        10: 'A', #此处需重复定义内容
         9: 'A',
         8: 'B',
         7: 'C',
    }

    a=input('Input your score:')
    print(switch.get(int(int(a)/10),'D'))
  2. 创建一个switch类来处理程序的流转：
    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
    class switch:
        def __init__(self,value):
            self.value=value
            self.fall=False #如果case匹配，且没有break，则置为True，表示继续向下执行，且不论下面的case是否匹配
        
        def __iter__(self):
            yield self.match #由于yield关键字，__iter__()方法变成一个生成器方法，当调用该方法时将返回一个生成器对象（而生成器又是迭代器，因此switch类实例是一个可迭代对象），此时__iter__()内部实际还未执行，直到调用生成器对象的__next__()方法，返回match函数对象
            
        def match(self,*args): #args只允许接收0或1个参数
            if self.fall or not args: #如果fall为True，则返回True表示继续执行当前的case子句，或当前case子句没有匹配参数，则表示为default默认分支（请将default放在最后一行，但并无代码严格检查，此代码仅为demo展示）
                return True
            elif args[0]==self.value: #匹配成功
                self.fall=True
                return True
            else: #匹配失败
                return False
            
    score=96
    for case in switch(score//10): #这个for只迭代一次，case循环变量指向的就是match()函数对象
        if case(10):
            pass
        if case(9):
            print('A')
            break
        if case(8):
            print('B')
            break
        if case(7):
            print('C')
            break
        if case(): #default分支
            print('D')

不过实在没必要，特别是上述第二种方式，过于词不达意，这种for循环的写法就很迷，但是好像也找不到更好的写法

可以使用while（满足条件时不断循环直至条件不再满足）或for（遍历可迭代对象）实现循环，一般推荐使用for循环，如果想在迭代过程中同时获取下标索引，可以将可迭代对象iterable替换成enumerate(iterable)，其等同于zip(range(len(iterable)),iterable)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a=10
while (a>0): #while expression等同于while(expression)，即加不加括号都一样，expression表达式所得也是一个python对象嘛，而(obj)就并未变成一个元组对象，它仍是obj对象本身，有obj is (obj)成立，除非写成(obj,)，这才变成了一个长度为1的元组对象。括号常用于表达式中，用于界定不同运算的优先级别，最内层的括号中的子表达式最先运算，譬如：((a+b)*c)-2
    a-=1
    print(a)
print() #输出一个空行

i=888
for i in range(10):
    print(i)
print(f'i:{i}') #注意输出的是i:9，因为迭代变量（i）的作用域并非for语句私有，即如果前面已经定义过一个相同名称的变量，它的值将被改写

#迭代过程中同时获取下标索引
a='muggledy'
for index,element in enumerate(a):
    print(index,element)

注（for-else语句）：else语句会在for循环结束之后执行，除非循环过程中遇到break（或者遇到其他意外如抛出异常，当然也不会执行到else语句），特别地，如果循环根本就没有开始（可迭代序列长度为0时），也会执行else语句，一般来说，else语句可以用于编写循环正常结束时的某些后续操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
for i in range(4):
    pass
else:
    print('demo1: for循环全部遍历结束')

for i in []:
    pass
else:
    print('demo2: for循环全部遍历结束')

for i in range(4):
    if i==2:
        break
else:
    print('demo3: for循环全部遍历结束')
    
'''OUTPUT
demo1: for循环全部遍历结束
demo2: for循环全部遍历结束
'''

异常会中断正常的程序执行流，可以使用raise exception([value])来手动抛出异常（exception是异常类型，内置异常类型请查阅文献[1]-p70，value是一个与指定异常相关的可选参数，通常是一条自定义的错误消息，如果raise语句不带任何参数，则将会重复引发最近一次出现的异常，如果最近没有出现异常，则抛出运行时异常RuntimeError: No active exception to reraise），使用try-except（能够嵌套使用）可以捕捉异常，except语句中用于编写异常处理程序，其还有一个可选的修饰符as var，可以将捕捉到的异常实例赋给变量var，另外可以在一个try块后跟随多个except块以捕捉多种不同类型的异常，当然也可以在一个except中同时捕捉，这时你可以在except语句块内使用isinstance进行异常类型判断，示例：

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
#示例1
try:
    raise
except: #不带任何异常类型时将捕捉所有异常，也可以捕捉指定类型异常：except RuntimeError:
    print('出现异常！')

#示例2
try:
    raise RuntimeError('运行错误啦！')
except Exception as e: #将异常实例赋值给变量e（Exception是所有非退出异常类型的基类，这样你就可以捕捉任意派生自Exception的异常类型）
    print('异常:',e)
    
#示例3（示例3和示例4都是不可执行的伪代码）
try:
    do something may cause IOError, TypeError or NameError...
except IOError as e:
    process IOError...
except TypeError as e:
    process TypeError...
except NameError as e:
    process NameError...
    
#示例4（示例3的另一种写法）
try:
    do something may cause IOError, TypeError or NameError...
except (IOError,TypeError,NameError) as e: #注意括号不可省略
    if isinstance(e,IOError):
        process IOError...
    elif isinstance(e,TypeError):
        process TypeError...
    else isinstance(e,NameError):
        process NameError...

try-except支持else子句（可省），但必须跟随在最后一个except子句后，如果try块中的内容并未引发异常，就会执行else子句中的代码（除非try块直接return返回了）。try-except还支持finally子句（可省），其必须写在最最后，无论try是否出现异常都会执行finally块中的内容（即使在try块、except块或else块中遇到return，也会执行finally块），且在except或else之后执行

1
2
3
4
5
6
7
8
9
10
11
12
13
try:
    f=open('foo.txt','r')
except IOError as e:
    print(f'Fail to open!({e})')
else:
    print('Open successfully!')
finally: #如果文件打开（f存在）则关闭之，否则什么也不做
    try:
        f.close()
    except:
        pass
        
#小结：try-except是基本的异常捕获流程，else和finally则都是可选的，一般的执行顺序是：首先执行try中语句，如果没有异常，则跳转到else块，最后是finally块；如果try块中存在异常，则由except捕获异常，最后进入finally块

关于异常捕捉中return返回值的问题，试想，如果try块中存在return语句，通常我们认为函数遇到return会立即返回，确实如此吗？如果存在finally块，那么其中的代码还会执行吗？具体看下面的例子：

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
100
101
102
103
104
105
106
107
108
109
110
111
#try-except-finally结构
#示例1
def f(a):
    try:
        return a+1 #首先计算表达式a+1的值然后保存下来，暂不return，转而执行finally块，（由于finally中没有遇到return，于是）结束后会回到此处，return之前保存的表达式值
    except:
        return a-1
    finally:
        a+=4
        print(f'a={a}')
        
print(f(1))

'''OUTPUT
a=5
2
'''

#示例2
def f(a):
    try:
        return a/0 #出现除0异常，显然此return永远也不会执行，直接进入except块
    except:
        return a-1 #计算表达式a-1的值，然后先保存下来，继续执行finally中的代码，（由于finally中没有遇到return，于是）结束后回到此处，return之前保存的表达式值
    finally:
        a+=4
        print(f'a={a}')
        
print(f(1))

'''OUTPUT
a=5
0
'''

#示例3
def f(a):
    try:
        return a+1 #首先计算表达式a+1的值然后保存下来，暂不return，转而执行finally块
    except:
        return a-1
    finally:
        a+=4
        print(f'a={a}')
        return a #在finally中遇到return，那就不管了，函数直接返回，OVER
        
print(f(1))

'''OUTPUT
a=5
5
'''

#try-except-else-finally结构
#示例4
def f(a):
    try:
        return a+1 #首先计算表达式a+1的值然后保存下来，暂不return，但因为return的存在，虽然没有异常也不会执行else块，但是finally必须执行，（由于finally中没有遇到return，于是）结束后仍回到此处，return之前保存下来的a+1的值，OVER
    except:
        return a-1
    else:
        return a+2
    finally:
        a+=4
        print(f'a={a}')
        
print(f(1))

'''OUTPUT
a=5
2
'''

#示例5
def f(a):
    try:
        a+1
    except:
        return a-1
    else:
        return a+2 #try中没有异常和return，于是执行else块，首先保存下表达式a+2的值，然后进入finally，（由于finally中没有遇到return，于是）结束后仍回到此处，return之前保存下来的值，OVER
    finally:
        a+=4
        print(f'a={a}')
        
print(f(1))

'''OUTPUT
a=5
3
'''

#示例6
def f(a):
    try:
        a+1
    except:
        return a-1
    else:
        return a+2 #try中没有异常和return，于是跳转到else块，（由于finally的存在）首先保存下表达式a+2的值，然后进入finally
    finally:
        a+=4
        print(f'a={a}')
        return a #finally中有return，于是不会再回到else块中的return位置处，此时函数直接返回，OVER
        
print(f(1))

'''OUTPUT
a=5
5
'''

要自定义异常类型，需继承Exception基类，引发异常时传递的参数即是__init__()构造函数的参数，可以重载__str__()方法，以自定义异常输出的错误消息，示例：

1
2
3
4
5
6
7
8
9
10
11
class myException(Exception):
    def __init__(self,*args): #可以接收n个（任意个）错误信息
        self.args=args
        
    def __str__(self):
        return f"myException: {','.join(map(lambda i:str(i),self.args))}"
        
try:
    raise myException('错误信息1','错误信息2',8848)
except myException as e:
    print(e)

正确地管理各种资源（如文件句柄的获取与关闭、互斥锁的获取与释放和数据库的连接与断开等），在涉及异常时通常都比较棘手，异常的引发很可能导致控制流跳过负责释放某些关键资源的语句，with语句支持在由上下文管理器对象控制的运行时上下文中执行一系列语句，譬如：

1
2
3
4
5
6
#此种写法可以确保文件资源被安全释放
with open('debuglog.txt','a') as f:
    f.write('Debugging\n')
    ...
    f.write('Done\n')
#在控制流离开with语句块时会自动执行文件关闭的操作，不论with语句块中是否引发异常

with obj语句在控制流进入和离开其后的相关代码块时，允许（上下文管理器）对象obj管理所发生的的事情，执行with obj语句时，将执行obj.__enter__()来指示进入一个新的上下文，当控制流离开该上下文时，就会执行obj.__exit__(type,value,traceback)，如果没有引发异常，__exit__()方法的三个参数均被设为None，否则，它们将包含导致控制流离开上下文的异常相关的类型、值和跟踪信息，__exit__()方法返回True或False，用于指示被引发的异常是否得到处理，如果返回False，引发的任何异常都将被继续向外抛出。with obj语句接受一个可选的as var修饰符，此时obj.__enter__()方法的返回值将被赋给变量var

自定义一个上下文管理器的伪代码示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class contextor: #类实现的“上下文管理器”
    def __init__(self,*args,**kwargs):
        #初始化上下文管理器
        ...
    
    def __enter__(self):
        #可以是获取资源等操作
        ...
        return something #返回值将赋给with的as从句所定义的变量var
        
    def __exit__(self, type, value, traceback):
        #可以是释放资源等操作
        ...
        return True or False #是否向with语句块外抛出异常

with contextor(*args,**kwargs) as var:
    #with语句块
    ...

还有一种定义上下文管理器的方式，借助contextlib模块的contextmanager装饰器实现，伪代码示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from contextlib import contextmanager

@contextmanager
def contextor(*args,**kwargs): #函数版本的“上下文管理器”
    #语句块1
    ...
    try:
        yield expression
    except:
        #捕捉with语句块内可能发生的异常，如果不捕捉，将被抛给with的外层，这也意味着语句块2（等同于上下文管理器的__exit__()方法代码）不会执行，这与上下文管理器的精神相违背（即不论with语句块内是否引发异常，__exit__()方法都会执行），因此一般都要在yield位置捕捉可能的异常
        #2023.5.2 update: 由于支持try...finally写法，因此可以选择外抛异常同时确保语句块2的执行，即将语句块2写在finally中
        ...
    #语句块2
    ...
    
with contextor(*args,**kwargs) as var:
    #with语句块
    ...

contextmanager装饰器的原理很简单，其实现依赖于一个名为_GeneratorContextManager的类，这是一个定义了__enter__()和__exit__()方法的上下文管理器类型，而被装饰的函数contextor是一个生成器函数，根据装饰器原理有contextor=contextmanager(contextor)，返回的是一个闭包函数对象，其包含有一个指向真实contextor函数地址的变量，姑且记作func，当你调用contextor(*args,**kwargs)时将使用args、kwargs和func来初始化构造一个_GeneratorContextManager类实例，姑且记作c，具体的，在其初始化函数__init__()中会执行func(*args,**keargs)得到一个生成器对象，并保存为实例属性，姑且记作c.g，配合with使用时（with contextor(*args,**kwargs) as var），将自动调用c的__enter__()方法，而__enter__()的实现即是执行return c.g.__next__()，换句话说，上述生成器函数中yield之前的语句块1将作为上下文管理器的__enter__()方法定义，且yield表达式值将赋给变量var，当离开with语句块，将自动调用c的__exit__()方法，而__exit__()的实现即是再一次调用c.g.__next__()，换句话说，yield之后的语句块2将作为上下文管理器的__exit__()方法定义，另外，由于with语句块内部可能引发异常，异常将被c的__exit__()方法接收，默认下c.__exit__()返回False，即异常将被抛给with的外层，如果你不想抛出异常，则需要在上述生成器函数的yield位置处捕捉，因为c.__exit__()中会在存在异常的情况下，调用生成器对象的throw()方法，具体的，执行c.g.throw(type,value,traceback)，该方法会在yield位置处抛出参数所指异常，如果你手动捕捉了异常，程序会继续向下执行一次生成器的next()方法，即执行语句块2，否则意味着用户定义的上下文管理器的退出方法不会被调用，这一点千万注意。不管何种情况，我们总是应该将语句块2写在finally中，并通过是否写except来决定是否将异常抛到with语句块外

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
#示例1（来自文献[1]-p73）
class ListTransaction:
    def __init__(self,thelist):
        self.thelist=thelist
        
    def __enter__(self):
        self.workingcopy=list(self.thelist)
        return self.workingcopy
        
    def __exit__(self,type,value,tb):
        if type is None:
            self.thelist[:]=self.workingcopy
        return True #返回True，避免with语句块内的异常继续向上抛给外层
        
items=[1,2,3]
with ListTransaction(items) as working:
    working.append(6)
    working.append(7)
    #raise ValueError('xxx')
print(items) #[1, 2, 3, 6, 7]，如果上一行注释取消，则输出[1, 2, 3]

#示例2
from contextlib import contextmanager
@contextmanager
def ListTransaction(thelist):
    workingcopy=list(thelist)
    try:
        yield workingcopy
    except ValueError as e:
        print(e)
    thelist[:]=workingcopy
    
items=[1,2,3]
with ListTransaction(items) as working:
    working.append(6)
    working.append(7)
    raise ValueError('xxx')
print(items)
'''OUTPUT
xxx
[1, 2, 3, 6, 7]
'''

#示例3
from contextlib import contextmanager
@contextmanager
def ListTransaction(thelist):
    workingcopy=list(thelist)
    yield workingcopy #对比示例2，如果不在yield位置处捕捉异常，当with语句块中引发异常时候，yield后面的代码将不会被执行（该部分代码是作为上下文管理器的__exit__()方法定义）
    thelist[:]=workingcopy
    
items=[1,2,3]
try:
    with ListTransaction(items) as working:
        working.append(6)
        working.append(7)
        raise ValueError('xxx')
except ValueError as e:
    print(e)
print(items)

'''OUTPUT
xxx
[1, 2, 3]
'''

#示例4（2023.5.2 update）
from contextlib import contextmanager
@contextmanager
def ListTransaction(thelist):
    workingcopy=list(thelist)
    try:
        yield workingcopy #对比示例3，虽然没有except捕捉异常，但是finally确保了thelist[:]=workingcopy的执行
    finally:
        thelist[:]=workingcopy

items=[1,2,3]
try:
    with ListTransaction(items) as working:
        working.append(6)
        working.append(7)
        raise ValueError('xxx')
except ValueError as e:
    print(e)
print(items)
'''OUTPUT
xxx
[1, 2, 3, 6, 7]
'''

一般格式为assert expression[, msg]，其中expression为False时，将触发AssertionError异常，msg是可选的自定义错误消息，注意assert不应用于必须执行以确保程序正确的代码，因为如果python运行在最优模式（通过对解释器使用-O选项进入该模式），断言语句将不会执行，那么何时使用assert呢？assert语句用于检查应该始终为真的内容

函数式编程

函数定义使用def关键字（另外可以使用lambda关键字创建表达式形式的匿名函数，形如lambda *args, **kwargs : expression），通常函数的第一条语句会使用文档字符串来描述函数的用途，可以在查看函数帮助时获取到该文档（help(func)），譬如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def f():
    '''This is a demo.
       Author: muggledy
    '''
    pass

print(help(f))

'''OUTPUT
Help on function f in module __main__:

f()
    This is a demo.
    Author: muggledy
'''

函数作为对象也具有属性，譬如上述文档字符串就存储于函数对象的__doc__属性中，函数名存储在__name__属性中，事实上，可以给函数对象绑定任意属性，这些新增属性保存在函数对象的__dict__属性中，要查看对象的所有属性，则使用dir(obj)函数，或者通过getattr(obj,attr)获取对象的指定属性（另hasattr(obj,attr)检查对象是否具有名为attr的属性，setattr(obj,attr,value)为对象设置属性），函数都是可调用的（callable(func)返回True）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> class A: pass
...
>>> a=A()
>>> setattr(a,'can\'t be touched','zj') #setattr()相当逆天，你可以通过该方法为对象设置一些不能够通过属性访问符.号访问的属性
>>> a.__dict__
{"can't be touched": 'zj'}
>>> a.can't be touched
  File "<stdin>", line 1
    a.can't be touched
                     ^
SyntaxError: EOL while scanning string literal
>>> getattr(a,'can\'t be touched')
'zj'
>>> hasattr(a,'can\'t be touched')
True

要调用函数，只要使用函数名加上用圆括号括起来的参数即可（函数名和括号之间允许有空格），python中函数传参的形式主要有五种，分别为位置传递、关键字传递、默认传递、包裹传递和解包裹传递（后两种在前一章节已经说过了，就不重复了），看示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#位置传递
def f1(x,y,z):
    print(f'{x}+{y}+{z}={x+y+z}')
    
f1(1,2,3) #1+2+3=6 #即不具名传递，仅凭位置上的一一对应

#关键字传递
f1(4,z=6,y=5) #给所传递的参数值具名的一种传递方式，明确告诉某一参数值是交由函数的哪一个参数变量接收的，如此我们就不需要按照位置参数的固定位置序号排列，可以在函数定义中定义命名关键字参数或者可变字典参数，这两种参数都必须以键值对形式传递，见后

#默认传递
def f2(x,y,z=6):
    print(f'{x}+{y}+{z}={x+y+z}')
    
f2(2,3) #默认参数传递即隐式传递，具有默认值的参数在函数调用时可以不明确给出

若按照参数类型划分，则可分为位置参数、默认参数、可变参数和命名关键字参数，其中默认参数又分为默认位置参数和默认关键字参数（且只有命名关键字参数可以有默认值，其他关键字参数没有或者说没法设置默认值），可变（长）参数又分为可变元组参数和可变关键字参数（或可变字典参数），这里只单说一下“命名关键字参数”，函数参数定义中位于*或*args（可变元组参数）之后以及可变关键字参数之前（假设存在的话）的就是命名关键字参数，在调用时其必须具名传递，命名关键字参数可以有默认值，也可以没有，譬如：

1
2
3
4
def f3(x,*,y=1,z): #x为位置参数，y和z是命名关键字参数，前者有默认值
    print(x,y,z)

f3(1,z=3) #如果调用f3(1,1,3)将报错TypeError: f3() takes 1 positional argument but 3 were given

不同类型参数的组合使用（定义和调用时注意顺序，基本原则是，位置参数在前，关键字参数在后）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#示例1
def f(a,b,c=3,*args): #位置参数+带默认值的位置参数+可变元组参数
    print(a,b,c,*args)
    
f(1,2,c=3) #1 2 3
f(a=1,b=2,c=3) #1 2 3
#f(a=3,b=2,c=1,0) #SyntaxError: positional argument follows keyword argument
f(1,2,3,4,5,6,7) #1 2 3 4 5 6 7

#示例2
def f(a,b,*,x,y,**kwargs): #位置参数+命名关键字参数+可变字典参数
    print(a,b,x,y,kwargs)
    
f(1,2,x=3,y=4,z=5) #1 2 3 4 {'z': 5}
#f(1,2,x=3,z=4) #TypeError: f() missing 1 required keyword-only argument: 'y'

#示例3
def f(a,b,c=3,*args,x=4,y,**kwargs): #最全组合：位置参数+带默认值的位置参数+可变元组参数+（带默认值的，可带可不带）命名关键字参数+可变关键字参数
    print(a,b,c,args,x,y,kwargs)
    
f(1,2,4,3,x=5,y=6,z=7) #1 2 4 (3,) 5 6 {'z': 7}
f(1,2,4,3,y=6,z=7) #1 2 4 (3,) 4 6 {'z': 7}
#f(b=2,a=1,3,4,y=6,x=5,z=7) #SyntaxError: positional argument follows keyword argument

在编程时，尽量避免传递可变对象（如列表、字典等），因为在函数内部对可变对象的修改将反映在原始对象中，若无法避免，则应在函数中使用可变对象的拷贝，另外函数可以不显式写return语句，在运行结束时候，会默认返回None

关于函数的作用域问题（lambda表达式遵循与函数相同的作用域规则），python中只有函数、类、模块会产生作用域（在作用域内定义的变量仅此作用域可见，但注意不同的作用域可能是包含关系，如全局作用域的范围包含局部作用域，全局作用域定义的变量在局部作用域也可访问），代码块不会产生作用域（如for循环变量会直接覆写外部的同名变量，或者说for循环变量可以在外部使用，而不仅限于for循环内部），每执行一个函数，就会创建新的局部命名空间，包含了函数参数名称和在函数体内定义的变量名称，在函数内访问变量首先会在局部空间中查找，找不到再去全局空间查找，具体的，python中有四种作用域：Local（局部作用域）、Enclosing（嵌套作用域）、Global（全局作用域）、Built-in（内置作用域），且变量的查找遵循“LEGB”规则，以内层嵌套函数为例，其首先搜索自己的局部命名空间，没有找到将由内而外在外层函数的局部命名空间中一层层地寻找（因为可以多层函数嵌套），仍没有找到，才会到全局命名空间和内置命名空间查找，如果还没有，则引发NameError异常

可以在函数内部使用global关键字将（局部）变量动态声明为全局变量，使其位于全局命名空间，影响全局作用域，如：

1
2
3
4
5
6
7
8
def f():
    global x #global语句可以放在函数内任意行或重复使用
    x=8 #如果外层已经存在此变量，则函数内部的修改将体现在外层空间
    print('局部命名空间:',locals()) #空，此函数未创建任何局部变量
    print('全局命名空间:',globals()) #上面创建的变量x位于全局命名空间

f()
print(x) #8

类似的，对于嵌套函数，尽管它可以访问到嵌套作用域中的变量，一旦尝试对其执行如赋值等操作（如果是可变对象，则可以修改之，且无需声明nonlocal），实际会在嵌套函数的局部命名空间中新建一个同名变量，python3提供了nonlocal关键字，该声明会将名称动态绑定为外层函数中首次访问到的同名变量（多层嵌套时，可能多个外层函数都定义了同一变量，具体绑定哪个就看谁最靠内最先被访问到），于是可以在嵌套函数中修改并体现在外层，譬如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def f():
    i=4
    j=7
    k=13
    def inner1():
        nonlocal i
        j=70
        def inner2():
            nonlocal i,j #nonlocal限定于python3且嵌套函数使用，用于绑定至外层函数的局部变量，当声明为nonlocal变量时，该变量必须能在嵌套作用域中查获（见__closure__属性），否则报错，具体的，此处i绑定为f中的变量i，j绑定在inner1中的变量j
            i=6
            print(j) #70
            j=8
            print(k) #13
        i=5
        print(i) #5
        inner2()
        print(i) #6
    inner1()
    print(j) #7
    
f()

变量必须先赋值或定义才能使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
i=3
def f():
    print(i) #i实际是局部变量，打印前需先赋值
    i+=3 #尽管函数内部可以访问全局命名空间中的变量，一旦对其进行赋值等操作（可变对象则可以随意修改，而无需声明`global`），将会在函数内部创建一个同名的局部变量
    print(i)
    
f()

'''OUTPUT
Traceback (most recent call last):
  File "C:\Users\muggledy\Desktop\ttt2.py", line 7, in <module>
    f()
  File "C:\Users\muggledy\Desktop\ttt2.py", line 3, in f
    print(i)
UnboundLocalError: local variable 'i' referenced before assignment
'''

函数作为第一类对象（所谓第一类对象的特性是，对象可以赋值给变量、对象可以被当做参数传递、对象可以被当做函数的返回值返回、对象可以作为元素被添加到容器类型中），在下面的例子中，函数接受另一个函数作为输入并调用它：

1
2
3
4
#定义于文件foo.py，示例来自文献[1]-p79
x=6
def callf(func):
    return func()

下面的例子使用了上述函数：

1
2
3
4
5
6
import foo
x=8 #如果注释掉此句，将报错NameError: name 'x' is not defined
def helloworld():
    return f'Hello World. x is {x}'
    
print(foo.callf(helloworld)) #Hello World. x is 8

注意helloworld()使用的x的值是在与它相同的环境中定义的，事实上，解释器会将函数及其所在执行环境整个打包在一起，得到的函数对象称为“闭包函数”，每个函数都拥有一个指向定义该函数的全局命名空间的__globals__属性，对于嵌套函数，闭包同样将捕捉嵌套函数执行所需的整个环境，因此除了__globals__属性，还有一个指向定义该函数的嵌套作用域空间的__closure__属性，示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def greeting_conf(prefix):
    def greeting(name):
        print (prefix+' '+name) #greeting函数访问了外部定义的局部变量prefix，事实上在greeting_conf返回后，对greeting_conf可见的局部命名空间已经随着栈帧的销毁而销毁了，即locals()不可再获得，但是嵌套函数greeting会保存所需的执行环境，也就是说greeting_conf中定义的部分（为内层函数所使用到的）局部变量会继续存在于greeting的__closure__属性中
    return greeting
    
mGreeting=greeting_conf('Good Morning')
aGreeting=greeting_conf('Good Afternoon') #绑定了不同__closure__属性的闭包函数aGreeting和mGreeting是两个不同的函数对象，两者具有不同的执行环境，体现在两者id的不同
mGreeting('dy')
mGreeting('zj')
aGreeting('dxd')
aGreeting('zj')

print(mGreeting.__closure__,mGreeting.__closure__[0].cell_contents)
print(aGreeting.__closure__,aGreeting.__closure__[0].cell_contents)

'''OUTPUT
Good Morning dy
Good Morning zj
Good Afternoon dxd
Good Afternoon zj
(<cell at 0x000002A9B0E97288: str object at 0x000002A9B10DA170>,) Good Morning
(<cell at 0x000002A9B10687C8: str object at 0x000002A9B10DA1B0>,) Good Afternoon
'''

在开发过程中很可能需要对一些已有的函数进行改进，假设有一个用户注册函数register()，需要提交手机号码、用户名和注册邮箱信息，其中手机号码是数据库主键，具有唯一性，有天上司要求用户名也必须唯一，出于某些原因还不能破坏原有代码，怎么办？使用装饰器可以轻松完成这一工作，只需要编写一个检测是否存在相同用户名的装饰器函数if_unique_username()，然后在原有的register()函数定义前添加一行语句@if_unique_username就ok了，等价于执行register=if_unique_username(register)，@就是简化该操作的语法糖：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def if_unique_username(func): #装饰器函数
    def _(name,phone,email):
        '''DOC: 检测用户名唯一性函数'''
        print('用户姓名唯一性检测')
        return func(name,phone,email)
    #_.__doc__=func.__doc__ #如果借助functools模块，可以将此句替换为functools.update_wrapper(_,func)，效果等同于使用@functools.wraps(func)修饰_()函数
    return _

@if_unique_username #装饰器的实现原理依据闭包函数可以访问其执行环境变量或者说可以访问其嵌套作用域空间变量，这个嵌套作用域空间是绑定在函数对象上的（__closure__）
def register(name,phone,email): #被装饰函数
    '''DOC: 用户注册函数'''
    print('手机号唯一性检测')
    print('...')
    print(f'用户({name},{phone},{email})注册成功')
    
register('dy','152618xxxxx','31012xxxxx@qq.com')

'''OUTPUT
用户姓名唯一性检测
手机号唯一性检测
...
用户(dy,152618xxxxx,31012xxxxx@qq.com)注册成功
'''

有时候被装饰函数带有多种类型参数，譬如上述示例中装饰器if_unique_username()内层函数也需要定义和被装饰函数register一模一样的参数，其实没必要这样麻烦，可以用(*args,**kwargs)参数组合来接收任意数量的位置或关键字参数，因此实现一个通用装饰器如下：

1
2
3
4
5
6
7
8
def decorator(func):
    @wraps(func) #更简易使用我的改进版@wraps_fix，后面会详细介绍
    def wrapper(*args,**kwds): #即使没有参数也可以这样写
        #其他操作...
        ret=func(*args,**kwds)
        #其他操作...
        return ret
    return wrapper

由于数据量太大，上司决定将用户数据分地区存储在不同的数据库里，在登陆的时候根据用户的所在地来选择相应的数据库，我们希望能够给装饰器指定不同的（地区）参数，最终效果大概是：

1
2
3
4
@select_database(area='江苏') #等同于执行：register=select_database(area='江苏')(register)
def register():
    #用户注册操作
    pass

依据装饰器的原理，该功能其实不难实现，只需要定义一个三层嵌套的装饰器函数：

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
def select_database(area):
    def _1(func):
        def _2(*args,**kwargs):
            '''DOC: 选择地区数据库函数'''
            print(f'选择{area}地区数据库')
            return func(*args,**kwargs)
        #_2.__doc__=func.__doc__ #如果借助functools模块，可以将此句替换为functools.update_wrapper(_2,func)，效果等同于使用@functools.wraps(func)修饰_2()函数
        return _2
    return _1

@select_database('江苏')
def register(name,phone,email):
    '''DOC: 用户注册函数'''
    print('手机号唯一性检测')
    print('...')
    print(f'用户({name},{phone},{email})注册成功')
    
register('dy','152618xxxxx','31012xxxxx@qq.com')

'''OUTPUT
选择江苏地区数据库
手机号唯一性检测
...
用户(dy,152618xxxxx,31012xxxxx@qq.com)注册成功
'''

实际上，我们可以堆砌多个装饰器（装饰器链）：

1
2
3
4
5
6
7
8
9
@select_database('江苏')
@if_unique_username
def register(name,phone,email): #等同于执行register=select_database('江苏')(if_unique_username(register))
    '''DOC: 用户注册函数'''
    print('手机号唯一性检测')
    print('...')
    print(f'用户({name},{phone},{email})注册成功')
    
register('dy','152618xxxxx','31012xxxxx@qq.com')

现在有一个问题，假设你查看经过修饰后的register()函数文档register.__doc__，会输出DOC: 选择地区数据库函数，这不符合预期，但是原因也很明显，变量名称register最终已实际指向select_database()中的内层嵌套函数_2()，解决这个问题也很容易，只要改一下_2()的函数文档就好了，于是在_2()函数定义后写一句_2.__doc__=func.__doc__、同时在if_unique_username()中的内层嵌套函数_()定义后写一句_.__doc__=func.__doc__即可，当然不只是__doc__属性，__name__等函数属性也发生了变化，另外，上述操作还可以通过装饰器来实现以简化调用（见下我自定义的wraps()函数，然后分别在_2()函数和_()函数定义上方写上一句@wraps(func)即可）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def wraps(foo):
    def _1(func):
        def _2(*args,**kwargs):
            return func(*args,**kwargs)
        _2.__name__=foo.__name__ #此处只修改了__name__和__doc__属性，仅作为demo展示
        _2.__doc__=foo.__doc__
        return _2
    return _1

def decorator(func):
    @wraps(func)
    def wrapper(): #修饰后的wrapper变量名称实际指向wraps()中的内层嵌套函数_2()，于是原始被装饰函数foo变量名称也是指向_2()函数，因此要将foo()的函数文档赋给_2.__doc__即可
        '''wrapper function'''
        print('功能扩展')
        return func()
    return wrapper

@decorator #等同于执行：foo=decorator(foo)=wraps(foo)(wrapper)，于是foo变量名实际指向wraps()中的_2()函数
def foo():
    '''foo function'''
    print('原函数')
    
print(foo.__name__) #foo
print(foo.__doc__) #foo function

不过标准的解决方案还是调用functools模块的@wraps装饰器，用法同上，官方实现如下（借助偏函数）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__doc__', '__annotations__')
WRAPPER_UPDATES = ('__dict__',)
def update_wrapper(wrapper,
                   wrapped,
                   assigned = WRAPPER_ASSIGNMENTS,
                   updated = WRAPPER_UPDATES):
    for attr in assigned:
        try:
            value = getattr(wrapped, attr)
        except AttributeError:
            pass
        else:
            setattr(wrapper, attr, value)
    for attr in updated:
        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
    wrapper.__wrapped__ = wrapped
    return wrapper

def wraps(wrapped,
          assigned = WRAPPER_ASSIGNMENTS,
          updated = WRAPPER_UPDATES):
    return partial(update_wrapper, wrapped=wrapped,
                   assigned=assigned, updated=updated)

根据上述源码，除了使用@wraps修饰外，还有一种用法（直接调用update_wrapper()函数）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from functools import update_wrapper
def decorator(func):
    def wrapper():
        '''wrapper function'''
        print('功能扩展')
        return func()
    update_wrapper(wrapper,func)
    return wrapper

@decorator
def foo():
    '''foo function'''
    print('原函数')
    
print(foo.__name__) #foo
print(foo.__doc__) #foo function

另外还可以通过foo=foo.__wrapped__方便地将被装饰函数恢复为原函数（即“解除装饰器”），如果没有使用@functools.wraps，那么__wrapped__属性是不可获得的，需要注意的是，这仅仅适用于单个装饰器的情况，假设你堆砌了多个装饰函数，那么访问__wrapped__属性获取到的就不再是原函数了：

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
from functools import wraps
def decorator1(func):
    @wraps(func)
    def wrapper1():
        '''wrapper1 function'''
        print('功能扩展1')
        return func()
    return wrapper1

def decorator2(func):
    @wraps(func)
    def wrapper2():
        '''wrapper2 function'''
        print('功能扩展2')
        return func()
    return wrapper2

@decorator2
@decorator1
def foo():
    '''foo function'''
    print('原函数')
    
foo.__wrapped__() #结果指向decorator1()中的内层函数wrapper1()，而非希望的foo()，原因也很明显，上面对foo()的修饰，等同于执行了foo=decorator2(decorator1(foo))，具体的，第一步执行temp=decorator1(foo)时，根据functools.wraps原理，于是wrapper1.__wrapped__属性被赋值为foo，即指向foo()函数，第二步执行decorator2(temp)时，于是wrapper2.__wrapped__属性被赋值为temp，而temp变量实际指向wrapper1()函数，另修饰后的foo变量实际指向wrapper2()函数，于是foo.__wrapped__返回的是wrapper1()（闭包）函数，不过这时你也发现了，要获取到原函数，只要再迈出一步，即调用foo.__wrapped__.__wrapped__，返回的就是原始的foo()函数了

'''OUTPUT
功能扩展1
原函数
'''

要想实现多层装饰器的解除，可以稍稍修改update_wrapper()函数源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def update_wrapper(wrapper,
                   wrapped,
                   assigned = WRAPPER_ASSIGNMENTS,
                   updated = WRAPPER_UPDATES):
    for attr in assigned:
        try:
            value = getattr(wrapped, attr)
        except AttributeError:
            pass
        else:
            setattr(wrapper, attr, value)
    for attr in updated:
        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
-   wrapper.__wrapped__ = wrapped
+   if hasattr(wrapped, '__wrapped__'):
+       wrapper.__wrapped__ = getattr(wrapped, '__wrapped__')
+   else:
+       wrapper.__wrapped__ = wrapped
    return wrapper

如果不想修改源码，可以这样改：

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
from functools import wraps
def decorator1(func):
    @wraps(func)
    def wrapper1():
        '''wrapper1 function'''
        print('功能扩展1')
        return func()
    ###额外添加的代码
    if hasattr(func,'__wrapped__'):
        wrapper1.__wrapped__=getattr(func,'__wrapped__')
    else:
        wrapper1.__wrapped__=func
    ###以实现多装饰器的正常解除
    return wrapper1

def decorator2(func):
    @wraps(func)
    def wrapper2():
        '''wrapper2 function'''
        print('功能扩展2')
        return func()
    ###额外添加的代码
    if hasattr(func,'__wrapped__'):
        wrapper2.__wrapped__=getattr(func,'__wrapped__')
    else:
        wrapper2.__wrapped__=func
    ###以实现多装饰器的正常解除
    return wrapper2

@decorator2
@decorator1
def foo():
    '''foo function'''
    print('原函数')
    
foo.__wrapped__() #原函数

代码很简单，缺点是代码重复编写，此处我再给出一种解决方案💡：

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
from functools import wraps

def wraps_fix(f1):
    def _1(f2):
        @wraps(f1)
        def _2(*args,**kwds):
            return f2(*args,**kwds)
        if hasattr(f1,'__wrapped__'):
            _2.__wrapped__=getattr(f1,'__wrapped__')
        else:
            _2.__wrapped__=f1
        return _2
    return _1
    
def decorator1(func):
    @wraps_fix(func) #完美！
    def wrapper1():
        '''wrapper1 function'''
        print('功能扩展1')
        return func()
    return wrapper1

def decorator2(func):
    @wraps_fix(func)
    def wrapper2():
        '''wrapper2 function'''
        print('功能扩展2')
        return func()
    return wrapper2

@decorator2
@decorator1
def foo():
    '''foo function'''
    print('原函数')
    
foo.__wrapped__() #原函数

除了使用三层嵌套函数实现带参数的装饰器，还可以借助偏函数实现，仍以选择地区数据库注册用户为例：

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
from functools import wraps,partial
def select_database2(area,func=None):
    if func is None:
        return partial(select_database2,area)
    @wraps(func)
    def wrapper(*args,**kwargs):
        print(f'选择{area}地区数据库')
        return func(*args,**kwargs)
    return wrapper

@select_database2('江苏')
def register(name,phone,email):
    '''DOC: 用户注册函数'''
    print('手机号唯一性检测')
    print('...')
    print(f'用户({name},{phone},{email})注册成功')
    
register('dy','152618xxxxx','31012xxxxx@qq.com')

'''OUTPUT
选择江苏地区数据库
手机号唯一性检测
...
用户(dy,152618xxxxx,31012xxxxx@qq.com)注册成功
'''

网上看到一种通过类实现带参装饰器的方法，核心是借助于特殊函数__call__()使类实例变得可调用，此时上述案例可以这样写：

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
class select_database3:
    def __init__(self,area):
        self.area=area
    
    def __call__(self,func):
        def wrapper(*args,**kwargs):
            print(f'选择{self.area}地区数据库')
            return func(*args,**kwargs)
        return wrapper

@select_database3('江苏')
def register(name,phone,email):
    '''DOC: 用户注册函数'''
    print('手机号唯一性检测')
    print('...')
    print(f'用户({name},{phone},{email})注册成功')
    
register('dy','152618xxxxx','31012xxxxx@qq.com')

'''OUTPUT
选择江苏地区数据库
手机号唯一性检测
...
用户(dy,152618xxxxx,31012xxxxx@qq.com)注册成功
'''

不带参数的通用的基于类实现的装饰器：

1
2
3
4
5
6
7
8
9
10
11
12
from functools import update_wrapper

class decorator:
    def __init__(self,func):
        self.func=func
        update_wrapper(self,self.func)
    
    def __call__(self,*args,**kwargs):
        #其他操作...
        ret=self.func(*args,**kwargs)
        #其他操作...
        return ret

最后再看几个装饰器实现的案例，一是@singledispatch，被@singledispatch装饰的普通函数会变为泛函数，即根据第一个参数的类型以不同方式执行重载函数，称为单分派（而根据多个参数选择指定的函数，称为多分派，顾名思义singledispatch是单分派），如下：

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
from functools import singledispatch

class cattle:
    '''牛'''
    def __str__(self):
        return 'cattle'
    
class fish:
    '''鱼'''
    def __str__(self):
        return 'fish'

@singledispatch
def eat(obj): #(1) #eat是泛函数，任意类对象只要没有“注册”都将调用该方法，对于注册了的譬如cattle和fish类，则调用对应的重载函数
    print(str(obj)+' eats something')

@eat.register(cattle)
def _(obj): #(2) #_是一个无意义名字，当然也可取名为cattle_eat
    print(str(obj)+' eats grass')

@eat.register(fish)
def _(obj): #(3)
    print(str(obj)+' eats shrimp')
    
eat(cattle()) #cattle eats grass
eat(fish()) #fish eats shrimp
eat('muggledy') #muggledy eats something

#动物都需要进食，但是不同对象“吃”的行为却各不相同，牛吃草、小鱼吃虾米等等，如果用面向对象继承方式实现，基类“吃”的方法就是上述代码中的(1)，牛继承基类并重载“吃”的方法，见(2)，同理，小鱼的“吃”见(3)

二是带记忆装置的斐波那契数项计算，上一章我们讨论过了使用递归计算斐波那契数项的问题，代码很容易理解，但是性能却十分差，要改进它，一个合理的想法是为其配备“记忆装置”，对于计算过了的值我们直接从中获取以免重复计算造成资源浪费，利用装饰器我们不需要破坏原有代码，十分优美：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def memory(func):
    m={}
    def wrapper(n):
        if m.get(n) is None:
            m[n]=func(n)
        return m[n]
    return wrapper

@memory
def Fibonacci(n=6):
    if n in [1,2]:
        return 1
    else:
        return Fibonacci(n-2)+Fibonacci(n-1)
        
print(Fibonacci(35))
@lru_cache

由于计算机内存有限，记忆装置的缓存大小也应受限，但我们要做的不仅仅是限制缓存大小，还要基于LRU（Least Recently Used）“最近最少使用”思想来移除缓存中的过时数据，该算法的核心思想是，如果一个数据最近被访问过，则有理由相信它在将来被访问的概率也很高，反之，如果一个数据最近未被访问过，则可以认为它在将来被访问的概率也很低，实现它的最佳方式是使用“基于LRU的有序字典”来实现（按照访问频率高低按序排列，这就需要一个线性表，但是线性表查找时间复杂度为O(n)，考虑到字典查找时间复杂度为O(1)，因此可以通过next指针将字典中的元素依次串联起来，构成一个有序字典），官方文档collections.OrderedDict中基于OrderedDict实现了这样一个LRU字典，代码简洁明了（最后用下述LRU替换我上面写的memory装饰器函数中的变量m即可）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class LRU(OrderedDict):
    'Limit size, evicting the least recently looked-up key when full'
    
    def __init__(self, maxsize=128, *args, **kwds):
        self.maxsize = maxsize
        super().__init__(*args, **kwds)

    def __getitem__(self, key):
        value = super().__getitem__(key)
        self.move_to_end(key)
        return value

    def __setitem__(self, key, value): #这个有序字典从头到尾的使用频率是增高的，新增（__setitem__()）的自然在最右边，如果访问（__getitem__()）某元素则将其移动到末尾
        super().__setitem__(key, value)
        if len(self) > self.maxsize:
            oldest = next(iter(self))
            del self[oldest]

下面进入正题，看看@lru_cache的具体使用，首先导入：from functools import lru_cache，然后用于装饰你希望被装饰的递归函数：@lru_cache(maxsize=128, typed=False)，待缓存条目是被装饰函数的输入（作为缓存项的键）和输出（作为缓存项的值），如果maxsize参数设为None，那么缓存可以无限制增长，而当maxsize是2的次幂时，LRU功能表现最佳，如果typed参数设为True，那么同一数值但类型不同的函数参数调用将对应不同的缓存项（须知，对于被装饰函数，相同输入必须具有相同输出，假设输出不具有确定性，譬如受制于随机性函数，则@lru_cache失效，无法达到节省时间的效果）

1
2
3
4
5
6
7
8
9
10
from functools import lru_cache

@lru_cache(maxsize=128, typed=False)
def Fibonacci(n=6):
    if n in [1,2]:
        return 1
    else:
        return Fibonacci(n-2)+Fibonacci(n-1)
        
print(Fibonacci(35)) #9227465

装饰器@lru_cache提供了cache_clear()方法用于清除缓存或使缓存无效。一般说来，当我们使用装饰器之后，将“丢失”被装饰函数，被装饰函数的名字总是指向装饰函数，但@lru_cache类似@wraps也提供了__wrapped__属性，指向原始被装饰函数

三是使用装饰器修饰类对象，变相地执行继承，已知有一个限定了实例属性的类，要扩展一个额外的属性，但是不允许破坏原有代码，显然解决办法是继承这个类，并使新类代替旧类，该过程可以通过装饰器实现，比较新奇：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def addLength(oldcls):
    class NewClass(oldcls):
        __slots__=['_length']
        
        @property
        def length(self):
            if hasattr(self, '__len__'):
                self._length = len(self)
            return self._length
        
        @length.setter
        def length(self, value):
            self._length = value
    return NewClass #返回继承自（oldcls）旧类Tool的新类

@addLength
class Tool: #Tool=addLength(Tool)，变量名称Tool指向继承Tool的新类NewClass
    __slots__=['width','height']

t = Tool()
t.width=8
t.height=9
t.length = 10 #新增属性

还是以用户注册功能函数register()为例，设其接收两个参数，用户所属国家country和姓名name，对于某一地区，绝大部分人的国家属性相同，那么理应给country参数设置一个默认值，从而简化调用，具体的，定义一个参数配置函数configure()，接收原函数register地址和要设置的参数country值，并返回一个闭包函数（称为原函数的“偏函数”），当调用此闭包函数时，只需要再传入剩下的name参数，闭包函数内部会根据之前保存的country参数和刚传入的name参数去执行原函数register()实现用户注册

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def register(country,name):
    print(f'[{country}]{name}用户注册')
    pass
    
register('中国','muggle')

def configure(func,country): #python内置的实现相同功能的函数名称叫做partial
    def _(name):
        return func(country,name)
    return _
    
register_china=configure(register,'中国')
register_china('msy')
register_china('xiaodong')

register_japan=configure(register,'日本')
register_japan('艹')
register_japan('SB')

通用的配置函数形式：

1
2
3
4
def configure(func,*args1,**kwargs1):
    def _(*args2,**kwargs2):
        return func(*args1,*args2,**kwargs1,**kwargs2)
    return _

所谓偏函数（或者翻译成局部应用），即是固定住原函数的部分参数（设为k个），以实现简化调用的目的（设原函数共有n个参数，局部应用将一个n元函数转换成一个n-k元函数），另有一个概念叫做“柯里化”，是一种将接受多个参数的函数转变成接受一个单一参数的函数，并且返回接受余下的参数且返回结果的新函数的技术（柯里化将一个n元函数转换成n个一元函数），可能不太好理解，直接看示例，一个实现三个数相加的加法操作：

1
2
def add(a,b,c):
    return a+b+c

其柯里化版本为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def add(a):
    def _f1(b):
        def _f2(c):
            return a+b+c
        return _f2
    return _f1

add(1)(2)(3) #6

#可化简形式：
def add(a):
    return lambda b:lambda c: a+b+c

#或者：
add=lambda a:lambda b:lambda c:a+b+c
add(1)(2)(3) #6

显然，我们不可能每次都花这么大的功夫为一个函数特别定制其柯里化版本，为此，定义了一个转换函数curry()，能够接收一个函数对象作为参数，并将其转换为柯里化版本：

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
#这是一个更具通用性的curry()，随后你除了可以这样调用add(1)(2)(3)，还可以add(1)(2,3)或add(1,2)(3)
#改进版本参见：https://github.com/muggledy/myworld/blob/master/src/_base/decorator.py
def curry(func):
    argsnum=func.__code__.co_argcount
    allargs=[]
    def curried(*args):
        nonlocal allargs
        allargs+=list(args)
        if len(allargs)>=argsnum:
            ret=func(*allargs[:argsnum])
            allargs=[]
            return ret
        else:
            return curried
    return curried
    
'''设计思路
1.curry实现对一个函数的柯里化，因此只接收一个函数参数func，返回一个新的函数curried，其为func的柯里化版本
2.每次curried被传递进参数并调用，curried都会检查是否已接收了足够的参数（使用allargs存储），当其个数大于或等于原函数参数func定义的参数个数（由argsnum记录），此时立即计算最终结果并返回，否则继续返回curried以接收更多参数
'''

curriedAdd=curry(add) #curriedAdd是原函数add的柯里化版本，如果需要覆盖原函数，就直接add=curry(add)，而这正好可以使用装饰器的语法糖@来完成，更优美
print(curriedAdd(1)(2)(3)) #6
print(curriedAdd(1)(2,3)) #6
print(curriedAdd(1,2)(3)) #6
print(curriedAdd(1,2)(3,4)) #6
#curriedAdd(1,2,3)(4) #TypeError: 'int' object is not callable，由于curriedAdd(1,2,3)已经返回了正确结果6，整数显然是不可调用的，因此报错，对于curriedAdd(1,2)(3,4)，curriedAdd(1,2)返回的是一个函数，还能继续接收参数，但是只需要再接收一个就能正确计算，因此4被忽略（当然你也可以根据参数数量不一致raise报错），最终仍返回6

除了上述通用的配置函数实现，我在PEP文档中找到了一个利用__call__()实现的类版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
class partial(object):

    def __init__(*args, **kw):
        self = args[0] #__init__()的第一个参数是self对象
        self.fn, self.args, self.kw = (args[1], args[2:], kw) #args[1]是原函数，剩下的就是要预先固定的参数

    def __call__(self, *args, **kw):
        if kw and self.kw:
            d = self.kw.copy()
            d.update(kw)
        else:
            d = kw or self.kw
        return self.fn(*(self.args + args), **d)

最后要说的是，python中实现偏函数的标准方法是通过from functools import partial，另外，除了为函数预设部分参数值构成偏函数，实际上任何可以通过()调用的都可以进行“偏应用”，譬如类、类实例、类/实例方法都可以通过()调用：

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
from functools import partial

class A:
    def __init__(self,m,n):
        self.m=m
        self.n=n
    def __call__(self,k,flag): # k为乘积系数，flag表示是否输出结果
        if flag:
            print('m*k:',self.m*k,'\nn*k:',self.n*k)
        else:
            pass
    def hello(self,f1,f2): # 如果两个参数都是True，那么输出hello world，否则输出screw it
        if f1 and f2:
            print('hello,world!')
        else:
            print('screw it!')
            
#1.类A的参数m既定为3，那么我们就通过偏函数为类A的构造函数固定住这个参数m，其值为3
A_m=partial(A,3) # 偏应用的类A
obj_1=A_m(4)
print(obj_1.m,obj_1.n) # 3 4
obj_2=A_m(5)
print(obj_2.m,obj_2.n) # 3 5

#2.当类实现了__call__方法后，类实例对象将可以像函数一样被()调用，既然如此，我们为其固定住flag参数为True
obj=A(7,8)
obj_true=partial(obj,flag=True)
obj_true(2) # m*k: 14 \nn*k: 16
obj_true(3) # m*k: 21 \nn*k: 24

#3.实例方法，本质就是函数对象，我们将hello方法的f2参数置为True，是否输出问候语只需要f1参数
obj_hello=partial(obj.hello,f2=True) #事实上，实例属性方法访问返回的也是一个固定了self参数的偏应用
obj_hello(True) # hello,world!
obj_hello(False) # screw it!

在函数内，yield语句还可以用作出现在赋值运算右边的表达式，例如：

1
2
3
4
5
def receiver():
    print('Ready to receive')
    while True:
        n=(yield)
        print(f'Got {n}')

以这种方式使用yield语句的函数称为“协程”（协程反映了程序逻辑的一种需求：可重入（子程序/函数的）能力。协程能保留上一次调用时的状态，每次重入时，就相当于进入上一次调用的状态），它的执行是为了响应发送给它的值，其行为也类似于生成器：

1
2
3
4
5
6
7
8
>>> r=receiver() #此时函数尚未执行
>>> r.__next__() #首次调用next()方法以向前执行到第一条yield语句处并暂停
Ready to receive
>>> r.send(1) #发送值到yield处，且发送的值将被直接赋给yield赋值号左边的变量，然后继续向前直至再次遇到yield并暂停
Got 1
>>> print(r.send('Hello'))
Got Hello
None

上述示例中在执行发送前需要先调用一次next()方法，不太方便，可以定义一个装饰器以自动调用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def coroutine(func):
    def _(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g) #next()返回第一个遇到的yield语句中的表达式值（yield [expression]），假设expression缺省，则返回None
        return g
    return _
    
@coroutine
def receiver():
    print('Ready to receive')
    while True:
        n=(yield)
        print(f'Got {n}')
        
r=receiver()
r.send(1)
r.send('Hello')

协程的运行一般是无限期的，除非它被显式关闭（调用close()方法）或者自己退出，关闭后如果继续给协程发送值，将会引发StopIteration异常，正如之前在关于生成器的内容中所讲，close()操作将会在协程内部yield位置处引发GenaratorExit异常，你可以选择捕捉它。另外调用throw(exctype[,value[,tb]])方法也会在协程内部yield位置处引发异常，异常的类型、值和跟踪对象分别由exctype、value和tb参数指定

如果赋值号右边的yield语句本身含有表达式（不同于上面的var=yield，而是var=yield expression的形式），这个表达式的值将作为send()方法的返回值，此时协程可以使用yield语句同时接收和发出返回值，下面看一个生产者和消费者的示例：

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
import time

@coroutine
def consumer():
    r = None
    while True:
        n = yield r
        print('[CONSUMER] Consuming %s...' % n)
        time.sleep(1)
        r = '200 OK'

def producer(c):
    n = 0
    while n < 5:
        n += 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n) #将生产值发送给消费者，并接收消费者的反馈
        print('[PRODUCER] Consumer return: %s' % r)
    c.close() #生产结束后关闭消费者，当然也可以在外面关闭
    
c = consumer()
producer(c)

'''OUTPUT
[PRODUCER] Producing 1...
[CONSUMER] Consuming 1...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 2...
[CONSUMER] Consuming 2...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 3...
[CONSUMER] Consuming 3...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 4...
[CONSUMER] Consuming 4...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 5...
[CONSUMER] Consuming 5...
[PRODUCER] Consumer return: 200 OK
'''

需要注意的是，最开始的next()调用只会执行到赋值号右边的(yield [expression])处（且直到执行send()时才会完成赋值），并返回yield中的表达式expression值，在接下来的send()调用中，协程将从暂停处继起，直到再次遇到(yield [expression])暂停，并将此时计算得到的expression作为send()方法的返回值

  • 列表生成式

    1
    2
    3
    4
    5
    >>> ret=[x * x for x in range(10)]
    >>> ret
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    >>> type(_)
    <class 'list'>

  • 集合生成式

    1
    2
    3
    4
    5
    >>> ret={x * x for x in [-5,-3,-1,1,3,5]}
    >>> ret
    {25, 9, 1}
    >>> type(_)
    <class 'set'>

  • 字典生成式

    1
    2
    3
    4
    5
    >>> ret={x:x for x in range(5)}
    >>> ret
    {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}
    >>> type(_)
    <class 'dict'>

  • 生成器表达式

    和列表生成式几乎一样，只不过将中括号[]替换成()即可，返回的是生成器对象

注1，以上所有的生成式都支持多重for循环，如：[(i,j,k) for i in range(4) for j in range(3) for k in range(2)]（注意for循环的顺序是从左至右的，即左边for循环的迭代变量可以出现在右边for循环中但是反之不可以），譬如：

1
2
3
4
5
>>> ret=((x,y) for x in range(5) for y in range(x))
>>> ret
<generator object <genexpr> at 0x0000024BBAABBF10>
>>> list(_)
[(1, 0), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (4, 3)]

注2，以上所有的生成式都可以搭配if条件判断（没有else），以列表生成式为例：[expression for i in iterable if condition]（条件判断的作用同filter()函数，用于过滤序列中的部分元素），由于expression本身也可以是一个条件表达式，因此还可以写成：[expression1 if condition else expression2 for i in iterable]，示例：

1
2
3
4
5
6
7
8
>>> [i for i in range(10) if i%3==0] #从0-9的序列中筛选出3的整数倍
[0, 3, 6, 9]
>>> [(1 if i%3==0 else 0) for i in range(10)] #如果是3的整数倍，则置为1否则置为0
[1, 0, 0, 1, 0, 0, 1, 0, 0, 1]
>>> ['3+' if i>3 else str(i) for i in range(10) if i%3==0] #从0-9的序列中筛选出3的整数倍，且是字符串形式，进一步，如果大于6，则置为'3+'
['0', '3', '3+', '3+']
>>> [(i,j) for i in range(5) if i>2 for j in range(3)]
[(3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2)]

[1] Python参考手册 第4版 修订版 [美] 大卫·M.比兹利（David M.Beazley）著，谢俊，杨越，高伟 译

]]> 计算机基础 编程语言 Python Python基础 - 类型和对象 posts/5311/

📚 文档目录
🎃 类型和对象 - 🎈 程序结构与函数编程 - 🎏 面向对象编程

由于页面中的某些内容嵌套在了多重标签插件下，使得宽度变得过于狭窄，特别是手机端体验会很差，建议在电脑端阅读

该笔记内容可能存在一些错误，如果您能够帮助指正，鄙人将非常感谢

对象的身份与类型

Python中一切皆对象，包括一些常见的基础数据类型，如数字、字符串、列表、字典等，还有用户所自定义的对象（对象也称为类型的“实例”）。对象具有三大特征：

  1. 身份（id），可以理解为在内存中的地址，具有唯一性，可以通过id(obj)查看
  2. 类型（type），对象都是由类实例化产生的，对象所属类型可通过type(obj)或obj.__class__查看
  3. 值（value），不同对象具有不同值（体现在“属性”和“方法”的不同上），这也是其存在的现实意义

对象被创建后，其身份和类型就不可改变，根据其值是否可变，可以区分为“可变对象”与“不可变对象”

从身份、类型和值三个不同的角度分别比较对象：

1
2
3
4
5
6
7
def compare(a, b):
    if a is b:
        pass #a和b是同一个对象，或者说a和b指向同一内存地址
    if type(a) is type(b):
        pass #a和b属于同一类型
    if a == b:
        pass #a和b具有相同值

当使用==运算符时，请务必确保a==b中的左值对象a所属类型已重载了__eq__方法（特别提醒用户自定义对象，python中已有的基础对象类型都已经重载了该方法），否则比较是无实际意义的，须知a==b等同于执行a.__eq__(b)，而一切对象继承自object类型，object类型的__eq__方法其实比较的是身份（return a is b）。一般来说is用得较少，因为在实际场景中，要比较两个对象是否相等，并不是通过内存地址来判断的，而是应该通过这两个对象的部分属性值，或者全部属性值来对比判断的
注：在描述时，obj泛指的是任意python对象，而object则特指万物始祖之基类

Python中全部8种比较运算：>（对应__gt__()）, >=（对应__ge__()）, <（对应__lt__()）, <=（对应__le__()）, ==, !==（对应__ne__()）, is, is not。其他就不说了，is用在什么地方？
或许你已知道==None是不推荐使用的，应替换为is None，这基于两点理由：1）None在python中是一个单例对象（None作为对象也具有自己的类型，但是你无法用这个类型创造出另一个None对象），其内存地址唯一，而身份比较的一个好处就是速度快，因为无需对将要比较的对象本身进行检查，is操作符只需对对象所在的内存地址进行比较，因此采用is None速度更快，2）由于==是可重载的，导致某些非None对象也可能“等于”None，从而致使程序出错，譬如当重载定义为def __eq__(self,other): return True时

类型的类型

既然一切皆对象，类型本身作为对象又是谁的实例呢？答：type类。上结论：

  • 一切类的类都是type，即一切类（包括type自身）都是type类的实例
  • object是最顶层基类，一切类（除了object自身）追本溯源都继承自object
1
2
3
4
5
6
7
print(type(object)) #<class 'type'> #基类object作为对象，它的类型是type
print(type(type)) #<class 'type'> #type的类型是其自身
print(object.__base__) #None #object无父类
print(type.__base__) #<class 'object'> #type作为类，直接继承自object

print(list.__base__) #<class 'object'> #list、tuple、dict等以及自定义类都继承自object，类型为type
print(type(list)) #<class 'type'>
图1. object类和type类：图中虚线是实例关系、实线是继承关系[3]
isinstance()类型判断

早先在书上偶然看到一行代码isinstance(A,object) #返回True，其中A是一个自定义类，突然很不理解，没回过味来，还在SegmentFault上提问，好蠢/(ㄒoㄒ)/~~

根据帮助文档（help(isinstance)）可知：isinstance(obj, class_or_tuple)判断对象obj是否是class_or_tuple中某个类的实例或者其子类的实例。假设A继承自B，a=A()，那么显然isinstance(a,A)返回True，由于B是A的父类，所以B是a所属的更大的类的范畴，所以isinstance(a,B)也返回True，即a是B的实例。根据上面object类和type类之间的关系很容易推知：一切类（包括object和type）都是object的实例

1
2
3
4
5
6
7
8
9
10
>>> class A: pass
...
>>> isinstance(A(),object)
True
>>> isinstance(A,object)
True
>>> isinstance(object,object)
True
>>> isinstance(type,object)
True

官方建议当我们需要判断一个对象类型的时候应当使用isinstance()，虽然可以使用type()做“简单”类型判断，“简单”的原因在于，它无法判断一个对象是否属于其基类这一更大的范畴，譬如无法判断一只鹦鹉个体是否属于鸟类（谬论一），而只能判断它是鹦鹉类别

鹦鹉不是鸟：

1
2
3
4
5
6
7
8
9
10
11
>>> class Bird: pass
...
>>> class Parrot(Bird): pass
...
>>> a=Parrot()
>>> type(a) is Parrot
True
>>> type(a) is Bird
False
>>> isinstance(a,Bird)
True

另外在旧式类（完全没必要了解）中type()还具有一个缺陷，譬如两个完全不同的类实例竟然能得出“类型相同”的结果（谬论二），狗和猫是同类？示例如下（python2环境）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> class Dog: pass
...
>>> class Cat: pass
...
>>> d=Dog()
>>> c=Cat()
>>> type(d) is type(c)
True
>>> type(d)
<type 'instance'>
>>> isinstance(d,Cat)
False
>>> class Shiba(Dog): pass
...
>>> type(Shiba())
<type 'instance'>

对于新式类来说，实例化后的对象类型就是该类，这不容置疑，但是旧式类中没有基类object，实例化后的对象类型都是instance
补充：

1
2
3
4
5
6
7
8
9
>>> from collections import Iterator
>>> class A:
...     def __iter__(self):
...         ...
...     def __next__(self):
...         ...
...
>>> isinstance(A(), Iterator)
True

由此可见，python是根据“鸭子类型”的思想来进行类型判断的，即当看到一只鸟走起来像鸭子、游泳起来像鸭子、声音叫起来也像鸭子，那么这只鸟就可以被认为是鸭子，上述示例尽管A直接继承自object，但由于它实现了__iter__()和__next__()，因而A()被认为是一个迭代器对象

对象的引用与复制

在程序进行像a=b这样的赋值时，就会创建一个对b的新引用，对于像数字和字符串这样的不可变对象，这种赋值实际上创建了b的一个副本，修改b并不影响a，然而，对于可变对象（如列表和字典），行为则完全不同，譬如：

1
2
3
4
5
6
7
8
9
10
11
>>> a = [1,2,3,4]
>>> b = a #b和a指向内存中同一位置的对象
>>> b is a #id(a)==id(b)
True
>>> b[2] = -100 #修改容器b中一个元素
>>> a #此时a仍指向b所指向的对象，所以a的内容也相应改变
[1, 2, -100, 4]
>>> c = d = 12
>>> c = 13
>>> d
12

也就是说当两个变量引用指向同一个可变对象时，修改其中任意一个变量都会影响到另一个，为了避免这种情况，必须创建对象的副本而不是新引用。事实上对于像列表和字典这样的容器对象，存在两种复制操作：浅复制和深复制。浅复制虽然创建了一个新对象（体现在id变化），但它包含的还是对原始对象中所包含的元素（假设这个元素是可变对象的话）的引用，譬如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> a=[1,2,[3,4]] #a中第三个元素是可变对象（所谓可变对象就是对象的值变了，但其在内存中的地址仍保持不变，而改变不可变对象的值，将会在内存中新开辟一块内存存放修改后的对象）
>>> b=list(a) #list工厂函数属于浅复制，还有切片操作也是浅复制
>>> b
[1, 2, [3, 4]]
>>> a[0]=8
>>> b
[1, 2, [3, 4]]
>>> a[2][0]=30 #b中第三个元素其实是对a中第三个元素的引用，当a中第三个元素的值发生变化，b中第三个元素也将相应改变
>>> b
[1, 2, [30, 4]]
>>> a[2].append(5)
>>> b
[1, 2, [30, 4, 5]]
>>> a[2]=[11,12] #该赋值使得a中第三个元素指向了内存中另一个区域的（一个列表）对象，从而对列表[30,4,5]的引用计数减1，还剩下b中第三个元素对它的唯一引用
>>> b
[1, 2, [30, 4, 5]]

深复制也将创建一个新对象，且会递归地遍历它所包含的所有对象并创建其副本，需借助标准库中的copy.deepcopy()函数完成此操作

基础数据类型

None类型表示一个空对象，如果一个函数没有显式地返回值，则返回该对象。None经常用作可选参数的默认值，以便让函数检测调用者是否为该参数实际传递了值。None没有任何属性，在布尔表达式中求值时为False

Python内置了5种数字类型（都是不可变对象）：布尔型（bool）、整型（int）、长整型（long，目前好像没有long这一类型了，并入int）、浮点型（float）以及复数型（complex）。布尔值包括True和False两个值（参与数值运算时分别映射为数值1和0）。整数表示范围在-2147483648和2147483647（对应0111,1111,1111,1111,1111,1111,1111,1111，其最高位为符号位）之间的所有整数。浮点型是用机器上浮点数的本机双精度（64bit）表示的，提供大约17位数的精度和范围从-308到308的指数。复数使用一对浮点数表示（complex(1,2)），复数的实部和虚部分别使用.real和.imag访问，.conjugate()用于计算复共轭（a+bj的共轭是a-bj）

1
2
3
4
5
6
7
8
9
10
>>> d={}
>>> d[True] = "JavaScript"
>>> d[1] = "Ruby" #根据字典的原理，首先计算键1的哈希，于是找到了键True的存储位置，又发现True==1，于是认为这两个键是同一对象，于是直接将新值'Ruby'替换旧值'JavaScript'完事儿，于是现在字典中的数据变成了{True:'Ruby'}
>>> d[1.0] = "Python"
>>> d.keys()
dict_keys([True])
>>> d[True]
'Python'
>>> d[1.0]
'Python'

布尔类型是int类型的子类（如isinstance(True,int)为True），其满足True == 1 == 1.0 and False == 0 == 0.0为True的条件，换句话说，True、1、1.0这三个对象具有相同的哈希（同样False、0、0.0也是如此），在将其用作字典的键时，将映射到同一个值

进制转换

先说一下int(x, base)方法，其根据给定的进制base（取值为0、2~36，为什么最高是36？因为26个英文字母加上10个数字总计36，譬如有一个16进制数：e1，其十进制结果为225）将数字字符串x转换为十进制整数，也可用于将一个浮点数转换为整型（非字符串时不能传递base参数）。特别的，base取值为0时，将按照字符串的字面意思进行解释，譬如给定的字符串为0o16，此时不必明确告知base=8，因为0o打头的就表示这是一个八进制数。默认的base值为10，即默认将一个十进制数字字符串转换为十进制整型（int('1314')=1314）

1
2
3
4
5
6
7
#2、8、16进制转为10进制
>>> int('10010',2) #int('0b10010',0)
18
>>> int('32',8) #int('0o32',0)
26
>>> int('e1',16) #int('0xe1',0)
225

总而言之，int()只能用于将2~36进制的数（且为字符串类型）转换为10进制，如果你要将一个10进制数转换为2进制、8进制转为2进制、2进制转为8进制等等那它就无能为力了，下面介绍bin()、oct()以及hex()，分别用于将一个整数（这个整数可以是10进制的，也可以是2进制、8进制和16进制的）转换为2进制、8进制以及16进制：

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
#10进制转2进制
>>> bin(18)
'0b10010'
#8进制转2进制
>>> bin(0o22)
'0b10010'
#16进制转2进制
>>> bin(0x12)
'0b10010'
#10进制转8进制
>>> oct(26)
'0o32'
#2进制转8进制
>>> oct(0b11010)
'0o32'
#16进制转8进制
>>> oct(0x1a)
'0o32'
#10进制转16进制
>>> hex(225)
'0xe1'
#2进制转16进制
>>> hex(0b11100001)
'0xe1'
#8进制转16进制
>>> hex(0o341)
'0xe1'

以上描述了2、8、10、16进制数之间的相互转换，那么任意进制（2~36）之间如何相互转换呢，可以借助10进制数作为中间状态，代码如下：

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
from functools import partial

def transform(x,base=None,to=None):
    '''将base进制整数x转换为to进制数y，函数返回y
        合法的进制范围为2~36，
        x是一个字符串，是为了通用性考虑，因为整
        数类型只涵盖了2、8、10、16进制，譬如16：
        0b10000、0o20、16、0x10，但是其36进制为
        g，只能以字符串形式表示，特别的，输入允
        许以'0b'、'0o'、'0x'打头(此时base可以不
        给或任意)，也可以不是，但
        是作为输出的2、8、16进制数字字符串一律不
        会以'0b'、'0o'、'0x'打头。
        转换原理是，将base进制先转换为10进制，再
        将这个10进制转换为to进制
    '''
    x=x.lower()
    x_10=0
    if x[:2] in ['0b','0o','0x']:
        x_10=int(x,0)
    else:
        for i,e in enumerate(x[::-1]):
            x_10+=(pow(base,i)*(ord(e)-ord('a')+10 if 'a'<=e<='z' else int(e)))
    y=''
    while x_10>0:
        t=x_10%to
        y+=(chr(ord('a')+t-10) if t>9 else str(t))
        x_10//=to
    return y[::-1] if y!='' else '0'
    
transform('16',base=10,to=36) #g
f2t16=partial(transform,base=2,to=16) #from 2 to 16
f2t16('11100001') #e1

上述代码中十进制转任意进制部分，有人给出了递归写法（我用的循环）：

1
2
3
4
5
6
7
8
9
def transform_10_to_any(n,base):
    string='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' #''.join([*[str(i) for i in range(10)],*[chr(ord('A')+i) for i in range(26)]])
    if n<base:
        return string[n]
    else:
        return transform_10_to_any(n//base,base)+string[n%base]
        
print(transform_10_to_any(28,16)) #1C
print(transform_10_to_any(28**690,10)) #RecursionError: maximum recursion depth exceeded in comparison

由于存在递归深度限制，我将其改造成了尾递归版本，并使用@tail_call_optimized（见后，序列三大操作函数之reduce()案例3）进行修饰：

1
2
3
4
5
6
7
8
9
@tail_call_optimized
def transform_10_to_any(n,base,temp=''):
    string='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    if n<base:
        return string[n]+temp
    else:
        return transform_10_to_any(n//base,base,string[n%base]+temp)
        
print(transform_10_to_any(28**690,10))

注，任意进制转10进制的办法：按权相加，例如，将8进制数字 53627 转换成10进制：0o53627=5×84+3×83+6×82+2×81+7×80=224230o53627 = 5×8^4 + 3×8^3 + 6×8^2 + 2×8^1 + 7×8^0 = 22423 (十进制)。所谓“权”（即位权），对于一个8进制数，从左往右看，第1位的位权为 80=1，第2位的位权为 81=8，第3位的位权为 82=64，第4位的位权为 83=512，第5位的位权为 84=4096 …… 第n位的位权就为 8n-1，将各个位的数字乘以位权，然后再相加，就得到了十进制数值

将十进制转为任意N进制的办法，除N取余，逆序排列，例如将一个10进制数转换为8进制（36926 → 110076）：

1
2
3
4
5
6
36926/8 = 4615(除数) ··· 6(余数)
4615  /8 = 576              ··· 7
576    /8 = 72                ··· 0
72      /8 = 9                  ··· 0
9        /8 = 1                  ··· 1
1        /8 = 0                  ··· 1(除数为0时停止)

以上说的都是整数，那么如何对小数部分进行进制转换呢？例如将一个浮点数从8进制转换为10进制（还是按权相加）：423.5176423.5176 (八进制) =4×82+2×81+3×80+5×8−1+1×8−2+7×8−3+6×8−4=275.65576171875= 4×8^2 + 2×8^1 + 3×8^0 + 5×8^{-1} + 1×8^{-2} + 7×8^{-3} + 6×8^{-4} = 275.65576171875 (十进制)。即小数部分和整数部分情况相反，要从左往右看，第1（小数）位的位权为 8-1=1/8，第2位的位权为 8-2=1/64，第3位的位权为 8-3=1/512，第4位的位权为 8-4=1/4096 …… 第m位的位权就为 8-m

另外如何将一个浮点数从10进制转换为8进制呢？规则为：乘N取整，顺序排列，示例如下（0.930908203125 → 7345）：

1
2
3
4
0.930908203125×8 = 7.447265625 → 7(取整)
0.447265625      ×8 = 3.578125       → 3
0.578125            ×8 = 4.625             → 4
0.625                  ×8 = 5.0                 → 5(乘数结果小数部分为0时停止)

由于浮点计算的不精确性，无法在程序中判断小数点后是否为0，小数进制转换代码就不写了，可能需要借助Sympy符号运算库？

日常生活中逗号常见于大整数的表示中，如10,000,000，从python3.6开始支持整数中使用_标记，作用同逗号：a=10_000_000，也适用于十六进制或二进制等：b=0b1_010_101

Python内置序列对象包括字符串、列表和元组，字符串是字符的序列，而列表和元组是任意对象的序列。字符串和元组均属于不可变对象，而列表支持插入、删除、替换元素操作。所有序列都支持迭代（见可迭代对象）

字符串的方法太多，请参阅文献[1]-p34

格式化字符串

有两种格式化方式：占位符(%)和format()方法

  1. 占位符(%)

    取模运算符（s % d）也被用于生成格式化的字符串，其中s是一个格式字符串，而d是一个元组或映射对象（字典），格式字符串包含两种类型：普通字符和转换字符（总是以%打头），格式化程序会根据转换字符将相关元组或映射中的元素转换为对应的输出格式并替换原始的转换字符。如果d是一个元组，转换字符的个数必须与d中对象的个数保持一致，如果d是一个映射，每个转换字符都必须与映射中的一个有效键名相关联

    转换字符
    转换字符输出格式
    %c单个字符
    %s字符串,格式化对象时用str()生成字符串
    %r字符串,格式化对象时用repr()生成字符串
    %d,%i(长)整数(十进制)
    %u无符号(长)整数(十进制)
    %o(长)整数(八进制)
    %x(长)整数(十六进制)
    %X(长)整数(十六进制,大写字母)
    %e浮点数(科学计数法,如[-]m.dddddde±xx)
    %E浮点数(科学计数法,如[-]m.ddddddE±xx)
    %f浮点数(如[-]m.dddddd)
    %g,%G指数小于-4或更高精度时使用%e或%E,否则使用%f
    %p指针(用十六进制表示对象的内存地址)
    %%字面量百分号

    在%和转换字符之间可以出现以下修饰符，并且只能按照下述顺序出现：

    1. 位于括号中的一个键名，用于从映射对象中选出一个具体项，如果不存在此键，则引发KeyError异常
    2. 下面所列的一个或多个
      • -，左对齐标志，默认为右对齐
      • +，表示应该包含数字符号（即使为正值也是如此）
      • 0，表示零填充（仅用于数字类型，如%d、%f）
    3. 一个指定最小宽度的数字，转换后的值将被打印在至少为这个宽度的字段中，并且在左边填充至满字段宽（如果指定了-标志，则填充在右边）
    4. 一个小数点，用于按照精度分割字段宽度
    5. 一个数字，指定要打印字符串中的最大字符个数，或者浮点数中小数点之后的位数，或者整数的最小位数
    1
    2
    3
    4
    5
    6
    7
    >>> 'my name is %s%c%c, my age is %d' % ('muggle','d',121,23) #%c还可以接受整数（具体参见ASCII码表，或通过ord()、chr()转换）并转换为对应字符
    'my name is muggledy, my age is 23'
    >>> d={'x':13, 'y':1.54321, 'z':'hello world'}
    >>> '%.5s' % d['z']
    'hello'
    >>> '%(x)05d, %(y).2f' % d
    '00013, 1.54'
    ord()和chr()

    有些论坛不允许新人帖包含url链接，最简单的办法之一是将链接的每个字符转换成ASCII码，其他人再将ASCII转为字符。具体使用ord()函数返回单个字符的ASCII（0-255）以及chr()函数返回一个整数（0-255）对应的字符

    1
    2
    3
    4
    5
    >>> s='http://www.paperpass.com/'
    >>> [ord(i) for i in s] #编码
    [104, 116, 116, 112, 58, 47, 47, 119, 119, 119, 46, 112, 97, 112, 101, 114, 112, 97, 115, 115, 46, 99, 111, 109, 47]
    >>> ''.join([chr(i) for i in eval('[104,116,116,112,58,47,47,119,119,119,46,112,97,112,101,114,112,97,115,115,46,99,111,109,47]')]) #解码
    'http://www.paperpass.com/'
  2. format()方法

    高级字符串格式化，调用字符串s的format()方法：s.format(*args,**kwargs)，其接受位置参数和关键字参数的任意组合，并使用它们的值来替换s中嵌入的占位符，形式为{n}的占位符（n为数字，某些情况下可以省略）将被format()方法的第n个位置参数替换，而形式为{name}的占位符将被名为name的关键字参数值替换，如果要输出一个{或}，必须使用{{或}}的形式

    使用占位符还可以对位置参数或关键字参数进行数值或键索引，如{name[n]}（n为索引数字，对应name是列表）、{name[key]}（key为非数字字符串，对应name是字典），譬如：

    1
    2
    3
    4
    >>> 'my name is {1}, {0[0]}+{0[1]}={0[2]}, {2[x]}{2[y]}{2[z]}, {d}, {e[0]}, {e[1]}'.format([1,2,3],'dy',{'x':'a','y':'b','z':'c'},d=4,e=[5,'msy'])
    'my name is dy, 1+2=3, abc, 4, 5, msy'
    >>> '{d}, {},{}, {e}, {}'.format([1,2,3],'dy',{'x':'a','y':'b','z':'c'},d=4,e=[5,'msy']) #使用缺省的{}占位符，将和位置参数从左至右一一对应
    "4, [1, 2, 3],dy, [5, 'msy'], {'x': 'a', 'y': 'b', 'z': 'c'}"

    使用占位符还可以对位置参数或关键字参数进行属性查找，如{name.attr}：

    1
    2
    >>> '{0.real} {0.imag}'.format(x)
    '1.0 2.0'

    另外，还可以指定格式说明符，对输出进行更加精确的控制，具体是用一个冒号（:）给每个占位符添加可选的格式说明符，形如{place:format_spec}，使用这种说明符可以指定列宽、小数位和对齐方式，一般格式是[[fill]align][sign][0][width][.precision][type]（[]中的每个部分都是可选的，特别地，当给定fill时，也必须同时给定align），width说明符指定要使用的最小字段宽度，align说明符的可取值为<、>或^（分别代表左对齐、右对齐和居中对齐），fill是一个可选的填充字符，默认用空格填充，type说明符表示数据的类型，可以不提供，默认值分别是s（字符串）、d（整数）、e（浮点数，科学计数），sign说明符可取值为+、-或空格，用于在数值类型前加上符号，precision说明符指定十进制数的精度位数，另外如果在width前面加上一个0，就会使用0来填充数字前面的空白，看个例子：

    1
    2
    >>> '|{:#^10}|{age:^+10.2f}|'.format('dy',age=25.54321,)
    '|####dy####|  +25.54  |'
    Formatted string literals(f-string)

    F-string是python3.6引入的新特性，使用方式形如：f’字符串’或F’字符串’，字符串中使用大括号作为占位符标识要替换的字段，本质上f-string并非常量字符串，它将在运行时对其中的字段求值，f-string在设计上用于替代%和format()这两种传统格式化方法，性能优于二者且形式更加简便

    • 简单使用：
      1
      2
      3
      4
      >>> name = "Eric"
      >>> age = 74
      >>> f"Hello, {name}. You are {age}."
      'Hello, Eric. You are 74.'
    • 表达式求值和函数调用：
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      >>> f"{2 * 37}" #表达式求值
      '74'
      >>> def to_lowercase(input):
      . . .         return input.lower()
      . . .
      >>> name = "Eric Idle"
      >>> f"{to_lowercase(name)} is funny." #函数调用
      'eric idle is funny.'
      >>> f"{name.lower()} is funny." #调用对象方法
      'eric idle is funny.'
      >>> import math
      >>> f'The answer is {math.log(math.pi)}'
      'The answer is 1.1447298858494002'
      >>> comedian = {'name': 'Eric Idle', 'age': 74}
      >>> f"The comedian is {comedian['name']}, aged {comedian['age']}."
      The comedian is Eric Idle, aged 74.

      注：如果占位符{...}中的对象非字符串，那么将调用对象的__str__()方法（和__repr__()方法相比，前者面向人类，后者面向计算机，一般来说，你甚至可以通过执行（调用eval()函数）repr()返回的字符串重新生成对象，如果只实现__repr__()，那么str()还是会调用对象的__repr__()方法），并以返回的字符串替换占位符（如果同时也定义了__repr__()方法，且希望格式化时使用该方法返回的字符串，则写成{...!r}），看个例子：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      class Comedian:
          def __init__(self, first_name, last_name, age):
              self.first_name = first_name
              self.last_name = last_name
              self.age = age

          def __str__(self):
              return f"{self.first_name} {self.last_name} is {self.age}."

          def __repr__(self):
              return f"{self.first_name} {self.last_name} is {self.age}. Surprise!"

      new_comedian = Comedian("Eric", "Idle", "74")
      print(f'{new_comedian}') #Eric Idle is 74.
      print(f'{Comedian("Yang","Dai",25)}') #Yang Dai is 25.
      print(>>> f"{new_comedian!r}") #'Eric Idle is 74. Surprise!'
      注1：字符串内的引号不能和字符串外的引号定界符冲突，可根据情况灵活切换'和"（单引号和双引号），必要的时候，还可以使用三引号'''或者"""，再不行，还可以使用斜杠\对特殊字符进行转义，譬如'i\'m dy.'，但是f-string大括号内部不能使用斜杠\转义甚至说根本就不能出现任何斜杠

      注2，支持多重大括号写法，譬如双重大括号，f'{{5}}'将打印出字符串'{5}'，此时双重大括号中的内容是被当作普通字符串，再譬如：

      1
      2
      3
      4
      5
      6
      7
      8
      >>> f'{temp_a}' #temp_a从未定义，没有这个变量
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      NameError: name 'temp_a' is not defined
      >>> f'{{temp_a}}'
      '{temp_a}'
      >>> f'{{70 + 4}}'
      '{70 + 4}'

      要当作变量或表达式或函数调用，则再加一层大括号，即三重大括号：

      1
      2
      3
      4
      5
      6
      >>> f'{{{70 + 4}}}'
      '{74}'

      #如果是四重大括号（规律也很明显了）：
      >>> f'{{{{70 + 4}}}}'
      '{{70 + 4}}'

    • 多行f-strings：
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      name = "Eric"
      profession = "comedian"
      affiliation = "Monty Python"
      message = (
          f"Hi {name}. "
          f"You are a {profession}. "
          f"You were in {affiliation}."
      )
      print(message) #Hi Eric. You are a comedian. You were in Monty Python.

      #上述写法需要在每一行首部添加标识f或F，如果不像这样可以使用三引号实现多行字符串（但注意下面会输出三行）：
      message = f"""
          Hi {name}. 
          You are a {profession}. 
          You were in {affiliation}.
      """

      注，多个（位于同一行的）独立字符串之间不需要使用任何连接符（如果不在同一行，需要在行末加上斜杠表示换行（任意语句如果太长，你都可以在一行结尾处使用斜杠，然后就可以在下一行继续书写上一条语句剩余的内容，且不受python正常的缩进规则限制），如果不想写斜杠，也可以在所有独立字符串的左右两端裹上小括号），它们同样会被自动拼接：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      s="Hello" " world!"
      print(s) #Hello world!

      s="dy " "is " \
      'a'   ' ' \
      'muggle'
      print(s) #dy is a muggle

      #等同于：
      s=("dy " "is "
      'a'   ' '
      'muggle')
      print(s) #dy is a muggle

      且多个独立字符串作为函数参数时，不论是否在同一行，都无需斜杠作为换行符：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      def f(a,b):
          print(a)
          print(b)

      f("muggle"
      "dy","dai" \
      "xiao""dong")

      '''OUTPUT
      muggledy
      daixiaodong
      '''
    • 格式精确控制（对齐、宽度、符号、补零、精度、进制等）：
      类似format()，f-string使用形如{content:format_spec}进行格式的精确控制，其中content可以是变量、表达式或函数等，format_spec是格式描述符，采用默认格式时，则省略:format_spec，格式描述的使用顺序要注意，具体请参阅文章[2]相关部分
    print()函数

    当使用print()打印对象的时候，实际上是调用了标准输出并向其中写入字符串：sys.stdout.write(str(obj)+'\n')，sys.stdout就是标准输出对象，默认是写入到控制台设备并追加一个换行符（可以通过指定print()函数的end参数修改所追加的字符或字符串），当然你也可以修改sys.stdout的值，以实现输出重定向，譬如将输出重定向至某个文件：

    1
    2
    3
    4
    5
    6
    7
    >>> __console__ = sys.stdout #将控制台对象引用保存下来以便于恢复
    >>> file = open('redir_print.txt', 'w')
    >>> sys.stdout = file
    >>> print('Hello,World!') #此时等同于：file.write(...)
    >>> file.flush() #打印的内容首先存在于缓冲区flush中，直到下一次打印时上次的打印（内容）才被写到文件中，使用flush()强制刷新缓冲区将其写进文件
    >>> sys.stdout = __console__
    >>> file.close()

    在python3中不需要像上面这样繁琐，指定print()函数的file参数和flush参数即可：

    1
    >>> print('Hello,World!', file = file, flush = True)

    实际上你可以往print()中传递任意数量的任意对象且是以位置参数的形式，因为__str__()具有默认实现，其返回一个尖括号包裹的字符串，包含类名和内存地址信息，不同对象的输出字符串会自动连接且以单个空格作为间隔符：

    1
    2
    3
    4
    >>> class A: pass
    ...
    >>> print('muggledy','+',...,'zj',A())
    muggledy + Ellipsis zj <__main__.A object at 0x000001B0358AB7B8>
  1. 增加
    • s.append(x)
    • s.extend(t)
      注：不同于append追加元素，extend将一个新的序列扩展到原始序列中，等同于[*s,*t]（解包）
      解包与装包

      主要有三种用途：变量赋值，函数传参和简化容器添加

      1. 变量赋值
        • 将多个值或者说对象（其以逗号间隔）赋值给一个变量时，python会自动将这些值封装成元组，这种特性即称为“装包”：
          1
          2
          3
          >>> a=1,2,3
          >>> a
          (1, 2, 3)
        • 特别地，当函数返回多个数值时，也会进行装包：
          1
          2
          3
          4
          5
          def f(a,b,c):
              return a*1,b*2,c*3
              
          ret=f(1,2,3)
          print(ret,type(ret)) #(1, 4, 9) <class 'tuple'>
        • 将一个（可迭代）对象拆分成多个对象并依次赋值给多个变量，这种特性即称为“解包”，另外还可以用星号*修饰变量，使其接收多个拆解对象的组合（装包为列表类型）：
          1
          2
          3
          4
          5
          6
          7
          8
          9
          10
          11
          12
          13
          14
          15
          >>> a=[1,2,3]
          >>> x,y,z=a
          >>> x
          1
          >>> y
          2
          >>> z
          3
          >>> x,*y,z=range(10) #非*修饰变量（x,z）只能接收一个拆解对象
          >>> x
          0
          >>> y
          [1, 2, 3, 4, 5, 6, 7, 8]
          >>> z
          9
        • 可以解包的对象类型包括元组、列表、字典、生成器以及其它可迭代对象：
          1
          2
          3
          4
          5
          6
          7
          8
          9
          >>> d={'a':1,'b':2,'c':3} #字典也是可迭代对象，等同于迭代其键序列，但是要注意键序列其实是“无序”的
          >>> x,y,z=d
          >>> x,y,z
          ('a', 'b', 'c')
          >>> x,y,z=d.items() #如果要同时得到字典的键值的话
          >>> x,y,z
          (('a', 1), ('b', 2), ('c', 3))
          >>> a=(i for i in range(3)) #生成器也是可迭代对象
          >>> x,y,z=a

          装包和解包常用于“对称性赋值”操作和for循环中的变量拆解：

          1
          2
          3
          4
          5
          6
          7
          8
          9
          10
          11
          12
          13
          x,y=6,8
          x,y=y,x
          print(x,y) #将变量x和y的值对调，不需要像C语言那样借助临时变量实现。等号右边会先进行封装，变成元组(y,x)，然后元组被解包并依次赋值给x和y

          d={'a':1,'b':2,'c':3}
          for k,v in d.items():
             print('键:{}, 值:{}'.format(k,v))
              
          '''OUTPUT
          键:a, 值:1
          键:b, 值:2
          键:c, 值:3
          '''
        • 可以在变量赋值操作中对等号右边的可迭代对象直接使用星号*进行拆解或者说解包：
          1
          2
          3
          4
          >>> a=['dy',88,True]
          >>> v=1,2,*a,3
          >>> v
          (1, 2, 'dy', 88, True, 3)

          如果不想对右边的对象进行显式拆解，还可以在左边对将要接收的变量裹上一层或多层()或[]，以实现“多级嵌套解包”：

          1
          2
          3
          4
          5
          6
          7
          >>> a=['dy',88,True]
          >>> *_,(x,y,z),_=1,2,a,3 #写成*_,(x,y,z),*_=1,2,a,3是错误的，在同一级不能出现两个及以上的星号，什么意思？譬如写成*_,(x,*y),_=1,2,a,3则是正确的，这两个*不在同一级
          >>> x,y,z
          ('dy', 88, True)
          >>> _,(a,(b,c),d),_=1,[2,[3,4],5],6 #总之两边结构保持一致即可
          >>> b,c
          (3, 4)

          简单来说，星号出现在赋值号左边表示装包，出现在赋值号右边表示解包，不管是哪种，星号修饰符都必须位于一个序列中，可能不太好理解，看个例子即可：

          1
          2
          3
          4
          5
          6
          7
          8
          9
          10
          11
          12
          13
          >>> a=[1,2,3]
          >>> *x=a #报错
            File "<stdin>", line 1
          SyntaxError: starred assignment target must be in a list or tuple
          >>> *x,=a
          >>> (*x,)=a
          >>> [*x]=a #这三种改法都是正确的
          >>> x=*a #报错
            File "<stdin>", line 1
          SyntaxError: can't use starred expression here
          >>> x=*a,
          >>> x=(*a,)
          >>> x=[*a] #这三种改法都是正确的
      2. 函数传参
        • 装包传递（分两种，一是位置参数将被装包为一个元组，二是关键字参数将被装包为一个字典）：
          1
          2
          3
          4
          5
          6
          7
          8
          9
          def f1(*t):
              print(t)

          f1(1,2,3,4,5) #(1, 2, 3, 4, 5)

          def f2(**d):
              print(d)
              
          f2(X='a',Y='b',Z='c') #{'X': 'a', 'Y': 'b', 'Z': 'c'}
        • 解包传递（也分为两种情况，一是元组解包传递给位置参数，二是字典解包传递给关键字参数）：
          1
          2
          3
          4
          5
          6
          7
          8
          9
          10
          11
          12
          13
          def f3(x,y,z):
              print(x,y,z)

          t=(1,2,3)
          f3(*t) #等同于执行：f3(1,2,3)

          def f4(a,b=22,c=33):
              print(a,b,c)

          d={'a':1,'c':3}
          f4(**d) #等同于执行：f4(a=1,c=3)

          #特别地，如果调用f1(*t)或者f2(**d)，将同时完成解包和装包传递
      3. 简化容器添加
        • 当容器为list、tuple（虽然元组是不可变类型，但是没关系，能解包就行，这也并不涉及元组值的改变）、set类型时，同变量赋值操作中等号右边可迭代对象的拆解，使用单星号进行解包：
          1
          2
          3
          4
          5
          >>> a=(1,2,3)
          >>> (*a,4,5) #创建一个全新的元组
          (1, 2, 3, 4, 5)
          >>> {*a,4,5} #集合
          {1, 2, 3, 4, 5}
        • 当容器对字典时，使用的是双星号**进行解包：
          1
          2
          3
          >>> d={'1':1,'2':2,'3':3}
          >>> {**d,'4':4,'5':5}
          {'1': 1, '2': 2, '3': 3, '4': 4, '5': 5}

          但是需要注意的是，这虽然比通过dict.update()扩充字典的形式要简单一点，但须知，dict.update(another_dict)可以明确更新项目，而**字典解包则无法确保，譬如：

          1
          2
          3
          4
          5
          >>> d={'a':1,'b':2,'c':3}
          >>> {**d,'c':33}
          {'a': 1, 'b': 2, 'c': 33} #'c'键值更新了
          >>> {'c':33,**d}
          {'c': 3, 'a': 1, 'b': 2} #'c'键值没有更新

          另外就是效率问题，用*和**简化容器的添加操作，其性能和容器对象的update(),append()或add()方法相比，谁更优？根据下面的测试，解包比append()方法慢了3倍：

          1
          2
          3
          4
          5
          6
          import timeit
          t1=timeit.Timer('a.append(100)','a=list(range(100))')
          print(t1.repeat()) #[0.0850489117379404, 0.09039714449200119, 0.08290944329400407]

          t2=timeit.Timer('b=[*a,100]','a=list(range(100))')
          print(t2.repeat()) #[0.2924700997522413, 0.2945020249114667, 0.2961987540175306]
    • s.insert(i,x)
  2. 删除
    • s.pop([i])
      注：函数定义或签名中的[]表示可选参数
    • s.remove(x)
    • del s[i]、del s[i:j]、del s[i:j:stride]
      注：这是可变序列的通用操作
  3. 查找
    • s.index(x,[,start[,stop]])
      注：返回满足s[start:stop][i]==x的最小i值，如果找不到，会抛出异常
    • s[i]、s[i:j]、s[i:j:stride]
      注：这是序列的通用操作。i:j其实是一个特殊的切片对象slice(i,j,None)，且i、j、stride都是任意可省的，如s[::]
  4. 修改
    • s.reverse()
      注：这是原址操作，可以通过切片实现s[::-1]（返回一个新对象，上面说过，属于浅复制）
    • s.sort([key[,reverse]])
      sort()方法

      基本形式：sorted(iterable[,cmp[,key[,reverse]]])（副本排序）、 iterable.sort(cmp[,key[,reverse]])（原址排序）

      参数：iterable为可迭代对象，cmp指定排序时进行比较的函数，key也是函数，指定待排序元素将要参与排序的特征，reverse实现降序，默认False为升序
      注：python3去掉了cmp参数

      简单示例：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      #1.原址排序（对原始的序列对象进行内部排序而不是返回一个新的已排的序列对象）
      n=[7,4,1,3,2,8,9]
      n.sort()
      print(n) #[1, 2, 3, 4, 7, 8, 9]

      #2.副本排序
      #两种：创建原始对象的一个副本，然后对副本做原址排序，或者使用sorted方法，其将返回一个类型为列表的副本
      x=[4,3,5,2,1]
      y=x[:] #对于列表对象来说，创建副本的方式有很多：切片、工厂函数、copy.copy（前三种是浅拷贝）、copy.deepcopy
      y.sort()
      print(x,y) #x未排序，y已排序

      m=[3,4,1,7,5,0,2]
      print(sorted(m))
      print(m) #sorted()不改变原始对象

      高级用法：

      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
      #1.自定义比较函数cmp(x,y)
      #既然python3不支持，就不说了

      #2.自定义待排序元素特征keys（接受一个参数，表示待排序的元素对象）
      #之所以在key后面加上s，是因为特征可以有多个，首先按照第一个特征对元素排序，然后在此基础之上，再用第二个特征排序，第一个特征优先级最高。此即为多级排序
      def keys(x):
          return len(x)

      array=['daiyang','sb','miaosiyu','jianglicheng','liuhan'] #按照字符串的长度进行排序（降）
      print(sorted(array,key=keys,reverse=True)) #由于取消了cmp比较函数，因此只能通过reverse设定升降顺序
      array.sort(key=lambda x:len(x),reverse=True)
      print(array) #['jianglicheng', 'miaosiyu', 'daiyang', 'liuhan', 'sb']

      #3.多级排序
      arrays_1=[(2,3,10),(1,2,3),(5,6,7),(2,5,10),(2,4,10)]
      arrays_2=[('2','3','10'),('1','2','3'),('5','6','7'),('2','5','10'),('2','4','10')]
      arrays_1.sort(key=lambda x:(x[2],x[1])) #例1 #[(1, 2, 3), (5, 6, 7), (2, 3, 10), (2, 4, 10), (2, 5, 10)]
      print(arrays_1)
      print(sorted(arrays_2,key=lambda x:list(map(int,(x[2],x[1]))))) #例2

      #将operator.itemgetter函数用在多级排序中
      from operator import itemgetter
      #itemgetter函数用于选择对象的指定维数的数据，注意itemgetter返回的是一个函数对象
      a=[1,2,3]
      gets=itemgetter(1,2) #获取“对象[1]”和“对象[2]”，这个对象是广义化的，由你任意指定，如下：
      ret=gets(a) #返回一个元组：(a[1],a[2])
      print(ret)

      #结果同例2:
      print(sorted(arrays_2,key=lambda x:list(map(int,itemgetter(2,1)(x)))))
      #结果同例1:
      print(sorted(arrays_1,key=itemgetter(2,1)))

      注，获取排序后的索引序列：

      1
      2
      3
      4
      5
      6
      7
      def argsort(arr):
          return [i for i,v in sorted(enumerate(arr),key=lambda x:x[1])]
          
      a=[1,3,2,9,4,2,0]
      inds=argsort(a)
      print(f'sorted-index:{inds}') #sorted-index:[6, 0, 2, 5, 1, 4, 3]
      print(f'sorted-value:{[a[ind] for ind in inds]}') #sorted-value:[0, 1, 2, 2, 3, 4, 9]

类似于列表，只不过元组一旦创建不能修改，比列表要省内存

首先新建一个链表类（目前就是一个普通的容器，可以存储数据，但是尚未实现__iter__方法，因此还不是可迭代对象），实现了链表的基本操作，索引、追加、插入、删除：

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
100
101
102
103
104
105
106
__all__=['Link',]

class Node:
    def __init__(self,val):
        '''节点对象，有数据域和指针域（指向下一元素）'''
        self.data=val
        self.next=None
        
class Link:
    def __init__(self):
        '''初始化链表，初始化一个头节点，其数据域默认为空，可以添加链表长度等信息'''
        head=Node(0)
        self.pointer=head #语义：链表指针，指向头节点
        
    def append(self,val):
        '''在链表尾部追加新元素'''
        node=Node(val)
        p=self.pointer    #语义：工作指针
        while p.next:     #获取指向最后一个元素的指针
            p=p.next
        p.next=node       #看起来next“指针域”指向了node，因为next中保存的是对node的引用，而不是node的拷贝，这和C中的指针效果是一样的
        self.pointer.data+=1
        
    def printf(self):
        '''打印链表中元素'''
        print('[链表] ',end='')
        p=self.pointer
        while p.next:
            print(p.next.data,end=', ')
            p=p.next
        print()
        
    def delete(self,index,get=False):
        '''删除链表中第index个元素，get参数用于get()函数代码复用，这个参数应该隐藏（譬如作为类属性）而不该放在函数定义中'''
        if index<1 or index>self.len:
            raise ValueError('下标溢出')
        p=self.pointer
        i=1
        while p.next:
            if i==index:
                if not get:
                    p.next=p.next.next #断开的节点无需手动free，因为python有垃圾回收机制
                else:
                    return p.next
                break
            p=p.next
            i+=1
        self.pointer.data-=1
        
    def deleteall(self):
        '''删除全部元素，即头节点指针域指空'''
        p=self.pointer
        p.next=None
        self.pointer.data=0
        
    def get(self,index):
        '''获取第index个节点元素，index取值1~len(Link)'''
        return self.delete(index,True).data
        
    @property
    def len(self):
        '''链表长度，之前我们说头节点有空闲的数据域，我们可以存储链表长度信息，通过实时更新其值，可以避免硬计算'''
        p=self.pointer
        i=0
        while p.next:
            p=p.next
            i+=1 # 硬计算
        if self.pointer.data!=i: #为了避免错误，暂时我仍使用硬计算，并对头节点的数据域中的长度值进行检测
            print('头节点错误')
        return i
        
    def insert(self,index,val):
        '''插入元素，index合法取值1到len(Link)+1，特别地，当index取值len(Link)+1时，为在尾部追加（特殊插入）'''
        node=Node(val)
        if index<1 or index>self.len+1:
            print('下标溢出')
            return
        if index==self.len+1:
            self.append(node)
            return
        p=self.pointer
        i=1
        while p.next:
            if i==index:
                t=p.next
                p.next=node
                node.next=t
                break
            p=p.next
            i+=1
        self.pointer.data+=1
        
if __name__=='__main__':
    L=Link() #空链表
    L.append(1)
    L.append(2)
    L.append(3)
    L.insert(1,0)
    L.printf()
    L.delete(1)
    L.printf()
    L.deleteall()
    L.append('muggle')
    L.append('daiyang')
    L.printf()
    print(L.get(2))

凡是可迭代对象都可以用for语句逐一遍历全部元素，这是检查一个对象是否可迭代的标准，要创建一个可迭代对象，必须实现__iter__()方法，其返回一个迭代器，迭代器内部持有一个状态，用于记录当前迭代所在的位置，迭代器必须实现__next__()用于迭代获取下一个元素并更新迭代状态，而迭代器也属于可迭代对象的范畴，因此也必须实现__iter__()方法，具体实现时返回自身即可

下面我们试着将上述不可迭代的链表对象（Link）转变为可迭代的列表对象（List），并在链表的基础上构建一个迭代器对象：

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
class List(Link):
    def __iter__(self): #实现了__iter__方法之后，链表变成可迭代对象
        return ListIteration(self)
        
class ListIteration: #简单来说，迭代器就相当于“普通容器+迭代状态”
    def __init__(self,container):
        self.data=container #迭代器由容器数据和状态构成
        self.iterstate=1 #迭代器当前的迭代状态
        self.stopstate=self.data.len #终止
        
    def __iter__(self): #对一个迭代器获取其迭代器，就是其本身
        return self
        
    def __next__(self): #根据当前迭代状态迭代下一个元素，并更新状态
        while self.iterstate<=self.stopstate:
            self.iterstate+=1
            return self.data.get(self.iterstate-1)
        raise StopIteration #对超出范围的元素迭代需要返回StopIteration，在for语句中该异常将被捕捉
        
a=List() #创建一个列表（可迭代对象）
a.append(10)
a.append(12)
a.append(14)
a.append(16)
b=iter(a) #将自动调用a.__iter__()
print(b.__next__()) #10 #或者写next(b)
c=iter(b) #对迭代器调用iter()，返回自身，因此下面的c都可以替换为b
print(c.__next__()) #12
for i in c:
    print(i) #14 16
for i in a:
    print(i) #10 12 14 16
for循环原理
1
2
for x in [1,2,3]:
    print(x)

等价于：

1
2
3
4
5
6
7
8
9
#1.首先通过iter()获取迭代器对象
iterator=iter([1,2,3])
#2.在循环中不断调用next方法获取迭代器对象的下一个值直至捕捉到StopIteration异常退出循环
while True:
    try:
        x=next(iterator)
        print(x)
    except StopIteration:
        break

itertools模块提供了诸多具有特殊用途的迭代器，譬如count()返回一个无限循环的迭代器（既然无限循环为什么不直接使用while？因为count()可以很方便地记录当前迭代次序），再如cycle()从有限序列生成无限序列，用于循环遍历序列，等等，下面是cycle的实现（我随便写的，非官方实现）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class cycle:
    def __init__(self,container,start=0): #start指定从序列的哪一个元素开始循环迭代
        self.data=container
        self.iterstate=start
        self.len=len(container)
        
    def __iter__(self):
        return self
        
    def __next__(self):
        self.iterstate+=1
        return self.data[(self.iterstate-1)%self.len]
        
a=cycle([1,2,3],) #不同于上面自定义的列表是一个可迭代对象（但非迭代器对象），此处cycle(...)直接就是迭代器对象，当然也就是可迭代对象。再如python几种内置类型list、tuple、dict、set、str等，也都是可迭代对象，但非迭代器对象（为何这样设计？道理很简单，迭代器对象都是用完即扔的，这实在是太浪费资源了，于是你需要不停在内存中创建和回收对象，但重复将可迭代对象转换为迭代器就很便宜了），譬如a=[1,2,3];next(a)将报错：TypeError: 'list' object is not an iterator
print(next(a),next(a),next(a),next(a),next(a),next(a),next(a)) #1 2 3 1 2 3 1
for i in a:
    print(i) #无限循环，因为for循环只会在next(迭代器)抛出StopIteration（停止迭代异常）的时候终止

判断是否可迭代以及是否是迭代器：

1
2
3
4
5
>>> import collections
>>> isinstance([],collections.Iterable) #list是可迭代对象吗？
True
>>> isinstance([],collections.Iterator) #list是迭代器对象吗？
False
图2. 可迭代对象、迭代器、生成器关系[4]

再说说生成器，实际上生成器本质就是迭代器（因此生成器也是用完即弃），只要迭代的下一个元素是即时计算（惰性计算）的，那就是生成器，普通迭代器迭代下一个元素，是从某个容器中取出来，所有元素事先已经计算得出，其始终占用着一片内存区域（因此只有生成器才能实现“无限序列”）。在python2中range()就是一个普通迭代器（譬如range(10000)内存中真的就存在10000个数字），xrange()则是生成器（此时内存中就没有10000个数据占用），下面我们自行设计一个生成器版本的range（Range）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Range(object):
    def __init__(self,*args):
        if len(args)==1:
            self.start,self.stop,self.step=0,args[0],1
        elif len(args)==2:
            self.start,self.stop,self.step=*args,1
        elif len(args)==3:
            self.start,self.stop,self.step=args
        else:
            raise ValueError('[参数错误] Range(start[,stop[,step]])')
        
    def __iter__(self):
        return self
        
    def __next__(self):
        while self.start<self.stop:
            self.start+=self.step
            return self.start-self.step
        raise StopIteration
        
for i in Range(3,9,2):
    print(i) #3, 5, 7
print(list(Range(5))) #[0, 1, 2, 3, 4]，工厂函数list自动计算生成器各个元素的值并以列表返回

通常采用yield关键字构造生成器，在函数中使用yield关键字代替return关键字（称为生成器函数），函数调用将返回一个生成器对象，此时函数内部代码不会立即执行，除非对其调用next()方法，函数执行流将在yield位置中止，并返回yield语句中的表达式值，继续调用next()方法，函数执行流将从yield中止处继起并在下一次遇到yield时中止…，yield使得生成器的语法变得相当优雅（我们几乎从不使用上面Range示例的方式编写生成器，python本身也不认为那是一个生成器对象，如isinstance(Range(5),types.GeneratorType)会返回False），简单来说生成器函数就是在一个循环中不断计算并产生新值的过程且只在需要时计算（“惰性计算”，不调用next()方法则不计算），它定义了数据生产的流程，当我们需要将生产和消耗分离的时候，使用生成器可以方便地解耦，任意函数稍作修改便可转换为生成器函数，只需要将return关键字改成yield关键字，现在我们用yield方式重写Range：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def Range(*args):
    if len(args)==1:
        start,stop,step=0,args[0],1
    elif len(args)==2:
        start,stop,step=*args,1
    elif len(args)==3:
        start,stop,step=args
    else:
        raise ValueError('[参数错误] Range(start[,stop[,step]])')
    while start<stop:
        start+=step
        yield start-step
    raise StopIteration #生成器其实没必要在结束位置处显式抛出该异常，因为会自动抛，但是（非生成器的）迭代器必须手动抛出
            
for i in Range(3,9,2):
    print(i)
    
print(list(Range(5))) #[0, 1, 2, 3, 4]
惰性计算

为了深入了解“惰性计算”，看个示例：

1
2
3
4
g=(i for i in range(4))
for i in [1,10]:
    g=(i+j for j in g)
print(list(g))

不少人（包括我）认为结果会是[11,12,13,14]，但是解释器运行结果却是[20, 21, 22, 23]，why？

对于一个生成器表达式(expression1 for variables in expression2)，expression1只有在调用生成器对象的__next__()方法时才会执行，而for子句则是即时计算的，即expression2是即时计算的（根据for原理expression2应返回一个可迭代对象），另注意，for子句可能是多层for循环嵌套的，只有最左边的for子句才会即时计算，譬如：

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
n=2
def bar():
    return range(n)

g1=(i for i in bar()) #for子句表达式是即时计算的，此处等同于：g1=(i for i in range(2))
n=3
g2=((i,j) for i in bar() for j in bar()) #只有最左侧的for子句表达式才即时计算，此处等同于：g2=((i,j) for i in range(3) for j in bar())
n=4
print(list(g1))
print(list(g2)) #list遍历生成器元素，由于最后修改的n值为4，于是此处等同于：g2=((i,j) for i in range(3) for j in range(4))

'''OUTPUT
[0, 1]
[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3)]
'''

#如果expression2是一个变量引用，将变量引用指向其他对象不会改变生成器数值，如果变量引用指向一个可变对象，修改该可变对象则会改变生成器数值：
a=range(2)
g=(i for i in a)
a=range(10)
print(list(g)) #[0, 1]

a=[1,2,3,4]
g=(i for i in a)
a.append(5)
print(list(g)) #[1, 2, 3, 4, 5]

回到最初的问题，第一次循环，生成器g中的值其实就是[i+0,i+1,i+2,i+3]（尚未计算），第二次循环，g变成[i+(i+0),i+(i+1),i+(i+2),i+(i+3)]（尚未计算），最后通过list(g)遍历时，i=10，于是输出[20,21,22,23]。将其用生成器函数改写一下同时展开for循环，其执行过程相当于：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def gen1():
    for i in range(4):
        yield i

i=1
def gen2():
    for j in gen1():
        yield i+j

i=10
def gen3():
    for j in gen2():
        yield i+j

print(list(gen3())) #[20, 21, 22, 23]

这就很明了了，或者再改写一下得到：

1
2
3
4
5
6
7
8
i=1

i=10
def gen3():
    for k in range(4):
        yield i+i+k

print(list(gen3())) #[20, 21, 22, 23]

另外如果不是通过list(g)输出生成器序列元素，而是用for循环替换之：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
for i in g:
    print(i)

'''OUTPUT
20
41
84
171
'''

#破解之法就是替换for循环变量
for k in g:
    print(k)

'''OUTPUT
20
21
22
23
'''

要注意迭代变量的使用，如果使用i作为迭代变量，结果将会发生变化，这仍是惰性计算导致的，结合for循环原理原因就很清楚了（每次循环都会执行i=next(g)，而i将影响生成器序列的数值计算）

GeneratorExit异常标志着生成器迭代过程的非正常终止，相反，正常终止不会引发该异常：

1
2
3
4
5
6
7
8
9
10
11
def f(n): #不断生产数据
    try:
        while n>0:
            yield n
            n-=1
    except GeneratorExit:
        print('exiting...')
        
g=f(3)
for i in g: #每产生一个数据就消耗一个数据，如果使用while循环是无法分离生产和消耗两个部分的，它们势必混合在一起
    print(i) #3 2 1

如果生成器仅被部分使用，将在yield处引发GeneratorExit异常（但一般不用人为捕获），并自动调用close()方法关闭生成器，如果再次调用next()方法将引发StopIteration异常，它已不能继续产生新值了：

1
2
3
4
5
6
7
g=f(3)
for i in g:
    if i>1:
        print(i) #3 2 exiting...
    else:
        break
g.__next__() #出现StopIteration异常，不要再期望输出1

注：for语句能判断生成器函数是否全部完成，如果你是通过while和next进行迭代是无法判断的（只有在整个程序终止时才会引发该异常），这个时候就需要显式关闭（但这不是必须的），鉴于你通常会忘记，一般我们只使用for循环来迭代生成器

手动执行close()方法亦将在yield处引发GeneratorExit异常（假设生成器已被使用过的话）：

1
2
3
g=f(3)
print(g.__next__()) #3
g.close() #exiting...

删除生成器对象也会引发该异常：

1
2
3
g=f(3)
print(g.__next__()) #3
del g #exiting...

小结一下：

  1. 生成器在close()方法后就无法再进行迭代，再调用next()方法就会抛出StopIteration异常
  2. 生成器调用close()方法会在yield处抛出GeneratorExit异常，但前提是至少调用一次生成器的next()方法才会产生GeneratorExit异常，如果生成器没有启动则不会抛出异常
  3. 生成器内捕捉GeneratorExit异常后，可以继续执行剩余的代码，但剩余的代码中不能再包含yield语句，否则抛出RuntimeError异常
  4. GeneratorExit异常不能通过Exception捕捉，因为其直接继承自所有异常的基类BaseException

上面我们说了为什么内置的类型如list、tuple、dict、set、str都被设计为可迭代对象而非迭代器（迭代器是“一次性”的），原因不止一条，譬如in关键字就不能用于迭代器对象，x in y语句的工作原理是，首先调用对象y上的iter()方法，然后不断执行next()方法获取下一个元素，直至x==next(y)，返回True，否则返回False，表示容器y中不存在x，看一个错误范例就明了了：

1
2
3
4
y=(i for i in range(5))
x=1
print(x in y) #True
print(x in y) #False

第一次执行x in y时候，iter(y)返回y自身，执行两次next(y)，生成器y中的前两个元素0和1被消耗（发现x存在于y中），结果返回True，第二次执行x in y的时候，iter(y)仍旧返回被部分消耗的y自身，继续调用next()方法，显然后面的元素2、3、4中不存在1，因此返回False。这种情况下如果要进行存在性判断，可以先将生成器转换为列表（list(y)），一个可迭代对象（而iter(可迭代对象)总是返回一个全新的迭代器对象）

yield与递归混用

将yield与递归混用时要小心，很容易出错，先来看一个示例，遍历一个嵌套的列表（展平操作）：

1
2
3
4
5
6
7
8
9
def flatten(lists):
    for i in lists:
        if isinstance(i,list):
            flatten(i)
        else:
            print(i)

a=[0,[1,2,3],[4,5,[6,7]],[8,9,10]]
flatten(a) #0 1 2 3 4 5 6 7 8 9 10

改写为生成器（这个改写是错误的）：

1
2
3
4
5
6
7
8
9
10
def flatten(lists):
    for i in lists:
        if isinstance(i,list):
            flatten(i) #位置2
        else:
            yield i #位置1
            
a=[0,[1,2,3],[4,5,[6,7]],[8,9,10]]
for i in flatten(a):
    print(i) #仅仅打印出0

这个结果似乎出人意料，分析一下，设g=flatten(a)，for语句第一次调用g的next()方法，由于列表a的第一个元素是数字，因此函数执行流将到达位置1处中止并返回yield表达式值，即0，第二次调用next()方法，执行流从中止处继续，由于列表a的第二个元素是列表，因此到达位置2处，关键即在于此，位置2处的flatten(i)将返回一个生成器，然而生成器是惰性的，在没有调用next()方法的情况下生成器根本不会执行（修正的办法就是手动去迭代这个生成器），更何况返回的生成器对象还没有被赋值，没有外部引用的它随即会被当作垃圾回收，因此完全可以忽略它的存在，即可以将位置2处的语句替换成pass，于是执行流继续向后执行，而列表a中的后面的两个元素仍都是列表对象，因此执行流不会再到达位置1，生成器也不会再生产值，执行流结束将抛出StopIteration异常，分析结束，可知g这个迭代器的长度仅为1。修正：

1
2
3
4
5
6
7
def flatten(lists):
    for i in lists:
        if isinstance(i,list):
            for j in flatten(i):
                yield j
        else:
            yield i

序列操作三大函数：

  • map(func,seq1[,seq2,...])
    批量映射函数，map将序列中的元素映射或转换成其他元素，func充当转换器

    1. 当只有一个序列参数时，map(func,seq)等同于[func(e) for e in seq]
    2. 当有多个序列参数时，map(func,seq1,seq2,...)等同于[func(*t) for t in [*zip(seq1,seq2,...)]]（这些序列的长度的长度可以不一致，按最短的来，在python2中，当func取None时，map就等同于zip，但python3已不再允许func参数为None）
      打个比方，如果将seq1、seq2、… 各自比作飞机的不同的零件提供商，那么map函数就是批量制造飞机的工厂，func就是制造飞机的原理图纸
    zip函数

    简单应用：

    • 快速构建字典

      1
      2
      3
      4
      >>> dict(zip(range(5),range(5,10))) #通过dict类初始化函数或者说工厂函数
      {0: 5, 1: 6, 2: 7, 3: 8, 4: 9}
      >>> {k:v for k,v in zip(range(5),range(5,10))} #通过字典生成式
      {0: 5, 1: 6, 2: 7, 3: 8, 4: 9}

    • 利用zip完成二维矩阵转置

      1
      2
      3
      4
      5
      6
      7
      8
      9
      a = [[11, 12, 13], [14, 15, 16], [17, 18, 19], [20, 21, 22]] #按行描述的矩阵，现将该矩阵按列描述，即为转置的结果
      for i in a: #原矩阵
          print(i)
      #利用列表生成式进行转置
      for i in [[row[col] for row in a] for col in range(len(a[0]))]:
          print(i)
      #这个生成式正是zip压缩的过程，因此直接用zip很简便：
      for i in zip(*a): #*为解包裹函数参数传递
          print(i)

    • 将序列按连续k个值分组

      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
      #假设是将序列a按连续两个值分组
      a = [1, 2, 3, 4, 5, 6, 7]

      #大佬写法1
      for i in zip(*[iter(a)]*2): #操作符优先级为：zip(*([iter(a)]*2))，这里的*是函数参数的解包裹传递方式，就是将一个序列解包为诸多的位置参数传给函数
          print(i)
          
      #普通写法2
      b=iter(a)
      for i in zip(b,b): #另注意不能构成长度为2的分组的部分元素（残值）将被丢弃
          print(i)

      '''OUTPUT
      (1, 2)
      (3, 4)
      (5, 6)
      '''

      #正常人写法3
      myslice=lambda a,k:[a[i:i+k] for i in range(0,len(a),k)] #缺点在于假设传入的a万一是一个迭代器（无法计算长度，无len()方法），那就需要转为列表或其它可计算长度的对象类型，相比之下，zip调用next()更鲁棒。这种写法不丢弃“残值”
      print(myslice(a,2)) #[[1, 2], [3, 4], [5, 6], [7]]

      #正常人写法4
      for i in zip(a[::2],a[1::2]): #相邻2个元素
          print(i)
      for i in zip(a[::3],a[1::3],a[2::3]): #相邻3个元素
          print(i)
      # 假设要相邻k个元素，就要进行k次切片，显然很麻烦，改写一下：
      myzip=lambda k:zip(*[a[i::k] for i in range(k)])
      for i in myzip(4):
          print(i)

      解释：先说一下zip函数的工作原理，函数接收任意数量的可迭代对象参数，第一步利用iter()将参数全部转换为迭代器对象，第二步在一个while循环中，每一轮，依次获取每个迭代器的下一项，然后组装成一个元组，并追加到返回值序列中，当最短的迭代器对象抛出StopIteration异常时，退出while循环。zip原理（看看就好）：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      def myzip(*args):
          '''the principle of function zip'''
          m=list(map(iter,args))
          try:
              ret=[] #返回值序列
              while 1:
                  li=[]
                  for i in range(len(m)):
                      li.append(m[i].__next__())
                  ret.append(tuple(li))
          except StopIteration:
              pass
          return ret
      ret=myzip([1,2,3],[4,5,6,7],[8,9,10,11,12],[13,14])
      print(ret) #[(1, 4, 8, 13), (2, 5, 9, 14)]

      '''或者：
      def myzip(*args): #直接根据最短的列表长度确定轮回次数nloop
          m=list(map(iter,args))
          nloop=min([len(args[i]) for i in range(len(m))])
          #ret=[tuple([m[i].__next__() for i in range(len(m))]) for j in range(len(list(m[0])))] #和下面修改的区别在于：list(one iteration)会导致对迭代器（参数）的一遍迭代，结果想再调用next就会立即抛出异常，由此我们可以大概知道工厂函数list的原理：list(iterable obj)，首先将可迭代参数对象转为迭代器，然后迭代(next)整个迭代器得到新的列表对象，其中的元素都是对参数对象中元素的引用
          ret=[tuple([m[i].__next__() for i in range(len(m))]) for j in range(nloop)]
          return ret
      '''

      现在回头看写法2就非常明了了，写法1就是换个写法而已，前提是你要知道[obj]*i将返回一个长度为i的序列[obj,obj,...]，其中每一项都是对原始的obj对象的引用（或者说浅复制），如果是按连续k个值分组，那就将zip(*[iter(a)]*2)中的2换成k即可
      注：实际上zip()的返回值是一个类似生成器的对象，即用即弃

    • 滑动窗口

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      from itertools import islice
      def slicing(obj,n):
          #obj为可迭代序列，n为窗口大小，每次滑动（步长为1）我们看见的序列内容都不一样，函数返回全部窗口滑动状态下的序列的内容视图
          return zip(*[islice(obj,i,None) for i in range(n)]) #注意obj只能是可迭代对象，不能是迭代器，因为islice会消耗迭代器。最简单的还是用obj[i:]替代islice(obj,i,None)，其实我也想不到islice有什么用处，参考：https://stackoverflow.com/questions/41079001/python-3-5-slice-vs-islice-vs-alternatives-efficiency-comparison
      for i in slicing([2,3,8,5,1],3):
          print(i)
          
      '''OUTPUT
      (2, 3, 8)
      (3, 8, 5)
      (8, 5, 1)
      '''

    • 反转字典

      1
      2
      3
      >>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4} #字典value必须都是不可变对象
      >>> dict(zip(*list(zip(*m.items()))[::-1]))
      {1: 'a', 2: 'b', 3: 'c', 4: 'd'}

  • filter(func,seq)
    序列过滤器，过滤掉不符合条件的元素，返回那些符合条件的元素所组成的新（子）序列，func充当筛选器（应返回True或False）。等同于[e for e in seq if func(e)]

  • reduce(func,seq[,initial])
    该函数工作流程是：在迭代seq的过程中，首先将前两个元素传给func函数（可以通过initial参数额外指定首个元素值，相当于序列seq增加了一个元素，新序列为[initial,*seq]），函数加工后将返回值和seq序列的第三个元素重新传入func函数，再将返回值和seq的第四个元素一起传入func函数，以此类推，直至遍历到seq的最后一个元素，最后一次执行的func函数输出将作为reduce函数的返回值
    注：python3从全局空间移除了该函数，需要从标准库functools中引入
    reduce最大的特点在于，过程中每一次迭代都携带着上一次的迭代结果，这种对历史的可见性有时候很有用。记忆力是个好东西
    案例1（计算阶乘）：

    1
    2
    3
    >>> from functools import reduce
    >>> reduce(lambda x,y:x*y,range(1,6)) # 也可以写成：import operator;reduce(operator.mul,range(1,6) #计算5!
    120

    案例2（将整数列表拼成整数）：

    1
    2
    >>> reduce(lambda x,y:x*10+y,[1,2,3,4,5])
    12345
    案例3（计算斐波那契）

    已知斐波那契数列：1、1、2、3、5、8、13、21、34、……
    要求：输出数列第n项的值

    1
    2
    3
    4
    #根据数列规律：当前项的值等于前两项的和，即在迭代过程中只要保留最近的历史（前两项元素值）即可，因此基调确定，即reduce中的func参数应该返回一个二元组，而参数seq其实对计算没用，仅用于迭代。且实际假设斐波那契序列为（增加首项0）：0,1,1,2,3,5,8,...，然后将前两项(0,1)作为reduce的initial参数，于是reduce首次迭代可以计算出第三项数值（前两项和）为1，并使func返回第二项和第三项的值(1,1)，然后第二次迭代可以计算出第四项数值为2，并使func返回第三项和第四项的值(1,2)，以此类推
    from functools import reduce
    fib=lambda n:1 if n==1 else reduce(lambda x,y:(x[1],x[0]+x[1]),range(n-1),(0,1))[1]
    print(fib(10)) #55
    其他实现

    普通递归：

    1
    2
    3
    4
    5
    6
    7
    8
    def Fibonacci(n=6):
        if n==1 or n==2:
            return 1
        else:
            return Fibonacci(n-2)+Fibonacci(n-1)
            
    ret=Fibonacci(10) #由于递归层数限制，如果n取值过大，会爆栈，所以严格来说，这种写法是错误的，另一个关键问题是递归计算实在是太耗时了，其具有指数级的时间复杂度！试试求取第35数值，已经明显迟钝，如果把上述递归树画出来，其实有大量结点是重复计算，关于速度的改进参见第二章节·装饰器
    print(ret)

    看看大佬们是怎么写的：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    def fib1(n):
        return n<=2 and 1 or fib1(n-1)+fib1(n-2) #秀我一脸
      
    #等价于：
    def fib2(n):
        return 1 if n<=2 else fib2(n-1)+fib2(n-2)
        
    #形式再简化：
    fib3=lambda n:1 if n<=2 else fib3(n-1)+fib3(n-2)
    and与or

    and和or执行布尔逻辑运算，但是在python中返回值并非True或False，其返回的是两端的比较值之一

    运算规则：

    • and运算规则
      1. 当and左端表达式为真时，继续对右端表达式进行计算并返回该(右端)表达式的值
      2. 当and左端表达式为假时，立即返回该(左端)表达式的值
    • or运算规则
      1. 当or左端表达式为假时，继续对右端表达式进行计算并返回该(右端)表达式的值
      2. 当or左端表达式为真时，立即返回该(左端)表达式的值

    两规则的第二条体现了and和or的截断作用（其右端表达式可能并没有被计算），因此and和or又被称为“短路运算符”（再次注意只有在and左边为假或者or左边为真才会表现出该特性）

    1
    2
    print(0 and (3-2)) #0
    print(1 or 0) #1

    简单使用：

    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
    #（一）and和or单独使用（多个and或者多个or）
    #and：从左到右扫描，返回第一个为假的表达式值，无假值则返回最后一个表达式值。简单说就是：and返回真，除非遇见一个假，则返回假
    print(-1 and 'dy' and ...) #注意负数、字符串都是逻辑为真，而...其实是一个Ellipse对象（该对象没有任何属性，python也没有任何内置类型使用该对象），其逻辑为真
    print(True if -1 and 'dy' and ... else False) #建议使用all([-1,'dy',...])替代
    #or：从左到右扫描，返回第一个为真的表达式值，无真值则返回最后一个表达式值。简单说就是：or返回假，除非遇见一个真，则返回真
    print(0 or 0 or 1 or 2 or 0) #1
    print(True if 0 or 0 or 1 or 2 or 0 else False) #建议使用any([0,0,1,2,0])替代

    #（二）and-or搭配使用
    #and优先级大于or，结合性从左到右
    #经典案例之逻辑表达式(condition and a or b)：
    a,b="JAVA","PYTHON"
    print(1 and a or b) #JAVA
    print(0 and a or b) #PYTHON
    #我们可以通过控制condition的真假，控制输出a还是输出b。语义即为：“若 真 则返回 a，否则返回 b”，等同于C++中的条件运算符(bool? a:b)，但是必须注意：a和b都必须是逻辑真的

    print(1 and 0 or a and b and 0 and a or b) #b
    #对于一个比较复杂的and-or混合运算，将and视为乘、or视为加：((1 and 0) or (((a and b) and 0) and a)) or b

    #由于(condition and a or b)中a和b都要满足逻辑真，这如何确保？先看个反例：
    a,b=[],1 #a是逻辑假的，此时and-or实现的条件运算将失效
    print(True and a or b) #1
    print(False and a or b) #1

    #还是有安全的解法的，如下（套个[]强制变成逻辑真，新的逻辑表达式变为(condition and [a] or [b])[0]）：
    a=''
    b="MSY"
    print((0 and [a] or [b])[0])

    #通常情况下，还是建议if-else实现条件运算符的功能，以增强程序的可读性，装B除外
    print('daiyang' if False else 'daixiaodong') #daixiaodong

    上述小结（可跳过代码）：

    and-or实现条件运算：(condition and [a] or [b])[0]等同于condition ? a : b

    all([condition1,condition2,...])等同于True if condition1 and condition2 and ... else False

    any([condition1,condition2,...])等同于True if condition1 or condition2 or ... else False


    全部逻辑运算
    运算名称逻辑函数表示短释实现
    A AND B与门A·B所有输入为高时，才有高的输出，一低出低A and B
    A OR B或门A+B所有输入为低时，才有低的输出，一高出高A or B
    NOT A非门Aˉ\bar{A}根据输入的高低逆转后输出not A
    A NAND B与非门A⋅B‾\overline{A·B}所有输入为高时，才有低的输出，一低出高not (A and B)
    A NOR B或非门A+B‾\overline {A+B}所有输入为低时，才有高的输出，一高出低not (A or B)
    A XOR B异或门A⊕BA\oplus B输入为一高一低时，才有高的输出，否则出低(A and not B) or (not A and B)
    A XNOR B同或门A⊕B‾\overline {A\oplus B}输入为一高一低时，才有低的输出，否则出高(A and B) or (not A and not B)
    BUF A是门A输出与输入相同的高低状态A
    A IMPLY B蕴含门A→BA\rightarrow B第一输入为低时输出高，否则输出同第二输入(not A) or B
    A NIMPLY B蕴含非门A→B‾\overline {A\rightarrow B}第一输入为低时输出低，否则输出与第二输入相反A and (not B)

    注1，表中的A、B均为二值型数据，要么是0，要么是1。最后一列是python代码实现，但不仅适用于二值0和1或布尔值TrueorFalse，且适用于其他任何自定义对象，只要实现__bool__()方法即可

    注2，上表中除了前三个门是基础外，其他门都可以用这三个门实现，譬如：“异或门”A⊕B=A⋅B‾+A‾⋅BA\oplus B=A·\overline B+\overline A·B、“同或门”A⊕B‾=A⋅B+A‾⋅B‾\overline {A\oplus B}=A·B+\overline A·\overline B、“蕴含门”A→B=A‾+BA\rightarrow B=\overline A+B、“蕴含非门”A→B‾=A⋅B‾\overline {A\rightarrow B}=A·\overline B。记忆：“与非门”是对“与门”输出取反，“或非门”是对“或门”输出取反，“同或门”是对“异或门”输出取反，“蕴含非门”是对“蕴含门”输出取反

    在某些语言如C中可以使用尾递归解决递归爆栈问题，虽然python本身不支持尾递归，但是存在一些解决方案可以间接实现尾递归，下面我先给出尾递归形式的写法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    def fib5(n): #计算原理同下面循环版本的fib4
        def fib_iter(n,n1,n2):
            if n==0: return n2
            else: return fib_iter(n-1,n2,n1+n2)
        return fib_iter(n,1,0)

    #lambda形式的尾递归
    fib6=lambda n,n1=1,n2=0:n2 if n==0 else fib6(n-1,n2,n1+n2) #同fib5

    #and-or形式的尾递归
    fib7=lambda n,n1=1,n2=0:n==0 and n2 or fib7(n-1,n2,n1+n2) #同fib6
    python实现尾递归

    在计算机中，函数调用是通过“栈”这种数据结构实现的，每调用一个函数，就会往栈中压入一个栈帧对象，其中保存着函数所对应的可执行代码（即代码对象，通常由compile()函数返回，可通过栈帧对象frame的f_code属性访问）、变量命名空间（包含frame.f_locals局部变量、frame.f_globals全局变量和frame.f_builtins内置名称）以及其他一些属性（如frame.f_back，表示对当前调用者而言的上一个栈帧对象），当函数执行结束，就会从栈中删除当前栈帧，如果函数没有结束就又发生了其他函数调用，栈中的帧数就会线性增加，由于栈的大小不是无限的，对于递归函数，如果递归过深，很容易导致栈溢出错误

    1
    2
    3
    >>> import sys
    >>> sys.getrecursionlimit #python允许的最大递归深度
    1000

    那么旧的栈帧能不能删除呢？一般来说递归调用的返回结果是要为上层函数所使用的，即递归的回溯过程通常不可避免，所以不能删除。尽管如此，由于尾递归的特殊性（尾调用由于是函数执行流的最后一步，调用结果不需要反馈给调用者，因此在这种情况下旧的栈帧可以直接销毁，此即为“尾调用优化”），决定了这种递归形式在执行过程中是不需要回溯的，于是可以把原本需要线性复杂度栈内存空间的执行过程用常数复杂度的空间完成，实现该优化的解释器或编译器可以使得递归本身无论调用多少次，都只占用一个栈帧。本质上尾递归和循环没什么区别，要效率，还是建议循环

    大佬实现的TCO(Tail-Call Optimization)装饰器（原理简单来说就是当发现尾递归调用的函数在栈帧中重复出现时，手动抛出异常并携带着最新调用的函数参数返回上层，从而使之后重复调用的函数栈帧被销毁）：

    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
    class TailRecurseException(Exception):
        def __init__(self, args, kwargs):
            self.args = args
            self.kwargs = kwargs

    def tail_call_optimized(g):
        """
        This function decorates a function with tail call
        optimization. It does this by throwing an exception
        if it is it's own grandparent, and catching such
        exceptions to fake the tail call optimization.

        This function fails if the decorated
        function recurses in a non-tail context.
        """
        def func(*args, **kwargs):
            f = sys._getframe()
            if f.f_back and f.f_back.f_back \
                and f.f_back.f_back.f_code == f.f_code: #位置1
                raise TailRecurseException(args, kwargs)
            else:
                while 1:
                    try:
                        return g(*args, **kwargs) #位置2
                    except TailRecurseException as e:
                        args = e.args
                        kwargs = e.kwargs
        func.__doc__ = g.__doc__
        return func

    使用案例（尾递归实现的阶乘计算）：

    1
    2
    3
    4
    5
    6
    7
    8
    @tail_call_optimized
    def factorial(n, acc=1):
        "calculate a factorial" #函数__doc__文档
        if n == 0:
            return acc
        return factorial(n-1, n*acc) #位置3
        
    print(factorial(1000))

    解读：首先得知道装饰器的基本原理，于是有factorial=tail_call_optimized(factorial)，即变量名factorial实际指向闭包函数func，而func闭包内部的变量g实际指向函数factorial。在执行factorial(1000)时，由函数func构成的栈帧将首次被压入函数调用栈中，程序执行到位置1，不符合if条件，于是执行到位置2，再一次发生函数调用，此时由函数factorial构成的栈帧将被压入栈中，程序继而执行到位置3并函数调用，于是由函数func构成的栈帧将再次被压入栈中，然后执行到位置1发现满足条件（当前栈帧的前两个栈帧存在且上上个栈帧的代码对象和当前栈帧的代码对象相同，即发生重复调用），于是向上层抛出异常（具体返回到哪一层就看哪一层捕捉到了该异常），同时携带着最新的调用参数，显然程序将返回到第一个栈帧（即第一个函数调用）的位置2处（此时栈内就只有这一个帧了），此处异常被捕捉，由于处在一个while循环中，于是又来到位置2并发生函数调用，函数factorial构成的栈帧将被压入栈中，来到位置3并发生函数调用，函数func构成的栈帧将被压入栈中，判断if条件，再次满足条件，抛出异常…，依此类推

    之前的斐波那契问题，使用TCO修饰：

    1
    2
    3
    4
    5
    6
    def fib5(n):
        @tail_call_optimized
        def fib_iter(n,n1,n2):
            if n==0: return n2
            else: return fib_iter(n-1,n2,n1+n2)
        return fib_iter(n,1,0)

    注意，TCO只能用于尾递归，否则出错，示例如下：

    1
    2
    3
    4
    5
    6
    7
    @tail_call_optimized
    def f(n=6): #此递归函数功能：每深入调用一次递归函数，计数器增1，即函数返回递归的深度
        if n==0:
            return 0
        return 1+f(n-1)
        
    print(f()) #0 #去掉TCO时返回6

    最正确且效率最高的当属循环：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #能用循环解决的问题，尽量不要使用递归，有时候递归可以极大简化问题，那也应当在合理的递归深度范围内，否则意味着错误必将发生
    def fib4(n):
        n1,n2=1,0
        while n:
            n1,n2,n=n2,n1+n2,n-1
        return n2
      
    print(fib4(10000))

    #顺便给出打印完整数列的方法，稍微改造上述fib函数即可
    from itertools import count
    def all_fib(n):
        n1,n2=0,1
        for i in count():
            if i==n:break
            print(n2,end=',')
            n1,n2=n2,n1+n2

    all_fib(6) #1,1,2,3,5,8,13,21,34,55

    案例4（增量求平均）：
    记xn‾\overline{x_n}为序列{x1,...,xn}\{x_1, ..., x_n\}的均值，由xn‾−xn−1‾=x1+...+xnn−xn−1‾=xn−1‾(n−1)+xnn−xn−1‾=xn−xn−1‾n\overline{x_n}-\overline{x_{n-1}} = \frac{x_1+...+x_n}{n} - \overline{x_{n-1}} = \frac{\overline{x_{n-1}}(n-1)+x_n}{n} - \overline{x_{n-1}} = \frac{x_n - \overline{x_{n-1}}}{n}，则xn‾=xn−1‾+xn−xn−1‾n\overline{x_n}=\overline{x_{n-1}} + \frac{x_n - \overline{x_{n-1}}}{n}，于是有：

    1
    2
    3
    >>> avg = lambda arr : reduce(lambda avg_num, xn : (avg_num[0] + (xn - avg_num[0])/(avg_num[1] + 1), avg_num[1] + 1), arr, (0,0))[0]
    >>> avg([1,2,3,4])
    2.5

字典又名哈希表、散列表，实现一个哈希表需要讨论两大基本问题：地址映射和冲突处理

  1. 地址映射
    一个好的hash方法是在对象不相同的情况下能产生不相等的哈希值，这是最理想的情况，退而求次，hash方法应尽力将数据集合中不相同的对象均匀分布到所有可能的地址上面，即通过哈希函数应能得到一个“尽可能随机的地址”

  2. 冲突处理
    如果两个不同对象映射到了相同的地址，将产生冲突，无论怎样精心构造hash函数，这种冲突都不可避免，但是可以解决，如开放定址（探测再散列）、再哈希、链式、公共溢出区，其中链表法是比较常见的冲突处理办法，python采用开放定址办法

因此当我们对字典成员对象进行操作时，需要能够计算对象的哈希并比较对象之间的异同，特别是用户自定义类型，需要用户自己实现。先说说几个特殊方法（也叫“魔法方法”，以双下划线开头且以双下划线结尾，这些方法会在进行特定操作时被自动调用，譬如运算符重载方法，如上面提到过的对象比较==相当于调用对象的__eq__()方法、加法+相当于调用对象的__add__()方法等）：

  • object.__hash__(self)

    注：这是object基类所定义的哈希方法签名，下同

    __hash__()会在以下情况被调用：1）由内置方法hash()调用（hash(obj)即等同于obj.__hash__()），2）对散列集合成员进行操作时被调用，散列集合类型包括dict、set和frozenset。注意__hash__()应当返回一个整数，对于用户自定义类型，我们建议将对象的不同组件打包进元组，然后计算元组的哈希值，譬如：

    1
    2
    def __hash__(self):
        return hash((self.name, self.sex, self.age))
  • object.__getattribute__(self, name)

    实例属性访问时始终会调用__getattribute__()方法（类属性访问则不会调用之，很明显一个道理，__getattribute__()是实例方法嘛，怎么可能会调用它，当类属性不存在时也将触发AttributeError异常，而这就更不太可能触发调用__getattr__()了），如果还定义了__getattr__()，则除非__getattribute__()显式调用它或者其中引发了AttributeError异常（属性不存在的默认行为），否则不会调用后者。为了防止在此方法中陷入无穷递归，其实现应始终调用具有相同名称的基类方法来访问其所需的任何属性，如object.__getattribute__(self, name)（之所以要传入当前实例self，是因为在类上访问实例方法返回的是“非绑定方法”（即原始函数对象），而在实例上访问方法返回的则是“绑定方法”，所谓绑定，即绑定实例，实例方法访问返回的其实是一个闭包对象，譬如x.method返回的相当于partial(method,self=x)），不过一般还是使用super().method(arg)实现基类方法调用。下面的错误示例将导致无限递归（但受最大递归层数限制）：

    1
    2
    3
    4
    5
    6
    7
    8
    class A:
        def __init__(self,name):
            self.name=name
          
        def __getattribute__(self,item):
            return self.__dict__[item] #__dict__中存放着对象上绑定着的实例属性，若你想从中取值，self.__dict__又将调用self.__getattribute__()方法，从而陷入无穷递归
          
    print(A('a').name) #RecursionError: maximum recursion depth exceeded while calling a Python object
    修改： 
    1
    2
    def __getattribute__(self,item):
        return super(A,self).__getattribute__(item) #在python3中也可以简写为super()，完全等同于super(A,self)
    遇到的问题

    我写了下面的代码，但是对输出感到困惑：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    class A:
        def __init__(self,name):
            self.name=name
          
        def __getattribute__(self,item):
            print('属性访问:',item)
            print('object的__getattr__方法:',super(A,self).__getattr__) #？
            print(super(A,self).__getattr__(item)) #super到底发生了什么？
            return super(A,self).__getattribute__(item)
          
        def __getattr__(self,item):
            return 'daiyang'
          
    print(A('a').name)

    '''OUTPUT
    属性访问: name
    daiyang
    '''

    首先我们来看一下super(…)的原理（仅用于理解，因为super本身是一个类）：

    1
    2
    3
    def super(cls, inst):
        mro = inst.__class__.mro()
        return mro[mro.index(cls) + 1]

    MRO（method resolution order）列表记录了类继承体系中的成员解析顺序，每个类都有这样的属性，可以用来解决python中钻石继承的难题，核心就在于它将非线性的父类继承顺序通过C3算法转换成线性顺序。因此以后不要再单纯地认为super()返回的就是当前类的父类了，这不一定（单继承不用怀疑，肯定是父类啦，指的是多继承的情况下不一定），也可能是兄弟类（当然了，不管是“父类”还是“兄弟类”都是不严谨的说法，因为返回的是super类实例），看个例子：

    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
    class Base(object):
      def __init__(self):
          print("enter Base")
          print("leave Base")

    class A(Base):
        def __init__(self):
            print("enter A")
            #print(self.__class__.mro()) #[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>]
            super(A,self).__init__() #根据MRO列表可知，super(A,self)返回的是类B，注意了，这也是为什么说super()返回的不一定是父类，此处返回的是类A的兄弟B
            print("leave A")

    class B(Base):
        def __init__(self):
            print("enter B")
            #print(self.__class__.mro()) #[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>]
            super(B,self).__init__() #根据MRO列表可知，super(B,self)返回的是类Base
            print("leave B")

    class C(A,B):
        def __init__(self):
            print("enter C")
            #print(self.__class__.mro()) #[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>]
            super(C,self).__init__() #根据MRO列表可知，super(C,self)返回的是类A，准确来说返回的是绑定了self实例的super类对象（bound super object），可以通过__self__属性查看绑定的实例，super(C,self).__self__
            print("leave C")

    c=C()

    '''OUTPUT
    enter C
    enter A
    enter B
    enter Base
    leave Base
    leave B
    leave A
    leave C
    '''

    事实上，super(cls,inst)有两种用法，一是上述所说，参数1是类，参数2是实例，且必须满足isinstance(inst,cls)为True的条件，二是参数2也可以是一个类，此时则必须满足issubclass(inst,cls)为True的条件，两者返回的都是绑定了inst（应该是绑在__self__属性中）的super对象，注意并不是预期的父类哦，如果绑定的inst是实例，那么该super对象可以调用父类的实例方法，如果绑定的inst是类，那么该super对象则可以调用父类的类方法，当然也可以访问父类的其他类属性（包括类中定义的静态方法、非方法属性），如果父类中找不到的话，则会到父类的基类中继续搜寻，如果一直没有找到将抛出AttributeError

    回到原题，super(A,self).__getattr__理论上应该返回基类object相应的绑定方法（绑定了类A实例self），问题在于object类并未定义__getattr__()方法啊（参考书[1]出来挨打O(∩_∩)O），当访问一个不存在的属性将引发AttributeError异常，注意这个异常是在类A的__getattribute__()内部引发的，而由于还定义了__getattr__()，因此程序最终输出了字符串daiyang。我们可以捕捉该异常：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    class A:
        def __init__(self,name):
            self.name=name
          
        def __getattribute__(self,item):
            print('属性访问:',item)
            try:
                print('object的__getattr__方法:',super(A,self).__getattr__)
            except AttributeError as e:
                print('异常捕捉:',e)
            return super(A,self).__getattribute__(item)
          
        def __getattr__(self,item):
            return 'daiyang'
          
    print(A('a').name)

    '''OUTPUT
    属性访问: name
    异常捕捉: 'super' object has no attribute '__getattr__'
    a
    '''
  • object.__getitem__(self,key)
    执行self[key]时被调用，对于序列类型，接受的键应该是整数和切片对象，请注意，负索引的特殊解释（如果类希望模拟序列类型）取决于__getitem__()方法，如果key是不合适的类型，则可能引发TypeError，如果是序列的索引集合之外的值，则应引发IndexError，对于映射类型，如果缺少键（不在容器中），则应引发KeyError
  • object.__setitem__(self,key,value)
    执行self[key]=value时被调用

一般我们使用内置的标准字典或集合，甚至不需要子类化进行任何定制，即使有其它方面的需求，也有第三方库提供的数据结构供我们使用，譬如defaultdict、OrderedDict。但是自定义成员对象并通过字典等存取时，基本都得重写__hash__()和__eq__()方法，这一点很重要，现假设我们要向集合中存放自定义类对象，如：

1
2
3
4
5
6
7
8
9
class man:
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age
        
man1=man('muggle','male',22)
man2=man('muggle','male',22)
hash(man1)==hash(man2) #False

如你所见，两个“相同”（只要姓名、性别、年龄都一样，我们就认为两个人是同一人啊）对象的哈希值不一样，将它们存放到字典s=set([man1,man2])中的后果就是，字典s中竟然“有两个一毛一样的人”，这实在是匪夷所思，原因即在于，执行映射类容器相关操作的时候（譬如向字典中添加一个键值对，或查询某键的值），会先后调用键（此处man实例对象就是“键”）对象的__hash__()以及__eq__()，现在我们两个对象man1和man2的哈希值不一样，而且默认的__eq__方法也判断两个对象不相同，尽管哈希值不一样的键也有可能落到同一个“桶”里面，但是现在这两对象也不equal啊，于是这两个对象必然不同且同时存在于集合中，解决的办法就是为man类重写__hash__()和__eq__()（一般修改其中任意一个方法，另一个也要相应修改），它们必须满足以下两大规则：

  1. 如果两个对象相同，即obj1.equal(obj2)==True，则两个对象的哈希地址映射也必须相同，即hash(obj1)==hash(obj2)（否则对象明明存在于容器中，却找不到）
  2. 如果两个对象的哈希地址映射不同，即hash(obj1)!=hash(obj2)，则两个对象必须不相同，即obj1.equal(obj2)==False（否则容器中将存在同一对象的多个“副本”，浪费存储资源）

修改后的man类已满足上述规则：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class man:
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age
        
    def __hash__(self): #用姓名、性别和年龄判断两个人是否相同，若相同，此时他们的哈希也必然相同，但是相同的哈希也可能对应不同的人，此时就要靠equal方法来判断了
        return hash((self.name, self.sex, self.age))
        
    def __eq__(self,other):
        if self.name==other.name and self.sex==other.sex and self.age==other.age:
            return True
        else:
            return False

关于__hash__()和__eq__()，官方文档中有非常明确的指示：

  1. 如果重写了__eq__()，必须重写__hash__()，因为两个“相同”对象的哈希地址映射不一定相同，为了确保这一点，必须重写__hash__()加以保证。反之，如果重写了__hash__()，也必须重写__eq__()，因为两个哈希地址相同的对象，如果是相同对象，__eq__()也必须相同，否则不同，若两个对象哈希地址不同，则__eq__()必须不同，否则出错

  2. 如果只重写了__eq__()，那么该类对象将不能用于映射类容器，因为此时__hash__()将隐式地被赋为None，即此时__hash__方法失效，该类实例将不可哈希。如果想使用父类的__hash__()，需要明确说明：

    1
    2
    3
    4
    class B(A):
        __hash__=A.__hash__
        def __eq__(self,other):
            pass

  3. 如果没有重写__eq__()，又希望使__hash__()失效，应明确赋值为None：

    1
    2
    3
    4
    5
    class A():
        __hash__=None
            
    s=set()
    s.add(A()) #TypeError: unhashable type: 'A'

  4. 如果可变对象的类实现了__eq__()，就不必再为之重写__hash__()了，因为即使你重写了一个看似不会抛异常的__hash__()，但是由于对象可变，它总是会出错（可变对象就不能作为字典或集合的“键”）。举个例子，我们子类化列表，重写__eq__()，规定只要新列表的第一个元素相同，那么两个新列表就相同，同时重写__hash__()，使它返回新列表第一个元素的哈希值，这一设定是合理的，并假设新列表的第一个元素我们总是使它是可哈希的，我们创建一个新列表的实例a=['muggle']，设对象a的哈希地址为addr1，将其添加到集合s中，于是s={['muggle'],}，我们修改a的第一个元素值为'jingjing'，结果就是addr1地址上存放的字符串从muggle变成了jingjing，现在新建一个新列表实例b=['jingjing']，设对象b的哈希地址为addr2，且addr1!=addr2，将b也添加到s中，于是s={['jingjing'],['jingjing'],}，可是根据我们的__eq__和__hash__方法，显然有a==b以及hash(a)==hash(b)成立啊，即这两个对象“完全相同”，而不该在集合中重复出现！代码如下：

    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
    class MyArray(list):
        def __init__(self,*args):
            for i in args:
                self.append(i)
            
        def set(self,index,value):
            self[index]=value
            
        def __hash__(self):
            return hash(self[0])
            
        def __eq__(self,other):
            if self[0]==other[0]:
                return True
            else:
                return False
            
    a=MyArray('muggle')
    s=set()
    s.add(a) #s={['muggle']}
    a[0]='jingjing' #{['jingjing']}
    b=MyArray('jingjing')
    s.add(b) #{['jingjing'], ['jingjing']}
    hash(a)==hash(b) #True
    a==b #True

  5. 用户自定义类默认的__hash__()和__eq__()继承自基类object，它们都是非常严格的，判断两个实例相不相同是根据唯一身份标识id，哈希也是对身份标识进行哈希

字典的使用和一些注意点：

  1. Python2中判断某个key是否存在字典中可使用has_key()方法，另外一种方式是使用in关键字（key in dict），推荐使用后者，因为in的处理速度更快，另一个原因是has_key()这个方法在Python3被移除了

  2. 获取字典中某个键的值，两种方式：dict[key]或dict.get(key[, default])，前者简便但如果键不存在会导致KeyError异常，为了避免异常不得不先进行键存在性的判断，或者捕捉异常，如果不想手动捕捉异常那就子类化字典并重新定义字典的__missing__()方法以避免异常的抛出，该特殊方法只有在使用dict[key]且key不存在时才会被调用。一般我们使用dict.get()方法，键不存在则返回None（可通过default参数修改该默认值），但并不会修改底层数据，这不同于defaultdict类或dict.setdefault(key,default)，示例：

    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
    class MyDict(dict):
        def __missing__(self,key):
            #self[key]=0 #通常都会这么做，修改底层数据，否则就没有意义了，因为还不如直接通过dict.get(key,default)设置缺省值
            return 0

    d=MyDict()
    for k in '11422134431': #计数器
        d[k]+=1
    print(d) #{'1': 4, '4': 3, '2': 2, '3': 2}

    #或者：
    d=dict()
    for k in '11422134431':
        d[k]=d.get(k,0)+1
    print(d) #{'1': 4, '4': 3, '2': 2, '3': 2}

    #或者：
    d={}
    for k in '11422134431':
        d[k]=d.setdefault(k,0)+1 #setdefault(key,default=None)和get(key,default=None)方法用法类似，区别是，如果键不存在于字典中，将会添加键并将值设为默认值，即会直接修改底层数据。如果字典中包含有给定键，则返回键所对应的值，否则返回为键设置的default值
    print(d) #{'1': 4, '4': 3, '2': 2, '3': 2}

    #或者：
    from collections import defaultdict

    d=defaultdict(int) #defaultdict类的初始化函数接受一个工厂函数作为参数，作用是当key不存在时，返回的是工厂函数的默认值，比如list对应[]，str对应的是空字符串，set对应set()，int对应0
    for k in '11422134431':
        d[k]+=1
    print(d) #defaultdict(<class 'int'>, {'1': 4, '4': 3, '2': 2, '3': 2})

  3. 创建字典的几种方式：

    • dict()实例化字典对象（默认无参数时创建一个空字典，也可以直接写d={}），可以传递任意数量的关键字参数，或者是一个二元元组列表以及任意数量的关键字参数，再或者是一个字典和任意数量的关键字参数

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      >>> dict()
      {}
      >>> data=[("animal", "bear"),("animal", "duck"),("plant", "cactus"),("vehicle", "speed boat"),("vehicle", "school bus")]
      >>> dict(data) #可以传入一个二元元组列表，实际上只要是可迭代的对象且对象元素也是可迭代对象且这些元素长度一律为2的都可以
      {'animal': 'duck', 'plant': 'cactus', 'vehicle': 'school bus'}
      >>> dict(zip(['a','b','c'],[1,2,3])) #使用zip构造二元组序列
      {'a': 1, 'b': 2, 'c': 3}
      >>> dict((['a',1],['b',2]),c=3) #可以传入关键字参数
      {'a': 1, 'b': 2, 'c': 3}
      >>> dict({1:2,3:4},last=6) #也可以传入一个字典，实际上只要是mapping类型都可以，python标准mapping就是dict
      {1: 2, 3: 4, 'last': 6}

    • dict.fromkeys(seq[,initial])根据序列seq构造字典，列表中的元素将作为键，需另外指定初始值initial，若未指定则值全部为None，fromkeys()完全可以用字典生成式实现

      1
      2
      3
      >>> d=['first','second','third']
      >>> dict.fromkeys(d,8)
      {'first': 8, 'second': 8, 'third': 8}

    • 字典生成式，现在有两个序列，分别为一一对应的键值序列，将其组装为字典：

      1
      2
      3
      4
      >>> a=['first','second','third']
      >>> b=[1,2,3]
      >>> d={k:v for k,v in zip(a,b)} #for子句中有一个变量解构操作
      {'first': 1, 'second': 2, 'third': 3}

  4. 字典更新

    • d.update(other_d)，用另一个字典other_d更新原字典d，对于原字典中不存在的键值对直接增添，若存在，则更新旧值为新值

      1
      2
      3
      >>> d={'1':1,'2':2,'3':3}
      >>> d.update({'1':11,'4':4,'5':5})
      {'1': 11, '2': 2, '3': 3, '4': 4, '5': 5}

    • d[key]=value方式用于添加一个新的键值对或者更新某个键的旧值

  5. 字典元素删除

    • 使用d.pop(key[,default])删除键值对，可以指定默认的返回值，可以避免由于键不存在而导致的KeyError：

      1
      2
      3
      4
      5
      6
      7
      >>> d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
      >>> d.pop('e')
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      KeyError: 'e'
      >>> d.pop('e',None)
      None

    • popitem()返回并删除字典中的最后一对键和值（这里没搞懂，最后一对键值是怎么确定的？）：

      1
      2
      3
      4
      >>> d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
      >>> d.popitem()
      >>> d
      {'a': 1, 'b': 2, 'c': 3}

    • 使用del执行删除，既可以删除整个字典，也可以删除字典的某个键值对，如果删除的键不存在，则会报错

      1
      2
      3
      >>> d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
      >>> del d['a']
      >>> del d

  6. 字典遍历
    d.keys()、d.values()、d.items()，其中items()多用于for循环遍历：

    1
    2
    for k,v in d.items():
        print(k,v)

    事实上，字典本身也是可迭代对象，且迭代字典对象等同于迭代字典的键序列：

    1
    2
    3
    >>> d={'a':1,'b':2,'c':3}
    >>> [k for k in d]
    ['a', 'b', 'c']

和字典一样，集合虽然可以迭代，但它们都是无序的，不支持切片和index（数值下标）索引（虽然集合不属于“映射类型”，但由于都是基于散列表实现，所以放在一起描述）

  • 创建集合
    1. 创建一个空集合：
      1
      2
      >>> set()
      {}
    2. 使用现有数据初始化一个集合，set(iterable)构造方法接受一个可迭代对象，如列表：
      1
      2
      >>> set([1,2,3])
      {1,2,3}
  • 查询集合
    集合是无序容器，不能通过下标索引元素，只能遍历： 
    1
    2
    for e in set([1,2,3]):
        print(e)

    使用in或not in检查某一元素是否存在于集合中：

    1
    2
    >>> 1 in set([1,2])
    True
  • 添加元素
    1. add(item)向集合中添加单项元素：
      1
      2
      3
      4
      >>> s=set()
      >>> s.add('msy')
      >>> s
      {'msy'}

      注：鉴于集合的原理（散列表），向集合中添加的元素既是value又是key，因此添加的元素必须是可哈希的，即集合元素必须是不可变类型

    2. update(iterable)使用一系列元素（可迭代序列）更新集合（s1.update(s2)等同于“并集”操作s1|=s2）：
      1
      2
      3
      >>> s={12,13}
      >>> s.update(['muggle',101,'msy'])
      {'muggle', 101, 12, 13, 'msy'}
  • 删除元素
    1. remove(item)从集合中删除元素item，无返回值，如果元素不存在则引发keyError：
      1
      2
      3
      4
      5
      6
      >>> s={'msy'}
      >>> s.remove('msy')
      >>> s.remove('msy')
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      KeyError: 'msy'
    2. discard(item)同remove(item)，但是元素不存在时不会引发异常
    3. pop()从集合中随机删除一个元素，由于集合是无序的容器，无法通过下标索引查询元素，因此pop()不接受任何参数（可对比列表的pop()方法），该方法会返回被（某种程度可以认为是“随机”）删除的元素：
      1
      2
      3
      4
      5
      6
      7
      8
      >>> s=set()
      >>> s.update('1a2b3c4d')
      >>> s
      {'1', '2', '3', '4', 'a', 'b', 'c', 'd'}
      >>> s.pop()
      'a'
      >>> s.pop()
      'c'
    4. clear()删除集合中的全部元素，无返回值
  • 交并集数学运算（非原址）
    1. s1.intersection(s2)返回集合s1和s2的交集，该操作对应的运算符为s1 & s2：
      1
      2
      3
      4
      5
      6
      >>> s1=set([1,2])
      >>> s2=set([2,3])
      >>> s1.intersection(s2)
      {2}
      >>> s1 & s2
      {2}
    2. s1.union(s2)返回集合s1和s2的并集，该操作对应的运算符为s1 | s2：
      1
      2
      3
      4
      5
      6
      >>> s1=set([1])
      >>> s2=set([2])
      >>> s1.union(s2)
      {1, 2}
      >>> s1 | s2
      {1, 2}
    3. s1.difference(s2)返回集合s1和s2的差集（简单来说就是返回集合s1中有的而集合s2中所没有的那些元素），该操作对应的运算符为s1 - s2：
      1
      2
      3
      4
      5
      6
      >>> s1=set([1,2,3])
      >>> s2=set([2,3])
      >>> s1.difference(s2)
      {1}
      >>> s1 - s2
      {1}
    4. s1.symmetric_difference(s2)返回集合s1和s2的对称差集（简单说就是返回集合s1中有的而集合s2中所没有的，以及集合s2中有的而集合s1中所没有的那些元素，等同于(s1-s2) | (s2-s1)），该操作对应的运算符为s1 ^ s2：
      1
      2
      3
      4
      5
      6
      >>> s1=set([1,2,3])
      >>> s2=set([2,3,4])
      >>> s1.symmetric_difference(s2)
      {1, 4}
      >>> s1 ^ s2
      {1, 4}
    注1，并集、交集、差集和对称差集的非运算符版本（non-operator，如s1.union(s2)）允许接受任何可迭代对象作为参数，但它们的运算符版本要求操作数必须都是集合类型： 
    1
    2
    3
    4
    5
    6
    >>> set([1]).union([2]) #合法
    {1, 2}
    >>> set([1]) | [2] #非法
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unsupported operand type(s) for |: 'set' and 'list'

    注2，我们知道在执行s1-s2的时候，将触发执行s1.difference(s2)，但操作执行完毕后s1的值仍保持不变，属于非原址操作，同样-=运算符也适用于两个集合对象，在计算差集之后会立即更新第一个操作数（即完成两个步骤：t=s1-s2; s1=t），属于原址操作，而它实际上将触发执行s1.difference_update(s2)：

    1
    2
    3
    4
    5
    6
    7
    >>> s1=set([1,2,3])
    >>> s2=set([2,3,4])
    >>> s1-s2
    {1}
    >>> s1.difference_update(s2) #s1-=s2
    >>> s1
    {1}

    其它原址操作：

    • s1.intersection_update(s2)交集更新操作，对应运算符为s1 &= s2
    • s1.update(s2)并集更新操作，对应运算符为s1 |= s2
    • s1.symmetric_difference_update(s2)对称差集更新操作，对应运算符为s1 ^= s2
  • 父集和子集判断
    1. s1.issubset(s2)判断集合s1是否是集合s2的子集，对应运算符为s1 <= s2：
      1
      2
      3
      4
      5
      6
      >>> s1=set([1,2])
      >>> s2=set([1,2,3])
      >>> s1.issubset(s2)
      True
      >>> s1 <= s2
      True
    2. s1.issuperset(s2)判断集合s1是否是集合s2的父集，对应运算符为s1 >= s2：
      1
      2
      3
      4
      >>> s2.issuperset(s1)
      True
      >>> s2 >= s1
      True
    注，两个集合只有在这种情况下是相等（s1 == s2，不等关系测试则使用!=）的：集合中的每一个元素同时也是另一个集合中的元素（或者说二者互为子集）。一个集合比另一个集合小（s1 < s2，用于严格意义上的子集测试）：只有在第一个集合是第二个集合的子集，且第二个集合不是第一个的子集时成立。一个集合比另一个集合大（s1 > s2）：只有在第二个集合是第一个集合的子集，且第一个集合不是第二个的子集时成立
  • “冰冻”集合
    Python提供一个集合的不可变版本frozenset，创建的方式同set，譬如：
    1
    >>> fs=frozenset([1,2,3])

    两者的区别主要在于，set是可变对象，不可哈希，有add()、remove()等方法，frozenset则是不可变的，存在哈希值，因此它可以作为字典的键，也可以作为其它集合的元素，缺点是一旦创建便不能更改，没有add()、remove()等方法，但是和普通集合一样，支持union()、difference()等交并运算以及issubset()等关系运算

    普通集合和冰冻集合可以混用，用于交并运算时，第一个操作数的类型还决定了返回值的类型，譬如第一个操作数是frozenset，第二个是set，那么返回值就是frozenset：

    1
    2
    >>> frozenset([1,2,3])-set([1])
    frozenset({2, 3})

    collections模块提供了两个集合类型，Set和MutableSet，后者用于判断是否是可变集合


Sponsor

[1] Python参考手册 第4版 修订版 [美] 大卫·M.比兹利（David M.Beazley）著，谢俊，杨越，高伟 译
[2] Formatted string literals 详解
[3] 知乎 Python的type和object之间是什么关系？
[4] 可迭代对象和迭代器

]]> 计算机基础 编程语言 Python Numpy基础教程 posts/10423/ .note.simple{ padding-left: 1rem;}.table-wrap { margin: 0 0 .3rem;}

考研那年年末学习和梳理了numpy和matplotlib这两个模块，该文档主要就是基于那时的笔记，matplotlib没有时间重新整理了，见原始笔记（matplotlib初级教程、3D绘图、patches与path）

Numpy主要提供了同构（所有元素类型相同）多维（维度也被称为“轴”）数组对象ndarray，具有矢量化运算能力，除了支持多维数组与矩阵运算，此外还针对数组运算提供大量的数学函数库

首先看看核心对象ndarray的主要属性：

  • ndim：轴的数量，即数组维数
  • shape：数组的形状，一个整数元组，长度即为数组维数，从左到右依次是每个维度的轴长，譬如一个n行m列的矩阵，其形状为(n,m)，表示第0维（轴）的长度为n、第1维（轴）的长度为m
  • dtype：数组元素类型，如np.int32、np.int16和np.float64（np是numpy的缩写）
  • flags：数组的内存布局信息
  • real和imag：分别是数组的实部和虚部（即时非虚数类型也有这两个属性）
  • itemsize：数组元素大小，以字节为单位，如元素为float64类型的数组itemsize为8（64/8，一个字节占8位），而complex32类型的数组itemsize为4（32/8），其等于ndarray.dtype.itemsize
  • size：数组中的元素个数（可用于判断数组是否为空，np.array([]).size=0）
  • T：数组转置，仅针对二维数组（或矩阵matrix对象）
  • strides：跨度元组，其中的整数是指为了前进到当前维度下一个元素需要“跨过”的字节数
  • flat：数组的元素迭代器，返回一个flatiter对象，可以用作一维数组“视图”
数据类型

内置数据类型包括（括号中是数据类型的格式字符或格式字符串）：
np.bool（?或b1）、np.int（默认为np.int32）、np.int8（b或i1或int8）、np.int16（h或i2或int16）、np.int32（i或i4或int32）、np.int64（q或i8或int64）、np.uint8（B或u1或uint8）、np.uint16（H或u2或uint16）、np.uint32（I或u4或uint32）、np.uint64（Q或u8或uint64）、np.float（默认为np.float64）、np.float16（e或f2或float16）、np.float32（f或f4或float32）、np.float64（d或f8或float64）、np.complex（默认为np.complex128）、np.complex64（F或c8或complex64）、np.complex128（D或c16或complex128）、np.str（a或S，可以在a或S后面添加数字，表示字符串长度，比如S3表示长度为三的字符串，不写则为最大长度）、np.unicode（U）、np.object（O）、np.void（V）。可以用格式字符（串）作为np.dtype()的参数来创建相应的数据类型对象，或作为np.array()等函数的参数用于创建数组对象，譬如np.dtype('i1')==np.int8、np.array([1,2,3,4],dtype='d')

注1：可以通过np.sctypeDict.keys()获取所有的字符代码，dtype对象有一个char属性用于获取对应的字符代码（另见str属性），还有一个type属性获取对应的数据类型
注2：数组的类型转换可以通过astype()方法实现，譬如np.array([1,2,3],dtype='i4').astype('float')（将数据类型从int32转换成float64）

自定义结构化数据类型

Numpy允许我们自定义结构化数据类型和结构化数组对象（numpy structured arrays），这些数组既可以通过标签索引也可以通过命名字段索引，看一个简单的示例：

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
>>> a=np.array([[[('a',1),('b',2),('c',3)],[('d',4),('e',5),('f',6)],[('g',7),('h',8),('i',9)]],[[('j',10),('k',11),('l',12)],[('m',13),('n',14),('o',15)],[('p',16),('q',17),('r',18)]]],dtype=[('char','S3'),('int',np.int)])
>>> a.shape
(2, 3, 3)
>>> a.dtype
dtype([('char', 'S3'), ('int', '<i4')])
>>> a[1]
array([[(b'j', 10), (b'k', 11), (b'l', 12)],
       [(b'm', 13), (b'n', 14), (b'o', 15)],
       [(b'p', 16), (b'q', 17), (b'r', 18)]],
      dtype=[('char', 'S3'), ('int', '<i4')])
>>> _.shape
(3, 3)
>>> a[1,1,1] #等同于a[1][1][1]
(b'n', 14)
>>> c=a['char'] #切片和索引得到的可变对象都是浅拷贝，所以对c的修改将如实反映在a中
>>> c
array([[[b'a', b'b', b'c'],
        [b'd', b'e', b'f'],
        [b'g', b'h', b'i']],

       [[b'j', b'k', b'l'],
        [b'm', b'n', b'o'],
        [b'p', b'q', b'r']]], dtype='|S3')
>>> c.shape
(2, 3, 3)
>>> c[1,1,1]='dy'
>>> a[1,1,1]
(b'dy', 14)
>>> a['int']
array([[[ 1,  2,  3],
        [ 4,  5,  6],
        [ 7,  8,  9]],

       [[10, 11, 12],
        [13, 14, 15],
        [16, 17, 18]]])
>>> _.dtype
dtype('int32')
>>> a[0]['int']
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>> a[['int','char']] #可以使用字段名称列表一次访问多个字段，类似于花式索引
array([[[( 1, b'a'), ( 2, b'b'), ( 3, b'c')],
        [( 4, b'd'), ( 5, b'e'), ( 6, b'f')],
        [( 7, b'g'), ( 8, b'h'), ( 9, b'i')]],

       [[(10, b'j'), (11, b'k'), (12, b'l')],
        [(13, b'm'), (14, b'n'), (15, b'o')],
        [(16, b'p'), (17, b'q'), (18, b'r')]]],
      dtype=[('int', '<i4'), ('char', 'S3')])

上面这个数组a的形状是(2,3,3)，只不过每一个元素都是结构化数据，其由两个字段构成，字段名称分别为char和int，类型分别为“长度为3的字符串”和“32位整数”，可以像访问字典那样将某一字段的数据从结构化数组中剥离出来，如a['int']，也可以同时访问多个字段，如a[['int','char']]。结构化数据类型同样可以用于创建特定数组，譬如：

1
2
3
4
5
6
>>> z=np.zeros(3,dtype=np.dtype([('first','i4'),('second','f')]))
>>> z
array([(0, 0.), (0, 0.), (0, 0.)],
      dtype=[('first', '<i4'), ('second', '<f4')])
>>> z.shape
(3,)

上述结构化数据类型的定义形如[(字段名,类型),...]（二元组列表），其中“类型”既可以是dtype对象，也可以是类型格式字符（串），且类型格式字符（串）前面还可以添加可选的“形状”信息，用于描述数组形状，换句话说，字段类型除了可以是整型、布尔型、字符串、复数类型等外，还可以是数组类型，譬如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> z=np.zeros(3,dtype=np.dtype([('first','(2,3)i4'),('second','f')]))
>>> z.shape
(3,)
>>> z['first']
array([[[0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0]]])
>>> _.shape
(3, 2, 3)

事实上，还有其他三种定义结构化数据类型的方式：

  • 以逗号分隔的类型格式字符串
    每个类型字符串各自代表一个字段，但是此种情况下无法自由指定字段名，默认的字段名为f0、f1、…，譬如：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    >>> z=np.zeros(3,dtype='3int8, float32, (2,3)float64') #包含三个字段，字段1为(3,)形单字节整数类型数组，字段2为32位浮点数，字段3为(2,3)形64位浮点数类型数组
    >>> z.shape
    (3,)
    >>> z['f0']
    array([[0, 0, 0],
           [0, 0, 0],
           [0, 0, 0]], dtype=int8)
    >>> z['f1']
    array([0., 0., 0.], dtype=float32)
    >>> z['f2']
    array([[[0., 0., 0.],
            [0., 0., 0.]],

           [[0., 0., 0.],
            [0., 0., 0.]],

           [[0., 0., 0.],
            [0., 0., 0.]]])
    >>> _.dtype
    dtype('float64')

  • 字典，形如{'names':[字段名1,...],'formats':[类型1,...]}：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    >>> z=np.zeros(3,{'names':['first','second'],'formats':[np.float32,'2i4']})
    >>> z.shape
    (3,)
    >>> z.dtype
    dtype([('first', '<f4'), ('second', '<i4', (2,))])
    >>> z['first']
    array([0., 0., 0.], dtype=float32)
    >>> z['second']
    array([[0, 0],
           [0, 0],
           [0, 0]])

  • 这个似乎比较特殊，我也不知道具体有什么应用，看个例子吧：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    >>> z=np.zeros(3, dtype=('i4',[('b1','u1'), ('b2','u1'), ('b3','u1'), ('b4','u1')]))
    >>> z.shape
    (3,)
    >>> z
    array([0, 0, 0],
          dtype=(numpy.int32, [('b1', 'u1'), ('b2', 'u1'), ('b3', 'u1'), ('b4', 'u1')]))
    >>> z['b1']
    array([0, 0, 0], dtype=uint8)
    >>> z['b1']=[1,2,3]
    >>> z['b2']=[11,12,13]
    >>> z
    array([2817, 3074, 3331],
          dtype=(numpy.int32, [('b1', 'u1'), ('b2', 'u1'), ('b3', 'u1'), ('b4', 'u1')]))

    简单解释一下，('i4',[('b1','u1'), ('b2','u1'), ('b3','u1'), ('b4','u1')])表示将一个4字节的整型划分成了四个部分，每部分都是一个单字节的无符号整型，分别对应字段b1（最低字节）、b2、b3、b4（最高字节），此时有z[i]==(z['b4'][i]<<24)+(z['b3'][i]<<16)+(z['b2'][i]<<8)+z['b1'][i]成立，以z[1]为例，z['b1'][1]=2（十进制的2对应二进制的00000010），z['b2'][1]=12（十进制的12对应二进制的00001100），z['b3'][1]=0（十进制的0对应二进制的00000000），z['b4'][1]=0（十进制的0对应二进制的00000000），于是将这四个字节拼接得到00000000,00000000,00001100,00000010，再转换成十进制即可得到3074

    1
    2
    3
    4
    5
    >>> 0b00000000_00000000_00001100_00000010
    3074
    >>> i=1
    >>> z[i]==(z['b4'][i]<<24)+(z['b3'][i]<<16)+(z['b2'][i]<<8)+z['b1'][i]
    True

    另外还可以这样定义：z=np.zeros(3, dtype=('i4','u1,u1,u1,u1'))、z=np.zeros(3, dtype=('i4',{'names':['b1','b2','b3','b4'],'formats':['u1','u1','u1','u1']}))，都是一样的

可以通过names属性访问和修改结构化数据类型的字段名，还有一个类似于字典的fields只读属性，键名为字段名，非结构化数据类型的names和fields都是None，因而可以据此判断一个dtype对象是否是结构化数据类型：

1
2
3
4
5
6
7
8
9
10
11
12
>>> d=np.dtype('i1,f,S10')
>>> d.type
<class 'numpy.void'>
>>> d.names
('f0', 'f1', 'f2')
>>> d.names=('field1','field2','field3')
>>> d
dtype([('field1', 'i1'), ('field2', '<f4'), ('field3', 'S10')])
>>> d.fields #键值为字段类型和偏移量构成的元组，我也不知道这个偏移量是什么鬼，官方文档里我没有找到相关解释啊
mappingproxy({'f0': (dtype('int8'), 0), 'f1': (dtype('float32'), 1), 'f2': (dtype('S10'), 5)})
>>> np.dtype('i4').names is None
True

可以按行、按列或者按字段对结构化数组进行填充：

1
2
3
4
5
6
7
8
9
10
11
12
>>> z=np.zeros((2,3),dtype=[('f1','i4'),('f2','f')])
>>> z
array([[(0, 0.), (0, 0.), (0, 0.)],
       [(0, 0.), (0, 0.), (0, 0.)]], dtype=[('f1', '<i4'), ('f2', '<f4')])
>>> z[0]=[(1,2),(3,4),(5,6)] #按行填充
>>> z[:,0]=[(11,12),(13,14)] #按列填充
>>> z['f1']=[[21,22,23],[24,25,26]] #按字段填充
>>> z[1,1]=(31,32) #注意只能使用元组填充某一个元素而不能使用列表，否则报错ValueError: setting an array element with a sequence.
>>> z
array([[(21, 12.), (22,  4.), (23,  6.)],
       [(24, 14.), (31, 32.), (26,  0.)]],
      dtype=[('f1', '<i4'), ('f2', '<f4')])

这里介绍的并不全面，实际上每个字段还可以指定偏移量和标题等（我也没大看懂，具体有什么用我也不知道），并且构造方式也不止上述几种形式，具体请参阅官方文档

创建结构化数组时需要注意的地方：

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
>>> L=[[[0, 0], [0, 1], [0, 2], [0, 3]], [[1, 0], [1, 1], [1, 2], [1, 3]], [[2, 0], [2, 1], [2, 2], [2, 3]]]
>>> LT=[[(0, 0), (0, 1), (0, 2), (0, 3)], [(1, 0), (1, 1), (1, 2), (1, 3)], [(2, 0), (2, 1), (2, 2), (2, 3)]]
>>> np.array(L,dtype='i4,i4')
array([[[(0, 0), (0, 0)],
        [(0, 0), (1, 1)],
        [(0, 0), (2, 2)],
        [(0, 0), (3, 3)]],

       [[(1, 1), (0, 0)],
        [(1, 1), (1, 1)],
        [(1, 1), (2, 2)],
        [(1, 1), (3, 3)]],

       [[(2, 2), (0, 0)],
        [(2, 2), (1, 1)],
        [(2, 2), (2, 2)],
        [(2, 2), (3, 3)]]], dtype=[('f0', '<i4'), ('f1', '<i4')])
>>> _.shape
(3, 4, 2)
>>> np.array(LT,dtype='i4,i4')
array([[(0, 0), (0, 1), (0, 2), (0, 3)],
       [(1, 0), (1, 1), (1, 2), (1, 3)],
       [(2, 0), (2, 1), (2, 2), (2, 3)]],
      dtype=[('f0', '<i4'), ('f1', '<i4')])
>>> _.shape
(3, 4)

我写了个函数（list2structarray()）来解决该问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np

#给定结构化数据类型将一个（嵌套）列表无差别转换成结构化数组对象
def list2structarray(a,dtype):
    a=np.array(a)
    t=[tuple(i) for i in a.reshape(-1,a.shape[-1])]
    return np.array(t,dtype=dtype).reshape(a.shape[:-1])
    
a=[[[0, 0], [0, 1], [0, 2], [0, 3]], [[1, 0], [1, 1], [1, 2], [1, 3]], [[2, 0], [2, 1], [2, 2], [2, 3]]]
s=list2structarray(a,'i4,i4')
print(s)
print(s.shape)
print(s.dtype)

'''OUTPUT
[[(0, 0) (0, 1) (0, 2) (0, 3)]
 [(1, 0) (1, 1) (1, 2) (1, 3)]
 [(2, 0) (2, 1) (2, 2) (2, 3)]]
(3, 4)
[('f0', '<i4'), ('f1', '<i4')]
'''

创建数组

np.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)
参数说明：

  • object：可以是python原生序列类型，如（嵌套）列表、（嵌套）元组等，也可以是ndarray类型及其子类，函数默认行为总是会返回object的（深）拷贝副本，两者占据完全不同的内存
  • dtype：设置数组元素的数据类型，缺省时会根据object的类型自行确定
  • copy：控制当object为ndarray类型或其子类matrix时是否进行（深）复制的行为，设为False，如果object是ndarray类型，将直接返回object自身（即满足is判断），如果object是matrix类型，则浅拷贝，修改任意一方都会体现在对方，且只有当subok置为True时才会返回object自身
  • order：指定数组在内存中的布局，有两种不同的风格（C或Fortran），C为行主方向（譬如一个二维数组，在内存中依次存储数组的每一行），F为列主方向（譬如一个二维数组，在内存中依次存储数组的每一列），如果object非ndarray类型，可取值就是C（默认）或者F，否则，还可以取值A或K，所创建的数组order由以下规则确定：
    ordercopy=Falsecopy=True
    'K'和object的order一致F & C order preserved, otherwise most similar order（没懂）
    'A'和object的order一致若object的order为F且非C，则order为F，反之为C
    'C'order为Corder为C
    'F'order为Forder为F
  • subok：默认情况下将创建的数组强制转换为基类数组对象（ndarray），设为True则返回子类（譬如矩阵类型matrix是ndarray的子类，m=np.matrix('1 2 3; 4 5 6');a=np.array(m,subok=True)，type(a)为numpy.matrixlib.defmatrix.matrix，且issubclass(type(a),np.ndarray)为True）
  • ndmin：设置最低维度，创建的多维数组至少是ndmin维（譬如object的形状为(2,3)，而ndmin为4，则创建的数组形状为(1,1,2,3)），当object的维度大于此值时，则不管，维度同object

注（order参数），给定一个二维数组a=[[1,2,3],[4,5,6]]，如果按照C顺序创建x=np.array(a,order='C')，此时默认的dtype为np.int32，x.itemsize为4，形状x.shape为(2,3)，其在内存中的存储为：|1|2|3|4|5|6|（因为内存总是连续的），每个格子占据4字节大小，其跨度元组x.strides为(12,4)，表示第0维前进到下一个元素需要“跨过”12个字节（如内存中1到4之间的距离），第1维前进到下一个元素需要“跨过”4个字节（如内存中1到2之间的距离），如果是按照F顺序创建y=np.array(a,order='F')，y.itemsize为4，形状y.shape为(2,3)，其在内存中的存储为：|1|4|2|5|3|6|，其跨度元组y.strides为(4,8)

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=[[1,2,3],[4,5,6]]
>>> b=np.array(a)
>>> b[0,0]=888
>>> a
[[1, 2, 3], [4, 5, 6]]
>>> c=np.array(b)
>>> c[0,0]=999
>>> b
array([[888,   2,   3],
       [  4,   5,   6]])
>>> d=np.array(b,copy=False)
>>> d is b
True
>>> d[0,0]=111
>>> b
array([[111,   2,   3],
       [  4,   5,   6]])
>>> e=np.matrix(a)
>>> e
matrix([[1, 2, 3],
        [4, 5, 6]])
>>> e[0,0]=222
>>> a
[[1, 2, 3], [4, 5, 6]]
>>> f=np.array(e,copy=False)
>>> f[0,0]=333
>>> e
matrix([[333,   2,   3],
        [  4,   5,   6]])
>>> f is e
False
np.copy()

np.copy(a, order='K')
函数说明：
深拷贝输入对象a（可以是ndarray也可以是python原生列表等），尽管np.array()可以达到相同的功能，但是np.copy()的函数名更加直截了当，即复制一个数组对象，通常直接在ndarray对象上调用（ndarray.copy()）

np.asarray(a, dtype=None, order=None)
函数说明：
作用也是将输入a转换为一个ndarray对象，除了比np.array()少了很多控制参数，最大的区别是，当a是ndarray对象时，将返回自身，如果a是列表、元组等，则还是深拷贝，但当a是matrix对象，则浅拷贝，此时虽然不满足is判断，但是修改任意一方，都会体现在对方，换句话说，np.asarray()相当于np.array()的参数copy置为False时的版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> import numpy as np
>>> a=[[1,2,3],[4,5,6]]
>>> b=np.array(a)
>>> c=np.asarray(b)
>>> b is c
True
>>> d=np.matrix('1 2 3;4 5 6')
>>> e=np.asarray(d)
>>> d is e
False
>>> e[0,0]=666
>>> d
matrix([[666,   2,   3],
        [  4,   5,   6]])

np.fromiter(iterable, dtype, count=-1)
函数说明：
将一个一维的可迭代（序列）对象iterable转为一维数组并返回，如果（序列）元素也是序列，则只能自定义结构化数据类型，否则出错。注意参数dtype是必填参数，count参数用于决定读取序列的多少个元素，默认值-1表示全部读取。须知，np.array()仅能将array_like对象转换为ndarray，如列表等，如果是生成器等或其他自定义可迭代对象则无法转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> g=(i for i in range(5))
>>> np.array(g)
array(<generator object <genexpr> at 0x00000239D28B0728>, dtype=object)
>>> np.fromiter(g,dtype='i',count=3)
array([0, 1, 2], dtype=int32)
>>> n=[(1,2,3),(4,5,6)]
>>> np.array(n)
array([[1, 2, 3],
       [4, 5, 6]])
>>> np.fromiter(n,dtype='i')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: setting an array element with a sequence.
>>> np.fromiter(n,dtype=np.dtype([('col1','i1'),('col2','i1'),('col3','i1')])) #参见numpy structured arrays
array([(1, 2, 3), (4, 5, 6)],
      dtype=[('col1', 'i1'), ('col2', 'i1'), ('col3', 'i1')])

np.fromfunction(function, shape, dtype=float)
函数说明：
function函数可接受参数个数应等于shape形状元组的长度（假设shape长度为n，则表示function是一个n元函数），同时shape也是将要创建的数组的形状。以二维为例，shape=(m,n)，则function是一个二元函数，创建的数组记作a，则有a[i,j]=function(i,j)。更一般的，对shape=(k1,k2,k3...kn)来说，fromfunction()将返回一个n维数组对象a，第i维的长度为ki，a[i1,i2,...,in]的值就是function(i1,i2,...,in)

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
#(3,4)形二维数组位置坐标
y,x=np.meshgrid(range(4),range(3))
print(list2structarray(np.rollaxis(np.stack([x,y]),0,3),'i4,i4')) #list2structarray()函数定义见numpy structured arrays

#设二元函数f(x,y)=x*y
def f(x,y):
    return x*y
print(np.fromfunction(f,(3,4)))

'''OUTPUT
[[(0, 0) (0, 1) (0, 2) (0, 3)]
 [(1, 0) (1, 1) (1, 2) (1, 3)]
 [(2, 0) (2, 1) (2, 2) (2, 3)]]
[[0. 0. 0. 0.]
 [0. 1. 2. 3.]
 [0. 2. 4. 6.]]
'''

'''间隙等于1太大？希望缩小至1/m，则：
def f(i1,i2,...,in):
    i1/=m
    ...
    in/=m
    ...
相应的shape也应成倍增大，fromfunction(f,(m*k1,m*k2,...,m*kn))
'''
#举个一维的例子，设一维函数：f(x)=x^2，要求画出在x轴[0,8]区间上的图像，采样间隔设为1/5，相较于间隔为1时的图像将显得更为光滑
y=np.fromfunction(lambda x:(x/5)**2,(8*5,))
x=[i/5 for i in range(8*5)]

import matplotlib.pyplot as plt
plt.plot(x,y)
plt.show()
np.arange()

np.arange([start,] stop[, step,], dtype=None)
函数说明：
类似于python内置的range()函数，区别在于，range()不接受浮点数作为参数，只接受整数类型，而np.arange()允许浮点数作为参数，一般说来两者都是在左闭右开的数值范围内产生均匀间隔的值，但np.arange()由于允许接受浮点型参数，受计算精度影响得到的结果有可能是左闭右闭的，譬如np.arange(3,3.2,0.1)的结果是[3.0,3.1,3.2]，而np.arange(3,3.3,0.1)的结果却又是[3.0,3.1,3.2]，具体原因不明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> np.arange(5)
array([0, 1, 2, 3, 4])
>>> np.arange(2,7)
array([2, 3, 4, 5, 6])
>>> np.arange(2.3,4.1,0.3)
array([2.3, 2.6, 2.9, 3.2, 3.5, 3.8])
>>> np.arange(3,3.2,0.1)
array([3. , 3.1, 3.2])
>>> range(5)
range(0, 5)
>>> list(_)
[0, 1, 2, 3, 4]
>>> list(range(2,7))
[2, 3, 4, 5, 6]
>>> list(range(2.3,4.1,0.3))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer
np.linspace()

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
函数说明：
和np.arange()的区别：np.arange()通过指定开始值、终值和步长创建一个等差的一维数组，得到的结果中是不包含终值的，而np.linspace()则是通过指定开始值、终值和元素个数创建等差的一维数组，并且可以通过endpoint参数指定是否包含终值，默认值为True即表示包含终值，参数retstep为True时，将返回一个元组，第一个元素是生成的等差数组，第二个元素则是差值或者说间距

1
2
3
4
5
6
7
8
>>> np.linspace(0,1,12)
array([0.        , 0.09090909, 0.18181818, 0.27272727, 0.36363636,
       0.45454545, 0.54545455, 0.63636364, 0.72727273, 0.81818182,
       0.90909091, 1.        ])
>>> np.linspace(0,1,12,endpoint=False,retstep=True)
(array([0.        , 0.08333333, 0.16666667, 0.25      , 0.33333333,
       0.41666667, 0.5       , 0.58333333, 0.66666667, 0.75      ,
       0.83333333, 0.91666667]), 0.08333333333333333)
np.logspace()

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
函数说明：
该函数用于创建一个一维的对数等比数组，计算过程是这样的：首先将除base以外的参数（暂且假设endpoint为True）全部传递给np.linspace()函数创建一个等差数列[start,start+Δ,start+2·Δ,...,start+(num-1)·Δ]（其中Δ为差值，满足条件start+(num-1)·Δ=stop），然后据此创建等比数列：[base^start,base^(start+Δ),base^(start+2·Δ),...base^(stop)]，公比为base^Δ

1
2
3
4
5
6
7
8
>>> np.logspace(0,5,5)
array([1.00000000e+00, 1.77827941e+01, 3.16227766e+02, 5.62341325e+03,
       1.00000000e+05])
>>> np.linspace(0,5,5)
array([0.  , 1.25, 2.5 , 3.75, 5.  ])
>>> 10**_
array([1.00000000e+00, 1.77827941e+01, 3.16227766e+02, 5.62341325e+03,
       1.00000000e+05])
np.geomspace()

np.geomspace(start, stop, num=50, endpoint=True, dtype=None)
函数说明：
该函数用于创建一个一维的指数等比数组，其返回（暂且假设endpoint为True）：[start^1,start^(1+Δ),start^(1+2·Δ),...,start^(1+(num-1)·Δ)]（其中Δ满足start^(1+(num-1)·Δ)=stop），公比为start^Δ，可以对比np.logspace()，np.logspace()需要指定等比数列取对数后的等差数列的首项和末项，而np.geomspace()则需要指定等比数列本身的首项和末项

1
2
3
4
5
6
7
#np.geomspace()的输出取底为start的对数后将得到一个等差数列[1,1+Δ,1+2·Δ,...,1+(num-1)·Δ]
#设start=3，Δ=1，num=10，则stop=start^(1+(num-1)·Δ)=59049
>>> np.geomspace(3,59049,10)
array([3.0000e+00, 9.0000e+00, 2.7000e+01, 8.1000e+01, 2.4300e+02,
       7.2900e+02, 2.1870e+03, 6.5610e+03, 1.9683e+04, 5.9049e+04])
>>> np.log10(_)/np.log10(3) #换底公式：log_a(b)=log_10(b)/log_10(a)，含义为：以a为底b的对数等于以10为底b的对数除以以10为底a的对数
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])
np.empty()

np.empty(shape, dtype=float, order='C')
函数说明：
创建形状为shape的空数组，并以随机值填充（所谓“空”是指数组中没有任何有效值，这和np.zeros()不同，0是有效值）

1
2
3
4
5
6
>>> np.empty((2,3))
array([[6.23042070e-307, 5.11798224e-307, 1.37961370e-306],
       [4.22795269e-307, 9.34609790e-307, 1.06101441e-312]])
>>> np.empty((2,3)) #同一形状每次生成的结果是相同的
array([[6.23042070e-307, 5.11798224e-307, 1.37961370e-306],
       [4.22795269e-307, 9.34609790e-307, 1.06101441e-312]])
np.empty_like()

np.empty_like(a, dtype=None, order='K', subok=True)
函数说明：
创建形状、类型同a的空数组，但仍可通过dtype参数指定类型

np.zeros()

np.zeros(shape, dtype=float, order='C')
函数说明：
创建形状为shape的零数组

np.zeros_like()

np.zeros_like(a, dtype=None, order='K', subok=True)
函数说明：
创建形状、类型同a的零数组，但仍可通过dtype参数指定类型

np.ones()

np.ones(shape, dtype=None, order='C')
函数说明：
创建形状为shape的全1数组

np.ones_like()

np.ones_like(a, dtype=None, order='K', subok=True)
函数说明：
创建形状、类型同a的全1数组，但仍可通过dtype参数指定类型

np.full()

np.full(shape, fill_value, dtype=None, order='C')
函数说明：
用指定的值fill_value填充一个形状为shape的多维数组

1
2
3
>>> np.full((2,3),8)
array([[8, 8, 8],
       [8, 8, 8]])
np.full_like()

np.full_like(a, fill_value, dtype=None, order='K', subok=True)
函数说明：
用指定的值填充与给定数组a形状、类型相同的多维数组，但仍可通过dtype参数指定类型

np.eye()

np.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
函数说明：
能够用于创建单位矩阵（二维ndarray对象，对角线元素值为1，其余为0），N指定行数，M指定列数（缺省情况下M=N），参数k（整型）用于指定“主对角线”的偏移量，当为负数时，向左方偏移，为正数时向右方偏移

1
2
3
4
5
6
7
8
9
10
11
12
>>> np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> np.eye(3,5)
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.]])
>>> np.eye(3,5,k=2)
array([[0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])
np.identity()

np.identity(n, dtype=None)
函数说明：
专门用于创建形状为(n,n)的单位矩阵

如果希望能够重现生成的伪随机数，只需要设置相同的随机种子np.random.seed(seed)（参数seed是一个整数，范围限于[0,232−1][0,2^{32}-1]），如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> np.random.seed(20210527)
>>> np.random.rand(2,3)
array([[0.94230071, 0.7680507 , 0.41849498],
       [0.23640405, 0.28777521, 0.53928407]])
>>> np.random.rand(2,3)
array([[0.03641101, 0.3279482 , 0.48352279],
       [0.77410674, 0.50404311, 0.4773902 ]])
>>> np.random.seed(20210527) #种下同一种子，随机函数结果一致
>>> np.random.rand(2,3)
array([[0.94230071, 0.7680507 , 0.41849498],
       [0.23640405, 0.28777521, 0.53928407]])
>>> np.random.rand(2,3)
array([[0.03641101, 0.3279482 , 0.48352279],
       [0.77410674, 0.50404311, 0.4773902 ]])
np.random.rand()

np.random.rand(d0, d1, ..., dn)
函数说明：
生成形状为(d0,d1,...,dn)的数组，并使用[0.0, 1.0)上均匀分布的随机样本（浮点数）填充它，如果没有给定任何参数，则返回单个浮点数

1
2
3
4
5
6
7
>>> np.random.rand()
0.6258827101037749
>>> np.random.rand(5)
array([0.62735357, 0.88232692, 0.23067855, 0.59308295, 0.22785762])
>>> np.random.rand(2,3)
array([[0.98092414, 0.32172215, 0.94662153],
       [0.27608697, 0.89694515, 0.55163334]])

如果希望生成的范围区间介于[a,b)，可以通过(b - a) * np.random.rand(...) + a得到：

1
2
3
>>> a,b=3,5
>>> (b - a) * np.random.rand(5) + a
array([3.55059992, 4.37930213, 3.03409387, 4.17120523, 3.04866055])
np.random.sample()

np.random.random_sample(size=None)
函数说明：
作用同np.random.rand()，只不过传入的是size形状参数，若size为None，则返回单个随机浮点数

np.random.randn()

np.random.randn(d0, d1, ..., dn)
函数说明：
生成形状为(d0,d1,...,dn)的数组，并使用服从标准正态分布（均值为0，方差为1）的随机样本（浮点数，钟型曲线在-1.96～+1.96范围下的面积等于0.95）填充它，如果没有给定任何参数，则返回单个浮点数

如果你希望构造服从均值为μ\mu、方差为σ2\sigma^2的随机数（组），记作X∼N(μ,σ2)X\sim N(\mu,\sigma^2)，根据标准化有X−μσ∼N(0,1)\frac{X-\mu}{\sigma}\sim N(0,1)，设Z=X−μσZ=\frac{X-\mu}{\sigma}，即有Z∼N(0,1)Z\sim N(0,1)，X=σZ+μ∼N(μ,σ2)X=\sigma Z+\mu\sim N(\mu,\sigma^2)，因此可以通过σ*np.random.randn(...)+μ来获取这样的XX：

1
2
3
4
5
6
7
8
import numpy as np
import matplotlib.pyplot as plt
μ,σ=2,3
X=σ*np.random.randn(10000)+μ #或者X=np.random.normal(loc=μ, scale=σ,size=(10000,))
print((μ-3*σ,μ+3*σ)) #(-7, 11) #“3σ原则”
plt.hist(X,80,density=True,color='g',edgecolor='k')
plt.title(f'$X\sim N(\mu,\sigma^2),\mu={μ},\sigma^2={σ**2}$')
plt.show()
np.random.standard_normal()

np.random.standard_normal(size=None)
函数说明：
作用同np.random.randn()，区别好像仅在于np.standard_normal()允许接受形状元组作为参数

np.random.normal()

np.random.normal(loc=0.0, scale=1.0, size=None)
函数说明：
生成服从均值为loc（μ\mu）、标准差为scale（σ\sigma）的正态分布的形状为size的数组

np.random.randint()

np.random.randint(low, high=None, size=None, dtype='l')
函数说明：
生成一个数值介于[low,high)左闭右开区间的形状为size的整型随机数组。特别地，当只传入参数low且参数high为None时，生成的随机整数将处于[0,low)区间，当size形状为None时，将返回一个标量，而当size是一个整数时，将返回一个长度为size的一维数组

1
2
3
4
>>> np.random.randint(1) #显然此时总是返回0
0
>>> np.random.randint(-10,10,size=(5,))
array([ 1, -6, -8, -9,  5])
np.random.choice()

np.random.choice(a, size=None, replace=True, p=None)
函数说明：
用于从给定的一组数据a中产生随机样本（或依照指定概率p），采样数目由size参数决定（数目为np.cumprod(a.shape)[-1]），并组织成形状为size的数组返回
参数说明：

  • a：可以是一维数组（也可以是python列表）或者整型标量，特别地，当其为标量时，相当于a=np.arange(a)，表示从[0,a)中随机采样
  • size：指定输出数组形状，也可以指定为一个整型标量，如n，相当于size=(n,)，如果size为None，函数将输出单个样本
  • replace：决定采样中是否有重复值（True表示可以重复），只有当size小于等于len(a)的时候（采样数小于全部样本数），才能置为False
  • p：一个一维序列，对应着a中每个样本的概率分布，如果没有指定，则使用均匀分布
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> np.random.choice([3,5,7,9,12,67,1,19],size=10)
array([ 1,  3,  1,  3, 67, 19, 67, 12,  5,  3])
>>> np.random.choice(5, 3)
array([1, 2, 2])
>>> np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])
array([0, 3, 3], dtype=int64)
>>> np.random.choice(5, 3, replace=False)
array([2, 1, 0])
>>> np.random.choice(5, 8, replace=False)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "mtrand.pyx", line 1166, in mtrand.RandomState.choice
ValueError: Cannot take a larger sample than population when 'replace=False'
>>> np.random.choice(['pooh', 'rabbit', 'piglet', 'Christopher'], 5, p=[0.5, 0.1, 0.1, 0.3])
array(['pooh', 'rabbit', 'Christopher', 'pooh', 'rabbit'], dtype='<U11')
np.random.shuffle()

np.random.shuffle(x)
函数说明：
沿第0维对数组x（x还可以是python列表，shuffle操作并不会改变其类型）进行“洗牌”（打乱顺序），且为原址操作，函数无返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
>>> a=np.arange(10)
>>> np.random.shuffle(a)
>>> a
array([5, 0, 1, 8, 4, 6, 9, 7, 2, 3])
>>> a=np.arange(9).reshape((3,3))
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> np.random.shuffle(a)
>>> a
array([[0, 1, 2],
       [6, 7, 8],
       [3, 4, 5]])
>>> a=['Christopher','pooh','rabbit','pooh','pooh']
>>> np.random.shuffle(a)
>>> a
['pooh', 'rabbit', 'Christopher', 'pooh', 'pooh']
>>> type(a)
<class 'list'>
np.random.permutation()

np.random.permutation(x)
函数说明：
功能同np.random.shuffle()，但非原址操作，函数将返回打乱后的数组，x除了可以是python列表，还可以是一个整型参数，相当于对数组np.arange(x)进行shuffle

1
2
3
4
5
6
7
>>> a=['Christopher','pooh','rabbit','pooh','pooh']
>>> np.random.permutation(a)
array(['pooh', 'Christopher', 'rabbit', 'pooh', 'pooh'], dtype='<U11')
>>> a
['Christopher', 'pooh', 'rabbit', 'pooh', 'pooh']
>>> np.random.permutation(10)
array([9, 1, 3, 4, 6, 5, 8, 0, 2, 7])

形状重塑

np.reshape(a, newshape, order='C')
函数说明：
将多维数组a变形为newshape，一般是直接在ndarray对象上调用该方法，形式为ndarray.reshape(newshape,order='C')（此时既可以直接传递形状元组，也可以将其解包为多个位置参数传递）， 需要注意的是，reshape()函数返回的新数组其实是原多维数组对象a的“视图”，所谓“视图”，即你对视图的修改将原封不动地反映在原始数据中，因此对reshape()函数返回的“新数组”的修改将影响到a（如果a是python对象自然不会影响），如果不希望变形操作影响原数组，则采用np.resize()替代，或者先进行一次深拷贝（np.copy()）
参数说明：

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
>>> np.reshape([[1,2,3],[4,5,6]],(-1,))
array([1, 2, 3, 4, 5, 6])
>>> a=np.arange(6)
>>> a.reshape((2,3))
array([[0, 1, 2],
       [3, 4, 5]])
>>> a.reshape(2,3) #手动将newshape解包为多个位置参数传递
array([[0, 1, 2],
       [3, 4, 5]])
>>> a.reshape(*(2,3)) #利用*自动将newshape解包为多个位置参数传递
array([[0, 1, 2],
       [3, 4, 5]])
>>> _[0,0]=666 #对视图的修改将反映在原数组上，反之对原数组的修改也可以通过视图实时显示
>>> a
array([666,   1,   2,   3,   4,   5])
>>> a = np.array([[0, 1],
...               [2, 3],
...               [4, 5]])
>>> o=np.reshape(a, (2, 3), order='F') #第一步，按照列主序读取数组a，得到|0|2|4|1|3|5|，然后第二步，按照列主序顺序将其依次存储在(2,3)形的新数组中，对于第二步的实施其实很简单，首先新数组在内存中连续存储的就是|0|2|4|1|3|5|，只需要再设置一下flags为列主序以及跨度元组strides即可，而strides显然为(4,8)，这也变相告诉了计算机新数组各维度大小，即(2,3)
>>> o
array([[0, 4, 3],
       [2, 1, 5]])
>>> o.flags
  C_CONTIGUOUS : False
  F_CONTIGUOUS : True
  OWNDATA : False
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False
>>> o.strides
(4, 8)

需要注意的是，如果reshape()的order参数为C，只有在a为C-contiguous（a.flags['C_CONTIGUOUS']为True）时才会返回视图，否则返回深拷贝，反之，若order为F，则只有在a为F-contiguous（a.flags['F_CONTIGUOUS']为True）时才会返回视图，否则返回深拷贝

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
>>> a=np.array([[1,2,3],[4,5,6]],order='F')
>>> a
array([[1, 2, 3],
       [4, 5, 6]])
>>> a.flags
  C_CONTIGUOUS : False
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False
>>> a.reshape(3,2)
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> _[0,0]=666
>>> a
array([[1, 2, 3],
       [4, 5, 6]])
>>> a.reshape(3,2,order='F')
array([[1, 5],
       [4, 3],
       [2, 6]])
>>> _[0,0]=666
>>> a
array([[666,   2,   3],
       [  4,   5,   6]])

np.resize(a, newshape)
函数说明：
作用同np.reshape()，最大的区别在于np.resize()返回的是一个完全独立的新数组，对其所做的一切修改不会影响原数组，且此时允许指定错误的或者说不匹配的newshape，多余的部分会被丢弃，不足的部分则会复用已有的数据补全（描述能力有限，具体见示例），另外，虽然也可以直接在ndarray对象上调用resize()方法，但ndarray.resize(...)是原址操作，无返回值（返回值为无意义的None），此时newshape形状元组中禁止使用代表缺省维数的-1（np.resize(...)虽然不直接报错，但是结果也不正确，也必须禁止），不匹配的newshape则会导致错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
>>> a=np.arange(10)
>>> np.resize(a,(2,-1))
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])
>>> _[0,0]=666
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a.resize((2,-1))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: negative dimensions not allowed
>>> np.resize(a,(8,)) #丢弃部分
array([0, 1, 2, 3, 4, 5, 6, 7])
>>> np.resize(a,(2,9)) #不足补全，不足部分将不断重复ndarray.flat中的数据
array([[0, 1, 2, 3, 4, 5, 6, 7, 8],
       [9, 0, 1, 2, 3, 4, 5, 6, 7]])
>>> a.resize((2,9))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: cannot resize an array that references or is referenced
by another array in this way.  Use the resize function

np.swapaxes(a, axis1, axis2)
函数说明：
用于交换多维数组的某两个维度，函数返回原数组的“视图”，可以直接在ndarray上调用ndarray.swapaxes(axis1,axis2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> x = np.array([[1,2,3]])
>>> np.swapaxes(x,0,1)
array([[1],
       [2],
       [3]])
>>> _[0,0]=666
>>> x
array([[666,   2,   3]])
>>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
>>> np.swapaxes(x,0,2) #同np.swapaxes(x,2,0)
array([[[0, 4],
        [2, 6]],

       [[1, 5],
        [3, 7]]])

以二维或三维数组为例，将其分别放到二维平面和三维空间坐标系中，swapaxes()操作相当于交换某两个轴的名称

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
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d.art3d import Poly3DCollection,Line3DCollection
import numpy as np
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False

x=np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
y=np.swapaxes(x,0,2)

points=[(1,1,0),(0,1,0),(0,0,0),(1,0,0),(1,1,1),(0,1,1),(0,0,1),(1,0,1)]
faces=[(0,4,7,3,0),(0,1,5,4,0),(1,2,6,5,1),(2,3,7,6,2),(4,5,6,7,4),(0,1,2,3,0)]
plots=[[points[point_num] for point_num in face] for face in faces]

line3d=Line3DCollection(plots)
ax1=plt.subplot(121,projection='3d')
ax1.add_collection3d(line3d)
plt.xlabel('轴0')
plt.ylabel('轴1')
plt.gca().set_zlabel('轴2')
plt.xticks([])
plt.yticks([])
plt.gca().set_zticks([])

line3d=Line3DCollection(plots)
ax2=plt.subplot(122,projection='3d')
ax2.add_collection3d(line3d)
plt.xlabel('轴2') #只需要交换两根轴的名称即可
plt.ylabel('轴1')
plt.gca().set_zlabel('轴0')
plt.xticks([])
plt.yticks([])
plt.gca().set_zticks([])

for pos in points:
    ax1.text(*pos,f'{x[pos]}:{pos}',color='red' if pos==(0,0,0) else 'black')
    ax2.text(*pos,f'{x[pos]}:{pos}',color='red' if pos==(0,0,0) else 'black')
plt.suptitle(f'交换数组x的0轴和2轴：y=np.swapaxes(x,0,2)\n x={x}\n y={y}')
plt.show()

np.transpose(a, axes=None)
函数说明：
区别于np.swapaxes()只能一次性交换两个维度，该操作用于同时变换n个轴的名称（n≤a.ndim），axes即是一个长度为a.ndim的元组，里面是要转换的维度序号，当其为None时，相当于np.transpose(a,axes=list(reversed(range(len(a.shape)))))，此时可以用于二维数组的转置操作，函数返回的是原数组的“视图”（ndarray对象的T属性返回的也是“视图”），也可以直接在ndarray上调用ndarray.transpose(axes=None)。另外轴变换后得到的数组内存布局将会发生变化，譬如一个二维的列主序数组，transpose后会变成行主序

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
>>> x=np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
>>> x.transpose() #显然对于三维数组，axes为None时等同于x.swapaxes(0,2)
array([[[0, 4],
        [2, 6]],

       [[1, 5],
        [3, 7]]])
>>> x.transpose((2,1,0))
array([[[0, 4],
        [2, 6]],

       [[1, 5],
        [3, 7]]])
>>> a=np.array([[0,1],[2,3],[4,5]])
>>> a.transpose()
array([[0, 2, 4],
       [1, 3, 5]])
>>> a.T #多维数组的.T属性返回的也是“视图”，所有视图之间实时共享数据
array([[0, 2, 4],
       [1, 3, 5]])
>>> _[0,0]=666
>>> a
array([[666,   1],
       [  2,   3],
       [  4,   5]])

np.rollaxis(a, axis, start=0)
函数说明：
向前或向后滚动特定的轴axis到一个特定位置start，在滚动过程中，其它轴的相对位置不会改变，默认是将某根轴向前滚动到位置0，即变成轴0，向前滚动时要滚动到位置几就将start置为几即可，譬如将轴2滚动到轴1位置处，即为np.rollaxis(a,2,1)，但是向后滚动时需要人为加1，譬如一个三维数组，要将轴0滚动到原本的轴2位置处，应当是np.rollaxis(a,0,3)而非np.rollaxis(a,0,2)，函数返回的仍是“视图”，但是ndarray对象上并无rollaxis()方法属性

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
>>> a=np.arange(24).reshape(2,3,4)
>>> a
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])
>>> np.rollaxis(a,0,3)
array([[[ 0, 12],
        [ 1, 13],
        [ 2, 14],
        [ 3, 15]],

       [[ 4, 16],
        [ 5, 17],
        [ 6, 18],
        [ 7, 19]],

       [[ 8, 20],
        [ 9, 21],
        [10, 22],
        [11, 23]]])
>>> _.shape
(3, 4, 2)
>>> np.rollaxis(a,0,2)
array([[[ 0,  1,  2,  3],
        [12, 13, 14, 15]],

       [[ 4,  5,  6,  7],
        [16, 17, 18, 19]],

       [[ 8,  9, 10, 11],
        [20, 21, 22, 23]]])
>>> _.shape
(3, 2, 4)
>>> np.rollaxis(a,2,1)
array([[[ 0,  4,  8],
        [ 1,  5,  9],
        [ 2,  6, 10],
        [ 3,  7, 11]],

       [[12, 16, 20],
        [13, 17, 21],
        [14, 18, 22],
        [15, 19, 23]]])
>>> _.shape
(2, 4, 3)

ndarray.flatten(order='C')
函数说明：
用于“一维化”多维数组（降维），返回的是原数组的深拷贝

1
2
3
4
5
>>> a=np.array([[0,1,2],[3,4,5]])
>>> a.flatten()
array([0, 1, 2, 3, 4, 5])
>>> a.flatten('F')
array([0, 3, 1, 4, 2, 5])
np.ravel()

np.ravel(a, order='C')
函数说明：
作用同ndarray.flatten()，区别在于np.ravel()（或ndarray.ravel()）返回的是原数组的“视图”，不过我更倾向于使用ndarray.reshape(-1)

1
2
3
4
5
6
7
8
>>> a=np.arange(6).reshape(2,3)
>>> b=a.ravel()
>>> b[0]=666
>>> b
array([666,   1,   2,   3,   4,   5])
>>> a
array([[666,   1,   2],
       [  3,   4,   5]])

需要注意的是，如果ravel()的order参数为C，只有在a为C-contiguous时才会返回视图，否则返回深拷贝，反之，如果order为F，则只有在a为Fortran-contiguous时才会返回视图，否则返回深拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
>>> a=np.arange(6).reshape(2,3,order='F')
>>> a
array([[0, 2, 4],
       [1, 3, 5]])
>>> b=a.ravel()
>>> b[0]=666
>>> b
array([666,   2,   4,   1,   3,   5])
>>> a
array([[0, 2, 4],
       [1, 3, 5]])
>>> a.flags['C_CONTIGUOUS']
False
>>> a.flags['F_CONTIGUOUS']
True
>>> b=a.ravel(order='F')
>>> b[0]=888
>>> b
array([888,   1,   2,   3,   4,   5])
>>> a
array([[888,   2,   4],
       [  1,   3,   5]])

np.expand_dims(a, axis)
函数说明：
该函数用于扩展数组a的维度，一次只能增加一个维度，新增维度的轴长为1，函数将返回原数组的“视图”，比较常见的是扩充第一个或最后一个维度，但一般会用a[None,...]或a[...,None]简写达到同样的效果

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
>>> a=np.arange(6).reshape(2,-1)
>>> a
array([[0, 1, 2],
       [3, 4, 5]])
>>> np.expand_dims(a,0)
array([[[0, 1, 2],
        [3, 4, 5]]])
>>> _.shape
(1, 2, 3)
>>> np.expand_dims(a,1)
array([[[0, 1, 2]],

       [[3, 4, 5]]])
>>> _.shape
(2, 1, 3)
>>> np.expand_dims(a,2)
array([[[0],
        [1],
        [2]],

       [[3],
        [4],
        [5]]])
>>> _.shape
(2, 3, 1)
>>> np.expand_dims(a,-1) #扩充最后一个维度时，axis参数可以写-1
array([[[0],
        [1],
        [2]],

       [[3],
        [4],
        [5]]])
>>> _.shape
(2, 3, 1)
>>> a[None,...]
array([[[0, 1, 2],
        [3, 4, 5]]])
>>> _.shape
(1, 2, 3)
>>> a[None,:,:]
array([[[0, 1, 2],
        [3, 4, 5]]])
>>> _.shape
(1, 2, 3)
>>> a[:,None,:]
array([[[0, 1, 2]],

       [[3, 4, 5]]])
>>> _.shape
(2, 1, 3)
>>> a[...,None]
array([[[0],
        [1],
        [2]],

       [[3],
        [4],
        [5]]])
>>> _.shape
(2, 3, 1)
>>> a[:,:,None]
array([[[0],
        [1],
        [2]],

       [[3],
        [4],
        [5]]])
>>> _.shape
(2, 3, 1)
>>> a=np.arange(24).reshape(2,3,4)
>>> a[:,None,:,None,:] #还可以同时写多个None，用于同时扩充多个维度
array([[[[[ 0,  1,  2,  3]],

         [[ 4,  5,  6,  7]],

         [[ 8,  9, 10, 11]]]],



       [[[[12, 13, 14, 15]],

         [[16, 17, 18, 19]],

         [[20, 21, 22, 23]]]]])

np.squeeze(a, axis=None)
函数说明：
该函数默认用于删除多维数组a中的所有轴长为1的维度（axis为None），函数将返回原数组的“视图”，也可以直接在ndarray对象上调用该方法，也可以指定axis参数，即删除指定的维度（但该维度的轴长必须为1）

1
2
3
4
5
6
>>> a=np.arange(24).reshape(2,3,4)
>>> b=a[:,None,:,None,:]
>>> b.squeeze().shape
(2, 3, 4)
>>> b.squeeze(1).shape
(2, 3, 1, 4)

数组切片和索引

先说说（数值）索引，对数组（单个）元素的索引是通过数字下标进行定位的，譬如a[i][j]表示沿着数组a的第0轴获取第i个位置上的元素，记作b=a[i]，然后再沿着数组b的第0轴获取第j个位置上的元素，就得到a[i][j]，简写形式为a[i,j]，其中逗号用于分隔不同的维度（事实上，不管是此处的数值索引还是后面的切片索引，对于不足的维度说明，譬如a[i]就是只给出了第0维的索引说明，总是会自动在最后使用...对其他维度的索引说明进行补全，譬如a[i]即等同于a[i,...]，...含义后面会说），而切片索引可以同时访问多个元素，有两种使用方式（同原生python），一是创建切片对象slice(start,end,stride)（切片范围不包括end在内），二是使用冒号语法start:end:stride（同样切片范围不包括end在内）替代slice对象，譬如a[i:j]，同样，可以使用逗号作为不同维度的间隔，譬如a[i:j,i:j]表示沿着数组a的第0轴获取第i个位置到第j个位置之前的所有元素，记作b=a[i:j]，然后再沿着数组b的第1轴获取第i个位置到第j个位置之前的所有元素，即b[:,i:j]，要知道每进行一次数值索引，返回的数组维数都会减一，而切片索引的返回结果则始终保持维数不变（许多numpy函数都有一个叫做keepdims的参数，就是这个意思），因此上面a[i][j]的描述也可以改成：首先沿着数组a的第0轴获取第i个位置上的元素且保持维数不变，即得到b=a[i:i+1]，然后再沿着数组b的第1轴获取第j个位置上的元素且保持维数不变，即b[:,j:j+1]，所得相当于[[a[i,j]]]，数值索引和切片索引自然可以混用，譬如a[:,i]（表示获取数组a的第i列），另外，numpy索引还支持...（ellipse对象，须知其在索引中只能出现一次，原生python索引不支持）用于替代一个或多个（逗号间隔且连续的）:，譬如a[i:j,:,:]可以替换成a[i:j,...]、a[:,:,i:j]可以替换成a[...,i:j]、a[:]可以替换成a[...]、a[:,i]可以替换成a[...,i]

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
>>> a=list(range(10))
>>> a[::-1] #原生python切片索引示例
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> a[2:10:2]
[2, 4, 6, 8]
>>> a[5:7]
[5, 6]
>>> a=np.arange(12).reshape(3,4)
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> a[1,2]
6
>>> a[0:2:1]
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])
>>> a[::-1]
array([[ 8,  9, 10, 11],
       [ 4,  5,  6,  7],
       [ 0,  1,  2,  3]])
>>> a[:2,1:-1] #numpy切片索引，由于是多个维度，可以通过逗号间隔不同维度的切片
array([[1, 2],
       [5, 6]])
>> a[slice(0,2),slice(1,-1)]
array([[1, 2],
       [5, 6]])
>>> a[...,2]
array([ 2,  6, 10])
>>> a[...,2:2+1] #要保持维度一致，有时我会这样写：a[...,[2]]，但这并不总是正确，譬如a[0:0+1,[1]]和a[[0],[1]]结果就有区别，后者的维度依旧没有保持住，可以参见高级索引，前者属于花式索引（一维花式索引和切片索引混用），后者则属于全坐标索引，实际上，在所有维度都是数值索引的情况下，不能全都用括号括起来以进行维度保持，因为全坐标索引返回的结果总是一维数组，除非你在进行全坐标索引的时候指定形状信息，a[[[0]],[[1]]]，索引坐标放在一个(1,1)形状的数组中，返回的索引结果也会按照相应形状组织
array([[ 2],
       [ 6],
       [10]])
>>> a[0,::]
array([0, 1, 2, 3])
>>> a[0,...]
array([0, 1, 2, 3])

Numpy索引还支持一个特殊对象None，之前在介绍np.expand_dims()时顺带展示了相关用法，这里再简单回顾一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> a=np.arange(10).reshape((2,-1))
>>> _=a[...,None]
>>> _.shape
(2, 5, 1)
>>> _=a[:,None] #None是多出来的一个维度，而a是一个二维数组，因此维度说明应有两处，此处仅出现一处，因此在最后加上...变成a[:,None,...]，也就是a[:,None,:]
>>> _.shape
(2, 1, 5)
>>> _=a[:,None,:]
>>> _.shape
(2, 1, 5)
>>> _=a[:,None,...]
>>> _.shape
(2, 1, 5)
全坐标索引

这算是最简单的一种索引方式，需要将全部待索引元素的坐标按不同维度分别组织起来（过程相当于zip(坐标点1,坐标点2,...)），称为坐标分量（此时是一维的序列），然后将其以逗号间隔用于索引，索引结果将被存放于一个一维数组中，譬如一个二维数组，全坐标索引形式为：ndarray[行索引序列,列索引序列]

1
2
3
4
5
>>> a=np.array([[1,2,3],[6,7,8],[11,12,13]]) #要索引第一行第一个元素、第二行第二个元素以及第三行第三个元素，这三个元素的位置坐标分别为：(0,0)、(1,1)、(2,2)
>>> x=[0,1,2] #行索引序列
>>> y=[0,1,2] #列索引序列
>>> a[x,y] #全坐标索引总是返回一个一维数组
array([ 1,  7, 13])

上述坐标分量被放在一个一维列表（数组）中，返回的结果也是一维的，事实上，你可以将坐标分量放在嵌套列表（多维数组）中，索引结果也会按照相应的形状结构组织：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> a=np.arange(1,28).reshape((3,3,-1)) #这是一个(3,3,3)形状的数组，八个顶点上的坐标分别为：(0,0,0),(0,2,0),(0,0,2),(0,2,2),(2,0,0),(2,2,0),(2,0,2),(2,2,2)，下面索引之
>>> x=[0,0,0,0,2,2,2,2] #0轴分量
>>> y=[0,2,0,2,0,2,0,2] #1轴分量
>>> z=[0,0,2,2,0,0,2,2] #2轴分量
>>> a[x,y,z]
array([ 1,  7,  3,  9, 19, 25, 21, 27])
>>> x=[[[0,0],[0,0]],[[2,2],[2,2]]] #如果我们希望返回的8个顶点仍以原始相对位置展示，即索引返回(2,2,2)的三维数组，只需要将坐标分量组织为(2,2,2)形状
>>> y=[[[0,0],[2,2]],[[0,0],[2,2]]]
>>> z=[[[0,2],[0,2]],[[0,2],[0,2]]]
>>> a[x,y,z]
array([[[ 1,  3],
        [ 7,  9]],

       [[19, 21],
        [25, 27]]])

假设给出了待索引的所有坐标点，可以通过zip()函数简化全坐标分量序列的构造：

1
2
3
4
5
6
7
8
>>> a=np.arange(1,28).reshape((3,3,-1))
>>> points=[(0,0,0),(0,2,0),(0,0,2),(0,2,2),(2,0,0),(2,2,0),(2,0,2),(2,2,2)]
>>> x,y,z=zip(*points)
>>> a[x,y,z]
array([ 1,  7,  3,  9, 19, 25, 21, 27])
>>> pos=zip(*points)
>>> a[[*pos]] #标准的全坐标索引形式为ndarray[轴0坐标分量,轴1坐标分量,...]，实践发现在这些所有分量外面再套一层中括号，结果不变，即可以写成ndarray[[轴0坐标分量,轴1坐标分量,...]]，因此此处，[*pos]（*的简化容器添加功能）返回[(0, 0, 0, 0, 2, 2, 2, 2), (0, 2, 0, 2, 0, 2, 0, 2), (0, 0, 2, 2, 0, 0, 2, 2)]，可以直接将其用于全坐标索引，为什么不a[*pos]呢？因为该语法非法。套一层括号结果不变，套两层乃至更多层呢？结果是会变的，实际将变成一种花式索引
array([ 1,  7,  3,  9, 19, 25, 21, 27])
布尔索引

布尔索引通过构建一个布尔型多维数组（称为“掩码数组”），用于数组元素的过滤（过滤出的元素会被放在一个一维数组中，假设过滤元素是标量，那么返回的将是一维数组，如果过滤元素是向量，则会返回二维数组），譬如条件过滤a[a>0]将返回数组a中所有大于0的元素（a>0可以得到一个与a同形的掩码数组，因而过滤出的元素是标量，最终该布尔索引将返回一个一维数组），须知掩码数组的形状（记为ms，设长度为m）应和待索引数组的形状（记为ns，设长度为n）具有“前向一致性”（我胡诌的名词，一般掩码数组应是ndarray对象，如果是python列表则有可能会出错），即ms应构成ns的前m项，且满足m≤n，譬如ns=(2,3,4)，那么ms只能是(2)、(2,3)或(2,3,4)的其中一种，特别地，当进行一维布尔索引时（指布尔掩码数组是一维的），可以以逗号间隔多个维度，且可以和（单个）数值索引、切片索引混用，但注意只能在其中一个维度上使用布尔掩码（长度需和当前维度的轴长一致），和全坐标索引自然不能混用，另外和（一维）花式索引也不能混用，否则结果错误，具体见下示例：

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
>>> a=np.arange(10).reshape((2,-1)) #现给定一个二维数组，输出其中所有大于3的元素
>>> a
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
>>> def f(a): #手动构建与待索引数组同形的二维布尔数组：对待索引数组中的每一个元素进行判断，符合条件为True，不符合为False
...     s=a.shape
...     return np.array([True if i>3 else False for i in a.reshape((-1))]).reshape(s)
...
>>> a[f(a)]
array([4, 5, 6, 7, 8, 9])
>>> a>3 #ndarray对象上的关系运算将返回一个布尔型数组，满足关系的为True，不满足为False
array([[False, False, False, False,  True],
       [ True,  True,  True,  True,  True]])
>>> a[a>3]
array([4, 5, 6, 7, 8, 9])
>>> b=[True,False] #待索引数组形状为(2,5)，此掩码数组的形状为(2,)，这是允许的，含义是沿待索引二维数组的0轴进行元素过滤选取，具体的，此处表示第一行符合条件，而第二行不符合条件
>>> a[b]
array([[0, 1, 2, 3, 4]])
>>> a[0,[True,False,False,False,True]] #以逗号间隔不同维度的索引，其中第0维是（单个）数值索引，第1维是（一维）布尔索引，如果改成a[[True,True],[True,False,False,False,True]]，结果是没意义的，尽管不会直接报错，因为布尔索引在不同维度上至多只能使用一次，再譬如改成a[[0,1],[True,False,False,False,True]]，返回array([0, 9])结果也是没意义的，第0维上其实是（一维）花式索引，和布尔索引不能混用
array([0, 4])
>>> a[[True,False]][:,[True,False,False,False,True]] #如果要对不同维度分别进行布尔索引，应像这样使用，交换顺序也正确，a[:,[True,False,False,False,True]][[True,False]]
array([[0, 4]])
>>> a=np.arange(24).reshape(2,3,4)
>>> a
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])
>>> a[np.array([[True,False,False],[False,True,True]])] #待索引数组形状为(2,3,4)，布尔掩码数组形状是(2,3)，这是允许的，表示沿着0轴和1轴构成的“面”进行过滤，过滤出的元素是长度为4的一维数组，过滤出的元素将被放在一个一维数组中，因此返回的结果将是(n,4)形状的，其中n是过滤出的元素个数
array([[ 0,  1,  2,  3],
       [16, 17, 18, 19],
       [20, 21, 22, 23]])
>>> a[[[True,False,False],[False,True,True]]] #同上，只不过掩码数组是list类型，此时出错，而之前如一维的布尔掩码数组则允许是list类型，有点莫名
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: boolean index did not match indexed array along dimension 0; dimension is 2 but corresponding boolean dimension is 3
>>> a[[True,True],:,[True,True,False,False]] #注意这是一个错误示例，输出不符合预期（因为一维布尔索引只能出现一次，不能出现在多个维度上），按理说，由于数组a轴0长度为2，该索引应该相当于a[...,[True,True,False,False]]，观察输出，后者正常
array([[ 0,  4,  8],
       [13, 17, 21]])

使用布尔索引可以“较为方便”地操作“表”结构（其实就是二维或三维的numpy数组，三维即表示“多层叠加的表”），为此，还需要准备有字段数组，用于标识“表”不同维度所代表的信息，譬如下面我们预备构建一个(2,3,3)形的三维数组，其中(3,3)的子数组记录的是所有3个学生3门科目的成绩信息，第0维的2表示期中和期末两个阶段的成绩，另构建三个字段数组，第一个表示“时间”维度信息，第二个表示“学生”维度信息，第三个表示“科目”维度信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'''学生成绩单
                            语文      数学    英语
期中：Daiyang：  80       78      70
            Muggle:      90       82      86
            Huamulan:   87       78      83
期末：Daiyang：  78       76      85
            Muggle:      88       91      79
            Huamulan:   92       89      90
'''
scores=np.array([[[80,78,70],[90,82,86],[87,78,83]],
                 [[78,76,85],[88,91,79],[92,89,90]]])

periods=np.array(['Midterm','Endterm'])
names=np.array(['Daiyang','Muggle','Huamulan'])
subjects=np.array(['Chinese','Math','English'])

要获取Muggle期中的三科成绩：

1
2
3
4
5
6
>>> scores[periods=='Midterm'].squeeze()[names=='Muggle']
array([[90, 82, 86]])
>>> scores[periods=='Midterm'][:,names=='Muggle'] #这种方式看起来更好一点
array([[[90, 82, 86]]])
>>> scores[:,names=='Muggle'][periods=='Midterm'] #交换顺序也正确
array([[[90, 82, 86]]])

要获取所有人的期末英语成绩：

1
2
3
4
5
6
7
8
9
10
>>> scores[periods=='Endterm'][:,:,subjects=='English']
array([[[85],
        [79],
        [90]]])
>>> scores[...,subjects=='English'][periods=='Endterm']
array([[[85],
        [79],
        [90]]])
>>> scores[periods=='Endterm'].squeeze().T[subjects=='English']
array([[85, 79, 90]])

要获取Muggle期中期末的数学成绩：

1
2
3
4
5
6
>>> scores[:,names=='Muggle'][...,subjects=='Math']
array([[[82]],

       [[91]]])
>>> scores.swapaxes(0,1)[names=='Muggle'].squeeze().T[subjects=='Math']
array([[82, 91]])

要获取Daiyang和Huamulan期末的语文成绩：

1
2
3
>>> scores[periods=='Endterm'][:,(names=='Daiyang')|(names=='Huamulan')][...,subjects=='Chinese']
array([[[78],
        [92]]])
花式索引

何为花式索引？设待索引数组a为二维，给定两个整数序列s1和s2，含义上，s1选中了二维数组中的某些行，s2选中了二维数组中的某些列，现要获取这些行列交线的交点所在位置的元素，这就是花式索引，很简单，通过a[np.ix_(s1,s2)]即可获得，所得结果数组形状为(len(s1),len(s2))，换句话说，这两个整数序列s1和s2的笛卡尔积就是将要定位的全部元素的二维位置坐标，再譬如三维数组的花式索引，给定三个整数序列s1、s2、s3，这三个整数序列的笛卡尔积就是将要定位的全部元素的三维位置坐标，可以通过a[np.ix_(s1,s2,s3)]快速获取，返回的数组形状显然就是(len(s1),len(s2),len(s3))，事实上，对于任意一个待索引的n维数组，传入np.ix_()的整数序列数量≤n即可，仍以三维待索引数组a为例（将其视为由诸多一维数组元素构成的二维数组，数组元素a[i][j]即是一个一维数组），a[np.ix_(s1,s2)]表示在轴0和轴1构成的“面”上进行花式索引，由于索引的元素本身就是一维数组，因此该花式索引将返回三维数组，形状为(len(s1),len(s2),a.shape[2])，特别地，当传入np.ix_()的整数序列数量为1时，表示特殊的一维花式索引（由于np.ix_(s,)将返回s本身，所以一维花式索引a[np.ix_(s,)]可以简写成a[s]），此时可以以逗号间隔不同的维度，但是只能在其中一个维度上使用（一维）花式索引，其可以和（单个）数值索引、切片索引混用，和全坐标索引自然不能混用，另外也不能和（一维）布尔索引混用，否则结果错误（整体十分类似于上面介绍的布尔索引）

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
>>> a=np.arange(12).reshape(3,4)
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> a[np.ix_([0,1],[1,3])]
array([[1, 3],
       [5, 7]])
>>> b=np.arange(24).reshape(2,3,4)
>>> b
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])
>>> b[np.ix_([0,1],[1],[1,3])]
array([[[ 5,  7]],

       [[17, 19]]])
>>> b[np.ix_([1],[0,1])] #在三维数组轴0和轴1构成的“面”上进行花式索引
array([[[12, 13, 14, 15],
        [16, 17, 18, 19]]])
>>> np.rollaxis(b,1,3)[np.ix_([0,1],[2,3])] #如果要在轴0和轴2构成的“面”上进行花式索引的话，需要先变换数组的轴，使原来的轴2滚动到轴1的位置上
array([[[ 2,  6, 10],
        [ 3,  7, 11]],

       [[14, 18, 22],
        [15, 19, 23]]])
>>> a[np.ix_([0,2])]
array([[ 0,  1,  2,  3],
       [ 8,  9, 10, 11]])
>>> a[[0,2]] #同上，因为np.ix_([0,2])将返回np.array([0,2])，其实也就是[0,2]。这是一维花式索引，允许以逗号为间隔指定多个维度的索引方式，其等同于a[[0,2],...]
array([[ 0,  1,  2,  3],
       [ 8,  9, 10, 11]])
>>> a[:,[0,2]] #一维花式索引可以和切片索引混用
array([[ 0,  2],
       [ 4,  6],
       [ 8, 10]])
>>> a[1,[0,2]] #一维花式索引可以和（单个）数值索引混用
array([4, 6])
>>> b[:,1,[0,3]] #同上
array([[ 4,  7],
       [16, 19]])
>>> b[[0,1],:,[0,1]] #注意这是一个错误示例，输出不符合预期（因为一维花式索引只能出现一次，不能出现在多个维度上），按理说，由于数组b轴0长度为2，此处不应该相当于b[...,[0,1]]么？观察两者输出，后者正常
array([[ 0,  4,  8],
       [13, 17, 21]])
笛卡尔积计算

废话不多说，直接看代码吧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
'''任意数量的序列的笛卡尔积，递归法求解
编写思路：
1.函数返回的是什么？返回的形式总为：[(),(),...,()]
2.一般步骤是什么？对于N个序列的“笛卡尔积”，只要求出前N-1个，其结果记为t（形如[(),(),...,()]，设其长度为s），那么与第N个序列（[e0,e1,...,en]）再做一次“笛卡尔积”的结果将为：[(*t[0],e0),...,(*t[s],e0),(*t[0],e1),...,(*t[s],e1),(*t[0],e2),...,(*t[s],e2),......,(*t[0],en),...,(*t[s],en)]
3.递归的终点是什么（问题分解的最小规模）？只有一个序列（记为seq）的“笛卡尔积”，返回结果就是：[(e,) for e in seq]
'''
def cross_product(*arrs):
    ret=[]
    if len(arrs)==1:
        return [(i,) for i in arrs[0]]
    t=cross_product(*arrs[:-1])
    for i in t:
        for j in arrs[-1]:
            ret.append((*i,j))
    return ret

print(cross_product([1,2,3])) #个数3
print(cross_product([1,2],[3,4,5])) #个数2*3=6
print(cross_product([1,2,3],[4,5,6],[7,8,9])) #个数3*3*3=27
特别地，np.ix_()还允许接收布尔型序列boolean_sequence，它将被自动转化为np.nonzero(boolean_sequence))，也就是序列中为真值True的下标，还是以之前的“学生成绩单”为案例，再要获取Muggle期中的三科成绩：
1
2
3
4
>>> scores[np.ix_(periods=='Midterm',names=='Muggle')]
array([[[90, 82, 86]]])
>>> scores[np.ix_(periods=='Midterm',names=='Muggle',subjects=='Math')] #进一步获取Muggle的期中数学成绩
array([[[82]]])
再要获取所有人的期末英语成绩：
1
2
>>> np.rollaxis(scores,1,3)[np.ix_(periods=='Endterm',subjects=='English')]
array([[[85, 79, 90]]])
掌握技巧就会很容易写：将要进行条件选择的字段提前，不需要的一律置后，譬如上面的例子，periods和subjects两个字段需要进行条件选择，而names字段（“所有人”嘛）不需要，因此将names字段滚动到最后一个轴位置处，其他两个字段也就相对提前了，再举个例子，要获取Muggle的所有成绩，只有names字段需要条件选择，因此只需要将该字段提到最前即可：
1
2
3
>>> np.rollaxis(scores,1)[np.ix_(names=='Muggle')] #或np.rollaxis(scores,1)[names=='Muggle']
array([[[90, 82, 86],
        [88, 91, 79]]])
再要获取Muggle期中期末的数学成绩：
1
2
>>> np.rollaxis(scores,0,3)[np.ix_(names=='Muggle',subjects=='Math')]
array([[[82, 91]]])
再要获取Daiyang和Huamulan期末的语文成绩：
1
2
3
>>> scores[np.ix_(periods=='Endterm',(names=='Daiyang')|(names=='Huamulan'),subjects=='Chinese')]
array([[[78],
        [92]]])

最后再看一种特殊的（一维）花式索引，在上述一维花式索引使用的基础上，譬如a[s]，其中s是一个一维序列，事实上，s可以reshape成任意形状（必须是ndarray对象），此时a[s]返回的结果相当于t=a[s.flatten()];a[s]=t.reshape(*s.shape,*t.shape[1:])，再譬如a[:,s]的返回结果相当于t=a[:,s.flatten()];a[:,s]=t.reshape(*t.shape[:-1],*s.shape)，看个示例：

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
>>> a=np.arange(6)
>>> a[np.array([[0,3],[1,4],[2,5]])]
array([[0, 3],
       [1, 4],
       [2, 5]])
>>> s=np.array([[0,3],[1,4],[2,5]]);t=a[s.flatten()];t.reshape(*s.shape,*t.shape[1:]) #验证
array([[0, 3],
       [1, 4],
       [2, 5]])
>>> a=np.arange(12).reshape(3,4)
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> a[np.array([[0,1,2],[2,1,0]])]
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[ 8,  9, 10, 11],
        [ 4,  5,  6,  7],
        [ 0,  1,  2,  3]]])
>>> _.shape
(2, 3, 4)
>>> a[:,np.array([[0,1,2],[2,1,0]])]
array([[[ 0,  1,  2],
        [ 2,  1,  0]],

       [[ 4,  5,  6],
        [ 6,  5,  4]],

       [[ 8,  9, 10],
        [10,  9,  8]]])
>>> s=np.array([[0,1,2],[2,1,0]]);t=a[:,s.flatten()];t.reshape(*t.shape[:-1],*s.shape) #验证
array([[[ 0,  1,  2],
        [ 2,  1,  0]],

       [[ 4,  5,  6],
        [ 6,  5,  4]],

       [[ 8,  9, 10],
        [10,  9,  8]]])

看一个利用该原理的示例，构建循环队列：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def circular_queue(arr):
    t=list(range(len(arr)))
    inds=list(zip(*[(t+t[:-1])[i:] for i in range(len(t))]))
    return np.array(arr)[np.array(inds)]

print(circular_queue([4,4,6,3,2,7]))

'''OUTPUT
[[4 4 6 3 2 7]
 [4 6 3 2 7 4]
 [6 3 2 7 4 4]
 [3 2 7 4 4 6]
 [2 7 4 4 6 3]
 [7 4 4 6 3 2]]
'''

数组元素迭代

np.nditer(a, order, flags, op_flags, ...)
函数说明：
对一个多维数组使用for循环迭代只能遍历第0维上的元素，要迭代所有元素，需使用flatten()等函数展平（一维化）数组，并且可以指定访问风格，行主序或列主序，numpy为我们提供了一个专门的函数nditer()，通过该函数将创建一个在多维数组上的元素迭代器
参数说明（部分）：

  • order：指定数组元素的迭代风格，行主序或列主序
  • flags参数（部分）可取值（一个字符串序列，可以同时指定以下多个值）：
    • c_index：表示跟踪C顺序的索引（从0开始计数），索引值通过函数返回的迭代器的index属性获取，即便实际是以F风格（order参数）迭代数组元素，给出的也是C风格索引。注意c_index和f_index两者只能取其一
    • f_index：表示跟踪F顺序的索引，同上
    • multi_index：表示跟踪迭代元素的全（位置）坐标，通过函数返回的迭代器的multi_index属性获取
    • external_loop（没懂）：其将多维数组a视为由诸多一维数组元素构成的数组，若指定order='F'，那么迭代次数将为reduce(lambda x,y:x*y,a.shape[1:])，此时第0维上的向量被视为单个元素，若指定order='C'，那么迭代次数将为1，访问的元素就是np.flatten(a)，一个一维数组，这有何用？
  • op_flags：默认取值readonly，即视待遍历的数组为只读对象，为了在遍历数组的同时实现对数组元素值的修改，需指定为readwrite或writeonly
元素迭代器的属性和方法

函数所返回的迭代器上的（部分）属性和方法：

  • finished：判断元素是否迭代完毕，也可以通过迭代器对象的iternext()方法的返回值来判断
  • iterindex：返回当前迭代位置处元素的索引，至于是C风格还是F风格由order参数决定
  • has_index：如果返回True，表示迭代器是指定c_index或f_index标志（flags参数）创建的，此时属性index才是可获得的
  • index：同iterindex，只不过具体的风格是由flags参数决定，且只有当has_index属性为True时，可以使用该属性，否则引发ValueError异常
  • has_multi_index：如果返回True，表示迭代器是指定multi_index标志（flags参数）创建的，此时属性multi_index才是可获得的
  • multi_index：返回当前迭代位置处元素的全坐标（即该元素在原始数组中的位置坐标），只有当has_multi_index属性为True时，可以使用该属性，否则引发ValueError异常
  • itersize：返回迭代器中元素的个数（还有ndim和shape属性，我还没弄明白它们的输出，譬如nditer(np.arange(12).reshape(3,-1),flags=['f_index']).shape为什么是(4,3)，而将其中的f_index改成c_index输出又变成(12,)？）
  • iternext()：表示执行一次内部迭代，但不返回迭代元素，只返回True或False，用于判断当前迭代器是否已尽，返回False表示没有元素可供迭代了（继续执行iternext()方法仍会返回False，调用iterable[0]则会出错，除非调用reset()方法重置状态以从头开始迭代），而要获取当前迭代位置处的元素，可以通过下标0索引该迭代器（即iterator[0]，事实上，你可以使用nditer()并行迭代多个多维数组对象，于是第二个多维数组的元素可以通过iterable[1]获取，以此类推。注意在使用nditer()创建迭代器后，立即就可调用iterable[0]来获取第一个迭代元素，而无需先调用iternext()方法）的方式获取。除了使用iternext()，常规的迭代方法则是使用for循环遍历迭代器（自动调用迭代器对象的__next__()方法），当然也可以手动调用__next__()方法（此时需自行捕捉StopIteration异常）
  • reset()：重置迭代器的状态
  • copy()：返回迭代器在当前状态下的一个副本
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
100
101
102
import numpy as np

print('### nditer() ###')
a=np.arange(6).reshape((2,3),order='F')
print(a)
for i in np.nditer(a,order='C'): #默认order为'K'，其将会按照a的布局进行访问，打印0,1,2,3,4,5,
    print(i,end=',')
print()

print('### read_write mode ###')
#读写模式
for i in np.nditer(a,op_flags=('readwrite',),order='C'):
    i*=2
    print(i,end=',')
print()
print(a) #可以看到原始数组也已经被修改了

print('### while+iternext() ###')
#通过while循环不断输出迭代器对象的索引属性值
a=np.array([1,3,5,7,2,4,6,8]).reshape((2,2,-1))
print(a)
it=np.nditer(a,flags=['f_index'])
print(it.ndim,it.shape,it.itersize)
while not it.finished:
    print("[F]index-%d: %d [C]index-%d" % (it.index,it[0],it.iterindex)) #index属性跟踪F顺序的索引，即使当前实际是以C风格访问数组元素
    it.iternext()
it=np.nditer(a,flags=['multi_index'])
while not it.finished:
    print("index-%s: %d" % (it.multi_index,it[0])) #全位置坐标
    it.iternext()

print('### external_loop ###')
for i in np.nditer(a,flags=['external_loop'],order='F'):
    print(i,end=',')
print()
for i in np.nditer(a,flags=['external_loop'],order='C'): #有什么用？
    print(i,end=',')
print()

print('### copy() ###')
it=np.nditer(np.arange(24).reshape(2,3,4))
print(it.__next__())
print(it.__next__())
it2=it.copy() #副本保存了原件的状态
print(it2.__next__())
print(it.__next__())

print('### return of iternext() ###')
it=np.nditer(np.array([12,13]))
print(it.iternext())
print(it.__next__())
print(it.iternext())
print(it.iternext())
print(it.iternext())

'''OUTPUT
### nditer() ###
[[0 2 4]
 [1 3 5]]
0,2,4,1,3,5,
### read_write mode ###
0,4,8,2,6,10,
[[ 0  4  8]
 [ 2  6 10]]
### while+iternext() ###
[[[1 3]
  [5 7]]

 [[2 4]
  [6 8]]]
3 (2, 2, 2) 8
[F]index-0: 1 [C]index-0
[F]index-4: 3 [C]index-1
[F]index-2: 5 [C]index-2
[F]index-6: 7 [C]index-3
[F]index-1: 2 [C]index-4
[F]index-5: 4 [C]index-5
[F]index-3: 6 [C]index-6
[F]index-7: 8 [C]index-7
index-(0, 0, 0): 1
index-(0, 0, 1): 3
index-(0, 1, 0): 5
index-(0, 1, 1): 7
index-(1, 0, 0): 2
index-(1, 0, 1): 4
index-(1, 1, 0): 6
index-(1, 1, 1): 8
### external_loop ###
[1 2],[5 6],[3 4],[7 8],
[1 3 5 7 2 4 6 8],
### copy() ###
0
1
2
2
### return of iternext() ###
True
13
False
False
False
'''

并行迭代，如果两个数组是同形的（弱化条件为两者可以广播至同一形状），那么nditer()能够同时迭代它们：

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
import numpy as np
a=np.arange(0,60,5).reshape(3,4)
b=np.array([1,  2,  3,  4])
print(a)
print(b)
#b（形状为(1,4)）可以广播至与a的相同形状(3,4)
for ia,ib in np.nditer([a,b]):
    print(ia,',',ib)

it=np.nditer([a,b],flags=['multi_index'])
while not it.finished:
    print(f'pos:{it.multi_index},item(a):{it[0]},item(b):{it[1]}')
    it.iternext()

'''OUTPUT
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]
[1 2 3 4]
0 , 1
5 , 2
10 , 3
15 , 4
20 , 1
25 , 2
30 , 3
35 , 4
40 , 1
45 , 2
50 , 3
55 , 4
pos:(0, 0),item(a):0,item(b):1
pos:(0, 1),item(a):5,item(b):2
pos:(0, 2),item(a):10,item(b):3
pos:(0, 3),item(a):15,item(b):4
pos:(1, 0),item(a):20,item(b):1
pos:(1, 1),item(a):25,item(b):2
pos:(1, 2),item(a):30,item(b):3
pos:(1, 3),item(a):35,item(b):4
pos:(2, 0),item(a):40,item(b):1
pos:(2, 1),item(a):45,item(b):2
pos:(2, 2),item(a):50,item(b):3
pos:(2, 3),item(a):55,item(b):4
'''

该属性返回多维数组的元素迭代器（一个flatiter对象，由于是迭代器对象，用完即弃），遵循C风格，也可以作为一个一维数组“视图”使用，支持切片索引、花式索引等，flatiter对象上有一个copy()方法将其转为（一维的）ndarray对象（深拷贝），其还有三个主要属性：

  • base：返回flatiter对象的原始数组引用
  • index：返回当前迭代元素的索引（从0开始计数）
  • coords：返回当前迭代元素在原数组中的全坐标
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np
a=np.arange(10).reshape((2,-1))
b=a.flat
print(b.base is a)
for i in b:
    print('元素:',i,'索引:',b.index,'位置坐标:',b.coords)
print()

'''OUTPUT
True
元素: 0 索引: 1 位置坐标: (0, 1)
元素: 1 索引: 2 位置坐标: (0, 2)
元素: 2 索引: 3 位置坐标: (0, 3)
元素: 3 索引: 4 位置坐标: (0, 4)
元素: 4 索引: 5 位置坐标: (1, 0)
元素: 5 索引: 6 位置坐标: (1, 1)
元素: 6 索引: 7 位置坐标: (1, 2)
元素: 7 索引: 8 位置坐标: (1, 3)
元素: 8 索引: 9 位置坐标: (1, 4)
元素: 9 索引: 10 位置坐标: (2, 0)
'''

上述输出不正确，这里不建议通过for循环的方式去获取索引或坐标，因为flatiter只有调用一次__next__()方法后才能获取到（第一个）迭代元素，而调用后其index和coords属性又会立即更新（变成第二个迭代元素的索引和坐标），因此必须在next()前获取index和coords，for循环无法控制next()调用的时机，因此可以通过while方式并手动调用next()迭代元素：

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
from itertools import count
a=np.arange(10).reshape((2,-1))
b=a.flat
for i in count():
    s=f'{b.index},{b.coords}'
    try:
        print(s,b.__next__())
    except StopIteration as e:
        break

'''OUTPUT
0,(0, 0) 0
1,(0, 1) 1
2,(0, 2) 2
3,(0, 3) 3
4,(0, 4) 4
5,(1, 0) 5
6,(1, 1) 6
7,(1, 2) 7
8,(1, 3) 8
9,(1, 4) 9
'''

ndarray.flat本身也可以作为展平后的一维数组“视图”使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import numpy as np
a=np.arange(10).reshape((2,-1))
print(a)
print(a.flat[[2,5,7]]) #对一维数组的花式索引
a.flat[[3,6]]=55 #对“视图”的修改将影响原数组
print(a)
a.flat.copy()[0]=78 #copy()深复制，不影响原数组
print(a)
a.flat=[i for i in range(100,200)] #可以将一个一维数组或列表赋给flat属性（长度不一致时会自动截取前n项），这常用于一个多维数组元素的修改
print(a)

'''OUTPUT
[[0 1 2 3 4]
 [5 6 7 8 9]]
[2 5 7]
[[ 0  1  2 55  4]
 [ 5 55  7  8  9]]
[[ 0  1  2 55  4]
 [ 5 55  7  8  9]]
[[100 101 102 103 104]
 [105 106 107 108 109]]
'''

广播机制

广播机制是处理不同维度数组间操作的一个非常重要的手段，要知道两个不同的多维数组能够进行操作的基本条件是其形状相同，当形状不同时，但符合广播的条件，则会自动对这两个或其中一个多维数组进行维度补齐并进行元素复制（补齐维数）
广播的规则：

  1. 让所有输入数组都向其中维数最大（shape最长）的数组看齐，shape中不足的部分在前面加1补齐维度
  2. 输出数组的shape根据所有输入数组shape的各个轴上的最大值得到
  3. 如果输入数组的某个轴和输出数组的对应轴的长度相同或者不同但其中一方长度为1时，这些输入数组被认为能够广播至输出数组的形状，即符合广播的条件，否则抛出异常
  4. 当输入数组的某个轴的长度为1且输出数组对应轴长大于1时，将沿着此轴复制第一个元素来进一步补齐维数
1
2
3
4
5
6
7
8
9
a=np.arange(24).reshape((2,3,4))
b1=np.arange(4).reshape((-1))
b2=np.arange(12).reshape((3,-1))
c1=a+b1 #首先维度补齐：b1.reshape((1,1,4))，确定输出数组形状：(2,3,4)，判断能够进行广播，最后进行元素复制
c2=a+b2 #同上，维度补齐后得到b2.reshape((1,3,4))，输出数组形状仍是(2,3,4)，且符合广播的条件

a=np.arange(8).reshape((1,2,1,4))
b=np.arange(12).reshape((1,1,1,3,-1))
c=a+b #a补齐维度a.reshape((1,1,2,1,4))，b补齐维度b.reshape((1,1,1,3,4))，再确定输出数组形状(1,1,2,3,4)，显然也符合广播条件

np.broadcast(*arrs)
函数说明：
函数可以接受任意数量（设为n）的输入数组，并产生基于这些输入数组的“广播对象”作为函数返回值，这个广播对象有一些属性和方法，其中shape和ndim（或nd）分别获取经广播机制作用后的输出数组的形状和维数，而iters属性返回一个长度为n（数量可由numiter属性获取）的由诸多flatiter对象构成的元组，这些flatiter（用完即弃）分别代表那些输入数组经广播（维度补齐和元素复制）后的数据内容，此外，广播对象本身也是一个迭代器（用完即弃），相当于并行迭代前面的flatiter对象，为了复用广播对象，其有一个reset()方法能够重置初始的迭代状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> x=np.array([[1], [2], [3]])
>>> y=np.array([4, 5, 6, 7, 8])
>>> broadcast_obj=np.broadcast(x,y) #两个输入数组x和y的形状分别为(3,1)和(5,)，于是输出数组的形状可以确定为(3,5)，并且符合广播条件，于是x和y分别沿着第1轴和第0轴按列复制和按行复制元素
>>> type(broadcast_obj)
<class 'numpy.broadcast'>
>>> broadcast_obj.shape
(3, 5)
>>> broadcast_obj.nd
2
>>> a,b=broadcast_obj.iters
>>> list(a)
[1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3]
>>> list(b) #之后再执行list(a)或list(b)只会得到空列表[]，除非执行重置reset()
[4, 5, 6, 7, 8, 4, 5, 6, 7, 8, 4, 5, 6, 7, 8]
>>> broadcast_obj.reset()
>>> [(i,j) for i,j in broadcast_obj]
[(1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8)]
手动实现两个多维数组的相加操作：
1
2
3
4
5
6
7
8
9
10
11
12
13
>>> x=np.array([[1], [2], [3]])
>>> y=np.array([4, 5, 6, 7, 8])
>>> x+y
array([[ 5,  6,  7,  8,  9],
       [ 6,  7,  8,  9, 10],
       [ 7,  8,  9, 10, 11]])
>>> bo=np.broadcast(x,y)
>>> z=np.empty(bo.shape,dtype='i4') #创建一个空的结果数组
>>> z.flat=[x+y for i,j in bo]
>>> z
array([[ 5,  6,  7,  8,  9],
       [ 6,  7,  8,  9, 10],
       [ 7,  8,  9, 10, 11]])

np.broadcast_to(array, shape, subok=False)
函数说明：
用于将一个数组广播至一个指定的形状

1
2
3
4
5
6
7
8
>>> np.broadcast_to(np.array([[1], [2], [3]]),(3,5))
array([[1, 1, 1, 1, 1],
       [2, 2, 2, 2, 2],
       [3, 3, 3, 3, 3]])
>>> np.broadcast_to(np.array([4, 5, 6, 7, 8]),(3,5))
array([[4, 5, 6, 7, 8],
       [4, 5, 6, 7, 8],
       [4, 5, 6, 7, 8]])

数组拼接与分割

np.concatenate()

np.concatenate((a1, a2, ...), axis=0, out=None)
函数说明：
用于沿指定轴（axis）连接多个数组对象（a1，a2，…），a1、a2等数组的形状完全相同固然最好（此时，可以沿任意轴进行连接），即使不相同，也必须满足“除了将要连接的那个轴的长度可以不一致外，其余轴长必须完全相同”的条件（举例：shape1=(2,3,4,5)，shape2=(2,3,7,5)，则连接轴只能设为2轴，否则出错，且显然输出形状为(2,3,11,5)），特别地，axis置为None时，a1、a2等数组首先会被“展平”（一维化）开来，然后沿0轴连接，out参数指定结果存放的数组

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
>>> a=np.array([[1,2],[3,4]]) #形状为(2,2)
>>> b=np.array([[5,6]]) #形状为(1,2)，显然这两个数组只能沿第0轴连接
>>> np.concatenate((a,b),axis=0)
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> np.concatenate((a,b),axis=None)
array([1, 2, 3, 4, 5, 6])
>>> np.concatenate((a,b.T),axis=1) #b转置后形状变为(2,1)，此时只能沿着第1轴连接
array([[1, 2, 5],
       [3, 4, 6]])
>>> a=np.arange(24).reshape((2,3,4))
>>> b=np.arange(24,56).reshape((2,4,4)) #显然a和b只能沿着第1轴连接，输出数组形状为(2,7,4)
>>> np.concatenate((a,b),axis=1)
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [24, 25, 26, 27],
        [28, 29, 30, 31],
        [32, 33, 34, 35],
        [36, 37, 38, 39]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23],
        [40, 41, 42, 43],
        [44, 45, 46, 47],
        [48, 49, 50, 51],
        [52, 53, 54, 55]]])
np.stack()

np.stack(arrays, axis=0, out=None)
函数说明：
沿新轴堆叠数组。用于堆叠的各数组形状必须完全一致，注意stack()总是会增加一个维度（最简单的就是二维数组的堆叠，结果将变成三维数组），“新轴”由参数axis指定，axis的取值为0~len(shape)+1，若取值len(shape)+1表示在最后新增一个维度，譬如有两个待堆叠数组，形状为(2,3,4)，若指定axis为3，返回的新数组形状将为(2,3,4,2)

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
>>> a=np.arange(12).reshape(3,-1)
>>> b=np.arange(12,24).reshape(3,-1)
>>> np.stack((a,b))
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])
>>> _.shape
(2, 3, 4)
>>> np.stack((a,b),axis=2)
array([[[ 0, 12],
        [ 1, 13],
        [ 2, 14],
        [ 3, 15]],

       [[ 4, 16],
        [ 5, 17],
        [ 6, 18],
        [ 7, 19]],

       [[ 8, 20],
        [ 9, 21],
        [10, 22],
        [11, 23]]])
>>> _.shape
(3, 4, 2)
np.vstack()

np.vstack((a1,a2,...))
函数说明：
不同于np.stack()，vstack()垂直堆叠（不改变维数）总是沿着第0轴连接（concatenate()）多个数组，a1、a2等除0轴外其余轴长必须保持一致，之所以叫“垂直”堆叠，是假设a1、a2等都是二维数组时，第0轴正是那根垂直的轴，特别地，要对一维数组进行“垂直堆叠”，等同于np.vstack((a1[None,:],a2[None,:],...))，因此这些一维数组的长度必须相同（只有在这种特殊情况下，堆叠后的数组维数发生改变）

1
2
3
4
5
6
7
8
9
10
11
12
>>> a=np.array((1,2,3))
>>> b=np.array((2,3,4))
>>> np.vstack((a,b))
array([[1, 2, 3],
       [2, 3, 4]])
>>> np.vstack((a[None,:],b[None,:]))
array([[1, 2, 3],
       [2, 3, 4]])
>>> np.vstack((np.arange(8).reshape(2,4),np.arange(4).reshape(1,4)))
array([[0, 1, 2, 3],
       [4, 5, 6, 7],
       [0, 1, 2, 3]])
np.row_stack()

np.row_stack((a1,a2,...))
函数说明：
按行堆叠，等同于np.vstack((a1,a2,...))

np.hstack()

np.hstack((a1,a2,...))
函数说明：
类似于np.vstack()，hstack()水平堆叠（不改变维数）总是沿着第1轴连接（concatenate()）多个数组，a1、a2等除1轴外其余轴长必须保持一致，特别地，要对一维数组进行“水平”堆叠，仍等同于np.hstack((a1[None,:],a2[None,:],...))，因此对这些一维数组的长度没有限制

1
2
3
4
5
6
7
8
9
>>> a=np.array((1,2,3))
>>> b=np.array((4,5,6,7))
>>> np.hstack((a,b))
array([1, 2, 3, 4, 5, 6, 7])
>>> c=np.arange(4,10).reshape(3,2,order='F')
>>> np.hstack((a[:,None],c))
array([[1, 4, 7],
       [2, 5, 8],
       [3, 6, 9]])
np.column_stack()

np.column_stack((a1,a2,...))
函数说明：
按列堆叠，等同于np.hstack((a1,a2,...))

np.dstack()

类似于np.vstack()或np.hstack()，dstack()深度堆叠（不改变维数）总是沿着第2轴连接（concatenate()）多个数组，a1、a2等除2轴外其余轴长必须保持一致，特别地，要对一维数组进行“深度”堆叠，等同于np.dstack((a1[None,:,None],a2[None,:,None],...))，因此这些一维数组的长度必须相同（只有在这种特殊情况下，堆叠后的数组维数发生改变）

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(24).reshape(3,4,2)
>>> b=np.arange(12).reshape(3,4,1)
>>> np.dstack((a,b))
array([[[ 0,  1,  0],
        [ 2,  3,  1],
        [ 4,  5,  2],
        [ 6,  7,  3]],

       [[ 8,  9,  4],
        [10, 11,  5],
        [12, 13,  6],
        [14, 15,  7]],

       [[16, 17,  8],
        [18, 19,  9],
        [20, 21, 10],
        [22, 23, 11]]])
>>> a=np.arange(3)
>>> b=np.arange(3,6)
>>> np.dstack((a,b))
array([[[0, 3],
        [1, 4],
        [2, 5]]])
>>> np.dstack((a[None,:,None],b[None,:,None]))
array([[[0, 3],
        [1, 4],
        [2, 5]]])
np.split()

np.split(arr, indices_or_sections, axis=0)
函数说明：
用于沿指定的轴axis将数组分割为多个子数组。参数indices_or_sections可以是整数，也可以是一个整数列表，分别表示不同的切割方式，当为整数n时，沿指定轴axis将数组arr平均切割为n份，如果该轴长度不足以均分为n等份时，将抛出异常，当为整数列表时，其中每一个整数表示一处切割的位置，譬如[2,5,7]表示分别在轴长刻度为2、5、7处进行切割（并得到四个子数组），具体的，第一份从刻度0开始但不包括刻度2，第二份从刻度2开始但不包括刻度5，第三份从刻度5开始但不包括刻度7，最后一份从刻度7开始直至最后（有可能是空数组），特别地，如果指定的切割位置超出轴长，则返回空的子数组而不会报错

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> a=np.arange(9)
>>> np.split(a,3)
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
>>> b=np.arange(16).reshape(2,-1)
>>> b
array([[ 0,  1,  2,  3,  4,  5,  6,  7],
       [ 8,  9, 10, 11, 12, 13, 14, 15]])
>>> np.split(b,[2,5,7],axis=1)
[array([[0, 1],
       [8, 9]]), array([[ 2,  3,  4],
       [10, 11, 12]]), array([[ 5,  6],
       [13, 14]]), array([[ 7],
       [15]])]
np.vsplit()

np.vsplit(arr, indices_or_sections)
函数说明：
垂直分割，特指沿0轴切割，注意不能对一维数组执行该操作（至少是二维）

1
2
3
4
5
>>> a=np.arange(8).reshape((4,-1))
>>> np.vsplit(a,2)
[array([[0, 1],
       [2, 3]]), array([[4, 5],
       [6, 7]])]
np.hsplit()

np.hsplit(arr, indices_or_sections)
函数说明：
水平分割，特指沿1轴切割，特别地，要对一维数组进行“水平”切割，相当于但不完全等同于np.hsplit(arr[None,:], indices_or_sections)（此处返回的子数组是二维的），返回的子数组仍是一维的

1
2
3
4
5
6
7
>>> np.hsplit(np.arange(8).reshape(2,-1),[2,3])
[array([[0, 1],
       [4, 5]]), array([[2],
       [6]]), array([[3],
       [7]])]
>>> np.hsplit(np.arange(8),4)
[array([0, 1]), array([2, 3]), array([4, 5]), array([6, 7])]
np.dsplit()

np.dsplit(arr, indices_or_sections)
函数说明：
深度分割，特指沿2轴切割，注意不对对一维或二维数组执行该操作（至少是三维）

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
>>> a=np.arange(24).reshape(4,3,-1)
>>> a
array([[[ 0,  1],
        [ 2,  3],
        [ 4,  5]],

       [[ 6,  7],
        [ 8,  9],
        [10, 11]],

       [[12, 13],
        [14, 15],
        [16, 17]],

       [[18, 19],
        [20, 21],
        [22, 23]]])
>>> np.dsplit(a,2)
[array([[[ 0],
        [ 2],
        [ 4]],

       [[ 6],
        [ 8],
        [10]],

       [[12],
        [14],
        [16]],

       [[18],
        [20],
        [22]]]), array([[[ 1],
        [ 3],
        [ 5]],

       [[ 7],
        [ 9],
        [11]],

       [[13],
        [15],
        [17]],

       [[19],
        [21],
        [23]]])]
>>> _[0].shape
(4, 3, 1)

数组增删改查

np.append(arr, values, axis=None)
函数说明：
用于沿指定轴axis向数组中追加数据values（多维数组对象），该操作基本同np.concatenate()函数，要追加的子数组values的形状和arr的形状除axis轴长度可以不一致外，其余轴长必须一致，另外当axis置为None时（默认值），会将一维化的arr和values连接成一个一维数组并返回

1
2
3
4
5
>>> np.append(np.arange(4).reshape(2,-1),np.arange(6).reshape(2,3),axis=1)
array([[0, 1, 0, 1, 2],
       [2, 3, 3, 4, 5]])
>>> np.append(np.arange(4).reshape(2,-1),np.arange(6).reshape(2,3),axis=None)
array([0, 1, 2, 3, 0, 1, 2, 3, 4, 5])

np.delete(arr, obj, axis=None)
函数说明：
用于沿指定轴axis删除特定位置处的子数组。obj参数可以是整数（指定要删除的刻度位置处的元素）、切片或整数列表（指定要删除的多个刻度对应位置处的元素），特别地，当axis置为None时（默认值），将会首先“展平”（一维化）arr数组

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
>>> arr=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
>>> arr
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
>>> np.delete(arr,[0,2]) #axis为None，则先展平再删除
array([ 2,  4,  5,  6,  7,  8,  9, 10, 11, 12])
>>> np.delete(arr,[0,2],axis=0) #沿着第0轴删除第0个元素和第2个元素
array([[5, 6, 7, 8]])
>>> np.delete(arr,[0,2],axis=1)
array([[ 2,  4],
       [ 6,  8],
       [10, 12]])
>>> np.delete(arr,slice(0,2),axis=0)
array([[ 9, 10, 11, 12]])
>>> np.delete(arr,np.s_[:2],axis=0) #这种切片方式更简便，效果同上
array([[ 9, 10, 11, 12]])
>>> np.delete(arr,np.s_[::],axis=1) #表示全部删除，返回一个空数组
array([], shape=(3, 0), dtype=int32)
>>> np.delete(arr,np.s_[::2],axis=1)
array([[ 2,  4],
       [ 6,  8],
       [10, 12]])
>>> np.s_[::2]
slice(None, None, 2)
>>> np.delete(arr,np.ix_(np.max(arr,axis=0)>10),axis=1) #删除arr数组中那些列中最大值大于10的列
array([[ 1,  2],
       [ 5,  6],
       [ 9, 10]])

np.insert(arr, obj, values, axis=None)
函数说明：
此操作类似于np.append()，可以认为append()是insert()的一个特例（在末尾插入子数组），参数obj可以是整数（在指定刻度位置处插入子数组values）、切片对象或整数列表（在指定的多个刻度位置处插入子数组values），具体的，当obj为切片或整数列表时，values的形状和arr的形状除了满足“除axis所在轴长度可以不一致外其余轴长必须相同”的条件外（基本原则），还需要满足“values的axis所在轴长要么是1，要么是切片或整数列表的长度”的条件，当obj为整数时，values的形状除了需要满足基本原则，还需要满足“values的axis所在轴长必须为1”的条件，最后还要删除这个多余的长度为1的axis维（squeeze()），当obj为单整数序列时，values的形状只需要满足基本原则即可。特别地，axis参数可以为None时（默认值），表示会将arr一维化展开，其余的，正常按照前述规则，就像在一维数组中插入数据一样

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
>>> a=np.arange(12).reshape(2,2,3)
>>> a
array([[[ 0,  1,  2],
        [ 3,  4,  5]],

       [[ 6,  7,  8],
        [ 9, 10, 11]]])
>>> np.insert(a,[0,1],np.arange(12,18).reshape(2,1,3),1) #由于obj为整数列表，根据规则，插入数据values的形状只能是(2,1,3)或(2,2,3)，当其为(2,1,3)时，表示沿1轴来看，values相当于单个元素，当沿着1轴在刻度0位置处插入数据values后，似乎没有元素可供插入刻度1位置处了，这时会复制一份一模一样的数据插在刻度1位置处
array([[[12, 13, 14],
        [ 0,  1,  2],
        [12, 13, 14],
        [ 3,  4,  5]],

       [[15, 16, 17],
        [ 6,  7,  8],
        [15, 16, 17],
        [ 9, 10, 11]]])
>>> np.arange(12,24).reshape(2,2,3)
array([[[12, 13, 14],
        [15, 16, 17]],

       [[18, 19, 20],
        [21, 22, 23]]])
>>> np.insert(a,[0,1],_,1) #当values形状为(2,2,3)时，沿1轴来看，values相当于有两个元素，于是分别插在原数组的刻度0和刻度1位置处
array([[[12, 13, 14],
        [ 0,  1,  2],
        [15, 16, 17],
        [ 3,  4,  5]],

       [[18, 19, 20],
        [ 6,  7,  8],
        [21, 22, 23],
        [ 9, 10, 11]]])
>>> np.insert(a,1,np.arange(12,18).reshape(2,3),1) #此处obj是单整数，根据规则，插入数据values的形状只能是(2,1,3)，且要删除axis所在轴（长度为1），于是形状只能是(2,3)，为什么要减去这个维度呢？之前在介绍数值索引时说过，数值索引总是会导致维度减1，譬如给定一个二维数组，a=np.arange(12).reshape(3,4)，a[:,0]或a[0]的结果总是一维的，因此在向二维数组a的某列或某行赋值时，也必须是一维的，即a[:,0]=np.array([666,777,888])，如果写成a[:,0]=np.array([666,777,888])[:,None]就会出错，同理，此处的insert()函数在obj为单整数时候，也是这个道理
array([[[ 0,  1,  2],
        [12, 13, 14],
        [ 3,  4,  5]],

       [[ 6,  7,  8],
        [15, 16, 17],
        [ 9, 10, 11]]])
>>> np.insert(np.arange(12).reshape(3,4),1,np.array([666,777,888]),1) #根据规则，插入数据values的形状只能是(3,1)，去除axis所在轴（长度为1），于是形状只能是(3,)
array([[  0, 666,   1,   2,   3],
       [  4, 777,   5,   6,   7],
       [  8, 888,   9,  10,  11]])
>>> np.insert(a,[1],np.arange(12,18).reshape(2,1,3),1) #如果obj是单整数序列呢？这个比较特殊，此时插入数据values的形状为(2,x,3)即可，其中x任意
array([[[ 0,  1,  2],
        [12, 13, 14],
        [ 3,  4,  5]],

       [[ 6,  7,  8],
        [15, 16, 17],
        [ 9, 10, 11]]])
>>> np.insert(a,[1],np.arange(12,42).reshape(2,5,3),1)
array([[[ 0,  1,  2],
        [12, 13, 14],
        [15, 16, 17],
        [18, 19, 20],
        [21, 22, 23],
        [24, 25, 26],
        [ 3,  4,  5]],

       [[ 6,  7,  8],
        [27, 28, 29],
        [30, 31, 32],
        [33, 34, 35],
        [36, 37, 38],
        [39, 40, 41],
        [ 9, 10, 11]]])
>>> a.flatten()
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
>>> np.insert(a,[2,5],[88])
array([ 0,  1, 88,  2,  3,  4, 88,  5,  6,  7,  8,  9, 10, 11])
>>> np.insert(a,[2,5],[66,88])
array([ 0,  1, 66,  2,  3,  4, 88,  5,  6,  7,  8,  9, 10, 11])
>>> np.insert(a,[2,5,7],[66,88,99])
array([ 0,  1, 66,  2,  3,  4, 88,  5,  6, 99,  7,  8,  9, 10, 11])
>>> np.insert(a,np.s_[::3],[66,77,88,99])
array([66,  0,  1,  2, 77,  3,  4,  5, 88,  6,  7,  8, 99,  9, 10, 11])
>>> np.insert(a,[2],[66,99,100])
array([  0,   1,  66,  99, 100,   2,   3,   4,   5,   6,   7,   8,   9,
        10,  11])
>>> np.insert(a,2,[66,99,100]) #这里也比较特殊，对于一维，obj为单整数，不仅可以插入[666]（长度为1的一维数组），也可以插入[666,777,888]（任意长度）
array([  0,   1,  66,  99, 100,   2,   3,   4,   5,   6,   7,   8,   9,
        10,  11])
>>> np.insert(a,2,[66])
array([ 0,  1, 66,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

np.unique(arr, return_index=False, return_inverse=False, return_counts=False, axis=None)
函数说明：
用于去除数组arr中的重复元素，返回以升序排序的去重值数组（由于axis默认为None，因此会首先一维化arr，并最终返回一个去重的一维数组）
参数说明：

  • axis：沿axis轴对数组元素进行去重，举个例子，当arr为二维数组，axis为1，表示要去重的元素是二维数组中的列向量，反之，axis为0，表示要去重的元素是二维数组中的行向量。axis置为None时，表示将arr一维化
  • return_index：若为True，同时返回去重数组中元素在原始数组中的位置下标
  • return_inverse：若为True，同时返回原始数组中元素在去重数组中的位置下标
  • return_counts：若为True，同时返回去重数组中元素在原始数组中出现的次数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
>>> a=np.array([6,7,6,6,5,2,9,8,2,5]).reshape(2,-1)
>>> a
array([[6, 7, 6, 6, 5],
       [2, 9, 8, 2, 5]])
>>> np.unique(a)
array([2, 5, 6, 7, 8, 9])
>>> r,ind=np.unique(a,axis=1,return_index=True)
>>> r
array([[5, 6, 6, 7],
       [5, 2, 8, 9]])
>>> ind
array([4, 0, 2, 1], dtype=int64)
>>> r,ind,cs=np.unique(a,axis=1,return_inverse=True,return_counts=True)
>>> r
array([[5, 6, 6, 7],
       [5, 2, 8, 9]])
>>> ind
array([1, 3, 2, 1, 0], dtype=int64)
>>> cs
array([1, 2, 1, 1], dtype=int64)
>>> r[:,ind] #（一维）花式索引重构原始数组
array([[6, 7, 6, 6, 5],
       [2, 9, 8, 2, 5]])

np.sort(a, axis=-1, kind='quicksort', order=None)
函数说明：
用于沿指定轴对输入数组进行排序。默认是沿着最后一个轴（axis=-1）进行排序，如果axis置为None，则先一维化展平数组a，然后再进行排序（最终将返回一个一维数组），kind参数指定排序算法，还可取值mergesort（归并排序）和heapsort（堆排序），此处的order参数并非有关内存布局，而是用于自定义结构化数据类型时，设置不同字段参与排序时的优先级（order列表中字段的优先级从左至右依次降低），没有出现在order的字段，其优先级低于order中的字段，且按照定义结构化数据类型dtype时的字段顺序依次降低

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
>>> a = np.array([[1,4],[3,1]])
>>> a
array([[1, 4],
       [3, 1]])
>>> np.sort(a)
array([[1, 4],
       [1, 3]])
>>> np.sort(a,axis=1)
array([[1, 4],
       [1, 3]])
>>> np.sort(a,axis=0)
array([[1, 1],
       [3, 4]])
>>> np.sort(a,axis=None)
array([1, 1, 3, 4])
>>> dtype = [('name', 'S10'), ('height', float), ('age', int)]
>>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38), ('Galahad', 1.7, 38)]
>>> a = np.array(values, dtype=dtype)
>>> np.sort(a, order='height')
array([(b'Galahad', 1.7, 38), (b'Arthur', 1.8, 41),
       (b'Lancelot', 1.9, 38)],
      dtype=[('name', 'S10'), ('height', '<f8'), ('age', '<i4')])
>>> np.sort(a, order=['age', 'height'])
array([(b'Galahad', 1.7, 38), (b'Lancelot', 1.9, 38),
       (b'Arthur', 1.8, 41)],
      dtype=[('name', 'S10'), ('height', '<f8'), ('age', '<i4')])
>>> np.sort(a)
array([(b'Arthur', 1.8, 41), (b'Galahad', 1.7, 38),
       (b'Lancelot', 1.9, 38)],
      dtype=[('name', 'S10'), ('height', '<f8'), ('age', '<i4')])
>>> b'Arthur'<b'Galahad'<b'Lancelot'
True
np.argsort()

np.argsort(a, axis=-1, kind='quicksort', order=None)
函数说明：
函数返回的是数组值从小到大排列的下标序列，参数同np.sort()

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
>>> x=np.random.randint(0,24,6)
>>> y = np.argsort(x)
>>> x[y] #（一维）花式索引构造升序排列的结果
array([ 4, 13, 16, 16, 21, 23])
>>> x = np.array([[0, 3], [2, 2]])
>>> x
array([[0, 3],
       [2, 2]])
>>> np.argsort(x, axis=0)
array([[0, 1],
       [1, 0]], dtype=int64)
>>> x[_,np.broadcast_to(np.arange(x.shape[1]),x.shape)] #全坐标索引构造二维数组沿0轴升序排列的结果
array([[0, 2],
       [2, 3]])
>>> np.argsort(x, axis=1)
array([[0, 1],
       [0, 1]], dtype=int64)
>>> x[np.broadcast_to(np.arange(x.shape[0])[:,None],x.shape),_] #全坐标索引构造二维数组沿1轴升序排列的结果
array([[0, 3],
       [2, 2]])
>>> np.argsort(x, axis=None)
array([0, 2, 3, 1], dtype=int64)
>>> x.flatten()[_]
array([0, 2, 2, 3])
>>> pos = np.unravel_index(np.argsort(x, axis=None), x.shape)
>>> x[pos] #全坐标索引
array([0, 2, 2, 3])
>>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
>>> np.argsort(x, order=('x','y'))
array([1, 0], dtype=int64)
>>> np.argsort(x, order=('y','x'))
array([0, 1], dtype=int64)
上面使用了一个叫做unravel_index(indices, dims, order='C')的函数，是干嘛用的？将一个多维数组按C或F风格（order参数）“展平”为一维数组后，可以通过取值范围为[0,len(arr.flat)-1]的下标i来索引任意元素，那么现在的下标索引i（指定参数indices，其也可以是一个整数列表）所指向的数组元素在原数组（指定形状参数dims）中的位置坐标又是几何？函数np.unravel_index()就是为了解决这个问题的，看个例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> a=np.arange(6).reshape(2,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5]])
>>> a.flatten(order='C') #按C风格展平，其中第1、3、5个元素在原始数组中的坐标为：np.unravel_index([1,3,5],(2,3))
array([0, 1, 2, 3, 4, 5])
>>> a.flatten(order='F') #按F风格展平，其中第1、3、5个元素在原始数组中的坐标为：np.unravel_index([1,3,5],(2,3),order='F')
array([0, 3, 1, 4, 2, 5])
>>> np.unravel_index(3,(2,3))
(1, 0)
>>> np.unravel_index([1,3,5],(2,3))
(array([0, 1, 1], dtype=int64), array([1, 0, 2], dtype=int64))
>>> np.unravel_index([1,3,5],(2,3),order='F')
(array([1, 1, 1], dtype=int64), array([0, 1, 2], dtype=int64))
上面列举了一维数组和二维数组的情况下如何根据argsort()的结果构造sort()的结果，下面再看看三维数组的情况：
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
>>> x=np.random.randint(0,100,24).reshape(2,3,4)
>>> np.sort(x,axis=-1) #等同于np.sort(x,axis=2)
array([[[39, 57, 60, 99],
        [26, 35, 38, 85],
        [ 8, 12, 35, 85]],

       [[30, 66, 86, 88],
        [21, 49, 66, 80],
        [ 3, 45, 47, 70]]])
>>> np.argsort(x,axis=-1)
array([[[3, 2, 0, 1],
        [3, 2, 1, 0],
        [0, 2, 1, 3]],

       [[2, 3, 1, 0],
        [3, 0, 2, 1],
        [0, 3, 2, 1]]], dtype=int64)
>>> x[np.broadcast_to(np.arange(2)[:,None,None],x.shape),np.broadcast_to(np.arange(3)[None,:,None],x.shape),_] #全坐标索引构造三维数组沿2轴升序排列的结果
array([[[39, 57, 60, 99],
        [26, 35, 38, 85],
        [ 8, 12, 35, 85]],

       [[30, 66, 86, 88],
        [21, 49, 66, 80],
        [ 3, 45, 47, 70]]])
>>> np.sort(x,axis=1)
array([[[ 8, 35, 12, 26],
        [60, 38, 35, 39],
        [85, 99, 57, 85]],

       [[ 3, 70, 30, 21],
        [49, 80, 47, 45],
        [88, 86, 66, 66]]])
>>> np.argsort(x,axis=1)
array([[[2, 2, 2, 1],
        [0, 1, 1, 0],
        [1, 0, 0, 2]],

       [[2, 2, 0, 1],
        [1, 1, 2, 2],
        [0, 0, 1, 0]]], dtype=int64)
>>> x[np.broadcast_to(np.arange(2)[:,None,None],x.shape),_,np.broadcast_to(np.arange(4)[None,None,:],x.shape)] #全坐标索引构造三维数组沿1轴升序排列的结果
array([[[ 8, 35, 12, 26],
        [60, 38, 35, 39],
        [85, 99, 57, 85]],

       [[ 3, 70, 30, 21],
        [49, 80, 47, 45],
        [88, 86, 66, 66]]])
>>> np.sort(x,axis=0)
array([[[60, 86, 30, 39],
        [49, 38, 35, 21],
        [ 3, 35, 12, 45]],

       [[88, 99, 57, 66],
        [85, 80, 66, 26],
        [ 8, 70, 47, 85]]])
>>> np.argsort(x,axis=0)
array([[[0, 1, 1, 0],
        [1, 0, 0, 1],
        [1, 0, 0, 1]],

       [[1, 0, 0, 1],
        [0, 1, 1, 0],
        [0, 1, 1, 0]]], dtype=int64)
>>> x[_,np.broadcast_to(np.arange(3)[None,:,None],x.shape),np.broadcast_to(np.arange(4)[None,None,:],x.shape)] #全坐标索引构造三维数组沿0轴升序排列的结果
array([[[60, 86, 30, 39],
        [49, 38, 35, 21],
        [ 3, 35, 12, 45]],

       [[88, 99, 57, 66],
        [85, 80, 66, 26],
        [ 8, 70, 47, 85]]])
上述写法还是太麻烦，可以借助np.meshgrid()简化坐标分量的构造（试问，还有更好更简便的写法吗？）：
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
>>> y,x,z=np.meshgrid(range(3),range(2),range(4)) #三个坐标分量，要通过meshgrid()构造任意形状多维数组的坐标分量，譬如shape=(s0,s1,s2,...,sn)，则有axis1,axis0,axis2,...,axisn=meshgrid(range(s1),range(s0),range(s3),...,range(sn))，即第0轴和第1轴比较特殊，是顺序反过来的
>>> np.sort(a,axis=-1)
array([[[33, 71, 90, 90],
        [41, 51, 56, 71],
        [23, 66, 70, 87]],

       [[32, 41, 62, 86],
        [48, 71, 75, 80],
        [54, 73, 83, 92]]])
>>> np.argsort(a,axis=-1)
array([[[2, 0, 1, 3],
        [2, 3, 1, 0],
        [2, 0, 1, 3]],

       [[3, 1, 2, 0],
        [0, 2, 1, 3],
        [2, 1, 3, 0]]], dtype=int64)
>>> a[x,y,_]
array([[[33, 71, 90, 90],
        [41, 51, 56, 71],
        [23, 66, 70, 87]],

       [[32, 41, 62, 86],
        [48, 71, 75, 80],
        [54, 73, 83, 92]]])
>>> np.sort(a,axis=1)
array([[[66, 56, 23, 51],
        [71, 70, 33, 87],
        [71, 90, 41, 90]],

       [[48, 41, 54, 32],
        [86, 73, 62, 80],
        [92, 75, 71, 83]]])
>>> np.argsort(a,axis=1)
array([[[2, 1, 2, 1],
        [0, 2, 0, 2],
        [1, 0, 1, 0]],

       [[1, 0, 2, 0],
        [0, 2, 0, 1],
        [2, 1, 1, 2]]], dtype=int64)
>>> a[x,_,z]
array([[[66, 56, 23, 51],
        [71, 70, 33, 87],
        [71, 90, 41, 90]],

       [[48, 41, 54, 32],
        [86, 73, 62, 80],
        [92, 75, 71, 83]]])
>>> np.sort(a,axis=0)
array([[[71, 41, 33, 32],
        [48, 56, 41, 51],
        [66, 70, 23, 83]],

       [[86, 90, 62, 90],
        [71, 75, 71, 80],
        [92, 73, 54, 87]]])
>>> np.argsort(a,axis=0)
array([[[0, 1, 0, 1],
        [1, 0, 0, 0],
        [0, 0, 0, 1]],

       [[1, 0, 1, 0],
        [0, 1, 1, 1],
        [1, 1, 1, 0]]], dtype=int64)
>>> a[_,y,z]
array([[[71, 41, 33, 32],
        [48, 56, 41, 51],
        [66, 70, 23, 83]],

       [[86, 90, 62, 90],
        [71, 75, 71, 80],
        [92, 73, 54, 87]]])
np.msort()

np.msort(a)
函数说明：
用于沿数组a的第0轴进行排序，相当于np.sort(a, axis=0)

1
2
3
4
5
6
7
8
9
>>> a=np.random.randint(0,24,12).reshape(3,-1)
>>> a
array([[15,  8, 23, 12],
       [14,  1, 17, 13],
       [ 5,  4, 14,  8]])
>>> np.msort(a)
array([[ 5,  1, 14,  8],
       [14,  4, 17, 12],
       [15,  8, 23, 13]])
np.lexsort()

np.lexsort(keys, axis=-1)
函数说明：
参数keys是一个元组（越靠后优先级越高），包含多个（至少两个）排序键（一维序列），lexsort()将会执行多重排序，其实就相当于sorted(zip(keys[::-1]),key=lambda x:x)，只不过lexsort()返回的是排序后的下标索引列表

看个例子，现有一个学生姓名列表，另外还有这些学生对应的语文成绩列表、数学成绩列表、英语成绩列表以及语数英总分列表，要对学生进行优劣排序，规则：首先按照总分降序排序，当总分相同时按照语文成绩降序排序，如果又出现相同，再依次按照数学、英语成绩降序排序，根据这些成绩排序结果，最终将得到学生的优劣先后，代码如下：
1
2
3
4
5
6
7
8
9
10
11
>>> names=['daiyang','daixiaodong','zhouqifei','dongjiazhou','liushaoliang','zhouzifeng']
>>> totals=[337,333,345,345,337,333]
>>> chinese=[103,90,108,108,103,86]
>>> math=[156,162,155,135,156,160]
>>> english=[78,81,82,102,78,87]
>>> inds=np.lexsort((english,math,chinese,totals))
>>> inds
array([5, 1, 0, 4, 3, 2], dtype=int64)
>>> np.array(names)[inds] #花式索引，这里其实是升序排列
array(['zhouzifeng', 'daixiaodong', 'daiyang', 'liushaoliang',
       'dongjiazhou', 'zhouqifei'], dtype='<U12')
也可以自定义结构化数组，并利用`np.argsort()`实现：
1
2
3
4
5
6
7
8
9
10
t=list2structarray(list(zip(totals,chinese,math,english)),dtype='i4,i4,i4,i4')
inds=np.argsort(t)[::-1] #按降序排列的下标索引
print(inds)
print(np.array(names)[inds])

'''OUTPUT
[2 3 4 0 1 5]
['zhouqifei' 'dongjiazhou' 'liushaoliang' 'daiyang' 'daixiaodong'
 'zhouzifeng']
'''
np.sort_complex()

np.sort_complex(a)
函数说明:
对复数数组按照先实部后虚部的顺序进行排序，注意是沿最后一维进行排序

1
2
3
4
5
6
7
8
9
10
11
>>> a = np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])
>>> np.random.shuffle(a)
>>> a
array([3.-2.j, 2.-1.j, 3.+5.j, 6.+2.j, 6.+1.j, 3.-3.j])
>>> b=a.reshape(2,-1)
>>> b
array([[3.-2.j, 2.-1.j, 3.+5.j],
       [6.+2.j, 6.+1.j, 3.-3.j]])
>>> np.sort_complex(b)
array([[2.-1.j, 3.-2.j, 3.+5.j],
       [3.-3.j, 6.+1.j, 6.+2.j]])

np.max(a, axis=None, out=None, keepdims=False)
函数说明：
该操作返回数组的最大值（axis=None的默认行为）或者沿轴的最大值（结果数组的维数可能会减1，以(m,n)形二维数组为例，若沿0轴获取最大值，即获取数组中每个列向量中的最大值，所得结果数组形状将变为(n,)，除非keepdims设为True，此时结果数组维数将变为(1,n)，仍为二维），另外也可以直接在ndarray对象上调用该方法。out参数用于存放结果数组，keepdims参数表示是否维持数组的维数不变。实际上，axis还可以是一个元组，以(m,n,q)形三维数组为例说明，若沿着axis=(0,1)获取最大值，即获取数组中（沿2轴的）每个“面”中的最大值，所得结果数组形状将变为(q,)，除非keepdims为True，此时结果数组维数将变为(1,1,q)，仍保持三维。最后提醒一下，np.max()还可以写成np.amax()，两个函数就是一回事

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
>>> a=np.random.randint(0,24,12).reshape(3,-1)
>>> a
array([[12, 11,  6, 21],
       [12, 17,  5, 16],
       [10, 14, 13, 17]])
>>> np.max(a)
21
>>> a.max()
21
>>> np.max(a,axis=0)
array([12, 17, 13, 21])
>>> np.max(a,axis=1,keepdims=True)
array([[21],
       [17],
       [17]])
>>> a=np.random.randint(0,24,24).reshape(2,3,4)
>>> a
array([[[ 7,  2,  0, 19],
        [20, 22, 17, 23],
        [11, 23, 14, 14]],

       [[11, 16, 16, 12],
        [13,  9, 17,  0],
        [ 8,  5, 15, 18]]])
>>> np.max(a,axis=(0,1))
array([20, 23, 17, 23])
>>> np.max(a,axis=(0,1),keepdims=True)
array([[[20, 23, 17, 23]]])
>>> np.max(a[:,:,0]) #沿2轴的首个“面”
20
>>> np.max(a[:,:,1])
23
>>> np.max(a[:,:,2])
17
>>> np.max(a[:,:,3]) #沿2轴的最后一个“面”
23
np.argmax()

np.argmax(a, axis=None, out=None)
函数说明：
返回数组或沿轴最大值的下标索引，参数见np.max()，只要说的是，当axis为None时（默认值），表示先将a展平，然后在一维化的数组a中寻找最大值并返回此时的下标，另外也可以直接在ndarray对象上调用该方法

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> a=np.array([[30,40,70],[80,20,10],[50,90,60],[12,56,3]])
>>> a.argmax()
7
>>> a.flat[_]
90
>>> a.max()
90
>>> a.argmax(axis=0)
array([1, 2, 0], dtype=int64)
>>> a[_,np.arange(a.shape[1])] #全坐标索引
array([80, 90, 70])
>>> a.max(axis=0)
array([80, 90, 70])
np.maximum()

np.maximum(arr1, arr2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
函数说明：
用于比较两个数组对象（arr1和arr2这两个数组必须是同形状或者可以广播至同一形状）并返回一个新数组，其中存储了两个数组对应位置上的较大值。其余参数暂时先不管了

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
>>> a=np.random.randint(20,size=(2,3,4))
>>> b=np.random.randint(20,size=(2,3,4))
>>> a
array([[[ 8, 12,  1, 16],
        [ 6, 17,  5,  2],
        [ 8,  9, 18, 11]],

       [[15, 15, 12,  1],
        [ 8,  4,  2,  3],
        [16, 12,  6,  0]]])
>>> b
array([[[18, 12,  2, 18],
        [ 7, 16,  7,  2],
        [ 2,  3, 11,  2]],

       [[ 6, 17,  5, 17],
        [ 3,  4, 14,  0],
        [ 3, 15,  2, 11]]])
>>> s=np.empty_like(a)
>>> np.maximum(a,b,out=s)
array([[[18, 12,  2, 18],
        [ 7, 17,  7,  2],
        [ 8,  9, 18, 11]],

       [[15, 17, 12, 17],
        [ 8,  4, 14,  3],
        [16, 15,  6, 11]]])
>>> s
array([[[18, 12,  2, 18],
        [ 7, 17,  7,  2],
        [ 8,  9, 18, 11]],

       [[15, 17, 12, 17],
        [ 8,  4, 14,  3],
        [16, 15,  6, 11]]])
>>> a=np.eye(2)
>>> b=[0.5, 2]
>>> np.maximum(a,b) #b形状为(2,)，而a形状为(2,2)，因此b发生广播，首先补齐维度变为(1,2)，然后沿0轴复制元素进一步补齐维数，于是b相当于[[0.5,2],[0.5,2]]，可通过np.broadcast_to(b,(2,2))验证
array([[1. , 2. ],
       [0.5, 2. ]])
np.nanmax()

np.nanmax(a, axis=None, out=None, keepdims=False)
函数说明：
只要数组中有一个元素为NaN（通常是无意义的异常值），则相应的np.max()比较得到的最大值也将为NaN，若要忽略NaN值，则使用np.nanmax()代替np.max()，该函数具体的用法参照np.max()即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> a=np.random.randint(0,24,12).reshape(3,-1).astype('float')
>>> a[1,2]=np.nan
>>> a[2,0]=np.nan
>>> a
array([[ 9., 19.,  5., 23.],
       [ 6.,  3., nan, 13.],
       [nan, 15., 17.,  2.]])
>>> np.max(a)
nan
>>> np.max(a,axis=1)
array([23., nan, nan])
>>> np.nanmax(a)
23.0
>>> np.nanmax(a,axis=1)
array([23., 13., 17.])

np.min(axis=None, out=None, keepdims=False)
函数说明：
等同于函数np.amin()，具体参见np.max()，只不过一个求最大一个求最小而已

np.argmin()

np.argmin(a, axis=None, out=None)
函数说明：
具体参见np.argmax()

np.minimum()

np.numpy.minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'minimum'>
函数说明：
具体参见np.maximum()

np.nanmin()

np.nanmin(a, axis=None, out=None, keepdims=False)
函数说明：
具体参见np.nanmax()

np.sum(a, axis=None, dtype=None, out=None, keepdims=False)
函数说明：
求和运算，类似于np.max()、np.min()，都是“聚合”操作，参数含义也都一样，就不多说了。可以直接在ndarray对象上调用该方法

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> a=np.arange(24).reshape(2,3,4)
>>> a.sum()
276
>>> a.sum(axis=0)
array([[12, 14, 16, 18],
       [20, 22, 24, 26],
       [28, 30, 32, 34]])
>>> a.sum(axis=(1,2))
array([ 66, 210])
>>> a[0].sum()
66
>>> a[1].sum()
210
np.cumsum()

np.cumsum(a, axis=None, dtype=None, out=None)
函数说明：
计算数组或沿轴元素的累加，当axis为None时，会先展平一维化数组，然后再计算累加，所得也会是一个一维数组。可以直接在ndarray对象上调用该方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> a.flatten() #继续上面的代码
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23])
>>> a.cumsum()
array([  0,   1,   3,   6,  10,  15,  21,  28,  36,  45,  55,  66,  78,
        91, 105, 120, 136, 153, 171, 190, 210, 231, 253, 276], dtype=int32)
>>> a.cumsum(axis=2)
array([[[ 0,  1,  3,  6],
        [ 4,  9, 15, 22],
        [ 8, 17, 27, 38]],

       [[12, 25, 39, 54],
        [16, 33, 51, 70],
        [20, 41, 63, 86]]], dtype=int32)

np.cumprod(a, axis=None, dtype=None, out=None)
函数说明：
计算数组或沿轴元素的累乘，当axis为None时，会先展平一维化数组，然后再计算累乘，所得也会是一个一维数组。可以直接在ndarray对象上调用该方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> a=np.random.randint(0,5,12).reshape(3,4)
>>> a
array([[3, 1, 1, 0],
       [3, 3, 3, 1],
       [1, 3, 0, 4]])
>>> a.flatten()
array([3, 1, 1, 0, 3, 3, 3, 1, 1, 3, 0, 4])
>>> np.cumprod(a)
array([3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int32)
>>> np.cumprod(a,axis=0)
array([[3, 1, 1, 0],
       [9, 3, 3, 0],
       [9, 9, 0, 0]], dtype=int32)
>>> np.cumprod(a,axis=1)
array([[ 3,  3,  3,  0],
       [ 3,  9, 27, 27],
       [ 1,  3,  0,  0]], dtype=int32)

np.nonzero(a)
函数说明：
用于返回数组a中非零元素的下标索引（按坐标分量返回），根据此下标索引可以获取所有非零元素并以一维数组返回，若要直接返回数组中的非零元素，直接a[a!=0]。该函数常用于查找条件为真的数组元素索引，譬如，给定数组a，条件a>3返回一个布尔数组，由于False就是整数0（有False==0成立），所以np.nonzero(a>3)将返回符合条件的数组元素的下标索引。另外也可以直接在ndarray对象上调用nonzero()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> a=np.random.randint(0,24,12).reshape(3,-1)
>>> a
array([[20, 12,  1,  0],
       [11,  3, 13,  4],
       [ 4, 11, 22, 21]])
>>> np.nonzero(_)
(array([0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], dtype=int64), array([0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))
>>> a[_] #全坐标索引获取非零元素
array([20, 12,  1, 11,  3, 13,  4,  4, 11, 22, 21])
>>> a[a!=0] #布尔索引获取非零元组
array([20, 12,  1, 11,  3, 13,  4,  4, 11, 22, 21])
>>> a[np.nonzero(a>3)] #等同于：a[a>3]
array([20, 12, 11, 13,  4,  4, 11, 22, 21])

np.where(condition, [x, y])
函数说明：
分两种情况（其中condition将返回一个布尔数组）：

  1. np.where(condition)：此时等同于condition.nonzero()
  2. np.where(condition,x,y)：首先创建一个空的结果数组，形状同condition，如果condition某个位置的元素为True，表示符合条件，则从x中对应位置处取出元素并放到结果数组中的相应位置，如果condition某个位置的元素为False，表示不符合条件，则从y中对应位置处取出元素并放到结果数组中的相应位置。并不要求x、y和condition的形状完全一致，但是其应能广播至同一形状
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
>>> np.where([[0, 1],[1, 0]])
(array([0, 1], dtype=int64), array([1, 0], dtype=int64))
>>> np.array([[0, 1],[1, 0]]).nonzero()
(array([0, 1], dtype=int64), array([1, 0], dtype=int64))
>>> np.where([[True, False],
...           [True, True]],
...          [[1, 2],
...           [3, 4]],
...          [[9, 8],
...           [7, 6]])
array([[1, 8],
       [3, 4]])
>>> a=np.array([1,5,2,7])
>>> x=[[11,12,13,14],[15,16,17,18]]
>>> y=[-1]
>>> ret=np.where(a>3,x,y) #这里发生了广播
>>> ret
array([[-1, 12, -1, 14],
       [-1, 16, -1, 18]])
>>> a = np.arange(9.).reshape(3, 3)
>>> np.where(a < 5, a, -1) #大于等于5的元素被置为-1，不过最简单的做法还是：a[a>=5]=-1
array([[ 0.,  1.,  2.],
       [ 3.,  4., -1.],
       [-1., -1., -1.]])

np.extract(condition, arr)
函数说明：
用于从数组a中提取满足条件的元素。这不就是a[condition]么

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> arr = np.arange(12).reshape((3, 4))
>>> arr
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> condition = np.mod(arr, 3)==0
>>> condition
array([[ True, False, False,  True],
       [False, False,  True, False],
       [False,  True, False, False]])
>>> np.extract(condition, arr)
array([0, 3, 6, 9])
>>> arr[condition]
array([0, 3, 6, 9])

np.place(arr, mask, vals)
函数说明：
将数组arr中满足条件mask（掩码数组）的元素用数据vals进行替换（原址操作）。这不就是arr[mask]=vals么。注意vals参数是一个一维数组或一维序列，指定用于替换的元素，设其长度为N，而符合条件的元素个数记为M，若N>M，则将只使用vals序列的前M个元素用于替换，若N<=M，则将循环重复使用这个序列的元素，譬如vals=[1,2,3]，且符合条件的元素有5个，则用于替换的元素为：[1,2,3,1,2]

1
2
3
4
5
6
7
8
9
10
>>> arr = np.arange(12).reshape(3, 4)
>>> arr
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> np.place(arr, arr>2, [66, 88]) #相当于arr[arr>2]=[66,88]，不过此句实际会报错，因为等号两边替换的元素和符合条件的元素数量不一致
>>> arr
array([[ 0,  1,  2, 66],
       [88, 66, 88, 66],
       [88, 66, 88, 66]])

np.partition(a, kth, axis=-1, kind='introselect', order=None)
函数说明：
指定一个或多个数，对数组进行分区。这玩意儿常用来求序列的第k项最大（小）值，特别是前几项最大（小）值，效率较高，因为它不对分区元素排序
参数说明：

  • kth：可以是单个整数，也可以是多个整数的序列，单个整数值时，kth表示第k个元素，k是指按升序排序后的数组（记作s，参数axis决定了具体沿哪个轴进行排序）的下标索引，axis所在轴长也就是kth参数的合法取值（实际取值区间为[-len(arr),len(arr)-1]，负数索引譬如-1表示的是最后一个元素的索引，这里姑且假设axis取0，于是0轴长度就是len(arr)），函数的功能是将原数组中小于s[k]的元素放到（s[k]的）左边区域，将大于或等于s[k]的元素放到（s[k]的）右边区域，但分区区域中元素并无顺序。显而易见的是，由于第k个元素指的是排序后的数组（s）的第k个元素，因此s本身就是一个符合条件的函数返回值，因为s[k]左边的元素的确都比s[k]小，s[k]右边的元素的确都比s[k]大或等啊。当kth参数是多值序列时（设为[k0,k1,,k2,...]），序列中的每一个整数都要在“合法取值”内，只需记住：作为函数返回值的数组的第k0、k1、k2、…个元素就是按升序排列后的数组的第k0、k1、k2、…个元素，将这些元素视为一个一个的分界点，左边的数总是小于它，右边的数总是大于等于它
  • axis：指定要排序的轴，缺省为-1，表示沿最后一根轴排序，若指定为None，则首先将数组“展平”为一维，然后再排序，同np.sort()
  • order：非内存布局，而是用于自定义结构化数据类型时，指定字段排序优先级，仍同np.sort()
kth为整数时：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
>>> a=[3,4,5,2,1] #这里有五个数，使用np.sort()按升序排序得到：[1,2,3,4,5]，记作s
>>> np.partition(a,0) #以s的第0个元素为分界点，比它小的在前面，比它大的或相等的在后面，前后区域中的元素未排序
array([1, 4, 5, 2, 3])
>>> np.partition(a,-5)
array([1, 4, 5, 2, 3])
>>> np.partition(a,1) #以s的第1个元素为分界点，比它小的在前面，比它大的或相等的在后面，前后区域中的元素未排序
array([1, 2, 5, 4, 3])
>>> np.partition(a,-4)
array([1, 2, 5, 4, 3])
>>> np.partition(a,2) #以s的第2个元素为分界点，比它小的在前面，比它大的或相等的在后面，前后区域中的元素未排序
array([1, 2, 3, 4, 5])
>>> np.partition(a,-3)
array([1, 2, 3, 4, 5])
>>> np.partition(a,3) #以s的第3个元素为分界点，比它小的在前面，比它大的或相等的在后面，前后区域中的元素未排序
array([2, 1, 3, 4, 5])
>>> np.partition(a,-2)
array([2, 1, 3, 4, 5])
>>> np.partition(a,4) #以s的第4个元素为分界点，比它小的在前面，比它大的或相等的在后面，前后区域中的元素未排序
array([2, 1, 3, 4, 5])
>>> np.partition(a,-1)
array([2, 1, 3, 4, 5])
kth为多个整数序列时：
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
a=[2,6,10,1,5,2,4,8,1,9,7,7,13]
print('kth参数是多值序列时：如[3,5,8]，函数返回的数组的第3个元素（从0开始计数，第0个元素...）、第5个元素、第8个元素分别是原数组按升序排列后的第3、5、8个元素：')
b=np.frombuffer(b' '*len(a),dtype='S1')
b=b.copy() # 通过frombuffer()得到的将是一个只允许“读”模式的数组对象，op_flags参数无法开启“写”模式，只好拷贝一份副本而丢弃原数组对象
it=np.nditer(b,op_flags=['readwrite'])
while not it.finished:
    if it.iterindex in [3,5,8]:
        it[0]=b'|'
    #print(it[0])
    it.iternext()
print('   分区  界点 分区 界点 分区 界点 分区')
print('  ',end='')
for i in np.nditer(b):
    print(str(i, encoding='utf-8'),end='  ')
print()
print(np.sort(a),end=' -- sort(a)\n')
print(np.partition(a,(3,5,8)),end=' -- partition(a,[3,5,8])\n')

'''OUTPUT
kth参数是多值序列时：如[3,5,8]，函数返回的数组的第3个元素（从0开始计数，第0个元素...）、第5个元素、第8个元素分别是原数组按升序排列后的第3、5、8个元素：
   分区  界点 分区 界点 分区 界点 分区
           |     |        |
[ 1  1  2  2  4  5  6  7  7  8  9 10 13] -- sort(a)
[ 1  1  2  2  4  5  6  7  7  9  8 10 13] -- partition(a,[3,5,8])
'''
该函数常用于求数组的前几个最大或最小值：
1
2
3
4
5
6
7
>>> a=[2,6,10,1,5,2,4,8,1,9,7,7,13]
>>> np.partition(a,[-1,-2,-3]) #求数组的前三大元素（由于默认是升序，因此是取最后三项，使用负数索引），另外当kth为多值序列时，其中的索引无需计较先后顺序
array([ 2,  2,  1,  1,  4,  6,  7,  5,  7,  8,  9, 10, 13])
>>> np.partition(a,[-2,-3,-1])
array([ 2,  2,  1,  1,  4,  6,  7,  5,  7,  8,  9, 10, 13])
>>> np.partition(a,[-1,-2,-3])[[-1,-2,-3]] #花式索引
array([13, 10,  9])
再看一个自定义结构化类型和多维情况下的例子：
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
>>> dtype = [('name', 'S10'), ('height', float), ('age', int)]
>>> values = [('Lancelot', 1.9, 38), ('Arthur', 1.8, 41), ('muggledy', 1.8, 22), ('Galahad', 1.7, 38)] #尝试将'Arthur'改成'rthur'，看看结果会有什么不同（该实验将说明“未在order参数中出现的字段仍将影响排序结果”，对于order='height'来说，'height'字段出于最高优先级，其次是在dtype中先定义的'name'字段，最后是'age'字段）
>>> a = np.array(values, dtype=dtype)
>>> np.sort(a, order='height')
array([(b'Galahad', 1.7, 38), (b'Arthur', 1.8, 41),
       (b'muggledy', 1.8, 22), (b'Lancelot', 1.9, 38)],
      dtype=[('name', 'S10'), ('height', '<f8'), ('age', '<i4')])
>>> np.partition(a, kth=2, order='height')
array([(b'Galahad', 1.7, 38), (b'Arthur', 1.8, 41),
       (b'muggledy', 1.8, 22), (b'Lancelot', 1.9, 38)],
      dtype=[('name', 'S10'), ('height', '<f8'), ('age', '<i4')])
>>> np.sort(a, order=['age', 'height'])
array([(b'muggledy', 1.8, 22), (b'Galahad', 1.7, 38),
       (b'Lancelot', 1.9, 38), (b'Arthur', 1.8, 41)],
      dtype=[('name', 'S10'), ('height', '<f8'), ('age', '<i4')])
>>> np.partition(a, kth=2, order=['age', 'height'])
array([(b'muggledy', 1.8, 22), (b'Galahad', 1.7, 38),
       (b'Lancelot', 1.9, 38), (b'Arthur', 1.8, 41)],
      dtype=[('name', 'S10'), ('height', '<f8'), ('age', '<i4')])
>>> a=np.array([[3,7,1],[4,2,5],[2,3,2]])
>>> a
array([[3, 7, 1],
       [4, 2, 5],
       [2, 3, 2]])
>>> np.partition(a,kth=1,axis=0)
array([[2, 2, 1],
       [3, 3, 2],
       [4, 7, 5]])
>>> a=np.array([[[3,1],[6,5]],[[4,7],[2,3]]])
>>> a
array([[[3, 1],
        [6, 5]],

       [[4, 7],
        [2, 3]]])
>>> np.partition(a,kth=1,axis=1)
array([[[3, 1],
        [6, 5]],

       [[2, 3],
        [4, 7]]])
np.argpartition()

np.argpartition(a, kth, axis=-1, kind='introselect', order=None)
函数说明：
功能同np.partition()，只不过返回的是np.partition()结果数组中的元素在原数组a中的下标索引

1
2
3
4
5
6
7
8
9
>>> a=[2,6,10,1,5,2,4,8,1,9,7,7,13]
>>> s1=np.argpartition(a,5)
>>> s2=np.partition(a,5)
>>> s1
array([ 5,  0,  8,  3,  6,  4,  1, 10, 11,  9,  7,  2, 12], dtype=int64)
>>> s2
array([ 2,  2,  1,  1,  4,  5,  6,  7,  7,  9,  8, 10, 13])
>>> np.array(a)[s1]
array([ 2,  2,  1,  1,  4,  5,  6,  7,  7,  9,  8, 10, 13])

数学运算

np.dot(a, b, out=None)
函数说明：
矩阵乘法（可以在ndarray对象上直接调用该方法），等同于np.matmul(a,b)或使用@运算符：a @ b，注意区别于np.multiply()方法，这是用于两个数组之间的逐元素乘法操作，对应运算符*，即a * b

  • a和b都是标量，表示数值间的普通乘法
  • a和b都是一维时，表示计算这两个向量的内积
  • a和b都是二维或其中一个允许是一维，表示矩阵乘法
  • a是N维（N>2）而b是一维，则结果是a和b的最后一个轴上元素的和积，因此需满足条件：a和b最后一个轴的长度相同，等同于：reduce(lambda last,now:last+now[0]*now[1],zip(np.rollaxis(a,a.ndim-1),b),0)，结果数组形状为a.shape[:-1]
  • a是N维（N>2）而b是M维（M>=2），则结果是a的最后一个轴和b的倒数第二个轴上元素的和积，需满足条件：a的最后一个轴长等于b的倒数第二个轴长，且有：dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])，这条没看懂
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
>>> a=np.random.randint(0,10,3).reshape(3)
>>> b=np.random.randint(0,10,3).reshape(3)
>>> a
array([3, 4, 0])
>>> b
array([8, 9, 4])
>>> a.dot(b)
60
>>> c=np.arange(6).reshape(2,3)
>>> c.dot(a) #c形状为(2,3)，a形状为(3,)，允许这样，而并不一定要求a形状为(3,1)
array([ 4, 25])
>>> c.dot(a[:,None])
array([[ 4],
       [25]])
>>> a=np.arange(24).reshape(3,4,2)
>>> a
array([[[ 0,  1],
        [ 2,  3],
        [ 4,  5],
        [ 6,  7]],

       [[ 8,  9],
        [10, 11],
        [12, 13],
        [14, 15]],

       [[16, 17],
        [18, 19],
        [20, 21],
        [22, 23]]])
>>> b=np.array([1,2])
>>> a.dot(b)
array([[ 2,  8, 14, 20],
       [26, 32, 38, 44],
       [50, 56, 62, 68]])
np.out()

np.outer(a, b, out=None)
函数说明：
用于计算两个一维向量的外积，其尺寸各自随意，等同于a[:,None]@b[None,:]

1
2
3
4
5
6
7
8
9
10
>>> a=np.random.randint(0,10,3)
>>> a
array([4, 9, 3])
>>> b=np.random.randint(0,10,5)
>>> b
array([9, 2, 1, 8, 4])
>>> np.outer(a,b)
array([[36,  8,  4, 32, 16],
       [81, 18,  9, 72, 36],
       [27,  6,  3, 24, 12]])
np.inner()

np.inner(a, b)
函数说明：
用于计算两个一维向量的内积，其尺寸必须一致，等同于a[None,:]@b[:,None]

1
2
3
4
5
>>> a=np.random.randint(0,10,3)
>>> a
array([9, 6, 3])
>>> np.inner(a,a)
126

np.log(a)
函数说明：
逐元素的以e为底的对数计算，满足log(exp(x)) = x（以e为底exp(x)的对数就是x），还有np.log2()、np.log10()，而基于其他底数的对数计算，通常可以采用换底公式转换为以10为底的对数（也就是ln）计算：log⁡ab=log⁡10blog⁡10a=ln⁡bln⁡a\log_a b=\frac{\log_{10}b}{\log_{10}a}=\frac{\ln b}{\ln a}

1
2
3
4
5
6
>>> np.log(np.exp(12))
12.0
>>> np.log2(12)
3.584962500721156
>>> np.log10(12)/np.log10(2)
3.5849625007211565

np.sqrt(a)
函数说明：
逐元素计算平方根。要计算任意次方根，可以使用**运算符，如a**(1/2)、a**(1/3)，其等同于调用np.power()函数（或math库中的pow()），如np.power(a,1/2)、np.power(a,1/3)

1
2
3
4
>>> np.sqrt([1,4,9])
array([1., 2., 3.])
>>> np.array([1,4,9])**(1/2)
array([1., 2., 3.])
立方根

np.cbrt(a)
函数说明：
逐元素计算立方根。不建议使用a**(1/3)方式，譬如当a是负数时将返回复数类型，a**(1/5)等也是如此

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
>>> np.array([-1,-8,-27])**(1/3) #之所以返回nan，是因为np.array([-1,-8,-27])是int64整型，无法支持复数运算
array([nan, nan, nan])
>>> np.array([-1,-8,-27],dtype='complex')**(1/3)
array([0.5+0.8660254j , 1. +1.73205081j, 1.5+2.59807621j])
>>> np.power(np.array([-1,-8,-27],dtype="complex"),1/3)
array([0.5+0.8660254j , 1. +1.73205081j, 1.5+2.59807621j])
>>> (-27)**(1/3)
(1.5000000000000004+2.598076211353316j)
>>> -27**(1/3) #由于**运算符的优先级大于-，所以相当于-(27**(1/3))，因为有-(-a)^{1/3}=a^{1/3},a>0成立
-3.0
>>> np.cbrt(-27) #立方根（cube root）
-3.0
>>> import math
>>> x=-27
>>> math.pow(abs(x),float(1)/3) * (1,-1)[x<0] #参见https://stackoverflow.com/questions/1361740/cubic-root-of-the-negative-number-on-python
-3.0
>>> math.pow(-27,1/3) #参见https://vevurka.github.io/cs/python/cubic_root/
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: math domain error

np.mod(a,b)
函数说明：
逐元素的取模运算

1
2
3
4
5
6
7
>>> a=np.arange(8).reshape(2,4)
>>> a
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])
>>> np.mod(a,2)
array([[0, 1, 0, 1],
       [0, 1, 0, 1]], dtype=int32)

np.poly1d(c_or_r, r=False, variable='x')
函数说明：
用于创建一个一元多项式函数，有两种模式，一是r为False（默认），此时c_or_r指定多项式的系数，譬如c_or_r=[1,2,3]，创建的多项式函数为f(x)=1x2+2x1+3x0f(x)=1x^2+2x^1+3x^0，二是r为True，此时c_or_r指定多项式的根，仍以c_or_r=[1,2,3]为例，创建的多项式函数为f(x)=(x−1)(x−2)(x−3)=x3−6x2+11x−6f(x)=(x-1)(x-2)(x-3)= x^3 - 6x^2 + 11x -6，实际poly1d是一个类，若返回的类实例记作f=np.poly1d([1,2,3])，可以直接用()调用之（f()），返回多项式的具体值，variable参数指定未知变量字母，控制多项式函数的打印结果，默认为'x'，f有一些属性，r属性返回多项式的根，c属性返回多项式的系数数组，order属性返回多项式的最高次方，f可以用[i]进行索引，获取xix^i的系数，f还有两个方法，deriv([m])表示求导，可选的参数m表示求几次导，默认求一次导，返回的仍是一个多项式函数，integ([m,k])表示求积分，可选的参数m表示积几次分，k表示积分后的常数项的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> f=np.poly1d([1,2,3])
>>> print(f)
   2
1 x + 2 x + 3
>>> f.r
array([-1.+1.41421356j, -1.-1.41421356j])
>>> f(_)
array([4.4408921e-16+0.j, 4.4408921e-16+0.j])
>>> f.c
array([1, 2, 3])
>>> f[2]
1
>>> f.deriv()
poly1d([2, 2])
>>> print(_)
2 x + 2

[1] Numpy官方英文文档·用户手册
[2] Numpy中文网入门教程
[3] RUNOOB菜鸟教程 Numpy入门教程

]]> 计算机基础 编程语言 Python Butterfly魔改部分记录 posts/65257/ #article-container figure.highlight { margin: 0.5rem 0 0.5rem !important;}
  • 按照Lete乐特的教程添加了哔哩哔哩banner，用以替换原始顶图（Top image）
    这导致banner图不适应暗黑模式，问题就是如何将banner所在div调暗，现有两种解决方案（我采取第二种）：
    1. 通过亮度滤镜实现
      1
      2
      3
      [data-theme="dark"] #page-header {
          filter: brightness(60%);
      }
      实测发现，每当从暗黑模式进入新的页面，顶图变暗都有一个很大的延迟，我没有找出具体的原因，因此想了另一个解决方案，通过伪元素实现（黑色透明蒙板）遮罩层：
    2. 通过伪元素实现
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      [data-theme="dark"] #page-header::before {
          content:'';
          display:block;
          position:relative;
          width:100%;
          height:100%;
          z-index:7;
          background-color:#121212;
          opacity:0.7;
      }
  • 之前看到黑石博客首页文章卡片有模糊背景，很漂亮，我也来实现一下吧
    首先看一个实现该效果的简单示例：
    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
    <html>

    <style type="text/css">
      .wrapper{
          position: relative;
          width:500px;
          height:400px;
      }
      .blur_layer{
          position: absolute;
          width:100%;
          height:100%;
          filter: blur(8px);
          background:url(https://cdn.statically.io/gh/celestezj/ImageHosting/master/img/20210217120300.jpg);
          background-size: cover;
          opacity: 0.5;
      }
      .content{
          position:absolute;
          left: 50%;
          top: 50%;
          transform: translate(-50%);
      }
    </style>

    <div class="wrapper">
        <div class="blur_layer"></div>
        <div class="content">
            Hello, World!<!-- 这里放置你的内容 -->
        </div>
    </div>

    </html>
    简单来说就是将父div设为relative，然后额外添加一个子div充当blur层并设为absolute，在blur层上设置背景并进行高斯模糊，最后将你要显示在blur层之上的东西都放在blur层后面即可
    好了，思路有了，现在改源码，打开目标文件butterfly/layout/includes/mixins/post-ui.pug，在if post_cover && theme.cover.index_enable一行下面添加如下内容：
    1
    2
    3
    4
    5
    .dyblurbg
      if theme.lazyload.enable
        img(data-lazy-src=url_for(post_cover) onerror=`this.onerror=null;this.src='`+ url_for(theme.error_img.post_page) + `'` alt=title)
      else
        img(src=url_for(post_cover))
    这个.dyblurbg就是充当blur层的div，类名叫做dyblurbg，为了适配主题源码，还需要增加是否图片懒加载的判断，具体参见vanilla-lazyload
    新建butterfly/source/css/mystyle.css文件：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    .dyblurbg {
        position: absolute;
        width: 100%;
        height: 100%;
        filter: blur(15px);
        opacity: 0.5;
    }

    .dyblurbg img {
        width: 100%;
        height: 100%;
    }

    .recent-post-item{
        position: relative;
        overflow: hidden;
    }
    其中recent-post-item就是dyblurbg的父div，最后在主题配置的inject项中引入该css文件即可：
    1
    2
    3
    inject:
      head:
        - <link rel="stylesheet" href="/css/mystyle.css">

    经过测试，在PC端、手机端各浏览器都工作正常，唯独在iPad设备中背景模糊特效图片会时不时发生闪烁且残缺不全的状况，暂时无力解决，慎用

    解决不了问题那就消除问题好了，在移动端，我直接将blur层给置为none了😅
    1
    2
    3
    4
    5
    @media only screen and (max-width: 1500px){
        .dyblurbg {
            display: none;
        }
    }
  • 之前在Volantis主题中根据参考文章增加了文章日历图，稍稍改一点应用到Butterfly主题下
    下载资源
    1. 将下载下来的源码文件（post-calendar.pug）粘贴到themes/butterfly/layout/includes/目录下
    2. 在themes/butterfly/source/css/mystyle.css中添加样式：
      1
      2
      3
      4
      5
      6
      7
       #post-calendar {
           height: 225px;
           width: 100%;
           margin-top: 20px;
           border-radius: 12px;
           background:rgba(255,255,255,0);
      }
    3. 在themes/butterfly/layout/archive.pug中引入post-calendar.pug，在#archive位置下插入一行：include includes/post-calendar，注意空格，如下：
      1
      2
      3
      4
      5
      ...
      #archive
        include includes/post-calendar
        .article-sort-title= _p('page.articles') + ' - ' + site.posts.length
      ...
    4. 在主题配置文件（_config.butterfly.yml）中inject项中引入依赖文件：
      1
      2
      3
      4
      5
      6
      7
      inject:
        head:
          ...
          - <link rel="stylesheet" href="/css/mystyle.css">
          - <script src="http://cdn.staticfile.org/moment.js/2.24.0/moment.min.js"></script>
          - <script src="https://cdn.statically.io/gh/InfiniteYinux/cloud/2.44/Hexo/themeConfig/echarts.min.js"></script>
          ...
    注：目前本博客已去除文章日历，示例可参见：https://celestezj.github.io/archives/
  • 对相关文章的样式进行了修改（似乎比原来美观了那么一点点，或者还是丑陋~），目前只在电脑端体验
    注：不需要修改主题源文件，只需要在butterfly/source/css/mystyle.css中添加即可
    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
    @media only screen and (min-width: 1500px){
      
      .relatedPosts > .relatedPosts-list div {
          background: #f6f6f6;
      }
      [data-theme="dark"] .relatedPosts{
          background: #121212 !important;
      }
      [data-theme="dark"] .relatedPosts > .relatedPosts-list div{
          background: #121212 !important;
      }

      .relatedPosts > .relatedPosts-list .cover {
          height: 66%;
          opacity: 0.8;
      }

      .relatedPosts > .relatedPosts-list .content {
          top: 85% !important;
      }

      .relatedPosts > .relatedPosts-list .content .title, .date {
          color: #888888 !important;
          font-size: 0.82rem;
      }
      .relatedPosts > .relatedPosts-list .content .title {
          color: #656261 !important;
          height: 50px;
          display: block;
          overflow:hidden;
          white-space: nowrap;
          text-overflow:ellipsis;
      }

      .relatedPosts > .relatedPosts-list .content .title:hover {
          color: red !important;
      }

      .relatedPosts {
          background: #f6f6f6 !important;
      }

      .relatedPosts > .relatedPosts-list {
          width: 94% !important;
          margin: 0 auto;
          height: 215px;
          overflow: scroll;
      }

      .relatedPosts > .headline {
          font-size: 1.1em;
          margin-left: 3%;
          padding-top: 14.5px;
      }
      [data-theme="dark"] .relatedPosts > .headline {
          color: #b8b8b8;
      }

      ::-webkit-scrollbar {
          width: 5px;
      }

      ::-webkit-scrollbar-corner {
          background-color: #f6f6f6;
      }
      [data-theme="dark"] ::-webkit-scrollbar-corner {
          background-color: #121212;
      }
      
    }
  • 为存档、分类、标签页面的文章列表中的头图添加大图预览
    1. 新建themes/butterfly/source/js/article_img_preview.js文件：
      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
      this.imagePreview = function(){
        xOffset = 10;
        yOffset = 30;
        $("a.article-sort-item-img").hover(function(e){
           this.t = this.title;
           var c = (this.t != "") ? "<br/>" + this.t : "";
           $("body").append("<div id='article-img-preview'><img src='"+ $(this).find('img').attr('src') +"' alt='Article Image Preview' style='width:300px;' />"+ c +"</div>");
           $("#article-img-preview")
               .css("top",(e.pageY - xOffset) + "px")
               .css("left",(e.pageX + yOffset) + "px")
               .fadeIn("fast");
        },
        function(){
           $("#article-img-preview").remove();
        });
        $("a.article-sort-item-img").mousemove(function(e){
           $("#article-img-preview")
               .css("top",(e.pageY - xOffset) + "px")
               .css("left",(e.pageX + yOffset) + "px");
        });
      };

      // starting the script on page load
      $(document).ready(function(){
        imagePreview();
      });
    2. 在themes/butterfly/source/css/mystyle.css中添加预览图所在div样式：
      1
      2
      3
      4
      5
      6
      7
      #article-img-preview{
        position:absolute;
        background:#333;
        padding:5px;
        display:none;
        color:#fff;
      }
    3. 在主题配置文件的inject项中引入上述脚本以及jQuery库：
      1
      2
      3
      4
      5
      6
      inject:
        head:
          ...
          - <script src="https://cdn.staticfile.org/jquery/2.1.4/jquery.min.js"></script>
          - <script src="/js/article_img_preview.js"></script>
          ...
    好了，这就OK了，无需修改任何其他主题源码
    考虑到大部分人都会在主题配置中启用pjax，下面给出（在上述基础上）适配pjax的修改版本

    使用pjax后，一些用户自定义的js脚本在页面跳转时可能需要重新调用，参见主题文档
    将待执行的jquery代码用一个函数包裹起来，然后通过btf.isJqueryLoad(包裹函数)调用以避免多次加载jquery，参见主题文档

    1. 删除主题配置inject项中jquery.min.js的引用
    2. 替换themes/butterfly/source/js/article_img_preview.js文件：下载
    3. 修改themes/butterfly/layout/includes/layout.pug文件，在最后一行添加（注意空格，script打头空两格）：
      1
      2
      script(data-pjax).
        btf.isJqueryLoad(image_preview_wrapper);
  • 发现一款有意思的“随机文章”插件，不过正如作者所说，插件目前存在一个bug，当用于其他主题（非Sakura主题）时可能将无关页面载入随机文章列表。为了正确引入该功能，我给出两种方案
    • 按照原插件的思路，生成一个random.html页面，页面脚本存储着可供随机选择的全部文章列表，当访问该页面时候，浏览器自动跳转到某一随机文章页面，具体代码效仿404.html页面的生成：
      1. 新建themes/butterfly/layout/random.pug文件：
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        doctype html
        html(lang=config.language data-theme=theme.display_mode)
          head
          body(onload="javascript:dogo();")
            - let random_articles = []
            - site.posts.each(function (article) {
              - let if_random = article.random == true || article.random == false ? article.random : theme.random_article
              - if (if_random) random_articles.push(url_for(article.path))
          - })
          script.
          function dogo(){
            var urls="#{random_articles}";
            urls=urls.split(",");
            n = Math.floor(Math.random()*urls.length);
            location.href= urls[n];
          };
      2. 新建themes/butterfly/scripts/events/random.js文件：
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        /**
        * Butterfly
        * random article page
        */

        'use strict'

        hexo.extend.generator.register('random', function (locals) {
          return {
            path: 'random/index.html',
            data: locals.posts,
            layout: ['random']
          }
        })
      3. 在导航栏添加随机文章超链接，地址指向/random/，编辑主题配置文件：
        1
        2
        3
        4
        menu:
          . . .
          随便看看: /random/ || fas fa-layer-group faa-tada
          . . .
      4. 最后在主题配置文件中新增配置：
        1
        random_article: true
        表示默认将所有post文章都添加到随机列表，你可以在post的front-matter中覆盖此配置，譬如：
        1
        2
        3
        4
        5
        ---
        . . .
        random: false
        . . .
        ---
        这意味着当前post文章不会被添加到随机列表中
    • 不借助random.html页面，直接将随机跳转脚本写在layout.pug模板中（如果你启用了pjax，建议使用此方法）：
      1. 新建themes/butterfly/layout/includes/random-js.pug文件：
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        - let random_articles = []
        - site.posts.each(function (article) {
          - let if_random = article.random == true || article.random == false ? article.random : theme.random_article
          - if (if_random) random_articles.push(url_for(article.path))
        - })
        script.
          function dogo(){
            var urls="#{random_articles}";
            urls=urls.split(",");
            n = Math.floor(Math.random()*urls.length);
            pjax.loadUrl(urls[n]);
          };
      2. 编辑themes/butterfly/layout/includes/layout.pug文件，在include ./additional-js.pug下一行添加即可：
        1
        2
        include ./additional-js.pug
        + include ./random-js.pug
      3. 编辑主题配置文件，在导航栏添加随机文章超链接：
        1
        2
        3
        4
        5
        menu:
          . . .
          友链: /link/ || fas fa-link ||
          随便看看: javascript:void(0); || fas fa-layer-group faa-tada || dogo()
          . . .
        原本只有一个||间隔，左边表示链接地址，右边为图标标识，修改后，有两个||间隔，左边为链接，中间为标识，右边为onclick属性值，为此修改themes/butterfly/layout/includes/header/menu_item.pug文件：
        1
        2
        3
        4
        . . .
        - a.site-page(href=url_for(trim(value.split('||')[0])))
        + a.site-page(href=url_for(trim(value.split('||')[0])),onclick=trim(value.split('||')[2]))
        . . .
        还有一处：
        1
        2
        3
        4
        . . .
        - a.site-page.child.faa-parent.animated-hover(href=url_for(trim(val.split('||')[0])))
        + a.site-page.child.faa-parent.animated-hover(href=url_for(trim(val.split('||')[0])),onclick=trim(val.split('||')[2]))
        . . .
      4. 最后仍需在主题配置文件中新增配置（同样可以在front-matter中覆盖）：
        1
        random_article: true
  • 添加春节灯笼，灯笼样式来自博主itsNeko，步骤如下：
    1. 编辑主题配置文件，引入样式文件：
      1
      2
      3
      4
      5
      inject:
        head:
          . . .
          - <link rel="stylesheet" href="https://cdn.statically.io/gh/celestezj/Mirror1ImageHosting/master/data/denglong/denglong.css">
          . . .
    2. 编辑themes/butterfly/layout/includes/layout.pug，在页面中添加灯笼<div>标签：
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      body
        . . .
        if theme.denglong
          .denglong
            .deng-box
            .deng
                .xian
                .deng-a
                  .deng-b
                    .deng-t 喜迎
                .shui.shui-a
                  .shui-c
                  .shui-b
            .deng-box1
              .deng
                .xian
                .deng-a
                  .deng-b
                    .deng-t 春节
                .shui.shui-a
                  .shui-c
                  .shui-b
        . . .
    3. 再次编辑主题配置文件，引入开关：
      1
      denglong: true
      执行hexo g、hexo s就可以看到位于网站左上角的灯笼了
  • 参考糖果屋Akilar和Hassan，修改顶栏菜单样式
    1. 在themes/butterfly/source/css/mystyle.css中新增样式：
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      /*顶部菜单栏居中*/
      #nav .menus_items {
        display: flex;
        justify-content: center;
        position: absolute;
        width: 500px;
        left: 0;
        right: 0;
        top: 10px;
        margin: auto;
      }
      /* 横向排布子菜单 */
      #nav .menus_items .menus_item .menus_item_child li {
        display: inline-block;
      }
      /* 圆角隐藏 */
      #nav ul.menus_item_child {
        overflow: hidden;
        border-radius: 5px;
      }
      /* 调整空隙，确保不会天下武功唯快不破 */
      #nav .menus_items .menus_item .menus_item_child {
        margin-top: 0px !important;
      }
    2. 修改themes/butterfly/layout/includes/header/menu_item.pug：
      1
      2
      - ul.menus_item_child
      + ul.menus_item_child(style=`left:`+ (-5.6 * Object.keys(value).join("").length - 40.3) + `px;`)
      重新隐藏
      注意，稍稍不同于Akilar的计算方式x * Object.keys(value).length + y，譬如我有两个二级菜单，每个都有三项，这种方式计算的left偏移值应该是相同的，但是我这两个二级菜单宽度并不一样啊，所以替换为x * Object.keys(value).join("").length + y更合理
  • Plotly是一个基于d3.js与stack.gl的图形库，它可以用来绘制各种类型的图表，比如散点图、折线图、饼图、柱状图甚至3D图形等，与butterfly主题的集成可以参考这篇Plotly & Hugo
    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
      25
      26
      27
      import plotly.graph_objects as go
      from plotly.graph_objs import Layout
      import numpy as np
      # Generate sample data
      np.random.seed(42)
      x = np.random.rand(100)
      y = np.random.rand(100)
      z = np.random.rand(100)
      # Create a 3D scatter plot
      layout = Layout(
          paper_bgcolor='black', #设置黑色背景
          plot_bgcolor='rgba(0,0,0,0)'
      )
      fig = go.Figure(data=[go.Scatter3d(x=x, y=y, z=z, mode='markers', marker=dict(size=8, color=z, colorscale='Viridis'))], layout=layout)
      # Add title and labels
      fig.update_layout(scene=dict(xaxis_title='X-axis', yaxis_title='Y-axis', zaxis_title='Z-axis', 
                        xaxis=dict(backgroundcolor='rgba(0,0,0,0)',gridcolor='rgba(173, 216, 230, 0.8)',color='white'),
                        yaxis=dict(backgroundcolor='rgba(0,0,0,0)',gridcolor='rgba(173, 216, 230, 0.8)',color='white'),
                        zaxis=dict(backgroundcolor='rgba(0,0,0,0)',gridcolor='rgba(173, 216, 230, 0.8)',color='white'))) #设置坐标轴背景颜色为透明
      # 取消图像和边框之间的 margin
      fig.update_layout(margin=dict(l=0, r=0, t=0, b=0))
      # Show the plot
      fig.show()

      from plotly.io import write_image
      #... Generate the fig here.
      fig.write_json("plotly_demo.json")
    2. 通过HTML+JS读取步骤一保存的json图像数据文件并显示：
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      <html>
        <head>
          <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
        </head>
      <body>
        <div id="demo1" class="plotly" style="height:600px"></div>
        <script>
        Plotly.d3.json('http://192.168.0.103:8080/plotly_demo.json', function(err, fig) {
          Plotly.plot('demo1', fig.data, fig.layout, {responsive: true});
        });
        </script>
      </body>
      </html>
      这里涉及到跨域问题，浏览器不允许使用file协议访问plotly_demo.json，会报错：“Access to XMLHttpRequest at ‘file:///C:/Users/muggledy/Downloads/plotly_demo.json’ from origin ‘null’ has been blocked by CORS policy: Cross origin requests are only supported for protocol schemes: http, data, isolated-app, chrome-extension, chrome, https”，于是使用anywhere将本地目录变成一个静态文件服务器的根目录：
      1
      2
      C:\Users\muggledy\Downloads> npm install anywhere -g
      C:\Users\muggledy\Downloads> anywhere -p 8080
    3. 现在让我们将其集成到butterfly主题中，首先将plotly.js cdn链接放在_config.butterfly.yml配置文件中：
      1
      2
      3
      CDN:
        # plotly.js
        plotly_js: https://cdn.plot.ly/plotly-latest.min.js
      要启用plotly绘图，需要在文章front-matter头部添加plotly:enable来引入上述plotly.js，我们在butterfly/layout/includes/head.pug中加以控制：
      1
      2
      if page.plotly
        script(src=url_for(theme.CDN.plotly_js))
      最后编写标签插件简化书写：
      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
      'use strict';

      function plotly(args) {
        args = args.join(' ').split(', ')
        let id = args[0].trim();
        let json_url = args[1].trim();
        let style = '';
        if (args.length > 2) {
          for (let i = 2; i < args.length; i++) {
            let tmp = args[i].trim();
            if (tmp.includes('height=')) {
              style += 'height:' + tmp.substring(7, tmp.length) + ';';
            }
          }
        }
        if (!style.includes('height:')) {
          style += 'height:400px;';
        }
        return `<div id="${id}" class="plotly" style="${style}"></div>
      <script>
      Plotly.d3.json("${json_url}", function(err, fig) {
          Plotly.plot("${id}", fig.data, fig.layout, {responsive: true});
      });
      </script>`;
      }

      // {% plotly id, json_url[, height=400px] %}
      hexo.extend.tag.register('plotly', plotly);
    4. 示例，{% plotly plotly_demo1, http://192.168.0.103:8080/plotly_demo.json[, height=400px] %}：
]]> Butterfly