Wpz's Blog 闻道有先后，术业有专攻。 2026-09-20T09:12:05.372Z https://blog.wpz.homes/ wpz Hexo Mathjax 与 LaTex 公式 https://blog.wpz.homes/posts/e8b7be43/ 2024-09-06T10:20:23.000Z 2026-09-20T09:12:05.372Z

inline 和 displayed

MathJax中的公式排版有两种方式，inline和displayed。
inline表示公式嵌入到文本段中，使用$...$作为分隔符。
displayed表示公式独自成为一个段落，使用$$...$$作为分隔符。

希腊字母

名称大写符号命令小写符号命令
alpha$A$A$\alpha$\alpha
beta$B$B$\beta$\beta
gamma$\Gamma$\Gamma$\gamma$\gamma
delta$\Delta$\Delta$\delta$\delta
epsilon$E$E$\epsilon$\epsilon
zeta$Z$Z$\zeta$\zeta
eta$H$H$\eta$\eta
theta$\Theta$\Theta$\theta$\theta
iota$I$I$\iota$\iota
kappa$K$K$\kappa$\kappa
lambda$\Lambda$\Lambda$\lambda$\lambda
mu$M$M$\mu$\mu
nu$N$N$\nu$\nu
xi$\Xi$\Xi$\xi$\xi
omicron$O$O$\omicron$\omicron
pi$\Pi$\Pi$\pi$\pi
rho$P$P$\rho$\rho
sigma$\Sigma$\Sigma$\sigma$\sigma
tau$T$T$\tau$\tau
upsilon$\Upsilon$\Upsilon$\upsilon$\upsilon
phi$\Phi$\Phi$\phi$\phi
chi$X$X$\chi$\chi
psi$\Psi$\Psi$\psi$\psi
omega$\Omega$\Omega$\omega$\omega

如果需要斜体希腊字母，将命令前加上var即可，比如\varGamma呈现为$\varGamma$。

关系运算符

符号命令名称符号命令名称
$\gt$\gt大于$\ngtr$\ngtr不大于
$\lt$\lt小于$\nless$\nless不小于
$\ge$\ge大于等于$\ngeqslant$\ngeqslant不大于等于
$\le$\le小于等于$\nleqslant$\nleqslant不小于等于
$\gg$\gg远大于
$\ll$\ll远小于
$\neq$\neq不等于
$\doteq$\doteq点等于
$\sim$\sim相似于$\not\sim$\not\sim不相似于
$\simeq$\simeq近似等于$\not\simeq$\not\simeq不近似等于
$\approx$\approx约等于$\not\approx$\not\approx不约等于
$\asymp$\asymp趋于$\not\asymp$\not\asymp不趋于
$\cong$\cong全等于$\not\cong$\not\cong不全等于
$\equiv$\equiv恒等于$\not\equiv$\not\equiv不恒等于
$\subset$\subset子集
$\supset$\supset超集
$\subseteq$\subseteq子集或等于
$\supseteq$\supseteq超集或等于
$\sqsubseteq$\sqsubseteq方形子集或等于
$\sqsupseteq$\sqsupseteq方形超集或等于
$\in$\in包含于
$\ni$\ni包含
$\notin$\notin不包含于
$\models$\modelsModels
$\vdash$\vdash竖线短横
$\dashv$\dashv短横竖线
$\perp$\perp垂直
$\mid$\mid中线
$\parallel$\parallel平行
$\propto$\propto成比例
$\bowtie$\bowtie领结
$\prec$\prec先于
$\preceq$\preceq先于等于
$\succ$\succ后于
$\succeq$\succeq后于等于

括号

符号命令名称符号命令名称
$\lbrace$\lbrace左花括号$\rbrace$\rbrace右花括号
$\lbrack$\lbrack左方括号$\rbrack$\rbrack右方括号
$\langle$\langle左尖括号$\rangle$\rangle右尖括号
$\lceil$\lceil左上半框括号$\rceil$\rceil右上半框括号
$\lfloor$\lfloor左下半框括号$\rfloor$\rfloor右下半框括号
.不可见括号

小括号使用原始的()，方括号可以使用原始的[]，也可以使用\lbrack和\rbrack。

未自适应括号命令自适应括号命令
$(\frac{x}{y})$(\frac{x}{y})$\left(\frac{x}{y}\right)$\left(\frac{x}{y}\right)
$[\frac{x}{y}]$[\frac{x}{y}]$\left[\frac{x}{y}\right]$\left[\frac{x}{y}\right]
$\lbrace\frac{x}{y}\rbrace$\lbrace\frac{x}{y}\rbrace$\left\lbrace\frac{x}{y}\right\rbrace$\left\lbrace\frac{x}{y}\right\rbrace

自适应括号使用\left和\right。小括号自适应为\left(和\right)，中括号自适应为\left[和\right]，大括号自适应为\left\lbrace和\right\rbrace。

箭头符号

符号命令名称符号命令名称
$\leftarrow$\leftarrow左箭头$\rightarrow$\rightarrow右箭头
$\Leftarrow$\Leftarrow左双线箭头$\Rightarrow$\Rightarrow右双线箭头
$\longleftarrow$\longleftarrow长左箭头$\longrightarrow$\longrightarrow长右箭头
$\Longleftarrow$\Longleftarrow长双线左箭头$\Longrightarrow$\Longrightarrow长双线右箭头
$\leftrightarrow$\leftrightarrow左右双向箭头$\Leftrightarrow$\Leftrightarrow左右双向双线箭头
$\longleftrightarrow$\longleftrightarrow长左右双向箭头$\Longleftrightarrow$\Longleftrightarrow长左右双向双线箭头
$\hookleftarrow$\hookleftarrow弯钩左箭头$\hookrightarrow$\hookrightarrow弯钩右箭头
$\leftharpoonup$\leftharpoonup上半钩左箭头$\rightharpoonup$\rightharpoonup上半钩右箭头
$\leftharpoondown$\leftharpoondown下半钩左箭头$\rightharpoondown$\rightharpoondown下半钩右箭头
$\uparrow$\uparrow上箭头$\downarrow$\downarrow下箭头
$\Uparrow$\Uparrow上双线箭头$\Downarrow$\Downarrow下双线箭头
$\updownarrow$\updownarrow上下双向箭头$\Updownarrow$\Updownarrow上下双向双线箭头
$\nwarrow$\nwarrow左斜上箭头$\nearrow$\nearrow右斜上箭头
$\swarrow$\swarrow左斜下箭头$\searrow$\searrow右斜下箭头
$\mapsto$\mapsto映射箭头$\longmapsto$\longmapsto长映射箭头

表格

使用$$\begin{array}{列样式}...\end{array}$$来表示表格。

列样式可以是clr|。c表示居中对齐，l表示左对齐，r表示右对齐，|表示一条竖线。

表格中各行使用\\分隔，各列使用&分隔，\hline表示一条横线。

$$\begin{array}{c|lcr}    n & \text{Left} & \text{Center} & \text{Right} \\    \hline 1 & 0.24 & 1 & 125 \\    2 & -1 & 189 & -8 \\    3 & -20 & 2000 & 1+10i\end{array}$$

矩阵

基本用法

使用$$\begin{matrix}...\end{matrix}$$来表示矩阵。

$$\begin{matrix}    1 & x & x^2 \\    1 & y & y^2 \\    1 & z & z^2\end{matrix}$$

加括号

如果要对矩阵加括号，可以像上文中提到的那样，使用\left与\right配合表示括号符号。也可以使用特殊的matrix，即替换$$\begin{matrix}...\end{matrix}$$中的matrix为pmatrix，bmatrix，Bmatrix，vmatrix，Vmatrix。

pmatrix：，bmatrix：，Bmatrix：，vmatrix：，Vmatrix：。

省略元素

可以使用\cdots：⋯，\ddots：⋱，\vdots：⋮来省略矩阵中的元素。

$$\begin{pmatrix}    a_1 & a_1^2 & a_1^3 & \cdots & a_1^n \\    a_2 & a_2^2 & a_2^3 & \cdots & a_2^n \\    \vdots & \vdots & \vdots & \ddots & \vdots \\    a_m & a_m^2 & a_m^3 & \cdots & a_m^n\end{pmatrix}$$

增广矩阵

增广矩阵需要使用前面的array来实现。

$$ \left[    \begin{array}{cc|c}        1 & 2 & 3 \\        4 & 5 & 6    \end{array}\right] $$

对齐公式

使用$$\begin{align}...\end{align}$$来对齐公式。其中需要使用&来指示需要对齐的位置。

$$\begin{align}    \sqrt{37} & = \sqrt{\frac{73^2-1}{12^2}} \\    & = \sqrt{\frac{73^2}{12^2} \cdot \frac{73^2-1}{73^2}} \\    & = \frac{73}{12} \sqrt{1 - \frac{1}{73^2}} \\    & \approx \frac{73}{12} \left( 1 - \frac{1}{2 \cdot 73^2} \right)\end{align}$$

分类表达式

使用$$\begin{cases}...\end{cases}$$来分类表达式。其中需要使用&来指示需要对齐的位置。

$$f(n) =    \begin{cases}        n/2, & \text{if $n$ is even} \\        3n+1, & \text{if $n$ is odd}    \end{cases}$$

上述公式也可以移动到右侧，不过需要使用array来实现，如下：

$$    \left. \begin{array}{l}        \text{if $n$ is even:} & n/2 \\        \text{if $n$ is odd:} & 3n+1    \end{array} \right\} = f(n)$$

字体

字体命令显示
默认字体$ABCDEFGHIJKLMNOPQRSTUVWXYZ$
$abcdefghijklmnopqrstuvwxyz$
$0123456789$
数学斜体\mit$\it{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
$\mit{abcdefghijklmnopqrstuvwxyz}$
$\mit{0123456789}$
意大利体\it$\it{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
$\it{abcdefghijklmnopqrstuvwxyz}$
$\it{0123456789}$
罗马体\rm$\rm{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
$\rm{abcdefghijklmnopqrstuvwxyz}$
$\rm{0123456789}$
花体\cal$\cal{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
$\cal{abcdefghijklmnopqrstuvwxyz}$
$\cal{0123456789}$
打字机体\tt$\tt{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
$\tt{abcdefghijklmnopqrstuvwxyz}$
$\tt{0123456789}$
等线体\sf$\sf{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
$\sf{abcdefghijklmnopqrstuvwxyz}$
$\sf{0123456789}$
粗体\bf$\bf{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
$\bf{abcdefghijklmnopqrstuvwxyz}$
$\bf{0123456789}$
黑板粗体\Bbb$\Bbb{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
$\Bbb{abcdefghijklmnopqrstuvwxyz}$
$\Bbb{0123456789}$
手写体\scr$\scr{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
$\scr{abcdefghijklmnopqrstuvwxyz}$
$\scr{0123456789}$
旧德式体\frak$\frak{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
$\frak{abcdefghijklmnopqrstuvwxyz}$
$\sf{0123456789}$

字体设置：$\字体种类{文本}$。

字体大小

字体大小字宽(pt)命名显示
小初36 pts\Huge{小初字体(36pts)}$\Huge{小初字体(36pts)}$
一号27.5 pts\huge{一号字体(27.5pts)}$\huge{一号字体(27.5pts)}$
二号21 pts\LARGE{二号字体(21pts)}$\LARGE{二号字体(21pts)}$
三号15.75 pts\Large{三号字体(15.75pts)}$\Large{三号字体(15.75pts)}$
四号13.75 pts\large{四号字体(13.75pts)}$\large{四号字体(13.75pts)}$
小四12 pts\normalsize{小四字体(12pts)}$\normalsize{小四字体(12pts)}$
默认12 pts默认字体(12pts)$默认字体(12pts)$
五号10.5 pts\small{五号字体(10.5pts)}$\small{五号字体(10.5pts)}$
六号7.875 pts\scriptsize{六号字体(7.875pts)}$\scriptsize{六号字体(7.875pts)}$
七号5.25 pts\tiny{七号字体(5.25pts)}$\tiny{七号字体(5.25pts)}$

字体大小设置：$\字体大小{文本}$。

字体特效

字体特效命令显示
下划线\underline{下划线}​$\underline{下划线}​$
水平删除线\enclose{horizontalstrike}{水平删除线}​$\enclose{horizontalstrike}{水平删除线}​$
垂直删除线\enclose{verticalstrike}{垂直删除线}​$\enclose{verticalstrike}{垂直删除线}​$
上对角删除线\enclose{updiagonalstrike}{上对角删除线}​$\enclose{updiagonalstrike}{上对角删除线}​$
下对角删除线\enclose{downdiagonalstrike}{下对角删除线}​$\enclose{downdiagonalstrike}{下对角删除线}​$
组合多种删除线\enclose{horizontalstrike,verticalstrike,updiagonalstrike,downdiagonalstrike}{组合多种删除线}​$\enclose{horizontalstrike,verticalstrike,updiagonalstrike,downdiagonalstrike}{组合多种删除线}​$

字体颜色

字体颜色命令显示
黑色(black)\color{black}{黑色(\text{black})}​$\color{black}{黑色(\text{black})}​$
灰色(grey)\color{grey}{灰色(\text{grey})}​$\color{grey}{灰色(\text{grey})}​$
银色(silver)\color{silver}{银色(\text{silver})}​$\color{silver}{银色(\text{silver})}$
白色(white)\color{white}{白色(\text{white})}​$\color{white}{白色(\text{white})}​$
紫红色(maroon)\color{maroon}{紫红色(\text{maroon})}​$\color{maroon}{紫红色(\text{maroon})}$
红色(red)\color{red}{红色(\text{red})}​$\color{red}{红色(\text{red})}​$
紫色(purple)\color{purple}{紫色(\text{purple})}​$\color{purple}{紫色(\text{purple})}​$
黄色(yellow)\color{yellow}{黄色(\text{yellow})}​$\color{yellow}{黄色(\text{yellow})}​$
橄榄绿(olive)\color{olive}{橄榄绿(\text{olive})}​$\color{olive}{橄榄绿(\text{olive})}$
浅绿色(lime)\color{lime}{浅绿色(\text{lime})}​$\color{lime}{浅绿色(\text{lime})}$
绿色(green)\color{green}{绿色(\text{green})}​$\color{green}{绿色(\text{green})}​$
藏青色(navy)\color{navy}{藏青色(\text{navy})}​$\color{navy}{藏青色(\text{navy})}$
蓝色(blue)\color{blue}{蓝色(\text{blue})}​$\color{blue}{蓝色(\text{blue})}​$
蓝绿色(teal)\color{teal}{蓝绿色(\text{teal})}​$\color{teal}{蓝绿色(\text{teal})}$
]]> <p><span></span></p> （一）PyTorch 张量 https://blog.wpz.homes/posts/668e89ae/ 2024-08-26T08:17:41.000Z 2026-09-20T09:12:05.372Z

Tensor 数据类型

Data typedtypeCPU TensorGPU Tensor
Booleantorch.booltorch.BoolTensortorch.cuda.BoolTensor
8-bit integer (unsigned)torch.uint8torch.ByteTensortorch.cuda.ByteTensor
8-bit integer (signed)torch.int8torch.CharTensortorch.cuda.CharTensor
16-bit integer (signed)torch.int16 or torch.shorttorch.ShortTensortorch.cuda.ShortTensor
32-bit integer (signed)torch.int32 or torch.inttorch.IntTensortorch.cuda.IntTensor
64-bit integer (signed)torch.int64 or torch.longtorch.LongTensortorch.cuda.LongTensor
16-bit floating pointtorch.float16 or torch.halftorch.HalfTensortorch.cuda.HalfTensor
16-bit floating pointtorch.bfloat16torch.BFloat16Tensortorch.cuda.BFloat16Tensor
32-bit floating pointtorch.float32 or torch.floattorch.FloatTensortorch.cuda.FloatTensor
64-bit floating pointtorch.float64 or torch.doubletorch.DoubleTensortorch.cuda.DoubleTensor

设置 Tensor 默认类型

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

print(torch.tensor(True).dtype)  # torch.bool
print(torch.tensor(True).type())  # torch.BoolTensor
print(torch.tensor(1).dtype)  # torch.int64
print(torch.tensor(1).type())  # torch.LongTensor
print(torch.tensor(1.).dtype)  # torch.float32
print(torch.tensor(1.).type())  # torch.FloatTensor
print(torch.tensor(3j).dtype)  # torch.complex64
print(torch.tensor(3j).type())  # torch.ComplexFloatTensor

torch.set_default_dtype(torch.double)  # 设置默认类型为 double

print(torch.tensor(True).dtype)  # torch.bool
print(torch.tensor(True).type())  # torch.BoolTensor
print(torch.tensor(1).dtype)  # torch.int64
print(torch.tensor(1).type())  # torch.LongTensor
print(torch.tensor(1.).dtype)  # torch.float64
print(torch.tensor(1.).type())  # torch.DoubleTensor
print(torch.tensor(3j).dtype)  # torch.complex128
print(torch.tensor(3j).type())  # torch.ComplexDoubleTensor

set_default_dtype()只能设置floating-point类型，否则会报TypeError: only floating-point types are supported as the default type错误。

标量与张量

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

# 标量
a = torch.tensor(1)
print(a.shape)  # torch.Size([])
print(a.size())  # torch.Size([])
print(a.ndim)  # 0
print(a.dim())  # 0

# 一维张量
b = torch.tensor([1, 2])
print(b.shape)  # torch.Size([2])
print(b.size())  # torch.Size([2])
print(b.ndim)  # 1
print(b.dim())  # 1

# 二维张量
c = torch.tensor([[1, 2]])
print(c.shape)  # torch.Size([1, 2])
print(c.size())  # torch.Size([1, 2])
print(c.ndim)  # 2
print(c.dim())  # 2

标量是一个单独的数，ndim为0。

创建 Tensor

.tensor

1
2
3
4
5
6
7
8
9
import torch

# 标量
print(torch.tensor(1))  # tensor(1)
print(torch.tensor(1, dtype=torch.float64))  # tensor(1., dtype=torch.float64)

# 张量
print(torch.tensor([1, 2]))  # tensor([1, 2])
print(torch.tensor([1, 2], dtype=torch.float64))  # tensor([1., 2.], dtype=torch.float64)

.from_numpy

1
2
3
4
5
6
7
import numpy as np
import torch

data = np.array([1, 2, 3])
print(torch.from_numpy(data))  # tensor([1, 2, 3], dtype=torch.int32)
data = np.array([1, 2, 3], dtype=np.float64)
print(torch.from_numpy(data))  # tensor([1., 2., 3.], dtype=torch.float64)

Tensor

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

# 参数为 shape 大小
print(torch.Tensor(1))  # tensor([-3.0434e+31])
print(torch.Tensor(1, 2))  # tensor([[0., 0.]])
print(torch.Tensor(1, 2, 3))
"""
tensor([[[-3.0741e+31,  1.6031e-42,  0.0000e+00],
         [ 0.0000e+00,  0.0000e+00,  0.0000e+00]]])
"""

# 参数为列表
print(torch.Tensor([1]))  # tensor([1.])
print(torch.Tensor([1, 2]))  # tensor([1., 2.])
print(torch.Tensor([1, 2, 3]))  # tensor([1., 2., 3.])

Tensor支持两种传参方式：

  1. 当参数为列表时，创建列表对应维度的Tensor并初始化数据为列表数据。
  2. 当参数不为列表时，与.empty()类似，创建参数指定的shape的空的Tensor。

BoolTensor、ByteTensor、CharTensor、ShortTensor、IntTensor、LongTensor、HalfTensor、FloatTensor、DoubleTensor也是一样。

.empty/.zeros/.ones/.full/.eye

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 torch

input = torch.tensor([1, 1, 1, 1, 1])

print(torch.empty(()))  # tensor(-6.5391e-19)
print(torch.empty((1, 5)))  # tensor([[-6.6069e-19,  1.3943e-42,  0.0000e+00,  0.0000e+00,  0.0000e+00]])
print(torch.empty_like((input)))  # tensor([0, 0, 0, 0, 0])

print(torch.zeros(()))  # tensor(0.)
print(torch.zeros((1, 5)))  # tensor([[0., 0., 0., 0., 0.]])
print(torch.zeros_like((input)))  # tensor([0, 0, 0, 0, 0])

print(torch.ones(()))  # tensor(1.)
print(torch.ones((1, 5)))  # tensor([[1., 1., 1., 1., 1.]])
print(torch.ones_like((input)))  # tensor([1, 1, 1, 1, 1])

print(torch.full((), 100))  # tensor(100)
print(torch.full((1, 5), 100))  # tensor([[100, 100, 100, 100, 100]])
print(torch.full_like((input), 100))  # tensor([100, 100, 100, 100, 100])

print(torch.eye(3))
"""
tensor([[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]])
"""
print(torch.eye(3, 5))
"""
tensor([[1., 0., 0., 0., 0.],
        [0., 1., 0., 0., 0.],
        [0., 0., 1., 0., 0.]])
"""

.arange/.linspace/.logspace

1
2
3
4
5
6
7
8
9
10
11
12
import torch

print(torch.arange(0, 10))  # tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
print(torch.arange(0, 10, step=3))  # tensor([0, 3, 6, 9])

# [0, 1] 等分成 5 份
print(torch.linspace(0, 1, steps=5))  # tensor([0.0000, 0.2500, 0.5000, 0.7500, 1.0000])

# 默认以 10 为底数，[0, 1] 等分成 5 份做为指数
print(torch.logspace(0, 1, steps=5))  # tensor([ 1.0000,  1.7783,  3.1623,  5.6234, 10.0000])
# 以 2 为底数，[0, 1] 等分成 5 份做为指数
print(torch.logspace(0, 1, steps=5, base=2))  # tensor([1.0000, 1.1892, 1.4142, 1.6818, 2.0000])

随机采样

随机种子

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

# 设置 CPU 随机种子
torch.manual_seed(1)

# 设置 GPU 随机种子
torch.cuda.manual_seed(1)

# 查看设置的随机种子
print(torch.initial_seed())  # 1

# 随机设置随机种子
torch.seed()

print(torch.initial_seed())  # 22287915889500

随机函数

.rand/.rand_like

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

# 固定随机种子
torch.manual_seed(1)

input = torch.empty(3, 3)

print(torch.rand(3, 3))
"""
tensor([[0.7576, 0.2793, 0.4031],
        [0.7347, 0.0293, 0.7999],
        [0.3971, 0.7544, 0.5695]])
"""

print(torch.rand_like(input))
"""
tensor([[0.4388, 0.6387, 0.5247],
        [0.6826, 0.3051, 0.4635],
        [0.4550, 0.5725, 0.4980]])
"""

torch.rand()返回在区间[0, 1)均匀分布的随机数填充的张量。

.randint/.randint_like

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

# 固定随机种子
torch.manual_seed(1)

input = torch.empty(3, 3)

print(torch.randint(low=0, high=10, size=(3, 3)))
"""
tensor([[5, 9, 4],
        [8, 3, 3],
        [1, 1, 9]])
"""

print(torch.randint_like(input, high=10))
"""
tensor([[2., 8., 9.],
        [6., 3., 3.],
        [0., 2., 1.]])
"""

torch.randint(low, high)返回在区间[low, high)的随机数填充的张量。

.randperm

1
2
3
4
5
6
import torch

# 固定随机种子
torch.manual_seed(1)

print(torch.randperm(10))  # tensor([5, 6, 1, 2, 0, 8, 9, 3, 7, 4])

torch.randperm(n)返回在区间[0, n)的随机排列整数。

.randn/.randn_like

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

# 固定随机种子
torch.manual_seed(1)

input = torch.empty(3, 3)

# 标准正态分布 N(0, 1)，均值为 0，方差为 1
print(torch.randn(3, 3))
"""
tensor([[ 0.6614,  0.2669,  0.0617],
        [ 0.6213, -0.4519, -0.1661],
        [-1.5228,  0.3817, -1.0276]])
"""

print(torch.randn_like(input))
"""
tensor([[-0.5631, -0.8923, -0.0583],
        [-0.1955, -0.9656,  0.4224],
        [ 0.2673, -0.4212, -0.5107]])
"""

torch.randn()从标准正态分布中随机采样。

.normal

1
2
3
4
5
6
7
import torch

# 固定随机种子
torch.manual_seed(1)

# 离散正态分布 N(mean, std)
print(torch.normal(mean=torch.full((5,), 0.), std=torch.arange(0, 1, 0.2)))  # tensor([ 0.0000,  0.0534,  0.0247,  0.3728, -0.3615])

torch.normal(mean, std)从给定参数mean、std的离散正态分布中随机采样。

.bernoulli

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 torch

input = torch.empty(3, 3).uniform_(0, 1)  # generate a uniform random matrix with range [0, 1]

print(torch.bernoulli(input))
"""
tensor([[1., 0., 0.],
        [1., 0., 1.],
        [0., 1., 1.]])
"""

print(torch.bernoulli(torch.ones(3, 3)))  # probability of drawing "1" is 1
"""
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]])
"""

print(torch.bernoulli(torch.zeros(3, 3)))  # probability of drawing "1" is 0
"""
tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])
"""

torch.bernoulli()从伯努利分布中抽取二进制随机数（0 或 1）。输入的值必须在[0, 1]范围内。

.poisson

1
2
3
4
5
6
7
8
9
10
11
import torch

torch.manual_seed(1)

rates = torch.rand(3, 3) * 5  # rate parameter between 0 and 5
print(torch.poisson(rates))
"""
tensor([[5., 1., 1.],
        [3., 0., 2.],
        [0., 2., 0.]])
"""

torch.poisson()从泊松分布中随机采样。

.multinomial

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

weights = torch.tensor([[1, 3, 5, 7, 9], [2, 4, 6, 8, 10]], dtype=torch.float)

print(torch.multinomial(weights, 5))
"""
tensor([[2, 3, 4, 1, 0],
        [3, 2, 1, 4, 0]])
"""

# replacement 默认为 False，表示不允许重复抽查，所以采样次数不能大于抽查个数
# print(torch.multinomial(weights, 6))  # RuntimeError: cannot sample n_sample > prob_dist.size(-1) samples without replacement

# replacement=True 允许重复抽查
print(torch.multinomial(weights, 6, replacement=True))
"""
tensor([[3, 0, 3, 3, 4, 2],
        [0, 1, 4, 4, 2, 4]])
"""

torch.multinomial(input, num_samples, replacement)对input的每一行做从多项式分布中采样num_samples次，输出的张量是每一次取值时input张量对应行的下标。

索引与切片

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

# 4 张 3 通道，高 28，宽 28 的图片
images = torch.rand(4, 3, 28, 28)
print(images.shape)  # torch.Size([4, 3, 28, 28])

# 获取第一张图片
print(images[0].shape)  # torch.Size([3, 28, 28])
# 获取第一张图片的第一个通道数据
print(images[0, 0].shape)  # torch.Size([28, 28])
# 获取前两张图片
print(images[:2].shape)  # torch.Size([2, 3, 28, 28])
# 获取前两张图片前两个通道数据
print(images[:2, :2].shape)  # torch.Size([2, 2, 28, 28])
# 获取前两张图片最后一个通道数据
print(images[:2, -1].shape)  # torch.Size([2, 28, 28])
# 间隔获取图片数据
print(images[:, :, ::2, ::2].shape)  # torch.Size([4, 3, 14, 14])

# 获取所有图片
print(images[...].shape)  # torch.Size([4, 3, 28, 28])
# 获取第一张图片
print(images[0, ...].shape)  # torch.Size([3, 28, 28])
# 间隔获取图片宽数据
print(images[..., ::2].shape)  # torch.Size([4, 3, 28, 14])

.narrow/.narrow_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
import torch

data = torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9 ,10], [11, 12, 13, 14, 15]])
print(data)
"""
tensor([[ 1,  2,  3,  4,  5],
        [ 6,  7,  8,  9, 10],
        [11, 12, 13, 14, 15]])
"""

print(torch.narrow(data, dim=0, start=1, length=2))
"""
tensor([[ 6,  7,  8,  9, 10],
        [11, 12, 13, 14, 15]])
"""
print(torch.narrow(data, dim=1, start=1, length=3))
"""
tensor([[ 2,  3,  4],
        [ 7,  8,  9],
        [12, 13, 14]])
"""

print(torch.narrow_copy(data, dim=0, start=1, length=2))
"""
tensor([[ 6,  7,  8,  9, 10],
        [11, 12, 13, 14, 15]])
"""
print(torch.narrow_copy(data, dim=1, start=1, length=3))
"""
tensor([[ 2,  3,  4],
        [ 7,  8,  9],
        [12, 13, 14]])
"""

torch.narrow()在指定维度缩小张量，可以简单理解为类似切片，tensor[start: start + length]

torch.narrow_copy()与torch.narrow()相同，但返回的是副本而不是共享存储。

.select/.index_select

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

# 4 张 3 通道，高 28，宽 28 的图片
images = torch.rand(4, 3, 28, 28)
print(images.shape)  # torch.Size([4, 3, 28, 28])

# 获取第一张图片
print(torch.select(images, dim=0, index=0).shape)  # torch.Size([3, 28, 28])
# 获取所有图片的第一个通道
print(torch.select(images, dim=1, index=1).shape)  # torch.Size([4, 28, 28])

# 获取第二张和第四张图片
print(torch.index_select(images, dim=0, index=torch.tensor([1, 3])).shape)  # torch.Size([2, 3, 28, 28])
# 获取所有图片二三通道数据
print(torch.index_select(images, dim=1, index=torch.tensor([1, 2])).shape)  # torch.Size([4, 2, 28, 28])
# 间隔获取所有图片高数据
print(torch.index_select(images, dim=2, index=torch.arange(0, 28, 2)).shape)  # torch.Size([4, 3, 14, 28])
# 间隔获取所有图片宽数据
print(torch.index_select(images, dim=3, index=torch.arange(0, 28, 2)).shape)  # torch.Size([4, 3, 28, 14])

torch.select()沿着维度dim，在给定索引index对input张量进行切片，等价于切片。比如：
tensor.select(0, index)等于tensor[index]。
tensor.select(2, index)等于tensor[:,:,index]。

torch.index_select()沿着维度dim对input张量进行索引。

.masked_select

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

torch.manual_seed(1)

data = torch.randn(3, 4)
print(data)
"""
tensor([[ 0.6614,  0.2669,  0.0617,  0.6213],
        [-0.4519, -0.1661, -1.5228,  0.3817],
        [-1.0276, -0.5631, -0.8923, -0.0583]])
"""

mask = data.ge(0)
print(mask)
"""
tensor([[ True,  True,  True,  True],
        [False, False, False,  True],
        [False, False, False, False]])
"""

print(torch.masked_select(data, mask))  # tensor([0.6614, 0.2669, 0.0617, 0.6213, 0.3817])

torch.masked_select()根据布尔掩码选择数据，返回的是一维数据。

.gather

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

torch.manual_seed(1)

data = torch.randperm(16).view(4,4)
print(data)
"""
tensor([[ 5, 15,  6,  4],
        [11,  2,  7, 12],
        [ 1,  0,  9,  8],
        [10,  3, 13, 14]])
"""

index = torch.tensor([[1, 0, 3, 2]])
print(index)  # tensor([[1, 0, 3, 2]])
print(index.t())
"""
tensor([[1],
        [0],
        [3],
        [2]])
"""

print(torch.gather(data, 0, index))  # tensor([[11, 15, 13,  8]])
print(torch.gather(data, 0, index.t()))
"""
tensor([[11],
        [ 5],
        [10],
        [ 1]])
"""
print(torch.gather(data, 1, index))  # tensor([[15,  5,  4,  6]])
print(torch.gather(data, 1, index.t()))
"""
tensor([[15],
        [11],
        [ 8],
        [13]])
"""

  • torch.gather(data, 0, index)对0维(行)进行

      tensor([[1, 0, 3, 2]])        第 0  1  2  3 列

    索引：
    [1][0] == 11
    [0][1] == 15
    [3][2] == 13
    [2][3] == 8
    加粗的是行索引的值1, 0, 3, 2，没加粗的为什么是0, 1, 2, 3呢？因为索引1是第0列，索引0是第1列，索引3是第2列，索引2是第3列。

  • torch.gather(data, 0, index.t())对0维(行)进行

      tensor([[1],   第0列          [0],   第0列          [3],   第0列          [2]])  第0列

    索引：
    [1][0] == 11
    [0][0] == 5
    [3][0] == 10
    [2][0] == 1
    加粗的是行索引的值1, 0, 3, 2，没加粗的都是0，因为索引1, 0, 3, 2都是第0列。

  • torch.gather(data, 1, index.t())对1维(列)进行

      tensor([[1],   第0行          [0],   第1行          [3],   第2行          [2]])  第3行

    索引：
    [0][1] == 15
    [1][0] == 11
    [2][3] == 8
    [3][2] == 13
    加粗的是列索引的值1, 0, 3, 2，没加粗的0, 1, 2, 3则是因为索引1是第0行，索引0是第1行，索引3是第2行，索引2是第3行。

.take/.take_along_dim

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

torch.manual_seed(1)

data = torch.randperm(16).view(4,4)
print(data)
"""
tensor([[ 5, 15,  6,  4],
        [11,  2,  7, 12],
        [ 1,  0,  9,  8],
        [10,  3, 13, 14]])
"""

index1 = torch.tensor([0, 5, 10, 15])
index2 = torch.tensor([[1, 0, 3, 2]])

print(torch.take(data, index1))  # tensor([ 5,  2,  9, 14])

print(torch.take_along_dim(data, index1))  # tensor([ 5,  2,  9, 14])
print(torch.take_along_dim(data, index2, dim=0))  # tensor([[11, 15, 13,  8]])
print(torch.take_along_dim(data, index2.t(), dim=0))  # 这里与torch.gather不同
"""
tensor([[11,  2,  7, 12],
        [ 5, 15,  6,  4],
        [10,  3, 13, 14],
        [ 1,  0,  9,  8]])
"""
print(torch.take_along_dim(data, index2, dim=1))  # 这里与torch.gather不同
"""
tensor([[15,  5,  4,  6],
        [ 2, 11, 12,  7],
        [ 0,  1,  8,  9],
        [ 3, 10, 14, 13]])
"""
print(torch.take_along_dim(data, index2.t(), dim=1))
"""
tensor([[15],
        [11],
        [ 8],
        [13]])
"""

torch.take_along_dim()当dim=None时，等价于torch.take()，先把张量打平转成1维在根据索引获取元素。

当dim不等于None时，则与data.gather()相似。

.argwhere/.nonzero

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 torch

data1 = torch.tensor([1, 0, 1, 0, 1, 0])
data2 = torch.tensor([[1, 0, 1], [0, 1, 0]])
print(data1)  # tensor([1, 0, 1, 0, 1, 0])
print(data2)
"""
tensor([[1, 0, 1],
        [0, 1, 0]])
"""

print(torch.argwhere(data1))
"""
tensor([[0],
        [2],
        [4]])
"""
print(torch.argwhere(data2))
"""
tensor([[0, 0],
        [0, 2],
        [1, 1]])
"""

print(torch.nonzero(data1))
"""
tensor([[0],
        [2],
        [4]])
"""
print(torch.nonzero(data1, as_tuple=True))  # (tensor([0, 2, 4]),)
print(torch.nonzero(data2))
"""
tensor([[0, 0],
        [0, 2],
        [1, 1]])
"""
print(torch.nonzero(data2, as_tuple=True))  # (tensor([0, 0, 1]), tensor([0, 2, 1]))

torch.argwhere()和torch.nonzero()都是返回非0元素的索引。

当torch.nonzero()参数as_tuple=False时，效果与torch.argwhere()相同。

.where

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

torch.manual_seed(1)

condition = torch.randn(3, 5) > 0
print(condition)
"""
tensor([[ True,  True,  True,  True, False],
        [False, False,  True, False, False],
        [False, False, False, False,  True]])
"""

data1 = torch.ones(3, 5)
print(data1)
"""
tensor([[1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.]])
"""

data2 = torch.full_like(data1, 100)
print(data2)
"""
tensor([[100., 100., 100., 100., 100.],
        [100., 100., 100., 100., 100.],
        [100., 100., 100., 100., 100.]])
"""

# 满足条件返回 data1, 不满足条件返回 data2
print(torch.where(condition, data1, data2))
"""
tensor([[  1.,   1.,   1.,   1., 100.],
        [100., 100.,   1., 100., 100.],
        [100., 100., 100., 100.,   1.]])
"""

.unravel_index

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

print(torch.arange(9).view(3, 3))
"""
tensor([[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]])
"""
print(torch.arange(9, 18).view(3, 3))
"""
tensor([[ 9, 10, 11],
        [12, 13, 14],
        [15, 16, 17]])
"""

print(torch.unravel_index(torch.tensor(2), shape=(3, 3)))  # (tensor(0), tensor(2))
print(torch.unravel_index(torch.tensor([4, 6, 9, 17]), shape=(3, 3)))  # (tensor([1, 2, 0, 2]), tensor([1, 0, 0, 2]))

索引2在shape为(3, 3)的0行2列。
索引9可以理解为9 / prod(shape) == 9 % 9 == 0，所以在0行0列。
索引17可以理解为17 / prod(shape) == 17 % 9 == 8，所以在2行2列。

维度变换

.t/.transpose/.movedim/.permute

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

data = torch.arange(9)
print(data)  # tensor([0, 1, 2, 3, 4, 5, 6, 7, 8])
print(torch.t(data))  # tensor([0, 1, 2, 3, 4, 5, 6, 7, 8])

data = torch.arange(9).view(3, 3)
print(data)
"""
tensor([[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]])
"""
print(torch.t(data))
"""
tensor([[0, 3, 6],
        [1, 4, 7],
        [2, 5, 8]])
"""

# 4 张 3 通道，高 1080，宽 1920 的图片
images = torch.rand(4, 3, 1080, 1920)
# BCHW
print(images.shape)  # torch.Size([4, 3, 1080, 1920])

# BCHW --> BWHC --> BHWC
print(images.transpose(1, 3).transpose(1, 2).shape)  # torch.Size([4, 1080, 1920, 3])

# BCHW --> BHWC
print(images.movedim(1, 3).shape)  # torch.Size([4, 1080, 1920, 3])

# BCHW --> BHWC
print(images.permute(0, 2, 3, 1).shape)  # torch.Size([4, 1080, 1920, 3])

torch.t(input)只能处理维度小于等于2的，否则会报错。当维度是0或1维时，返回相同的结果，当维度为2时，等价于torch.transpose(input, 0, 1)

torch.transpose(input, dim0, dim1)一次只能操作两个维度，对调两个维度的位置。

torch.movedim(input, source, destination)将source维度移动到destination维度。

torch.permute(input, dims)一次可以操作多个维度，dims指定所有维度的顺序。在多维度操作上使用torch.permute()更直观。

torch.swapaxes()是torch.transpose()的别名。
torch.swapdims()是torch.transpose()的别名。
torch.moveaxis()是torch.movedim()的别名。

.view/.reshape

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

# 4 张 3 通道，高 28，宽 28 的图片
images = torch.rand(4, 3, 28, 28)
print(images.shape)  # torch.Size([4, 3, 28, 28])

print(images.view(4, 3 * 28 * 28).shape)  # torch.Size([4, 2352])
# -1 会自动计算出数值
print(images.view(4, -1).shape)  # torch.Size([4, 2352])
# print(images.transpose(1, 3).transpose(1, 2).view(4, -1).shape)  # 报错
print(images.transpose(1, 3).transpose(1, 2).contiguous().view(4, -1).shape)  # torch.Size([4, 2352])
# print(images.permute(0, 2, 3, 1).view(4, -1).shape)  # 报错
print(images.permute(0, 2, 3, 1).contiguous().view(4, -1).shape)  # torch.Size([4, 2352])

print(images.reshape(4, 3 * 28 * 28).shape)  # torch.Size([4, 2352])
# -1 会自动计算出数值
print(images.reshape(4, -1).shape)  # torch.Size([4, 2352])
print(images.transpose(1, 3).transpose(1, 2).reshape(4, -1).shape)  # torch.Size([4, 2352])
print(images.permute(0, 2, 3, 1).reshape(4, -1).shape)  # torch.Size([4, 2352])

view()和reshape()都可以改变Tensor的维度，区别是：

view()只能对满足连续性的张量进行转换，当对不满足连续性的张量进行操作时会报RuntimeError: view size is not compatible with input tensor's size and stride (at least one dimension spans across two contiguous subspaces). Use .reshape(...) instead.错误。transpose()和permute()会改变张量连续性，使用view()前需要先执行contiguous()。

reshape()则没有上述要求，可以直接使用，无需先执行contiguous()。

.squeeze/.unsqueeze

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

data = torch.rand(2, 1, 2, 1)
print(data.shape)  # torch.Size([2, 1, 2, 1])

# dim=None，会把能挤压的维度挤压
print(torch.squeeze(data).shape)  # torch.Size([2, 2])
# 第一维度是 2 没法挤压，所以保持不变
print(torch.squeeze(data, dim=0).shape)  # torch.Size([2, 1, 2, 1])
# 第二维度挤压
print(torch.squeeze(data, dim=1).shape)  # torch.Size([2, 2, 1])

# 在第一维增加维度
print(torch.unsqueeze(data, dim=0).shape)  # torch.Size([1, 2, 1, 2, 1])
# 在最后一维增加维度
print(torch.unsqueeze(data, dim=-1).shape)  # torch.Size([2, 1, 2, 1, 1])

.expand/.repeat

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

# 4 张单通道，高 28，宽 28 的图片
images = torch.rand(4, 1, 28, 28)
data = torch.empty(4, 1, 1, 1)

# 第二维度扩展到 3 通道，-1 表示不扩展保持原样
print(images.expand(-1, 3, -1, -1).shape)  # torch.Size([4, 3, 28, 28])
print(images.expand(4, 3, 28, 28).shape)  # torch.Size([4, 3, 28, 28])
# 扩展到和 images 相同的 shape
print(data.expand_as(images).shape)  # torch.Size([4, 1, 28, 28])

# 各维度重复指定次数的数据
print(images.repeat(1, 3, 1, 1).shape)  # torch.Size([4, 3, 28, 28])

.tile

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

data = torch.arange(9).view(3, 3)
print(data)
"""
tensor([[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]])
"""

# 如果 dims 指定的维度小于 input 的维度，会扩展到相同的维度，比如 (2,) 会扩展到 (1, 2)
print(torch.tile(data, dims=(2,)))
"""
tensor([[0, 1, 2, 0, 1, 2],
        [3, 4, 5, 3, 4, 5],
        [6, 7, 8, 6, 7, 8]])
"""
print(torch.tile(data, dims=(1, 2)))
"""
tensor([[0, 1, 2, 0, 1, 2],
        [3, 4, 5, 3, 4, 5],
        [6, 7, 8, 6, 7, 8]])
"""
print(torch.tile(data, dims=(3, 2)))
"""
tensor([[0, 1, 2, 0, 1, 2],
        [3, 4, 5, 3, 4, 5],
        [6, 7, 8, 6, 7, 8],
        [0, 1, 2, 0, 1, 2],
        [3, 4, 5, 3, 4, 5],
        [6, 7, 8, 6, 7, 8],
        [0, 1, 2, 0, 1, 2],
        [3, 4, 5, 3, 4, 5],
        [6, 7, 8, 6, 7, 8]])
"""
# 如果 dims 指定的维度大于 input 的维度，input 会扩展到相同的维度，比如 input 是 (3, 3) 会扩展到 (1, 3, 3)
print(torch.tile(data, dims=(1, 3, 2)))
"""
tensor([[[0, 1, 2, 0, 1, 2],
         [3, 4, 5, 3, 4, 5],
         [6, 7, 8, 6, 7, 8],
         [0, 1, 2, 0, 1, 2],
         [3, 4, 5, 3, 4, 5],
         [6, 7, 8, 6, 7, 8],
         [0, 1, 2, 0, 1, 2],
         [3, 4, 5, 3, 4, 5],
         [6, 7, 8, 6, 7, 8]]])
"""

合并与拆分

.cat

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

torch.manual_seed(1)

data1 = torch.rand(2, 3)
print(data1)
"""
tensor([[0.7576, 0.2793, 0.4031],
        [0.7347, 0.0293, 0.7999]])
"""
data2 = torch.rand(2, 3)
print(data1)
"""
tensor([[0.7576, 0.2793, 0.4031],
        [0.7347, 0.0293, 0.7999]])
"""

# 行合并
print(torch.cat([data1, data1]))
"""
tensor([[0.7576, 0.2793, 0.4031],
        [0.7347, 0.0293, 0.7999],
        [0.7576, 0.2793, 0.4031],
        [0.7347, 0.0293, 0.7999]])
"""
# 列合并
print(torch.cat([data1, data1], dim=1))
"""
tensor([[0.7576, 0.2793, 0.4031, 0.7576, 0.2793, 0.4031],
        [0.7347, 0.0293, 0.7999, 0.7347, 0.0293, 0.7999]])
"""

torch.concat()是torch.cat()的别名。
torch.concatenate()是torch.cat()的别名。

.stack/.hstack/.vstack/.column_stack/.dstack

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

data = torch.tensor(9)
data1 = torch.arange(9)
data2 = torch.arange(9).view(3, 3)
data3 = torch.arange(9).view(1, 3, 3)
data4 = torch.arange(9).view(1, 1, 3, 3)
data5 = torch.arange(9).view(1, 1, 1, 3, 3)

print(data.shape)  # torch.Size([])
print(data1.shape)  # torch.Size([9])
print(data2.shape)  # torch.Size([3, 3])
print(data3.shape)  # torch.Size([1, 3, 3])
print(data4.shape)  # torch.Size([1, 1, 3, 3])
print(data5.shape)  # torch.Size([1, 1, 1, 3, 3])

# dim 默认为 0，在第一维度堆叠
print(torch.stack([data, data]).shape)  # torch.Size([2])
print(torch.stack([data1, data1]).shape)  # torch.Size([2, 9])
print(torch.stack([data2, data2]).shape)  # torch.Size([2, 3, 3])
print(torch.stack([data3, data3]).shape)  # torch.Size([2, 1, 3, 3])
print(torch.stack([data4, data4]).shape)  # torch.Size([2, 1, 1, 3, 3])
print(torch.stack([data5, data5]).shape)  # torch.Size([2, 1, 1, 1, 3, 3])

# dim=1，在第二维度堆叠
print(torch.stack([data1, data1], dim=1).shape)  # torch.Size([9, 2])
print(torch.stack([data2, data2], dim=1).shape)  # torch.Size([3, 2, 3])
print(torch.stack([data3, data3], dim=1).shape)  # torch.Size([1, 2, 3, 3])
print(torch.stack([data4, data4], dim=1).shape)  # torch.Size([1, 2, 1, 3, 3])
print(torch.stack([data5, data5], dim=1).shape)  # torch.Size([1, 2, 1, 1, 3, 3])

# 水平堆叠
print(torch.hstack([data, data]).shape)  # torch.Size([2])
print(torch.hstack([data1, data1]).shape)  # torch.Size([18])
print(torch.hstack([data2, data2]).shape)  # torch.Size([3, 6])
print(torch.hstack([data3, data3]).shape)  # torch.Size([1, 6, 3])
print(torch.hstack([data4, data4]).shape)  # torch.Size([1, 2, 3, 3])
print(torch.hstack([data5, data5]).shape)  # torch.Size([1, 2, 1, 3, 3])

# 垂直堆叠
print(torch.vstack([data, data]).shape)  # torch.Size([2, 1])
print(torch.vstack([data1, data1]).shape)  # torch.Size([2, 9])
print(torch.vstack([data2, data2]).shape)  # torch.Size([6, 3])
print(torch.vstack([data3, data3]).shape)  # torch.Size([2, 3, 3])
print(torch.vstack([data4, data4]).shape)  # torch.Size([2, 1, 3, 3])
print(torch.vstack([data5, data5]).shape)  # torch.Size([2, 1, 1, 3, 3])

# 列堆叠
print(torch.column_stack([data, data]).shape)  # torch.Size([1, 2])
print(torch.column_stack([data1, data1]).shape)  # torch.Size([9, 2])
print(torch.column_stack([data2, data2]).shape)  # torch.Size([3, 6])
print(torch.column_stack([data3, data3]).shape)  # torch.Size([1, 6, 3])
print(torch.column_stack([data4, data4]).shape)  # torch.Size([1, 2, 3, 3])
print(torch.column_stack([data5, data5]).shape)  # torch.Size([1, 2, 1, 3, 3])

# 深度堆叠，在第 3 维度堆叠
print(torch.dstack((data, data)).shape)  # torch.Size([1, 1, 2])
print(torch.dstack((data1, data1)).shape)  # torch.Size([1, 9, 2])
print(torch.dstack((data2, data2)).shape)  # torch.Size([3, 3, 2])
print(torch.dstack((data3, data3)).shape)  # torch.Size([1, 3, 6])
print(torch.dstack((data4, data4)).shape)  # torch.Size([1, 1, 6, 3])
print(torch.dstack((data5, data5)).shape)  # torch.Size([1, 1, 2, 3, 3])

torch.hstack)按水平方向（列方向）依次堆叠张量。

torch.vstack)按垂直方向（行方向）依次堆叠张量。

torch.column_stack()除了张量是0维和1维外，等价于torch.hstack()。当张量t是0维或1维时，先reshape重塑为(t.numel(), 1)再水平堆叠。

torch.row_stack()是torch.vstack()的别名。

torch.dstack()在第3维度进行堆叠。

torch.stack()是一个更通用的函数，通过dim指定在任意维度进行堆叠，dim默认等于0。它总是增加一个新的维度来堆叠张量。

.chunk

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

data = torch.arange(20).view(4, 5)
print(data)
"""
tensor([[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14],
        [15, 16, 17, 18, 19]])
"""

# 按行分成 3 块（PS: 这里实际只分成两块，因为每块大小是 2，4 行只能分成两块）
print(torch.chunk(data, 3))
"""
(tensor([[0, 1, 2, 3, 4],
        [5, 6, 7, 8, 9]]), tensor([[10, 11, 12, 13, 14],
        [15, 16, 17, 18, 19]]))
"""
# 按列分成 2 块
print(torch.chunk(data, 2, dim=1))
"""
(tensor([[ 0,  1,  2],
        [ 5,  6,  7],
        [10, 11, 12],
        [15, 16, 17]]), tensor([[ 3,  4],
        [ 8,  9],
        [13, 14],
        [18, 19]]))
"""

.split/.hsplit/.vsplit/.dsplit/.tensor_split

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

data1 = torch.arange(9)
data2 = torch.arange(9).view(3, 3)
data3 = torch.arange(9).view(1, 3, 3)

# 按每两个一组分割
print(torch.split(data1, 2))  # (tensor([0, 1]), tensor([2, 3]), tensor([4, 5]), tensor([6, 7]), tensor([8]))
# 分割成 3 组，第一组 1 份，第二组 3 份，第三组 5 份
print(torch.split(data1, [1, 3, 5]))  # (tensor([0]), tensor([1, 2, 3]), tensor([4, 5, 6, 7, 8]))
# 按每两个一组分割
print(torch.split(data2, 2, dim=1))
"""
(tensor([[0, 1],
        [3, 4],
        [6, 7]]), tensor([[2],
        [5],
        [8]]))
"""
# 分割成 2 组，第一组 1 份，第二组 2 份
print(torch.split(data2, [1, 2], dim=1))
"""
(tensor([[0],
        [3],
        [6]]), tensor([[1, 2],
        [4, 5],
        [7, 8]]))
"""

# 将具有一维或多维的张量 input 水平拆分为多个张量
# 平均分成 3 段
print(torch.hsplit(data1, 3))  # (tensor([0, 1, 2]), tensor([3, 4, 5]), tensor([6, 7, 8]))
# 以索引 3、5、7 分成 4 段
print(torch.hsplit(data1, [3, 5, 7]))  # (tensor([0, 1, 2]), tensor([3, 4]), tensor([5, 6]), tensor([7, 8]))
# 平均分成 3 段
print(torch.hsplit(data2, 3))
"""
(tensor([[0],
        [3],
        [6]]), tensor([[1],
        [4],
        [7]]), tensor([[2],
        [5],
        [8]]))
"""
# 以索引 1 分成 2 段
print(torch.hsplit(data2, [1]))
"""
(tensor([[0],
        [3],
        [6]]), tensor([[1, 2],
        [4, 5],
        [7, 8]]))
"""

# 将具有二维或多维的张量 input 垂直拆分为多个张量
# 平均分成 3 段
print(torch.vsplit(data2, 3))  # (tensor([[0, 1, 2]]), tensor([[3, 4, 5]]), tensor([[6, 7, 8]]))
# 以索引 2 分成 2 段
print(torch.vsplit(data2, [2]))
"""
(tensor([[0, 1, 2],
        [3, 4, 5]]), tensor([[6, 7, 8]]))
"""

# 将具有三个或更多维度的张量 input 在深度方向上拆分为多个张量
# 平均分成 3 段
print(torch.dsplit(data3, 3))
"""
(tensor([[[0],
         [3],
         [6]]]), tensor([[[1],
         [4],
         [7]]]), tensor([[[2],
         [5],
         [8]]]))
"""
# 以索引 1、2 分成 3 段
print(torch.dsplit(data3, [1, 2]))
"""
(tensor([[[0],
         [3],
         [6]]]), tensor([[[1],
         [4],
         [7]]]), tensor([[[2],
         [5],
         [8]]]))
"""

print(torch.tensor_split(data1, 3))  # (tensor([0, 1, 2]), tensor([3, 4, 5]), tensor([6, 7, 8]))
print(torch.tensor_split(data2, 3, dim=1))
"""
(tensor([[0],
        [3],
        [6]]), tensor([[1],
        [4],
        [7]]), tensor([[2],
        [5],
        [8]]))
"""
print(torch.tensor_split(data3, 3, dim=2))
"""
(tensor([[0],
        [3],
        [6]]), tensor([[1],
        [4],
        [7]]), tensor([[2],
        [5],
        [8]]))
"""

torch.hsplit(input, indices_or_sections)当input是1维时，等价于torch.tensor_split(input, indices_or_sections, dim=0)，当input是大于等于2维时，等价于torch.tensor_split(input, indices_or_sections, dim=1)。indices_or_sections如果是数字，必须能被整除，否则会抛出异常。

torch.vsplit(input, indices_or_sections)等价于torch.tensor_split(input, indices_or_sections, dim=0)。input必须大于等于2维。indices_or_sections如果是数字，必须能被整除，否则会抛出异常。

torch.dsplit(input, indices_or_sections)等价于torch.tensor_split(input, indices_or_sections, dim=2)。input必须大于等于3维。indices_or_sections如果是数字，必须能被整除，否则会抛出异常。

.unbind

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

data = torch.arange(9).view(3, 3)
print(data)
"""
tensor([[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]])
"""

# 按行解绑
print(torch.unbind(data))  # (tensor([0, 1, 2]), tensor([3, 4, 5]), tensor([6, 7, 8]))
# 按列解绑
print(torch.unbind(data, dim=1))  # (tensor([0, 3, 6]), tensor([1, 4, 7]), tensor([2, 5, 8]))

逐点运算

.add/.sub/.mul/.div/.remainder/.fmod/.positive/.neg/.abs

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

torch.manual_seed(1)

data = torch.randint(-10, 10, (2, 5))
print(data)
"""
tensor([[-5,  9, -6, -2, -7],
        [ 3,  1, -9,  9,  2]])
"""

# 加
print(torch.add(data, 2))  # 等价于 data + 2
"""
tensor([[-3, 11, -4,  0, -5],
        [ 5,  3, -7, 11,  4]])
"""

# 减
print(torch.sub(data, 2))  # 等价于 data - 2
"""
tensor([[ -7,   7,  -8,  -4,  -9],
        [  1,  -1, -11,   7,   0]])
"""

# 乘
print(torch.mul(data, 2))  # 等价于 data * 2
"""
tensor([[-10,  18, -12,  -4, -14],
        [  6,   2, -18,  18,   4]])
"""

# 除
print(torch.div(data, 2))  # 等价于 data / 2
"""
tensor([[-2.5000,  4.5000, -3.0000, -1.0000, -3.5000],
        [ 1.5000,  0.5000, -4.5000,  4.5000,  1.0000]])
"""
# 除完向下取整
print(torch.div(data, 2, rounding_mode='floor'))  # 等价于 data // 2
"""
tensor([[-3,  4, -3, -1, -4],
        [ 1,  0, -5,  4,  1]])
"""
# 除完只保留整数
print(torch.div(data, 2, rounding_mode='trunc'))
"""
tensor([[-2,  4, -3, -1, -3],
        [ 1,  0, -4,  4,  1]])
"""

# 取余不保留负数
print(torch.remainder(data, 2))  # 等价于 data % 2
"""
tensor([[1, 1, 0, 0, 1],
        [1, 1, 1, 1, 0]])
"""

# 取余保留负数
print(torch.fmod(data, 2))  # 等价于 data % -2
"""
tensor([[-1,  1,  0,  0, -1],
        [ 1,  1, -1,  1,  0]])
"""

# 加号
print(torch.positive(data))  # 等价于 +data
"""
tensor([[-5,  9, -6, -2, -7],
        [ 3,  1, -9,  9,  2]])
"""

# 减号
print(torch.neg(data))  # 等价于 -data
"""
tensor([[ 5, -9,  6,  2,  7],
        [-3, -1,  9, -9, -2]])
"""

# 绝对值
print(torch.abs(data))
"""
tensor([[5, 9, 6, 2, 7],
        [3, 1, 9, 9, 2]])
"""

torch.subtract()是torch.sub()的别名。
torch.multiply()是torch.mul()的别名。
torch.divide()是torch.div()的别名。
torch.true_divide()是torch.div()在rounding_mode=None时的别名。
torch.negative()是torch.neg()的别名。
torch.absolute()是torch.abs()的别名。

在PyTorch 1.13后（含1.13），可以认为torch.floor_divide()是torch.div()在rounding_mode='floor'时的别名，效果是一样的。

.pow/.square/.sqrt/.rsqrt/.reciprocal

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

data = torch.full((2, 2), 9)
print(data)
"""
tensor([[9, 9],
        [9, 9]])
"""

# 次方
print(torch.pow(data, 3))  # 等价于 data ** 3
"""
tensor([[729, 729],
        [729, 729]])
"""

# 平方
print(torch.square(data))  # 等价于 data ** 2
"""
tensor([[81, 81],
        [81, 81]])
"""

# 开方
print(torch.sqrt(data))  # 等价于 data ** 0.5
"""
tensor([[3., 3.],
        [3., 3.]])
"""

# 开方倒数
print(torch.rsqrt(data))  # 等价于 data ** -0.5
"""
tensor([[0.3333, 0.3333],
        [0.3333, 0.3333]])
"""

# 倒数
print(torch.reciprocal(data))  # 等价于 data ** -1
"""
tensor([[0.1111, 0.1111],
        [0.1111, 0.1111]])
"""

.exp/.log/.log2/.log10/.log1p

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

data1 = torch.exp(torch.tensor([0, 1, 2, 3, 4]))
print(data1)  # tensor([ 1.0000,  2.7183,  7.3891, 20.0855, 54.5981])

data2 = torch.exp(torch.ones(2, 2))
print(data2)
"""
tensor([[2.7183, 2.7183],
        [2.7183, 2.7183]])
"""

# 以 e 为底
print(torch.log(data1))  # tensor([0.0000, 1.0000, 2.0000, 3.0000, 4.0000])
print(torch.log(data2))
"""
tensor([[1.0000, 1.0000],
        [1.0000, 1.0000]])
"""

data3 = torch.tensor([1, 2, 4, 8, 16])
# 以 2 为底
print(torch.log2(data3))  # tensor([0., 1., 2., 3., 4.])

data4 = torch.tensor([1, 10, 100, 1000, 10000])
# 以 10 为底
print(torch.log10(data4))  # tensor([0., 1., 2., 3., 4.])

# 以 e 为底，input + 1 做为真数
print(torch.log1p(data1 - 1))  # tensor([0.0000, 1.0000, 2.0000, 3.0000, 4.0000])
print(torch.log1p(data2 - 1))
"""
tensor([[1.0000, 1.0000],
        [1.0000, 1.0000]])
"""

torch.log1p()计算input + 1的自然对数：。

.sin/.cos/.tan/.asin/.acos/.atan/.atan2/.sinh/.cosh/.tanh

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

data = torch.deg2rad(torch.arange(0, 361, 30))  # 角度转弧度
print(data)

# 正弦
print(torch.sin(data))
# 余弦
print(torch.cos(data))
# 正切
print(torch.tan(data))

# 反正弦
print(torch.asin(data))
# 反余弦
print(torch.acos(data))
# 反正切
print(torch.atan(data))
print(torch.atan2(data, data))

# 双曲正弦
print(torch.sinh(data))
# 双曲余弦
print(torch.cosh(data))
# 双曲正切
print(torch.tanh(data))

torch.arcsin()是torch.asin()的别名。
torch.arccos()是torch.acos()的别名。
torch.arctan()是torch.atan()的别名。
torch.arctan2()是torch.atan2()的别名。
torch.arcsinh()是torch.asinh()的别名。
torch.arccosh()是torch.acosh()的别名。
torch.arctanh()是torch.atanh()的别名。

.angle/.deg2rad

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import numpy as np
import torch

# 复数转弧度，结果在（π, -π）之间
print(torch.angle(torch.tensor([[1, 1 + 1j, 1j, -1 + 1j, -1, -1 -1j, -1j, 1 -1j]])))  # tensor([[ 0.0000,  0.7854,  1.5708,  2.3562,  3.1416, -2.3562, -1.5708, -0.7854]])
# 弧度转角度
print(torch.angle(torch.tensor([[1, 1 + 1j, 1j, -1 + 1j, -1, -1 -1j, -1j, 1 -1j]])) * 180 / np.pi)  # tensor([[   0.0000,   45.0000,   90.0000,  135.0000,  180.0000, -135.0000, -90.0000,  -45.0000]])

# 角度转弧度
print(torch.deg2rad(torch.tensor([[0, 45, 90, 135, 180, 360], [-360, -180, -135, -90, -45, 0]])))
"""
tensor([[ 0.0000,  0.7854,  1.5708,  2.3562,  3.1416,  6.2832],
        [-6.2832, -3.1416, -2.3562, -1.5708, -0.7854,  0.0000]])
"""

.bitwise_and/.bitwise_or/.bitwise_not/.bitwise_xor/.bitwise_left_shift/.bitwise_right_shift

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

# 按位与
print(torch.bitwise_and(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8)))  # tensor([1, 0, 3], dtype=torch.int8)
print(torch.bitwise_and(torch.tensor([True, True, False]), torch.tensor([False, True, False])))  # tensor([False,  True, False])

# 按位或
print(torch.bitwise_or(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8)))  # tensor([-1, -2,  3], dtype=torch.int8)
print(torch.bitwise_or(torch.tensor([True, True, False]), torch.tensor([False, True, False])))  # tensor([ True,  True, False])

# 按位非
print(torch.bitwise_not(torch.tensor([-1, -2, 3], dtype=torch.int8)))  # tensor([ 0,  1, -4], dtype=torch.int8)
print(torch.bitwise_not(torch.tensor([True, True, False])))  # tensor([False, False,  True])

# 按位异或
print(torch.bitwise_xor(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8)))  # tensor([-2, -2,  0], dtype=torch.int8)
print(torch.bitwise_xor(torch.tensor([True, True, False]), torch.tensor([False, True, False])))  # tensor([ True, False, False])

# 左移
print(torch.bitwise_left_shift(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8)))  # tensor([-2, -2, 24], dtype=torch.int8)
# 右移
print(torch.bitwise_right_shift(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8)))  # tensor([-1, -2,  0], dtype=torch.int8)

.floor/.ceil/.round

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

torch.manual_seed(1)

data = torch.rand(1, 5) * 10
print(data)  # tensor([[7.5763, 2.7931, 4.0307, 7.3468, 0.2928]])

# 向下取整
print(torch.floor(data))  # tensor([[7., 2., 4., 7., 0.]])
# 向上取整
print(torch.ceil(data))  # tensor([[8., 3., 5., 8., 1.]])
# 四舍五入
print(torch.round(data))  # tensor([[8., 3., 4., 7., 0.]])

torch.floor()向下取整，torch.ceil()向上取整，torch.round()四舍五入。

.trunc/.frac

1
2
3
4
5
6
7
8
9
10
11
import torch

torch.manual_seed(1)

data = torch.rand(1, 5) * 10
print(data)  # tensor([[7.5763, 2.7931, 4.0307, 7.3468, 0.2928]])

# 取整数
print(torch.trunc(data))  # tensor([[7., 2., 4., 7., 0.]])
# 取小数
print(torch.frac(data))  # tensor([[0.5763, 0.7931, 0.0307, 0.3468, 0.2928]])

torch.trunc()取整数，torch.frac()取小数。

torch.fix()是torch.trunc()的别名。

.clamp/.clamp_min/.clamp_max

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

torch.manual_seed(1)

data = torch.rand((2, 5)) * 20
print(data)
"""
tensor([[15.1526,  5.5862,  8.0614, 14.6937,  0.5856],
        [15.9972,  7.9427, 15.0874, 11.3902,  8.7756]])
"""

# 小于 10 的数变为 10
print(torch.clamp(data, 10))
"""
tensor([[15.1526, 10.0000, 10.0000, 14.6937, 10.0000],
        [15.9972, 10.0000, 15.0874, 11.3902, 10.0000]])
"""

# 大于 15 的数变为 15
print(torch.clamp(data, max=15))
"""
tensor([[15.0000,  5.5862,  8.0614, 14.6937,  0.5856],
        [15.0000,  7.9427, 15.0000, 11.3902,  8.7756]])
"""

# 小于 10 的数变为 10，大于 15 的数变为 15
print(torch.clamp(data, 10, 15))
"""
tensor([[15.0000, 10.0000, 10.0000, 14.6937, 10.0000],
        [15.0000, 10.0000, 15.0000, 11.3902, 10.0000]])
"""

# 小于 10 的数变为 10
print(torch.clamp_min(data, 10))
"""
tensor([[15.1526, 10.0000, 10.0000, 14.6937, 10.0000],
        [15.9972, 10.0000, 15.0874, 11.3902, 10.0000]])
"""

# 大于 15 的数变为 15
print(torch.clamp_max(data, 15))
"""
tensor([[15.0000,  5.5862,  8.0614, 14.6937,  0.5856],
        [15.0000,  7.9427, 15.0000, 11.3902,  8.7756]])
"""

torch.clamp()用于将输入的张量夹紧到区间[min, max]。

torch.clip()是torch.clamp()的别名。

.dot/.mm/.bmm/.matmul

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

# 一维矩阵相乘
print(torch.dot(torch.tensor([1, 2]), torch.tensor([3, 4])))  # tensor(11)

# 二维矩阵相乘
print(torch.mm(torch.full((2, 3), 2), torch.full((3, 2), 3)))
"""
tensor([[18, 18],
        [18, 18]])
"""

# 三维矩阵相乘
print(torch.bmm(torch.full((2, 2, 3), 2), torch.full((2, 3, 2), 3)))
"""
tensor([[[18, 18],
         [18, 18]],

        [[18, 18],
         [18, 18]]])
"""

data1 = torch.rand(4, 3, 800, 600)
print(data1.shape)  # torch.Size([4, 3, 800, 600])
data2 = torch.rand(4, 3, 600, 400)
print(data2.shape)  # torch.Size([4, 3, 600, 400])
# data1 @ data2 等价于 data1.matmul(data2)
print(data1.matmul(data2).shape)  # torch.Size([4, 3, 800, 400])

dot()只支持一维矩阵相乘，mm()只支持二维矩阵相乘，bmm()只支持三维矩阵相乘，matmul()支持任意维度矩阵相乘。

比较运算

.eq/.ne/.gt/.ge/.lt/.le/.equal

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

torch.manual_seed(1)

data = torch.randperm(10).view(2, 5)
print(data)
"""
tensor([[5, 6, 1, 2, 0],
        [8, 9, 3, 7, 4]])
"""

# 等于
print(torch.eq(data, 5))  # 等价于 data == 5
"""
tensor([[ True, False, False, False, False],
        [False, False, False, False, False]])
"""

# 不等于
print(torch.ne(data, 5))  # 等价于 data != 5
"""
tensor([[False,  True,  True,  True,  True],
        [ True,  True,  True,  True,  True]])
"""

# 大于
print(torch.gt(data, 5))  # 等价于 data > 5
"""
tensor([[False,  True, False, False, False],
        [ True,  True, False,  True, False]])
"""

# 大于等于
print(torch.ge(data, 5))  # 等价于 data >= 5
"""
tensor([[ True,  True, False, False, False],
        [ True,  True, False,  True, False]])
"""

# 小于
print(torch.lt(data, 5))  # 等价于 data < 5
"""
tensor([[False, False,  True,  True,  True],
        [False, False,  True, False,  True]])
"""

# 小于等于
print(torch.le(data, 5))  # 等价于 data <= 5
"""
tensor([[ True, False,  True,  True,  True],
        [False, False,  True, False,  True]])
"""

# 比较两个 tensor 是否相同
print(torch.equal(torch.tensor([1, 2]), torch.tensor([1, 2])))  # True
print(torch.equal(torch.tensor([1, 2]), torch.tensor([2, 1])))  # False

torch.not_equal()是torch.ne()的别名。
torch.greater()是torch.gt()的别名。
torch.greater_equal()是torch.ge()的别名。
torch.less()是torch.lt()的别名。
torch.less_equal()是torch.le()的别名。

.isfinite/.isinf/.isposinf/.isneginf/.isnan/.isreal/.isin

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 torch

data = torch.tensor([1, float('inf'), torch.inf, float('-inf'), -torch.inf, float('nan'), torch.nan, True, False])
# 是否不是无穷大
print(torch.isfinite(data))  # tensor([ True, False, False, False, False, False, False,  True,  True])
# 是否是无穷大
print(torch.isinf(data))  # tensor([False,  True,  True,  True,  True, False, False, False, False])
# 是否是正无穷大
print(torch.isposinf(data))  # tensor([False,  True,  True, False, False, False, False, False, False])
# 是否是负无穷大
print(torch.isneginf(data))  # tensor([False, False, False,  True,  True, False, False, False, False])
# 是否是 NaN
print(torch.isnan(data))  # tensor([False, False, False, False, False,  True,  True, False, False])
# 是否是实数
print(torch.isreal(torch.tensor([1, 1+1j, 2+0j, float('nan'), True, False])))  # tensor([ True, False,  True,  True,  True,  True])

elements = [[1, 2], [3, 4]]
test_elements = [2, 3]
# 对 elements 的每个元素进行判断是否在 test_elements 中
print(torch.isin(torch.tensor(elements), torch.tensor(test_elements)))
"""
tensor([[False,  True],
        [ True, False]])
"""

.isclose/.allclose

1
2
3
4
5
6
7
8
9
10
11
import torch

# 是否接近
print(torch.isclose(torch.tensor((1., 2, 3)), torch.tensor((1 + 1e-10, 3, 4))))  # tensor([ True, False, False])
print(torch.isclose(torch.tensor((float('inf'), 4)), torch.tensor((float('inf'), 6)), rtol=.5))  # tensor([True, True])

# 是否都接近
print(torch.allclose(torch.tensor([10000., 1e-07]), torch.tensor([10000.1, 1e-08])))  # False
print(torch.allclose(torch.tensor([10000., 1e-08]), torch.tensor([10000.1, 1e-09])))  # True
print(torch.allclose(torch.tensor([1.0, float('nan')]), torch.tensor([1.0, float('nan')])))  # False
print(torch.allclose(torch.tensor([1.0, float('nan')]), torch.tensor([1.0, float('nan')]), equal_nan=True))  # True

torch.isclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False)

torch.allclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False)

校验是否接近公式：

.maximum/.minimum/.fmax/.fmin

1
2
3
4
5
6
7
8
9
10
import torch

data1 = torch.tensor([9.7, float('nan'), 3.1, torch.nan, 11.1])
data2 = torch.tensor([-2.2, 0.5, torch.nan, float('nan'), 7.8])

print(torch.maximum(data1, data2))  # tensor([ 9.7000,     nan,     nan,     nan, 11.1000])
print(torch.minimum(data1, data2))  # tensor([-2.2000,     nan,     nan,     nan,  7.8000])

print(torch.fmax(data1, data2))  # tensor([ 9.7000,  0.5000,  3.1000,     nan, 11.1000])
print(torch.fmin(data1, data2))  # tensor([-2.2000,  0.5000,  3.1000,     nan,  7.8000])

torch.maximum()和torch.minimum()用于比较两数的大小，不支持比较NaN。

torch.fmax()和torch.fmin()用于比较两数的大小，支持比较NaN。

.sort/.msort/.argsort

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

torch.manual_seed(1)

data = torch.rand(2, 5)
print(data)
"""
tensor([[0.7576, 0.2793, 0.4031, 0.7347, 0.0293],
        [0.7999, 0.3971, 0.7544, 0.5695, 0.4388]])
"""

### dim 默认等于 -1，按列进行排序
print(torch.sort(data))
"""
torch.return_types.sort(
values=tensor([[0.0293, 0.2793, 0.4031, 0.7347, 0.7576],
        [0.3971, 0.4388, 0.5695, 0.7544, 0.7999]]),
indices=tensor([[4, 1, 2, 3, 0],
        [1, 4, 3, 2, 0]]))
"""
# 按行进行排序
print(torch.sort(data, dim=0))
"""
torch.return_types.sort(
values=tensor([[0.7576, 0.2793, 0.4031, 0.5695, 0.0293],
        [0.7999, 0.3971, 0.7544, 0.7347, 0.4388]]),
indices=tensor([[0, 0, 0, 1, 0],
        [1, 1, 1, 0, 1]]))
"""
# descending=True 降序排序
print(torch.sort(data, descending=True))
"""
torch.return_types.sort(
values=tensor([[0.7576, 0.7347, 0.4031, 0.2793, 0.0293],
        [0.7999, 0.7544, 0.5695, 0.4388, 0.3971]]),
indices=tensor([[0, 3, 2, 1, 4],
        [0, 2, 3, 4, 1]]))
"""

# 沿第一维度进行排序
print(torch.msort(data))  # 等价于 torch.sort(data, dim=0)[0]
"""
tensor([[0.7576, 0.2793, 0.4031, 0.5695, 0.0293],
        [0.7999, 0.3971, 0.7544, 0.7347, 0.4388]])
"""

### dim 默认等于 -1，按列进行排序，返回索引
print(torch.argsort(data))
"""
tensor([[4, 1, 2, 3, 0],
        [1, 4, 3, 2, 0]])
"""
# 按行进行排序，返回索引
print(torch.argsort(data, dim=0))
"""
tensor([[0, 0, 0, 1, 0],
        [1, 1, 1, 0, 1]])
"""
# descending=True 降序排序，返回索引
print(torch.argsort(data, descending=True))
"""
tensor([[0, 3, 2, 1, 4],
        [0, 2, 3, 4, 1]])
"""

torch.sort()排序后返回排序结果和索引。

torch.msort(input))等价于torch.sort()对第一维度进行排序在取排序结果，torch.sort(input, dim=0)[0]，返回结果不包含索引。

torch.argsort()返回排序后的索引。

.topk/.kthvalue

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

torch.manual_seed(1)

data = torch.randperm(30, dtype=torch.double).view(3, 10)
print(data)
"""
tensor([[25.,  4.,  6.,  8., 23., 18., 17., 20., 19., 12.],
        [ 5., 14., 22.,  3., 27., 15.,  9., 13.,  7., 11.],
        [10.,  2., 24., 29., 21., 26., 28.,  1., 16.,  0.]],
       dtype=torch.float64)
"""

# 获取前 k 大的数据
print(torch.topk(data, 3))
"""
torch.return_types.topk(
values=tensor([[25., 23., 20.],
        [27., 22., 15.],
        [29., 28., 26.]], dtype=torch.float64),
indices=tensor([[0, 4, 7],
        [4, 2, 5],
        [3, 6, 5]]))
"""
# 获取前 k 小的数据
print(torch.topk(data, 3, largest=False))
"""
torch.return_types.topk(
values=tensor([[4., 6., 8.],
        [3., 5., 7.],
        [0., 1., 2.]], dtype=torch.float64),
indices=tensor([[1, 2, 3],
        [3, 0, 8],
        [9, 7, 1]]))
"""

# 获取第 k 小的数据
print(torch.kthvalue(data, 8))
"""
torch.return_types.kthvalue(
values=tensor([20., 15., 26.], dtype=torch.float64),
indices=tensor([7, 5, 5]))
"""
print(torch.kthvalue(data, 2, dim=0))
"""
torch.return_types.kthvalue(
values=tensor([10.,  4., 22.,  8., 23., 18., 17., 13., 16., 11.], dtype=torch.float64),
indices=tensor([2, 0, 1, 0, 0, 0, 0, 1, 2, 1]))
"""

torch.topk()获取前k大的数据，torch.kthvalue()获取第k小的数据。

归约运算

.max/.min/.amax/.amin/.aminmax/.argmax/.argmin

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

torch.manual_seed(1)

data = torch.rand(4, 4)
print(data)
"""
tensor([[0.7576, 0.2793, 0.4031, 0.7347],
        [0.0293, 0.7999, 0.3971, 0.7544],
        [0.5695, 0.4388, 0.6387, 0.5247],
        [0.6826, 0.3051, 0.4635, 0.4550]])
"""

# 最大值
print(torch.max(data))  # tensor(0.7999)
print(torch.max(data, dim=0))
"""
torch.return_types.max(
values=tensor([0.7576, 0.7999, 0.6387, 0.7544]),
indices=tensor([0, 1, 2, 1]))
"""

# 最小值
print(torch.min(data))  # tensor(0.0293)
print(torch.min(data, dim=1))
"""
torch.return_types.min(
values=tensor([0.2793, 0.0293, 0.4388, 0.3051]),
indices=tensor([1, 0, 1, 1]))
"""

# 最大值
print(torch.amax(data))  # tensor(0.7999)
print(torch.amax(data, dim=0))  # tensor([0.7576, 0.7999, 0.6387, 0.7544])

# 最小值
print(torch.amin(data))  # tensor(0.0293)
print(torch.amin(data, dim=1))  # tensor([0.2793, 0.0293, 0.4388, 0.3051])

# 最大值和最小值
print(torch.aminmax(data))
"""
torch.return_types.aminmax(
min=tensor(0.0293),
max=tensor(0.7999))
"""
print(torch.aminmax(data, dim=0))
"""
torch.return_types.aminmax(
min=tensor([0.0293, 0.2793, 0.3971, 0.4550]),
max=tensor([0.7576, 0.7999, 0.6387, 0.7544]))
"""

# 最大值索引
print(torch.argmax(data))  # tensor(5)
print(torch.argmax(data, dim=0))  # tensor([0, 1, 2, 1])

# 最小值索引
print(torch.argmin(data))  # tensor(4)
print(torch.argmin(data, dim=1))  # tensor([1, 0, 1, 1])

torch.max()和torch.min()指定了dim时，返回极值和索引。

torch.amax()和torch.amin()只返回极值，不返回索引。

torch.argmax()和torch.argmin()返回极值对应的索引。不指定dim时，返回的是打平后的索引。

.mean/.nanmean

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

data = torch.tensor([[torch.nan, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, torch.nan]])
print(data)
"""
tensor([[nan,  1.,  2.,  3.,  4.],
        [ 5.,  6.,  7.,  8.,  9.],
        [10., 11., 12., 13., nan]])
"""

# 平均值
print(torch.mean(data))  # tensor(nan)
print(torch.mean(data, dim=0))  # tensor([nan, 6., 7., 8., nan])
print(torch.mean(data, dim=1))  # tensor([nan, 7., nan])

# 平均值（忽略 NaN 值）
print(torch.nanmean(data))  # tensor(7.)
print(torch.nanmean(data, dim=0))  # tensor([7.5000, 6.0000, 7.0000, 8.0000, 6.5000])
print(torch.nanmean(data, dim=1))  # tensor([ 2.5000,  7.0000, 11.5000])

.median/.nanmedian

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

data = torch.tensor([[torch.nan, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, torch.nan]])
print(data)
"""
tensor([[nan,  1.,  2.,  3.,  4.],
        [ 5.,  6.,  7.,  8.,  9.],
        [10., 11., 12., 13., nan]])
"""

# 中位数
print(torch.median(data))  # tensor(nan)
print(torch.median(data, dim=0))
"""
torch.return_types.median(
values=tensor([nan, 6., 7., 8., nan]),
indices=tensor([0, 1, 1, 1, 2]))
"""
print(torch.median(data, dim=1))  # tensor([nan, 7., nan])
"""
torch.return_types.median(
values=tensor([nan, 7., nan]),
indices=tensor([0, 2, 4]))
"""

# 中位数（忽略 NaN 值）
print(torch.nanmedian(data))  # tensor(7.)
print(torch.nanmedian(data, dim=0))
"""
torch.return_types.nanmedian(
values=tensor([5., 6., 7., 8., 4.]),
indices=tensor([1, 1, 1, 1, 0]))
"""
print(torch.nanmedian(data, dim=1))
"""
torch.return_types.nanmedian(
values=tensor([ 2.,  7., 11.]),
indices=tensor([2, 2, 1]))
"""

.sum/.nansum

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

data = torch.tensor([[torch.nan, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, torch.nan]])
print(data)
"""
tensor([[nan,  1.,  2.,  3.,  4.],
        [ 5.,  6.,  7.,  8.,  9.],
        [10., 11., 12., 13., nan]])
"""

# 累加
print(torch.sum(data))  # tensor(nan)
print(torch.sum(data, dim=0))  # tensor([nan, 18., 21., 24., nan])
print(torch.sum(data, dim=1))  # tensor([nan, 35., nan])

# 累加（忽略 NaN 值）
print(torch.nansum(data))  # tensor(91.)
print(torch.nansum(data, dim=0))  # tensor([15., 18., 21., 24., 13.])
print(torch.nansum(data, dim=1))  # tensor([10., 35., 46.])

.prod

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

data = torch.tensor([[torch.nan, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, torch.nan]])
print(data)
"""
tensor([[nan,  1.,  2.,  3.,  4.],
        [ 5.,  6.,  7.,  8.,  9.],
        [10., 11., 12., 13., nan]])
"""

# 累乘
print(torch.prod(data))  # tensor(nan)
print(torch.prod(data, dim=0))  # tensor([ nan,  66., 168., 312.,  nan])
print(torch.prod(data, dim=1))  # tensor([   nan, 15120.,    nan])

.var/.var_mean/.std/.std_mean

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

data = torch.arange(1, 10, dtype=torch.double).view(3, 3)
print(data)
"""
tensor([[1., 2., 3.],
        [4., 5., 6.],
        [7., 8., 9.]], dtype=torch.float64)
"""

# 样本方差
print(torch.var(data))  # tensor(7.5000, dtype=torch.float64)
# 总体方差
print(torch.var(data, unbiased=False))  # tensor(6.6667, dtype=torch.float64)
# 同时计算方差和平均值
print(torch.var_mean(data))  # (tensor(7.5000, dtype=torch.float64), tensor(5., dtype=torch.float64))

# 样本标准差
print(torch.std(data))  # tensor(2.7386, dtype=torch.float64)
# 总体标准差
print(torch.std(data, unbiased=False))  # tensor(2.5820, dtype=torch.float64)
# 同时计算标准差和平均值
print(torch.std_mean(data))  # (tensor(2.7386, dtype=torch.float64), tensor(5., dtype=torch.float64))

总体方差：

样本方差：

总体标准差：

样本标准差：

.norm

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

data = torch.full((2, 2), 2.)
print(data)
"""
tensor([[2., 2.],
        [2., 2.]])
"""

# 一范数
print(torch.norm(data, p=1))  # tensor(8.)
# 二范数
print(torch.norm(data))  # tensor(4.)
# 三范数
print(torch.norm(data, p=3))  # tensor(3.1748)

一范数：

二范数：

p范数：

.dist

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

input = torch.full((2, 2), 4.)
print(input)
"""
tensor([[4., 4.],
        [4., 4.]])
"""
other = torch.full((2, 2), 2.)
print(other)
"""
tensor([[2., 2.],
        [2., 2.]])
"""

# 一范数
print(torch.dist(input, other, p=1))  # tensor(8.)
# 二范数
print(torch.dist(input, other))  # tensor(4.)
# 三范数
print(torch.dist(input, other, p=3))  # tensor(3.1748)

torch.dist()返回(input - other)的p范数。

.any/.all

1
2
3
4
5
6
7
8
9
10
11
import torch

print(torch.any(torch.tensor([])))  # tensor(False)
print(torch.any(torch.tensor([True, True])))  # tensor(True)
print(torch.any(torch.tensor([True, False])))  # tensor(True)
print(torch.any(torch.tensor([False, False])))  # tensor(False)

print(torch.all(torch.tensor([])))  # tensor(True)
print(torch.all(torch.tensor([True, True])))  # tensor(True)
print(torch.all(torch.tensor([True, False])))  # tensor(False)
print(torch.all(torch.tensor([False, False])))  # tensor(False)

序列化

.save

1
2
3
4
5
6
7
8
9
10
import io
import torch

# Save to file
x = torch.tensor([0, 1, 2, 3, 4])
torch.save(x, 'tensor.pt')

# Save to io.BytesIO buffer
buffer = io.BytesIO()
torch.save(x, buffer)

.load

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

# Load a module with 'ascii' encoding for unpickling
torch.load('tensors.pt', encoding='ascii')
# Load all tensors onto the CPU
torch.load('tensors.pt', map_location=torch.device('cpu'))
# Map tensors from GPU 1 to GPU 0
torch.load('tensors.pt', map_location={'cuda:1': 'cuda:0'})

# Load from io.BytesIO buffer
with open('tensor.pt', 'rb') as f:
    buffer = io.BytesIO(f.read())
torch.load(buffer)
]]> <p><span></span></p> 汉诺塔 https://blog.wpz.homes/posts/3d0f623f/ 2019-06-29T06:08:10.000Z 2026-09-20T09:12:05.372Z

起源

汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

抽象为数学问题

如下图所示，从左到右有A、B、C三根柱子，其中A柱子上面有从小叠到大的n个圆盘，现要求将A柱子上的圆盘移到C柱子上去，期间只有一个原则：一次只能移到一个盘子且大盘子不能在小盘子上面，求移动的步骤和移动的次数。

调用方法的栈机制（先进后出）

从主线程开始调用方法（函数）进行不停的压栈和出栈操作，函数的调用就是将函数压如栈中，函数的结束就是函数出栈的过程，这样就保证了方法调用的顺序流，即当函数出现多层嵌套时，需要从外到内一层层把函数压入栈中，最后栈顶的函数先执行结束（最内层的函数先执行结束）后出栈，再倒数第二层的函数执行结束出栈，到最后，第一个进栈的函数调用结束后从栈中弹出回到主线程，并且结束。

算法分析（递归算法）

我们在利用计算机求汉诺塔问题时，必不可少的一步是对整个实现求解进行算法分析。到目前为止，求解汉诺塔问题最简单的算法还是通过递归来求，至于是什么是递归，递归实现的机制是什么，我们说的简单点就是自己是一个方法或者说是函数，但是在自己这个函数里有调用自己这个函数的语句，而这个调用怎么才能调用结束呢？这里还必须有一个结束点，或者具体的说是在调用到某一次后函数能返回一个确定的值，接着倒数第二个就能返回一个确定的值，一直到第一次调用的这个函数能返回一个确定的值。

实现这个算法可以简单分为三个步骤：

  1. 把 n-1 个盘子由 A 移到 B；
  2. 把第 n 个盘子由 A 移到 C；
  3. 把 n-1 个盘子由 B 移到 C；

从这里入手，在加上上面数学问题解法的分析，我们不难发现，移到的步数必定为奇数步：

  1. 中间的一步是把最大的一个盘子由 A 移到 C 上去；
  2. 中间一步之上可以看成把 A 上 n-1 个盘子通过借助辅助塔（C塔）移到了 B 上，
  3. 中间一步之下可以看成把 B 上 n-1 个盘子通过借助辅助塔（A塔）移到了 C 上；

代码实现

Java

Java 实现
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
import java.util.Scanner;

public class Hannota {

    public static void hannota(int n, char A, char B, char C) {
        if (n == 1) {
            move(n, A, C);
        } else {
            hannota(n - 1, A, C, B);
            move(n, A, C);
            hannota(n - 1, B, A, C);
        }
    }

    public static void move(int n, char from, char to) {
        System.out.printf("将编号为%d的盘子从柱子%c移动到柱子%c\n", n, from, to);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        hannota(n, 'A', 'B', 'C');
        scanner.close();
    }
}

Python

Python 实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def hannota(n, A, B, C):
    if n == 1:
        move(n, A, C)
    else:
        hannota(n - 1, A, C, B)
        move(n, A, C)
        hannota(n - 1, B, A, C)


def move(n, f, to):
    print('将编号为%d的盘子从柱子%c移动到柱子%c' % (n, f, to))


if __name__ == '__main__':
    n = input()
    hannota(int(n), 'A', 'B', 'C')

Go

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

import "fmt"

func Hannota(n int, A, B, C byte) {
    if n == 1 {
        Move(n, A, C) // 只有一个盘子，直接从 A 移动到 C
    } else {
        Hannota(n-1, A, C, B) // 先将 n-1 这个盘子从 A 借助 C 移动到 B
        Move(n, A, C)         // 经过上面的递归，n-1 这个盘子已经移动到了 B，现在将最后一个盘子 n 直接从 A 移动到 C
        Hannota(n-1, B, A, C) // 最后将 n-1 这个盘子从 B 借助 A 移动到 C
    }
}

func Move(n int, from, to byte) {
    fmt.Printf("将编号为%d的盘子从柱子%c移动到柱子%c\n", n, from, to)
}

func main() {
    var n int
    fmt.Scanf("%d", &n)
    Hannota(n, 'A', 'B', 'C')
}

参考文章

汉诺塔的图解递归算法

]]> <p><span></span></p> 二叉树前序、中序、后序遍历 https://blog.wpz.homes/posts/6ab4a85b/ 2019-06-29T02:15:28.000Z 2026-09-20T09:12:05.372Z

二叉树

二叉树是一种非常重要的数据结构，非常多其他数据结构都是基于二叉树的基础演变而来的。对于二叉树，有深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即我们寻常所说的层次遍历。由于树的定义本身就是递归定义，因此採用递归的方法去实现树的三种遍历不仅简单理解并且代码非常简洁，而对于广度遍历来说，须要其他数据结构的支撑。比方队列。所以。对于一段代码来说，可读性有时候要比代码本身的效率要重要的多。

遍历方式

前序遍历：根结点 ---> 左子树 ---> 右子树
中序遍历：左子树 ---> 根结点 ---> 右子树
后序遍历：左子树 ---> 右子树 ---> 根结点

前序遍历：1 2 4 5 7 8 3 6
中序遍历：4 2 7 5 8 1 3 6
后序遍历：4 7 8 5 2 6 3 1

代码实现

Java

Java 实现
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
public class BinaryTree {

    public int data;
    public BinaryTree left;
    public BinaryTree right;

    public BinaryTree(int data) {
        this.data = data;
    }

    public static void PreorderTraversal(BinaryTree node) { // 先序遍历
        if (node == null) {
            return;
        }
        System.out.print(node.data);
        PreorderTraversal(node.left);
        PreorderTraversal(node.right);
    }

    public static void InorderTraversal(BinaryTree node) { // 中序遍历
        if (node == null) {
            return;
        }
        InorderTraversal(node.left);
        System.out.print(node.data);
        InorderTraversal(node.right);
    }

    public static void PostorderTraversal(BinaryTree node) { // 后序遍历
        if (node == null) {
            return;
        }
        PostorderTraversal(node.left);
        PostorderTraversal(node.right);
        System.out.print(node.data);
    }

    public static void main(String[] args) {
        BinaryTree root = new BinaryTree(1);
        BinaryTree node2 = new BinaryTree(2);
        BinaryTree node3 = new BinaryTree(3);
        BinaryTree node4 = new BinaryTree(4);
        BinaryTree node5 = new BinaryTree(5);
        BinaryTree node6 = new BinaryTree(6);
        BinaryTree node7 = new BinaryTree(7);
        BinaryTree node8 = new BinaryTree(8);
        root.left = node2;
        root.right = node3;
        node2.left = node4;
        node2.right = node5;
        node3.right = node6;
        node5.left = node7;
        node5.right = node8;

        PreorderTraversal(root); // 12457836
        System.out.println();
        InorderTraversal(root); // 42758136
        System.out.println();
        PostorderTraversal(root); // 47852631
    }
}

Python

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
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
class BinaryTree:
    def __init__(self, data, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right


def PreorderTraversal(node):  # 先序遍历
    if node is None:
        return
    print(node.data, end='')
    PreorderTraversal(node.left)
    PreorderTraversal(node.right)


def InorderTraversal(node):  # 中序遍历
    if node is None:
        return
    InorderTraversal(node.left)
    print(node.data, end='')
    InorderTraversal(node.right)


def PostorderTraversal(node):  # 后序遍历
    if node is None:
        return
    PostorderTraversal(node.left)
    PostorderTraversal(node.right)
    print(node.data, end='')


if __name__ == '__main__':
    root = BinaryTree(1)
    node2 = BinaryTree(2)
    node3 = BinaryTree(3)
    node4 = BinaryTree(4)
    node5 = BinaryTree(5)
    node6 = BinaryTree(6)
    node7 = BinaryTree(7)
    node8 = BinaryTree(8)
    root.left = node2
    root.right = node3
    node2.left = node4
    node2.right = node5
    node3.right = node6
    node5.left = node7
    node5.right = node8

    PreorderTraversal(root)  # 12457836
    print()
    InorderTraversal(root)  # 42758136
    print()
    PostorderTraversal(root)  # 47852631

Go

Go 实现
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
package main

import "fmt"

type BinaryTree struct {
    data  int
    left  *BinaryTree
    right *BinaryTree
}

func PreorderTraversal(node *BinaryTree) { // 先序遍历
    if node == nil {
        return
    }
    fmt.Print(node.data)
    PreorderTraversal(node.left)
    PreorderTraversal(node.right)
}

func InorderTraversal(node *BinaryTree) { // 中序遍历
    if node == nil {
        return
    }
    InorderTraversal(node.left)
    fmt.Print(node.data)
    InorderTraversal(node.right)
}

func PostorderTraversal(node *BinaryTree) { // 后序遍历
    if node == nil {
        return
    }
    PostorderTraversal(node.left)
    PostorderTraversal(node.right)
    fmt.Print(node.data)
}

func main() {
    root := BinaryTree{data: 1}
    node2 := BinaryTree{data: 2}
    node3 := BinaryTree{data: 3}
    node4 := BinaryTree{data: 4}
    node5 := BinaryTree{data: 5}
    node6 := BinaryTree{data: 6}
    node7 := BinaryTree{data: 7}
    node8 := BinaryTree{data: 8}
    root.left = &node2
    root.right = &node3
    node2.left = &node4
    node2.right = &node5
    node3.right = &node6
    node5.left = &node7
    node5.right = &node8

    PreorderTraversal(&root) // 12457836
    fmt.Println()
    InorderTraversal(&root) // 42758136
    fmt.Println()
    PostorderTraversal(&root) // 47852631
}
]]> <p><span></span></p> 堆排序 https://blog.wpz.homes/posts/c2a5fdc5/ 2019-05-29T01:08:29.000Z 2026-09-20T09:12:05.372Z

堆排序（Heap Sort）

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

算法描述

  • 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
  • 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2….Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
  • 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2….Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素R[n-1]交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

算法分析

最佳情况：T(n) = O(nlogn)
最差情况：T(n) = O(nlogn)
平均情况：T(n) = O(nlogn)

代码实现

Java

Java 实现
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
import java.util.Arrays;

public class HeapSort {

    public static void maxHeapDown(int[] arr, int current, int size) {
        int max = current;
        int left = current * 2 + 1;
        int right = left + 1;
        if (left <= size && arr[max] < arr[left]) {
            max = left;
        }
        if (right <= size && arr[max] < arr[right]) {
            max = right;
        }
        if (max != current) {
            int temp = arr[max];
            arr[max] = arr[current];
            arr[current] = temp;
            maxHeapDown(arr, max, size);
        }
    }

    public static void heapSortAsc(int[] arr, int size) {
        for (int i = size / 2 - 1; i >= 0; i--) {
            maxHeapDown(arr, i, size - 1);
        }
        System.out.println(Arrays.toString(arr));
        for (int i = size - 1; i > 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            maxHeapDown(arr, 0, i - 1);
            System.out.println(Arrays.toString(arr));
        }
    }

    public static void main(String[] args) {
        int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
        System.out.printf("原始数组：%s\n", Arrays.toString(arr));
        heapSortAsc(arr, arr.length);
        System.out.printf("排序后数组：%s\n", Arrays.toString(arr));
    }
}

Python

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
28
def max_heap_down(arr, current, size):
    max = current
    left = current * 2 + 1
    right = left + 1
    if left <= size and arr[max] < arr[left]:
        max = left
    if right <= size and arr[max] < arr[right]:
        max = right
    if max != current:
        arr[max], arr[current] = arr[current], arr[max]
        max_heap_down(arr, max, size)


def heap_sort_asc(arr, size):
    for i in range(int(size / 2 - 1), -1, -1):
        max_heap_down(arr, i, size - 1)
    print(arr)
    for i in range(size - 1, 0, -1):
        arr[0], arr[i] = arr[i], arr[0]
        max_heap_down(arr, 0, i - 1)
        print(arr)


if __name__ == '__main__':
    arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
    print('原始数组：', arr)
    heap_sort_asc(arr, len(arr))
    print('排序后数组：', arr)

Go

Go 实现
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
package main

import (
    "fmt"
)

func MaxHeapDown(arr []int, current, size int) { // 最大堆
    max := current                            // 假设最大值的索引就是当前的根节点索引
    left := current*2 + 1                     // 左节点
    right := left + 1                         // 右节点
    if left <= size && arr[max] < arr[left] { // 左子节点大于父节点
        max = left
    }
    if right <= size && arr[max] < arr[left+1] { // 右子节点大于父节点
        max = right
    }
    if max != current { // 经过上面两步 if 判断，找出两个子节点中的最大的并且大于父节点的子节点
        arr[max], arr[current] = arr[current], arr[max]
        MaxHeapDown(arr, max, size)
    }
}

func HeapSortAsc(arr []int, size int) {
    for i := size/2 - 1; i >= 0; i-- { // 遍历完得到的数组实际上是一个大根堆
        MaxHeapDown(arr, i, size-1)
    }
    fmt.Println(arr)
    for i := size - 1; i > 0; i-- { // 从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
        arr[0], arr[i] = arr[i], arr[0] // 大根堆，第一个数最大，将其和最后一个数交换，此时最大值在数组的最后面
        MaxHeapDown(arr, 0, i-1)        // 经过上面的交换，a[0...i-1]，可能已经不是大根堆，所以需要重新排序成大根堆
        fmt.Println(arr)
    }
}

func main() {
    arr := []int{3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48}
    fmt.Printf("原始数组：%v\n", arr)
    HeapSortAsc(arr, len(arr))
    fmt.Printf("排序后数组：%v\n", arr)
}
]]> <p><span></span></p> 希尔排序 https://blog.wpz.homes/posts/1ac49179/ 2019-05-29T00:55:37.000Z 2026-09-20T09:12:05.372Z

希尔排序（Shell Sort）

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

算法描述

我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
按增量序列个数k，对序列进行k 趟排序；
每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

算法分析

最佳情况：T(n) = O(nlog2 n)
最坏情况：T(n) = O(nlog2 n)
平均情况：T(n) = O(nlog2 n)

代码实现

Java

Java 实现
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 java.util.Arrays;

public class ShellSort {

    public static void shellSort(int[] arr) {
        for (int step = arr.length / 2; step > 0; step /= 2) {
            for (int i = step; i < arr.length; i++) {
                if (arr[i] < arr[i - step]) {
                    int temp = arr[i];
                    int index = i;
                    while (index >= step && temp < arr[index - step]) {
                        arr[index] = arr[index - step];
                        index -= step;
                    }
                    arr[index] = temp;
                }
                System.out.println(Arrays.toString(arr));
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
        System.out.printf("原始数组：%s\n", Arrays.toString(arr));
        shellSort(arr);
        System.out.printf("排序后数组：%s\n", Arrays.toString(arr));
    }
}

Python

Python 实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def shell_sort(arr):
    step = int(len(arr) / 2)
    while step > 0:
        for i in range(step, len(arr)):
            if arr[i] < arr[i - step]:
                temp = arr[i]
                index = i
                while index >= step and temp < arr[index - step]:
                    arr[index] = arr[index - step]
                    index -= step
                arr[index] = temp
            print('分成%d组第%2d次排序第%d组后数组为：%s' % (step, i / step, (i % step) + 1, arr))
        step = int(step / 2)


if __name__ == '__main__':
    arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
    print('原始数组：', arr)
    shell_sort(arr)
    print('排序后数组：', arr)

Go

Go 实现
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
package main

import (
    "fmt"
)

func ShellSort(arr *[15]int) {
    for step := len(arr) / 2; step > 0; step /= 2 {
        for i := step; i < len(arr); i++ {
            if arr[i] < arr[i-step] {
                temp := arr[i] // 记录要插入的数
                index := i     // 记录要插入的位置
                for ; index >= step && temp < arr[index-step]; index -= step {
                    arr[index] = arr[index-step]
                }
                arr[index] = temp
            }
            fmt.Printf("分成%d组第%2d次排序第%d组后数组为：%v\n", step, i/step, (i%step)+1, *arr)
        }
    }
}

func main() {
    arr := [15]int{3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48}
    fmt.Printf("原始数组：%v\n", arr)
    ShellSort(&arr)
    fmt.Printf("排序后数组：%v\n", arr)
}
]]> <p><span></span></p> 快速排序 https://blog.wpz.homes/posts/ff8068c0/ 2019-05-28T07:20:48.000Z 2026-09-20T09:12:05.372Z

快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

  • 从数列中挑出一个元素，称为“基准”（pivot）；
  • 重新排序数列，所有比基准值小的元素都放在基准前面，所有比基准值大的元素都放在基准后面，相同的元素可以到任意一边。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  • 递归（recursive）地把小于基准值元素的子数列和大于基准值元素的子数列排序。

算法分析

最佳情况：T(n) = O(n log n)
最差情况：T(n) = O(n2)
平均情况：T(n) = O(n log n)　

代码实现

Java

Java 实现
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
import java.util.Arrays;

public class QuickSort {

    public static void quickSort(int[] arr, int l, int r) {
        if (l < r) {
            int left = l, right = r;
            int base = arr[left];
            while (left < right) {
                while (left < right && base <= arr[right]) {
                    right--;
                }
                while (left < right && base >= arr[left]) {
                    left++;
                }
                if (left < right) {
                    int temp = arr[left];
                    arr[left] = arr[right];
                    arr[right] = temp;
                }
            }
            if (l != left) {
                int temp = arr[l];
                arr[l] = arr[left];
                arr[left] = temp;
            }
            System.out.printf("以%2d为基准数排序后数组为：%s\n", base, Arrays.toString(arr));
            quickSort(arr, l, left - 1);
            quickSort(arr, right + 1, r);
        }
    }

    public static void main(String[] args) {
        int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
        System.out.printf("原始数组：%s\n", Arrays.toString(arr));
        quickSort(arr, 0, arr.length - 1);
        System.out.printf("排序后数组：%s\n", Arrays.toString(arr));
    }
}

Python

Python 实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def quick_sort(arr, l, r):
    if l < r:
        left, right = l, r
        base = arr[left]
        while left < right:
            while left < right and base <= arr[right]:
                right -= 1
            while left < right and base >= arr[left]:
                left += 1
            if left < right:
                arr[left], arr[right] = arr[right], arr[left]
        if l != left:
            arr[l], arr[left] = arr[left], arr[l]
        print('以%2d为基准数排序后数组为：%s' % (base, arr))
        quick_sort(arr, l, left - 1)
        quick_sort(arr, right + 1, r)


if __name__ == '__main__':
    arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
    print('原始数组：', arr)
    quick_sort(arr, 0, len(arr) - 1)
    print('排序后数组：', arr)

Go

Go 实现
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
package main

import (
"fmt"
)

func QuickSort(arr *[15]int, l, r int) {
    if l < r {
        left, right := l, r
        base := arr[left] // 以最左边的数作为基准数
        for left < right {
            for left < right && base <= arr[right] { // 先从右往左找大于基准数的位置
                right--
            }
            for left < right && base >= arr[left] { // 再从左往右找小于基准数的位置
                left++
            }
            if left < right {
                arr[left], arr[right] = arr[right], arr[left] // 交换找到的大于和小于基准数的两个数的位置
            }
        }
        if l != left {
            arr[l], arr[left] = arr[left], arr[l] // 交换基准数和(left=right)的位置
        }
        fmt.Printf("以%2d为基准数排序后数组为：%v\n", base, *arr)
        QuickSort(arr, l, left-1)  // 递归左边
        QuickSort(arr, right+1, r) // 递归右边
    }
}

func main() {
    arr := [15]int{3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48}
    fmt.Printf("原始数组：%v\n", arr)
    QuickSort(&arr, 0, len(arr)-1)
    fmt.Printf("排序后数组：%v\n", arr)
}
]]> <p><span></span></p> 插入排序 https://blog.wpz.homes/posts/96555fb2/ 2019-05-28T06:45:09.000Z 2026-09-20T09:12:05.372Z

插入排序（Insertion Sort）

插入排序的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

算法描述

  • 从第一个元素开始，该元素可以认为已经被排序；
  • 取出下一个元素（即要插入的元素），在已经排序的元素序列中从后向前扫描；
  • 如果已排序的元素大于要插入的元素，将该元素向后移动一位；
  • 重复步骤3，直到找到已排序的元素小于或者等于要插入的元素的位置；
  • 将要插入的元素插入到该位置后；
  • 重复步骤2~5。

动图演示

算法分析

最佳情况：T(n) = O(n)
最坏情况：T(n) = O(n2)
平均情况：T(n) = O(n2)

代码实现

Java

Java 实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.util.Arrays;

public class InsertionSort {

    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < arr[i - 1]) {
                int temp = arr[i];
                int index = i;
                while (index > 0 && temp < arr[index - 1]) {
                    arr[index] = arr[index - 1];
                    index--;
                }
                arr[index] = temp;
            }
            System.out.printf("排序第%2d次后数组为：%s\n", i + 1, Arrays.toString(arr));
        }
    }

    public static void main(String[] args) {
        int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
        System.out.printf("原始数组：%s\n", Arrays.toString(arr));
        insertionSort(arr);
        System.out.printf("排序后数组：%s\n", Arrays.toString(arr));
    }
}

Ptyhon

Ptyhon 实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def insertion_sort(arr):
    for i in range(1, len(arr)):
        if arr[i] < arr[i - 1]:
            temp = arr[i]
            index = i
            while index > 0 and temp < arr[index - 1]:
                arr[index] = arr[index - 1]
                index -= 1
            arr[index] = temp
        print('排序第%2d次后数组为：%s' % (i + 1, arr))


if __name__ == '__main__':
    arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
    print('原始数组：', arr)
    insertion_sort(arr)
    print('排序后数组：', arr)

Go

Go 实现
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
package main

import (
    "fmt"
)

func InsertionSort(arr *[15]int) {
    for i := 1; i < len(arr); i++ {
        if arr[i] < arr[i-1] {
            temp := arr[i] // 记录要插入的数
            index := i     // 记录要插入的位置
            for ; index > 0 && temp < arr[index-1]; index-- {
                arr[index] = arr[index-1]
            }
            arr[index] = temp
        }
        fmt.Printf("排序第%2d次后数组为：%v\n", i, *arr)
    }
}

func main() {
    arr := [15]int{3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48}
    fmt.Printf("原始数组：%v\n", arr)
    InsertionSort(&arr)
    fmt.Printf("排序后数组：%v\n", arr)
}
]]> <p><span></span></p> 选择排序 https://blog.wpz.homes/posts/43d00a99/ 2019-05-28T03:03:38.000Z 2026-09-20T09:12:05.372Z

选择排序（Selection Sort）

选择排序是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

选择排序是表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。选择排序还有一个好处就是不占用额外的内存空间。

算法描述

  • 初始状态：无序区为R[1..n]，有序区为空；
  • 第i趟排序(i=1, 2 , 3, …, n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R[i..n]。该趟排序从当前无序区中选出最小元素（按升序排序），将它与无序区的第1个记录交换，交换结束后，当前有序区和无序区分别为R[1..i]和R[i+1..n]；
  • 重复步骤2，当n-1趟结束后，数组有序化了。

动图演示

算法分析

最佳情况：T(n) = O(n2)
最差情况：T(n) = O(n2)
平均情况：T(n) = O(n2)

代码实现

Java

Java 实现
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 java.util.Arrays;

public class SelectionSort {

    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int index = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[index] > arr[j]) {
                    index = j;
                }
            }
            if (index != i) {
                int t = arr[index];
                arr[index] = arr[i];
                arr[i] = t;
            }
            System.out.printf("排序第%2d次后数组为：%s\n", i + 1, Arrays.toString(arr));
        }
    }

    public static void main(String[] args) {
        int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
        System.out.printf("原始数组：%s\n", Arrays.toString(arr));
        selectionSort(arr);
        System.out.printf("排序后数组：%s\n", Arrays.toString(arr));
    }
}

Python

Python 实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def selection_sort(arr):
    for i in range(0, len(arr) - 1):
        index = i
        for j in range(i + 1, len(arr)):
            if arr[index] > arr[j]:
                index = j
        if index != i:
            arr[index], arr[i] = arr[i], arr[index]
        print('排序第%2d次后数组为：%s' % (i + 1, arr))


if __name__ == '__main__':
    arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
    print('原始数组：', arr)
    selection_sort(arr)
    print('排序后数组：', arr)

Go

Go 实现
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
package main

import (
    "fmt"
)

func SelectionSort(arr *[15]int) {
    for i := 0; i < len(arr)-1; i++ {
        index := i
        for j := i + 1; j < len(arr); j++ {
            if arr[index] > arr[j] {
                index = j
            }
        }
        if index != i {
            arr[index], arr[i] = arr[i], arr[index]
        }
        fmt.Printf("排序第%2d次后数组为：%v\n", i+1, *arr)
    }
}

func main() {
    arr := [15]int{3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48}
    fmt.Printf("原始数组：%v\n", arr)
    SelectionSort(&arr)
    fmt.Printf("排序后数组：%v\n", arr)
}
]]> <p><span></span></p> 冒泡排序 https://blog.wpz.homes/posts/14e6f1eb/ 2019-05-28T01:53:14.000Z 2026-09-20T09:12:05.372Z

冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

算法描述

  • 比较相邻的元素。如果前面的数比后面的数大(按升序排序)，就交换它们两个；
  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样最大的元素就放在了最后面；
  • 针对所有的元素重复以上的步骤，除了最后一个；
  • 重复步骤1~3，直到排序完成。

动图演示

算法分析

最佳情况：T(n) = O(n)
最差情况：T(n) = O(n2)
平均情况：T(n) = O(n2)

代码实现

Java

Java 实现
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 java.util.Arrays;

public class BubbleSort {

    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
            System.out.printf("排序第%2d次后数组为：%s\n", i + 1, Arrays.toString(arr));
        }
    }

    public static void main(String[] args) {
        int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
        System.out.printf("原始数组：%s\n", Arrays.toString(arr));
        bubbleSort(arr);
        System.out.printf("排序后数组：%s\n", Arrays.toString(arr));
    }
}

Python

Python 实现
1
2
3
4
5
6
7
8
9
10
11
12
13
def bubble_sort(arr):
    for i in range(0, len(arr) - 1):
        for j in range(0, len(arr) - 1 - i):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
        print('排序第%2d次后数组为：%s' % (i + 1, arr))


if __name__ == '__main__':
    arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
    print('原始数组：', arr)
    bubble_sort(arr)
    print('排序后数组：', arr)

Go

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

import (
    "fmt"
)

func BubbleSort(arr *[15]int) {
    for i := 0; i < len(arr)-1; i++ {
        for j := 0; j < len(arr)-1-i; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
        fmt.Printf("排序第%2d次后数组为：%v\n", i+1, *arr)
    }
}

func main() {
    arr := [15]int{3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48}
    fmt.Printf("原始数组：%v\n", arr)
    BubbleSort(&arr)
    fmt.Printf("排序后数组：%v\n", arr)
}

为什么最佳情况是 O(n)

上面说过冒泡排序最佳情况是O(n)，这点我一开时很不理解，看上面代码实现，即便一开始已经是按顺序排序的，但最终还是要经过两层循环，也就是最佳情况依然是O(n2)。实际上，上面的代码是可以优化的，下面以Go语言来实现：

Go 实现
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
package main

import (
    "fmt"
)

func BubbleSort(arr *[15]int) {
    flag := false
    for i := 0; i < len(arr)-1; i++ {
        flag = false
        for j := 0; j < len(arr)-1-i; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
                flag = true
            }
        }
        fmt.Printf("排序第%2d次后数组为：%v\n", i+1, *arr)
        if !flag {
            break
        }
    }
}

func main() {
    arr := [15]int{3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48}
    fmt.Printf("原始数组：%v\n", arr)
    BubbleSort(&arr)
    fmt.Printf("排序后数组：%v\n", arr)
}

上面的代码，在数组已经从小到大排序的情况下，只需经过一轮循环遍历即可，也就是最佳情况为O(n)。

]]> <p><span></span></p> Redis 之 有序集合差集 https://blog.wpz.homes/posts/6574bc1f/ 2019-05-15T08:12:51.000Z 2026-09-20T09:12:05.372Z

有序集合没有差集命令

Redis集合中提供了SINTER、SUNION、SDIFF命令分别用来处理集合的交集、并集、差集运算。

有序集合中提供了ZINTERSTORE、ZUNIONSTORE命令分别用来处理有序集合的交集、并集运算。却没有提供用来处理有序集合差集的命令。

项目中用到Redis的有序集合来存储数据，需要对有序集合进行差集运算，在网上看到这篇文章：redis有序集合求差集 zdiff? 提供的解决方法，在此记录下。

解决思路

先使用ZUNIONSTORE计算并集，并设置并集后成员分数权重。

ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]

再使用ZREMRANGEBYSCORE去除分数为0的成员。

ZREMRANGEBYSCORE key min max

栗子

先添加两个有序集合chinese和english：

127.0.0.1:6379> ZADD chinese 100 user1 99 user2 98 user3(integer) 3127.0.0.1:6379> ZADD english 97 user3 96 user4 95 user5(integer) 3127.0.0.1:6379> ZRANGE chinese 0 10 WITHSCORES1) "user3"2) "98"3) "user2"4) "99"5) "user1"6) "100"127.0.0.1:6379> ZRANGE english 0 10 WITHSCORES1) "user5"2) "95"3) "user4"4) "96"5) "user3"6) "97"

再对有序集合chinese和english进行并集运算：

127.0.0.1:6379> ZUNIONSTORE result 2 chinese english WEIGHTS 1 0 AGGREGATE MIN(integer) 5127.0.0.1:6379> ZRANGE result 0 10 WITHSCORES1) "user3"2) "0"3) "user4"4) "0"5) "user5"6) "0"7) "user2"8) "99"9) "user1"10) "100"

这里有必要对ZUNIONSTORE的WEIGHTS和AGGREGATE选项进行说明一番：

  • WEIGHTS选项可以为每个给定的有序集合分别指定一个乘法因子(Multiplication Factor)。每个给定的有序集合的所有成员的分数在传递给聚合函数(Aggregation Function)之前都要先乘以该有序集合的因子。默认值为1。

  • AGGREGATE选项指定并集运算结果的聚合方式。默认值为SUM，即将所有相同成员的分数相加。当值为MIN或MAX时，则取所有相同成员的分数的最小值或最大值。

有序集合chinese的权重设置为1，所以合并后user1和user2的分数和合并前一样。有序集合english的权重设置为0，所以合并后user4和user5的分数变为0。至于user3的分数，chinese为98，english为0，由于AGGREGATE值为MIN，所以取最小值0。

最后移除有序集合result中分数为0的成员：

127.0.0.1:6379> ZREMRANGEBYSCORE result 0 0(integer) 3127.0.0.1:6379> ZRANGE result 0 10 WITHSCORES1) "user2"2) "99"3) "user1"4) "100"

现在有序集合result就为chinese和english进行差集运算的结果。

]]> <p><span></span></p> Redis 之 GEO 地理位置 https://blog.wpz.homes/posts/c09adc05/ 2019-05-14T06:59:50.000Z 2026-09-20T09:12:05.372Z

最近在做上门洗车项目时有个需求：需要根据用户选择的坐标位置和支持的服务范围来查找附近的洗车门店。项目中用到Redis来做缓存，刚好Redis有支持GEO地理位置的功能，用来实现该需求再合适不过了。遂研究了下Redis的GEO地理位置如何使用。

概述

Redis从3.2版本开始支持geohash算法，地理位置的坐标是以WGS84为标准。WGS84全称World Geodetic System 1984，是为GPS全球定位系统使用而建立的坐标系统。

GEO 命令

Redis的GEO目前提供以下6个命令，详情可点击查看。

1. GEOADD：增加某个地理位置的坐标。
2. GEOPOS：获取某个地理位置的坐标。
3. GEODIST：获取两个地理位置的距离。
4. GEORADIUS：根据给定地理位置坐标获取指定范围内的地理位置集合。
5. GEORADIUSBYMEMBER：根据给定地理位置获取指定范围内的地理位置集合。
6. GEOHASH：获取某个地理位置的geohash值。

GEOADD

GEOADD命令是用来增加地理位置坐标的，可以批量添加多个地理位置的坐标。命令格式为：

GEOADD key longitude latitude member [longitude latitude member ...]

key标识一个地理位置的集合，longitude是地理位置的经度，latitude是地理位置的纬度，member是该地理位置的名称。

Redis中接受的有效经度范围为-180～180度，有效纬度范围为-85.05112878～85.05112878度（靠近南北极的一小块地方是无法生成索引的）。

GEOPOS

GEOPOS命令是用来获取地理位置坐标的，可以批量获取多个地理位置的坐标。命令格式为：

GEOPOS key member [member ...]

GEODIST

GEODIST命令是用来获取两个地理位置的距离。命令格式为：

GEODIST key member1 member2 [unit]

unit单位可选项为m（米，默认值），km（千米），ft（英尺），mi（英里）。

GEORADIUS

GEORADIUS命令可以根据给定的地理位置坐标获取指定范围内的地理位置集合。命令格式为：

GEORADIUS key longitude latitude radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count] [ASC|DESC] [STORE key] [STOREDIST key]

key标识一个地理位置的集合，longitude是地理位置的经度，latitude是地理位置的纬度，radius表示范围距离，距离单位可以为m|km|ft|mi，还有一些可选参数：

  • WITHCOORD：同时返回匹配位置的经纬度。
  • WITHDIST：同时返回匹配位置与给定地理位置的距离。
  • WITHHASH：同时返回匹配位置的geohash值。
  • COUNT count：指定返回的结果个数，必须大于0。
  • ASC|DESC：默认返回的结果是未排序的，ASC为从近到远排序，DESC为从远到近排序。
  • STORE key：结果存到新的有序集合中，以geohash做为score，该选项与WITHCOORD、WITHDIST、WITHHASH、STOREDIST选项冲突。
  • STOREDIST key：结果存到新的有序集合中，以与指定位置的距离做为score，该选项与WITHCOORD、WITHDIST、WITHHASH、STORE选项冲突。

GEORADIUSBYMEMBER

GEORADIUSBYMEMBER命令可以根据给定的地理位置获取指定范围内的地理位置集合。命令格式为：

GEORADIUSBYMEMBER key member radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count] [ASC|DESC] [STORE key] [STOREDIST key]

很明显GEORADIUS命令传递的是地理位置坐标，GEORADIUSBYMEMBER命令传递的是地理位置名称。与GEORADIUS相比，使用GEORADIUSBYMEMBER更为方便，但使用GEORADIUS则更为灵活，可以获取任何坐标点范围内的地理位置。

GEOHASH

GEOHASH命令是用来获取地理位置的geohash值，可以批量获取多个地理位置的geohash值。命令格式为：

GEOHASH key member [member ...]

GEORADIUS_RO 和 GEORADIUSBYMEMBER_RO

GEORADIUS_RO和GEORADIUSBYMEMBER_RO是Redis 3.2.10后新引进的两个命令。由于GEORADIUS和GEORADIUSBYMEMBER命令存在STORE和STOREDIST选项，在Redis中该两个命令被标记为写命令类型。即使在从节点的连接设置了readonly模式下，标记为写命令类型的命令，依然会收到MOVED消息，被转向到相应主节点。所以Redis新增了该两个命令的只读版本，这两个命令除了不支持STORE和STOREDIST选项外，其他可选参数与GEORADIUS_RO和GEORADIUSBYMEMBER_RO一致。新增的两个只读命令在从节点连接设置readonly模式下可以在从节点执行。

GEO 实现

Redis GEO实现主要包含了以下两项技术：

1. 使用geohash保存地理位置的坐标。
2. 使用有序集合保存地理位置的集合。

使用 geohash 保存地理位置的坐标

使用geohash保存地理位置的坐标的思想是将二维的经纬度转换成一维的字符串hash值。geohash有以下三个特点：

1. 字符串越长，表示的范围越精确。编码长度为 8 时，精度在 19 米左右，而当编码长度为 9 时，精度在 2 米左右。
2. 字符串相似的表示距离相近。利用字符串的前缀匹配，可以快速的查询到附近的地理位置。
3. geohash 计算的字符串，可以反向解码出原来的经纬度。

这三个特性让geohash特别适合表示二维hash值。这篇文章：GeoHash核心原理解析详细的介绍了geohash的原理，想要了解geohash实现的朋友可以参考这篇文章。

使用有序集合保存地理位置的集合

各个命令的实现原理：

  • GEOADD命令增加地理位置时，先计算地理位置坐标的geohash值，然后geohash作为给定的member的score使用ZADD命令插入到有序集合。
  • GEOPOS命令获取地理位置坐标时，先根据给定的member获取到score，也就是地理位置的geohash值，然后decode得到地理位置的坐标。
  • GEODIST命令获取两个地理位置的距离时，先根据给定的member获得各自的坐标，然后计算两个坐标的距离。
  • GEORADIUS和GEORADIUSBYMEMBER使用相同的实现(GEORADIUSBYMEMBER多了一步把地理位置转换成对应的坐标)。先查找该坐标和周围对应8个坐标符合距离要求的地理位置。因为geohash得到的值其实是个格子，并不是点，这样通过计算周围对应8个坐标就能解决边缘问题。由于使用有序集合保存地理位置，在对地列位置基于范围查询，就相当于实现了ZRANGE命令，内部的实现确实与ZRANGE命令一致，只是GEO有些特别的处理，比如获得的某个地理位置，还需要计算该地理位置是否符合给定的距离访问。
  • GEOHASH命令获取地理位置的geohash值时，直接根据给定的member获取到score。

细心的读者可能发现，Redis没有实现地理位置的删除命令。不过由于GEO数据是使用有序集合保存的，所以可以使用ZREM命令来删除某个地理位置。

参考文章

redis3.2新功能—GEO地理位置命令介绍

[redis学习笔记]redis中Geo命令介绍

]]> <p><span></span></p> Dockerfile 之 ADD/COPY 指令 https://blog.wpz.homes/posts/b3b04b5f/ 2019-05-13T08:37:58.000Z 2026-09-20T09:12:05.372Z

Build Context(构建上下文)

在使用docker build命令通过Dockerfile创建镜像时，会产生一个build context(构建上下文)。所谓的构建上下文就是docker build命令的PATH或URL指定的路径中的文件的集合。在镜像build过程中可以引用上下文中的任何文件，比如我们要介绍的ADD和COPY指令就可以引用上下文中的文件。

ADD

ADD指令用于将构建上下文中指定的文件添加到镜像中的，支持两种形式的写法：

ADD src destADD ["src", "dest"]

ADD指令有以下几个特点：

1. 如果指定的 src 是归档文件(tar, zip, tgz, xz 等)会自动将其解压。
2. 如果指定的 src 是目录，只会添加目录中的内容而不包含目录自身。
3. 如果指定的 src 是 URL 地址，会从 URL 地址下载文件并将其添加到 dest，如果下载的文件是归档文件不会自动解压。

通过一个简单的栗子来说明

当前构建上下文目录结构：

root# tree.├── a│   ├── a.log│   └── b.log├── alpine-minirootfs-3.9.3-x86_64.tar.gz├── a.txt└── Dockerfile1 directory, 5 files
Dockerfile 文件
1
2
3
4
5
6
7
8
9
10
FROM scratch
WORKDIR /workspaces
# 添加归档文件到镜像中
ADD alpine-minirootfs-3.9.3-x86_64.tar.gz /
# 添加普通文件到镜像中
ADD a.txt .
# 添加目录到镜像中
ADD a .
# 从 URL 地址下载文件并添加到镜像中
ADD https://codeload.github.com/lz94wpz/lz94wpz.github.io/zip/master .

执行docker build -t alpine .构建镜像：

root# docker build -t alpine .Sending build context to Docker daemon  2.689MBStep 1/6 : FROM scratch---> Step 2/6 : WORKDIR /workspaces---> Running in 669cd08b2be7Removing intermediate container 669cd08b2be7---> 894324123641Step 3/6 : ADD alpine-minirootfs-3.9.3-x86_64.tar.gz /---> 471bc43f5e0cStep 4/6 : ADD a.txt .---> d22c05b89d9dStep 5/6 : ADD a .---> 54a77a7a1dd8Step 6/6 : ADD https://codeload.github.com/lz94wpz/lz94wpz.github.io/zip/master .Downloading    537kB---> a443738c3f2fSuccessfully built a443738c3f2fSuccessfully tagged alpine:latest

Step 1/6获取空白镜像，Step 2/6指定镜像工作空间为/workspaces，Step 3/6添加alpine-minirootfs-3.9.3-x86_64.tar.gz归档文件到镜像中，Step 4/6添加a.txt文件到镜像中，Step 5/6添加a目录到镜像中，Step 6/6下载归档文件并添加到镜像中。

执行docker run -it alpine /bin/sh启动容器：

root# docker run -it alpine /bin/sh/workspaces # ls /bin         etc         lib         mnt         proc        run         srv         tmp         vardev         home        media       opt         root        sbin        sys         usr         workspaces/workspaces # ls -ltotal 708-rw-r--r--    1 root     root             0 May 13 08:56 a.log-rw-r--r--    1 root     root             0 May 13 08:55 a.txt-rw-r--r--    1 root     root             0 May 13 08:56 b.log-rw-------    1 root     root        721697 Jan  1  1970 master

可以看到alpine-minirootfs-3.9.3-x86_64.tar.gz文件添加到/根目录，由于是归档文件被自动解压了。a.txt文件添加到当前目录，也就是工作目录(/workspaces)。a目录中的内容添加到当前目录(只添加目录中的内容而不包含目录自身)，https://codeload.github.com/lz94wpz/lz94wpz.github.io/zip/master下载的归档文件添加到当前目录，不会自动解压(URL下载和归档解包功能不能一起使用)。

解决添加目录，只添加目录中的内容而不包含目录自身的问题

上面的栗子可以看出，本意是要添加a目录到镜像中，结果只添加a目录下面的内容到镜像中。解决这个问题也很简单，稍微修改下Dockerfile文件：

1
ADD a .

改为：

1
ADD a ./a

解决从 URL 地址下载归档文件不自动解压的问题

解决从URL地址下载归档文件不自动解压的问题，思路也很简单，不自动解压那我们手动解压就是了：

1
2
ADD https://codeload.github.com/lz94wpz/lz94wpz.github.io/zip/master .
RUN unzip master && rm master

上面的方法虽然可行，但Docker官方不建议这么使用！Docker官方建议我们当需要从远程复制文件时，最好使用curl或wget命令来代替ADD命令。原因是，当使用ADD命令时，会创建更多的镜像层，当然镜像的size也会更大。现在我们使用wget来替代上面的命令：

1
RUN wget https://codeload.github.com/lz94wpz/lz94wpz.github.io/zip/master && unzip master && rm master

COPY

COPY指令用于将构建上下文中指定的文件复制到镜像中的，同样支持两种形式的写法：

COPY src destCOPY ["src", "dest"]

与ADD不同的是COPY不会自动解压归档文件，也不支持URL作为src参数，因此不能用于从远程位置下载文件。COPY可以看做是ADD的精简版本。

使用 ADD 还是 COPY？

使用ADD还是COPY？Docker团队的建议是在几乎所有情况下都使用COPY。唯一需要使用ADD的情况是需要自动解压归档文件。ADD通过URL下载文件则使用curl或wget代替。

]]> <p><span></span></p> Dockerfile 之 RUN/CMD/ENTRYPOINT 指令 https://blog.wpz.homes/posts/2262a086/ 2019-05-13T03:53:06.000Z 2026-09-20T09:12:05.372Z

RUN

RUN指令指定的命令在docker build构建镜像的时候执行。常用于安装软件包。可以有多个RUN指令，且每个都生效。

Dockerfile 文件
1
2
3
FROM ubuntu:18.04
RUN apt update && apt install -y vim
RUN touch a

执行docker build构建镜像时会在一层镜像层中更新源并安装vim命令，在另一个镜像层中创建a文件。

注意：apt update和apt install被放在一个RUN指令中执行，这样能够保证每次安装的是最新的包。如果apt install在单独的RUN中执行，则会使用apt update创建的镜像层，而这一层可能是很久以前缓存的。

CMD && ENTRYPOINT

CMD指令指定的命令在容器启动后执行。可以有多个CMD指令，但只有最后一个生效。CMD指定的命令会被docker run之后的参数替换。

Dockerfile 文件
1
2
3
FROM ubuntu:trusty
CMD hostname
CMD ping localhost

执行docker build -t ubuntu1 .构建一个ubuntu1镜像。执行docker run -t ubuntu1：

root# docker run -t ubuntu1PING localhost (127.0.0.1) 56(84) bytes of data.64 bytes from localhost (127.0.0.1): icmp_seq=1 ttl=64 time=0.031 ms64 bytes from localhost (127.0.0.1): icmp_seq=2 ttl=64 time=0.038 ms64 bytes from localhost (127.0.0.1): icmp_seq=3 ttl=64 time=0.037 ms^C

可以看出虽然Dockerfile文件中指定了两个CMD指令，但只有最后一个CMD指令执行，ping命令在容器启动后执行。

尽管指定了CMD指令，但我们可以在启动容器时, 执行其他命令行参数, 覆盖默认的CMD指令：

root# docker run -t ubuntu1 hostname59cd3e4806ee

容器启动后, 并没有执行ping命令, 而是执行了hostname命令。

和CMD指令类似ENTRYPOINT指令指定的命令也在容器启动后执行。也可以有多个ENTRYPOINT指令，也是只有最后一个生效。也可以被覆盖，在运行时使用--entrypoint覆盖默认值。

Dockerfile 文件
1
2
3
FROM ubuntu:trusty
ENTRYPOINT hostname
ENTRYPOINT ping localhost

执行docker build -t ubuntu2 .构建一个ubuntu2镜像。执行docker run -t ubuntu2：

root# docker run -t ubuntu2PING localhost (127.0.0.1) 56(84) bytes of data.64 bytes from localhost (127.0.0.1): icmp_seq=1 ttl=64 time=0.024 ms64 bytes from localhost (127.0.0.1): icmp_seq=2 ttl=64 time=0.038 ms64 bytes from localhost (127.0.0.1): icmp_seq=3 ttl=64 time=0.039 ms^C

执行docker run -t --entrypoint hostname ubuntu2：

root# docker run -t --entrypoint hostname ubuntu230a2145449c3

从根本上说，CMD指令和ENTRYPOINT指令都是让用户指定一个可执行程序, 这个可执行程序在容器启动后自动执行。实际上，如果你想让自己制作的镜像自动运行程序(不需要在docker run后面添加命令行指定运行的命令)，你必须在Dockerfile里面使用CMD指令或ENTRYPOINT指令。如果运行一个没有调用CMD指令或ENTRYPOINT指令的镜像, 一定返回错误：

Dockerfile 文件
1
2
FROM scratch
ADD alpine-minirootfs-3.9.3-x86_64.tar.gz /

执行docker build -t alpine .构建一个alpine镜像。执行docker run -t alpine：

root# docker run -t alpinedocker: Error response from daemon: No command specified.See 'docker run --help'.

Shell && Exec

RUN、CMD和ENTRYPOINT都支持两种形式的写法：Shell和Exec。二者在使用上有细微的区别。

Shell 格式
1
<instruction> <command>

当指令执行时，Shell格式的写法底层会调用/bin/sh -c <command>。

Dockerfile 片段
1
2
ENV WORLD world
ENTRYPOINT echo "Hello $WORLD"

容器启动后将输出：Hello world。

Exec 格式
1
<instruction> ["executable", "param1", "param2", ...]

当指令执行时，Exec格式的写法会直接调用<command>，不会被shell解析。

Dockerfile 片段
1
2
ENV WORLD world
ENTRYPOINT ["/bin/echo", "Hello $WORLD"]

容器启动后将输出：Hello $WORLD。

注意环境变量WORLD没有被替换。如果希望环境变量被替换，修改为：

Dockerfile 片段
1
2
ENV WORLD world
ENTRYPOINT ["/bin/sh", "-c", "echo Hello $WORLD"]

尽管CMD和ENTRYPOINT都支持两种形式的写法，但更推荐使用Exec格式。RUN则两种格式都可以。

CMD 作为参数传递给 ENTRYPOINT

上面说过尽管CMD和ENTRYPOINT都支持两种形式的写法，但更推荐使用Exec格式。因为当CMD作为参数为ENTRYPOINT提供额外的参数时，ENTRYPOINT必须使用Exec格式才能接收到参数。

Dockerfile 片段
1
2
ENTRYPOINT ["/bin/echo", "Hello"]
CMD ["world"]

执行docker run <image>启动容器后将输出：Hello world。执行docker run <image> 世界启动容器后将输出：Hello 世界。

Dockerfile 片段
1
2
ENTRYPOINT "echo Hello"
CMD ["world"]

执行docker run <image>启动容器后将输出：Hello。执行docker run <image> 世界启动容器后将输出：Hello。ENTRYPOINT的Shell格式会忽略任何CMD或docker run提供的参数。

]]> <p><span></span></p> 创建自己的 Docker 镜像 https://blog.wpz.homes/posts/e2f703e6/ 2019-05-10T03:32:09.000Z 2026-09-20T09:12:05.372Z

docker pull下来的镜像有时候不能满足我们的需求，这时候我们可以在这些镜像的基础上创建属于我们自己的镜像。

使用 docker commit 创建自己的镜像

执行docker run -it ubuntu:18.04 /bin/bash，进入容器后发现没有vim命令:

root# docker run -it ubuntu:18.04 /bin/bashroot@1d0e7bcf5430:/# vimbash: vim: command not found

以此为例，我们来创建一个已经安装了vim命令的ubuntu镜像。

先在容器内安装vim命令：

1
2
apt update && apt upgrade -y
apt install -y vim

安装完vim命令后我们就可以将这个容器打包成自己的镜像了。

首先我们要知道容器的ID，使用docker ps -a查看：

root# docker ps -aCONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES1d0e7bcf5430        ubuntu:18.04        "/bin/bash"         2 minutes ago       Up 2 minutes                            vigilant_kapitsa

容器ID为1d0e7bcf5430，执行docker commit 1d0e7bcf5430 ubuntu-vim-1:18.04将容器打包成镜像。ubuntu-vim-1:18.04为容器打包后的镜像名称和标签。

使用docker images查看打包后的镜像：

root# docker imagesREPOSITORY          TAG                 IMAGE ID            CREATED             SIZEubuntu-vim-1        18.04               ef1ded0d8102        12 seconds ago      191MBubuntu              18.04               d131e0fa2585        13 days ago         102MB

ubuntu:18.04为执行docker run自动pull下来的镜像，ubuntu-vim-1:18.04为我们docker commit创建的镜像。很明显ubuntu-vim-1:18.04的体积比ubuntu:18.04大，因为我们更新了软件(apt update && apt upgrade -y)并安装了vim(apt install -y vim)。

现在执行docker run -it ubuntu-vim-1:18.04 /bin/bash，进入容器后已经安装了vim命令。

使用 Dockerfile 创建自己的镜像

前面我们介绍了使用docker commit创建自己的镜像，除此之外我们也可以使用Dockerfile创建自己的镜像。

创建一个名为Dockerfile的文件，编写以下内容：

1
2
3
FROM ubuntu:18.04
RUN apt update && apt upgrade -y
RUN apt install -y vim

使用docker build构建镜像:

1
docker build -t ubuntu-vim-2:18.04 -f Dockerfile .

参数-t指定构建的镜像的名称和标签。参数-f指定构建镜像的Dockerfile文件，如果Dockerfile文件在当前路径下可以省略不指定。

使用docker images查看打包后的镜像：

root# docker imagesREPOSITORY          TAG                 IMAGE ID            CREATED             SIZEubuntu-vim-2        18.04               2e2c1d07123c        3 seconds ago       192MBubuntu-vim-1        18.04               ef1ded0d8102        2 minutes ago       191MBubuntu              18.04               d131e0fa2585        13 days ago         102MB

ubuntu-vim-2:18.04为我们通过Dockerfile文件构建的镜像。

执行docker run -it ubuntu-vim-2:18.04 /bin/bash，进入容器后同样已经安装了vim命令。

创建自己的 Docker 基础镜像

上面介绍的都是在ubuntu:18.04这个镜像的基础上继续叠加创建的镜像。使用docker history可以查看镜像的历史操作记录：

root# docker history ubuntu-vim-2:18.04IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT2e2c1d07123c        24 minutes ago      /bin/sh -c apt install -y vim                   59.5MB              5955d39b6725        25 minutes ago      /bin/sh -c apt update && apt upgrade -y         30.4MB              d131e0fa2585        13 days ago         /bin/sh -c #(nop)  CMD ["/bin/bash"]            0B                  <missing>           13 days ago         /bin/sh -c mkdir -p /run/systemd && echo 'do…   7B                  <missing>           13 days ago         /bin/sh -c rm -rf /var/lib/apt/lists/*          0B                  <missing>           13 days ago         /bin/sh -c set -xe   && echo '#!/bin/sh' > /…   745B                <missing>           13 days ago         /bin/sh -c #(nop) ADD file:7ce84f13f11609a50…   102MB

可以看到我们在ubuntu:18.04镜像的基础上添加了第六层和第七层(从下往上数)，生成了自己的新的镜像ubuntu-vim-2:18.04。

如果我们想要从第一层就开始自己创建，可以使用scratch镜像。scratch是Docker保留镜像，镜像仓库中的任何镜像都不能使用这个名字，使用FROM scratch表明我们要构建镜像中的第一个文件层。

创建Dockerfile文件，编写以下内容：

1
2
3
FROM scratch
ADD hello /
CMD ["/hello"]

在Dockerfile文件路径下执行docker build -t hello:1.0 .构建镜像。执行docker images查看镜像：

root# docker imagesREPOSITORY          TAG                 IMAGE ID            CREATED             SIZEhello               1.0                 3aedfc6e1ff4        3 minutes ago       4.75kBubuntu-vim-2        18.04               2e2c1d07123c        18 minutes ago      192MBubuntu-vim-1        18.04               ef1ded0d8102        20 minutes ago      191MBubuntu              18.04               d131e0fa2585        13 days ago         102MB

可以看到hello:1.0镜像的大小只有4.75kB，这就是使用scratch创建镜像的一个好处，我们可以根据自己的需求来制定镜像，尽量减少镜像的大小。

执行docker history hello:1.0查看镜像的历史操作记录：

root# docker history hello:1.0IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT3aedfc6e1ff4        16 minutes ago      /bin/sh -c #(nop)  CMD ["/hello"]               0B                  15ad555d6f11        16 minutes ago      /bin/sh -c #(nop) ADD file:68f5ca1511528e4f6…   4.75kB

这就是一个基础的镜像，但是如果需要基础镜像发挥更多的作用，我们还需要其他的工作。Docker中的容器运行在操作系统中，共享了操作系统的内核。对于在Mac、Windows平台下，则是基于Linux虚拟机的内核。而Linux内核仅提供了进程管理、内存管理、文件系统管理等一些基础的管理模块。除此之外，我们还需要一些Linux下的管理工具，包括ls、cp、mv、tar以及应用程序运行依赖的一些包。因此我们就需要首先构建一个Minimal的操作系统镜像。

创建 Linux 镜像：alpine

目前比较流行的rootfs应该就是alpine了，因为他的体积特别小，最简单的环境只需要5M，下面是他的目录结构，下载地址在这里。

创建Dockerfile文件，编写以下内容：

1
2
3
FROM scratch
ADD alpine-minirootfs-3.9.3-x86_64.tar.gz /
CMD ["/bin/sh"]

在Dockerfile文件路径下执行docker build -t alpine:3.9 .构建镜像：

root# docker build -t alpine:3.9 .Sending build context to Docker daemon  31.32MBStep 1/3 : FROM scratch---> Step 2/3 : ADD alpine-minirootfs-3.9.3-x86_64.tar.gz /---> f305258a780dStep 3/3 : CMD ["/bin/sh"]---> Running in c22527cf1c54Removing intermediate container c22527cf1c54---> c9cb5e863866Successfully built c9cb5e863866Successfully tagged alpine:3.9

执行docker images查看镜像：

root# docker imagesREPOSITORY          TAG                 IMAGE ID            CREATED             SIZEalpine              3.9                 c9cb5e863866        40 minutes ago      5.53MBhello               1.0                 3aedfc6e1ff4        About an hour ago   4.75kBubuntu-vim-2        18.04               2e2c1d07123c        About an hour ago   192MBubuntu-vim-1        18.04               ef1ded0d8102        About an hour ago   191MBubuntu              18.04               d131e0fa2585        13 days ago         102MB

执行docker history alpine:3.9查看镜像的历史操作记录：

root# docker history alpine:3.9IMAGE               CREATED             CREATED BY                                      SIZE                COMMENTc9cb5e863866        About an hour ago   /bin/sh -c #(nop)  CMD ["/bin/sh"]              0Bf305258a780d        About an hour ago   /bin/sh -c #(nop) ADD file:32fa3bc24e9a2340c…   5.53MB

运行：

root# docker run -it alpine:3.9/ # lsbin    dev    etc    home   lib    media  mnt    opt    proc   root   run    sbin   srv    sys    tmp    usr    var
]]> <p><span></span></p> Dockerfile 常用指令 https://blog.wpz.homes/posts/6cc4d10b/ 2019-05-09T02:31:20.000Z 2026-09-20T09:12:05.372Z

记录下Dockerfile中常用的指令，完整列表和说明可参考官方文档。

Dockerfile

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
FROM scratch

MAINTAINER lz94wpz

WORKDIR /workspaces

COPY alpine-minirootfs-3.9.3-x86_64.tar.gz /
# COPY ["alpine-minirootfs-3.9.3-x86_64.tar.gz", "/"]

ADD alpine-minirootfs-3.9.3-x86_64.tar.gz /
# ADD ["alpine-minirootfs-3.9.3-x86_64.tar.gz", "/"]

ENV HELLO hello
ENV WORLD world

RUN ["/bin/sh", "-c", "echo $HELLO"]
RUN echo $WORLD

CMD ["/bin/sh", "-c", "/bin/echo $HELLO"]
# CMD echo $WORLD

# ENTRYPOINT ["/bin/sh", "-c", "/bin/echo $HELLO"]
# ENTRYPOINT echo $WORLD

EXPOSE 80

VOLUME /test
1
2
docker build -t IMAGE_NAME:TAG .  # 默认使用指定路径下的Dockerfile文件构建镜像，Dockerfile文件不存在时会报错
docker build -t IMAGE_NAME:TAG -f Dockerfile .  # 使用-f参数指定构建镜像的Dockerfile文件

FROM

指定基础镜像。

MAINTAINER

设置镜像作者信息。

WORKDIR

设置镜像的工作目录，默认为/根目录。

ENV

设置环境变量。可设置多个。

EXPOSE

指定容器中的进程会监听某个端口，Docker可以将该端口暴露出来。

VOLUME

将文件或目录声明为volume。

COPY && ADD

COPY和ADD都是用于将构建环境中指定的文件添加到镜像中的。不同的是如果指定的文件是归档文件(tar, zip, tgz, xz等)，ADD指令会将其解压，COPY指令不会。

COPY和ADD都支持两种形式的写法：

COPY src destCOPY ["src", "dest"]ADD src destADD ["src", "dest"]

RUN && CMD && ENTRYPOINT

RUN指定的命令在docker build构建镜像的时候执行。可以有多个RUN指令，且每个都生效。

CMD指定的命令在容器启动时执行。可以有多个CMD指令，但只有最后一个生效。CMD指定的命令会被docker run之后的参数替换。

ENTRYPOINT指定的命令在容器启动时执行。可以有多个ENTRYPOINT指令，但只有最后一个生效。CMD或docker run之后的参数会被当做参数传递给ENTRYPOINT。ENTRYPOINT命令一定会执行。

RUN、CMD和ENTRYPOINT都支持两种形式的写法：

Shell 格式

Shell 格式
1
<instruction> <command>

当指令执行时，Shell格式的写法底层会调用/bin/sh -c <command>。

如：

ENV WORLD worldENTRYPOINT echo "Hello $WORLD"

执行docker run <image>将输出：Hello world。

Exec 格式

Exec 格式
1
<instruction> ["executable", "param1", "param2", ...]

当指令执行时，Exec格式的写法会直接调用<command>，不会被shell解析。

如：

ENV WORLD worldENTRYPOINT ["/bin/echo", "Hello $WORLD"]

执行docker run <image>将输出：Hello $WORLD。

注意环境变量WORLD没有被替换。如果希望环境变量被替换，修改为：

ENV WORLD worldENTRYPOINT ["/bin/sh", "-c", "echo Hello $WORLD"]

参考链接

Dockerfile 常用指令 - 每天5分钟玩转 Docker 容器技术（16）

RUN vs CMD vs ENTRYPOINT - 每天5分钟玩转 Docker 容器技术（17）

]]> <p><span></span></p> 使用 nohup 和 & 让命令在后台执行 https://blog.wpz.homes/posts/8777e763/ 2019-04-23T03:32:34.000Z 2026-09-20T09:12:05.372Z

&

在终端执行命令，如果想让命令在后台执行，不占用终端窗口，可以在该命令后面加上&。&可以把这个命令转换为后台运行的任务进程：

1
command &

不过，虽然进程在后台运行了，但进程运行中输出的日志一样会打印到终端窗口上。如果不想终端窗口产生大量输出，我们可以将这些输出重定向到某个文件中：

1
command > out.file 2>&1 &

这样，所有的标准输出和错误输出都将被重定向到out.file文件中。

使用&将命令转换为后台运行的任务进程时有两点需要了解下：

1. 命令转换为后台任务进程执行时，会返回该进程的 ID。有了 ID 我们就能对该进程进行操作了，如：结束进程。
2. 一旦执行该命令的终端窗口关闭了，后台运行的任务进程也会随之停止。换句话说，执行该命令的终端窗口不能关闭，除非你不想让后台任务进程继续运行了。

nohup

在前面介绍&的使用时我们知道，一旦运行&命令的终端窗口关闭了，后台运行的任务进程也会随之停止。这显然不是我们想要的，这时nohup就派上用场了。nohup命令可以使终端窗口关闭后，后台任务进程继续运行。nohup是no hang up的缩写，意思是不挂起。常与&一同使用，该命令的一般形式为:

1
nohup command &

执行完上面命令后，会在当前目录下生成一个名为nohup.out的文件，后台进程的所有输出都被重定向到该文件下。如果当前目录下的nohup.out文件不可写(用户没有写权限)，则输出重定向到$HOME/nohup.out文件中，如果$HOME/nohup.out文件也不可写，则nohup命令会执行失败。

当然，我们也可以自定义输出重定向：

1
nohup command > out.file 2>&1 &

不是所有命令都适合在后台运行

不是所有命令都适合在后台运行，比如：需要用户交互的命令不要放在后台执行。因为程序在后台运行，用户并不知道需要输入，程序执行到需要用户交互的地方时就会一直傻等在那里。

]]> <p><span></span></p> Crontab 定时任务 https://blog.wpz.homes/posts/f189e9a9/ 2019-04-23T02:22:48.000Z 2026-09-20T09:12:05.370Z

crontab

crontab命令常见于Unix和类Unix的操作系统之中，用于设置周期性被执行的指令。该命令从标准输入设备读取指令，并将其存放于crontab文件中，以供之后读取和执行。该词来源于希腊语chronos(χρνο)，原意是时间。通常，crontab储存的指令被守护进程激活，crond常常在后台运行，每一分钟检查是否有预定的作业需要执行。这类作业一般称为cron jobs。

/etc 目录下的几个 cron 目录

/etc目录主要用来存放系统中的配置文件，基本上所有的配置文件都可以在这里找到。运行以下命令查看：

1
ls /etc/cron*

这个命令会列出/etc目录下所有以cron开头的文件和文件夹。可以看到主要有以下文件夹：

1
2
3
4
5
/etc/cron.hourly  # 这里存放了每小时需要运行的脚本
/etc/cron.daily  # 这里存放了每天需要运行的脚本
/etc/cron.weekly  # 这里存放了每个星期需要运行的脚本
/etc/cron.monthly  # 这里存放了每月需要运行的脚本
/etc/cron.d  # 如果既不是按小时，也不按天，周和月来运行，就放在这个文件夹

我们可以把我们需要定时运行的脚本放到对应的文件夹中，系统就会定时运行对应的脚本了。那么系统是怎么做到的呢？

除了上面几个文件夹外，在/etc目录下，还有一个crontab文件，该文件内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# /etc/crontab: system-wide crontab
# Unlike any other crontab you don't have to run the `crontab'
# command to install the new version when you edit this file
# and files in /etc/cron.d. These files also have username fields,
# that none of the other crontabs do.

SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

# m h dom mon dow usercommand
17 ** * *root    cd / && run-parts --report /etc/cron.hourly
25 6* * *roottest -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily )
47 6* * 7roottest -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.weekly )
52 61 * *roottest -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.monthly )
#

crontab文件是一个系统级别的配置文件，里面配置了什么时候去运行什么文件的规则。Linux会定期去扫描对应的文件夹，运行里面的脚本。这就完成了定时执行任务的功能。

cron服务

cron是一个linux下的定时执行工具，可以在无需人工干预的情况下运行作业。由于cron 是Linux的内置服务，但它不自动起来，可以用以下的方法启动、关闭这个服务：

1
2
3
4
service cron start  # 启动服务
service cron stop  # 关闭服务
service cron restart  # 重启服务
service cron reload  # 重新载入配置

cron命令每分钟会定期检查是否有要执行的工作，如果有要执行的工作便会自动执行该工作。而Linux任务调度的工作主要分为以下两类：

  • 系统执行的工作：系统周期性所要执行的工作，如备份系统数据、清理缓存；
  • 个人执行的工作：某个用户定期要做的工作，例如每天备份数据库等。

在/var/spool/cron/目录下是所有用户的crontab文件，你也可以去看看。上面说到的/etc下的配置都是属于系统级别的，那么个人级别的定时执行如何来做呢？这就需要说到下面的crontab命令了。

crontab命令

cron服务提供crontab命令来设定cron服务的，以下是这个命令的一些参数与说明：

1
2
3
4
crontab -u //设定某个用户的cron服务，一般root用户在执行这个命令的时候需要此参数
crontab -l //列出某个用户cron服务的详细内容
crontab -r //删除没个用户的cron服务
crontab -e //编辑某个用户的cron服务

如果不指定用户，就是当前系统的登陆用户。

当你输入命令：crontab -e时，就会出现一个文件，让你填写对应的定时规则，这个规则是什么？

定时规则

看这条规则：

1
25 6    * * *   root    test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily )

这就是一条规则，表示每天的6点25分执行对应的脚本。没有看明白，不要紧，容我慢慢道来。

以下是 crontab 文件的格式：

1
{minute} {hour} {day-of-month} {month} {day-of-week} {full-path-to-shell-script}
  • minute：区间为0–59；
  • hour：区间为0–23；
  • day-of-month：区间为0–31；
  • month：区间为1–12；1是1月，12是12月；
  • Day-of-week：区间为0–6；周日是0。

除了数字还有以下几个特殊的符号需要特殊说明：
*：代表所有的取值范围内的数字；
/：代表每的意思，”*/5″表示每5个单位；
-：代表从某个数字到某个数字；
,：分开几个离散的数字。

以下举几个例子说明问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
每五分钟执行    */5 * * * * /home/jelly/test.sh
每小时执行      0 * * * * /home/jelly/test.sh
每天执行        0 0 * * * /home/jelly/test.sh
每周执行        0 0 * * 0 /home/jelly/test.sh
每月执行        0 0 1 * * /home/jelly/test.sh
每年执行        0 0 1 1 * /home/jelly/test.sh

每天早上6点     0 6 * * * /home/jelly/test.sh
每两个小时      0 */2 * * * /home/jelly/test.sh

晚上11点到早上8点之间每两个小时
0 23-7/2 * * * /home/jelly/test.sh

1月1日早上4点
0 4 1 1 * /home/jelly/test.sh

我想这下你应该明白了，如果还没有明白，没问题，再来个实例，你就能明白了。

一个小Demo

先准备以下这么一段简短的脚本：

1
2
3
4
5
6
7
#!/bin/bash

var="http://www.jellythink.com"

echo $var

exit 0

保存为文件backupDemo.sh。
bash脚本不懂，没关系，看这里：

在终端输入以下命令：

1
crontab -e

在显示的文件末尾添加以下规则：

1
*/1 * * * * /home/jelly/MySource/Shell/backupDemo.sh >> /home/jelly/log.log

编辑完成，保存完成以后，就会显示以下提示信息：

1
crontab: installing new crontab

这就说明正在安装新的定时任务，如果没有这条提示信息，请重新运行crontab -e命令。

接下来就会看到在/home/jelly目录下会生成一个log.log文件，并写入了输入的信息。

没有问题，搞定了。

]]> <p><span></span></p>