NumPy 新知

import numpy as np

a = np.arange(5)
a

array([0, 1, 2, 3, 4])

增加一个维度：

b = a[:, None]
c = a[:,np.newaxis]

b is c

False

b, c

(array([[0],
        [1],
        [2],
        [3],
        [4]]), array([[0],
        [1],
        [2],
        [3],
        [4]]))

import numpy as np

a = [1, 2, 3, 4]     	#
b = np.array(a)         	# array([1, 2, 3, 4])
type(b)                   	# <type 'numpy.ndarray'>

numpy.ndarray

b.shape

(4,)

b.argmax()

3

b.max()

4

b.mean()

2.5

c = [[1, 2], [3, 4]]  	# 二维列表
d = np.array(c)         	# 二维numpy数组

d.shape

(2, 2)

d.size

4

d.max(axis=0)            	# 找维度0，也就是最后一个维度上的最大值，array([3, 4])

array([3, 4])

d.max(axis=1)        	# 找维度1，也就是倒数第二个维度上的最大值，array([2, 4])

array([2, 4])

d.mean(axis=0)          	# 找维度0，也就是第一个维度上的均值，array([ 2.,  3.])

array([2., 3.])

d.flatten()              	# 展开一个numpy数组为1维数组，array([1, 2, 3, 4])

array([1, 2, 3, 4])

np.ravel(c)               # 展开一个可以解析的结构为 1 维数组，array([1, 2, 3, 4])

array([1, 2, 3, 4])

# 3x3的浮点型2维数组，并且初始化所有元素值为1
e = np.ones((3, 3), dtype=np.float)
print(e)
# 创建一个一维数组，元素值是把3重复4次，array([3, 3, 3, 3])
f = np.repeat(3, 4)
print(f)
# 2x2x3的无符号8位整型3维数组，并且初始化所有元素值为0
g = np.zeros((2, 2, 3), dtype=np.uint8)
print(g.shape)                    # (2, 2, 3)

[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
[3 3 3 3]
(2, 2, 3)

h = g.astype(np.float)  # 用另一种类型表示

l = np.arange(10)      	# 类似 range，array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
m = np.linspace(0, 6, 5)# 等差数列，0 到 6之间5个取值，array([ 0., 1.5, 3., 4.5, 6.])

p = np.array(
    [[1, 2, 3, 4],
     [5, 6, 7, 8]]
)

np.save('p.npy', p)     # 保存到文件
q = np.load('p.npy')    # 从文件读取

a = np.arange(24).reshape((2, 3, 4))
b = a[1][1][1]
b

17

b1 = a[1, 1, 1]
b1

17

用 : 表示当前维度上所有下标

c = a[:, 2, :]
c

array([[ 8,  9, 10, 11],
       [20, 21, 22, 23]])

d = a[:, :, 1]
d

array([[ 1,  5,  9],
       [13, 17, 21]])

用 ... 表示没有明确指出的维度

e = a[..., 1]
e

array([[ 1,  5,  9],
       [13, 17, 21]])

f = a[:, 1:, 1:-1]
f

array([[[ 5,  6],
        [ 9, 10]],

       [[17, 18],
        [21, 22]]])

平均分成3份

g = np.split(np.arange(9), 3)
g

[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]

按照下标位置进行划分

h = np.split(np.arange(9), [2, -3])
h

[array([0, 1]), array([2, 3, 4, 5]), array([6, 7, 8])]

1. vstack 是指沿着纵轴拼接两个 array，vertical
2. hstack是指沿着横轴拼接两个 array，horizontal
3. 更广义的拼接用 concatenate 实现，horizontal 后的两句依次等效于 vstack 和 hstack
4. stack 不是拼接而是在输入 array 的基础上增加一个新的维度

l0 = np.arange(6).reshape((2, 3))
l1 = np.arange(6, 12).reshape((2, 3))

m = np.vstack((l0, l1))
m

array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])

p = np.hstack((l0, l1))
p

array([[ 0,  1,  2,  6,  7,  8],
       [ 3,  4,  5,  9, 10, 11]])

q = np.concatenate((l0, l1))
q

array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])

r = np.concatenate((l0, l1), axis=-1)
r

array([[ 0,  1,  2,  6,  7,  8],
       [ 3,  4,  5,  9, 10, 11]])

s = np.stack((l0, l1))
s

array([[[ 0,  1,  2],
        [ 3,  4,  5]],

       [[ 6,  7,  8],
        [ 9, 10, 11]]])

按指定轴进行转置

t = s.transpose((2, 0, 1))
t

array([[[ 0,  3],
        [ 6,  9]],

       [[ 1,  4],
        [ 7, 10]],

       [[ 2,  5],
        [ 8, 11]]])

默认转置将维度倒序，对于 2 维就是横纵轴互换

u = a[0].transpose()	# 或者u=a[0].T也是获得转置
u

array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])

逆时针旋转90度，第二个参数是旋转次数

v = np.rot90(u, 3)
v

array([[ 3,  2,  1,  0],
       [ 7,  6,  5,  4],
       [11, 10,  9,  8]])

沿纵轴左右翻转

w = np.fliplr(u)
w

array([[ 8,  4,  0],
       [ 9,  5,  1],
       [10,  6,  2],
       [11,  7,  3]])

沿水平轴上下翻转

x = np.flipud(u)
x

array([[ 3,  7, 11],
       [ 2,  6, 10],
       [ 1,  5,  9],
       [ 0,  4,  8]])

按照一维顺序滚动位移

y = np.roll(u, 1)
y

array([[11,  0,  4],
       [ 8,  1,  5],
       [ 9,  2,  6],
       [10,  3,  7]])

按照指定轴滚动位移

z = np.roll(u, 1, axis=1)
z

array([[ 8,  0,  4],
       [ 9,  1,  5],
       [10,  2,  6],
       [11,  3,  7]])

import numpy as np

# 绝对值，1
a = np.abs(-1)

# sin函数，1.0
b = np.sin(np.pi/2)

# tanh逆函数，0.50000107157840523
c = np.arctanh(0.462118)

# e为底的指数函数，20.085536923187668
d = np.exp(3)

# 2的3次方，8
f = np.power(2, 3)

# 点积，1*3+2*4=11
g = np.dot([1, 2], [3, 4])

# 开方，5
h = np.sqrt(25)

# 求和，10
l = np.sum([1, 2, 3, 4])

# 平均值，5.5
m = np.mean([4, 5, 6, 7])

# 标准差，0.96824583655185426
p = np.std([1, 2, 3, 2, 1, 3, 2, 0])

广播

import numpy as np

a = np.array([
    [1, 2, 3],
    [4, 5, 6]
])

b = np.array([
    [1, 2, 3],
    [1, 2, 3]
])

'''
维度一样的array，对位计算
array([[2, 4, 6],
       [5, 7, 9]])
'''
a + b

'''
array([[0, 0, 0],
       [3, 3, 3]])
'''
a - b

'''
array([[ 1,  4,  9],
       [ 4, 10, 18]])
'''
a * b

'''
array([[1, 1, 1],
       [4, 2, 2]])
'''
a / b

'''
array([[ 1,  4,  9],
       [16, 25, 36]])
'''
a ** 2

'''
array([[  1,   4,  27],
       [  4,  25, 216]])
'''
a ** b

c = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
    [10, 11, 12]
])
d = np.array([2, 2, 2])

'''
广播机制让计算的表达式保持简洁
d和c的每一行分别进行运算
array([[ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11],
       [12, 13, 14]])
'''
c + d

'''
array([[ 2,  4,  6],
       [ 8, 10, 12],
       [14, 16, 18],
       [20, 22, 24]])
'''
c * d

'''
1和c的每个元素分别进行运算
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])
'''
c - 1

array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])

线性代数模块（linalg）

import numpy as np

a = np.array([3, 4])
np.linalg.norm(a)

5.0

b = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])
c = np.array([1, 0, 1])

# 矩阵和向量之间的乘法
np.dot(b, c)            		# array([ 4, 10, 16])
np.dot(c, b.T)          		# array([ 4, 10, 16])

array([ 4, 10, 16])

np.trace(b)             		# 求矩阵的迹，15

15

np.linalg.det(b)        		# 求矩阵的行列式值，0

0.0

np.linalg.matrix_rank(b)	# 求矩阵的秩，2，不满秩，因为行与行之间等差

2

d = np.array([
    [2, 1],
    [1, 2]
])

'''
对正定矩阵求本征值和本征向量
本征值为u，array([ 3.,  1.])
本征向量构成的二维array为v，
array([[ 0.70710678, -0.70710678],
       [ 0.70710678,  0.70710678]])
是沿着45°方向
eig()是一般情况的本征值分解，对于更常见的对称实数矩阵，
eigh()更快且更稳定，不过输出的值的顺序和eig()是相反的
'''

u, v = np.linalg.eig(d)

print('矩阵 d 的特征值为： \n{}; \n\n特征向量为： \n{}.'.format(str(u), str(v)))

矩阵 d 的特征值为：
[3. 1.]; 

特征向量为：
[[ 0.70710678 -0.70710678]
 [ 0.70710678  0.70710678]].

# Cholesky 分解并重建
l = np.linalg.cholesky(d)
l

array([[1.41421356, 0.        ],
       [0.70710678, 1.22474487]])

np.dot(l, l.T)

array([[2., 1.],
       [1., 2.]])

e = np.array([
    [1, 2],
    [3, 4]
])

# 对不正定矩阵，进行 SVD 分解并重建
U, s, V = np.linalg.svd(e)

S = np.array([
    [s[0], 0],
    [0, s[1]]
])

np.dot(U, np.dot(S, V))

array([[1., 2.],
       [3., 4.]])

随机模块（random）

随机模块包含了随机数产生和统计分布相关的基本函数，Python 本身也有随机模块 mmrandom，不过功能更丰富，还是来看例子：

import numpy as np
import numpy.random as random

# 设置随机数种子
random.seed(42)

# 产生一个1x3，[0,1)之间的浮点型随机数
random.rand(1, 3)

array([[0.37454012, 0.95071431, 0.73199394]])

# 产生一个[0,1)之间的浮点型随机数
random.random()

0.5986584841970366

# 下边4个没有区别，都是按照指定大小产生[0,1)之间的浮点型随机数array，不 Pythonic…
random.random((3, 3))
random.sample((3, 3))
random.random_sample((3, 3))
random.ranf((3, 3))

array([[0.17052412, 0.06505159, 0.94888554],
       [0.96563203, 0.80839735, 0.30461377],
       [0.09767211, 0.68423303, 0.44015249]])

# 产生 10 个 [1,6) 之间的浮点型随机数
5 * random.random(10) + 1

array([1.59797123, 4.56622394, 4.80392524, 3.80638599, 4.8548359 ,
       3.46897798, 3.61366415, 3.13770509, 1.12709563, 1.53945713])

random.uniform(1, 6, 10)

array([1.15714593, 4.18205206, 2.57177991, 3.54285346, 5.53783237,
       2.24646115, 3.05191462, 4.77775569, 2.14399083, 1.38489955])

# 产生10个[1,6)之间的整型随机数
random.randint(1, 6, 10)

array([3, 3, 4, 2, 2, 5, 1, 5, 4, 4])

# 产生2x5的标准正态分布样本
random.normal(size=(5, 2))

array([[-0.41476463, -1.39874088],
       [-0.34408054,  0.75078589],
       [-0.32762518, -0.86159805],
       [-0.2581848 ,  0.46095562],
       [-1.34938997, -1.01907279]])

# 产生5个，n=5，p=0.5的二项分布样本
random.binomial(n=5, p=0.5, size=5)

array([1, 3, 2, 3, 2])

a = np.arange(10)

# 从a中有回放的随机采样7个
random.choice(a, 7)

array([7, 5, 7, 8, 3, 0, 0])

# 从a中无回放的随机采样7个
random.choice(a, 7, replace=False)

array([6, 4, 7, 0, 2, 1, 5])

# 对a进行乱序并返回一个新的array
b = random.permutation(a)
b

array([7, 1, 4, 0, 9, 2, 8, 3, 6, 5])

# 对 a 进行 in-place 乱序
random.shuffle(a)
a

array([3, 2, 9, 6, 0, 7, 1, 5, 4, 8])

# 生成一个长度为 9 的随机bytes序列并作为 str 返回
random.bytes(9)

b'\xddO\x99\xe0)\xed\x1e\xb2b'

随机模块可以很方便地让我们做一些快速模拟去验证一些结论。比如来考虑一个非常违反直觉的概率题例子：一个选手去参加一个 TV 秀，有三扇门，其中一扇门后有奖品，这扇门只有主持人知道。选手先随机选一扇门，但并不打开，主持人看到后，会打开其余两扇门中没有奖品的一扇门。然后，主持人问选手，是否要改变一开始的选择？

这个问题的答案是应该改变一开始的选择。在第一次选择的时候，选错的概率是\(\frac{2}{3}\)，选对的概率是 \(\frac{1}{3}\)。第一次选择之后，主持人相当于帮忙剔除了一个错误答案，所以如果一开始选的是错的，这时候换掉就选对了；而如果一开始就选对，则这时候换掉就错了。根据以上，一开始选错的概率就是换掉之后选对的概率 \(\frac{2}{3}\)，这个概率大于一开始就选对的概率 \(\frac{1}{3}\)，所以应该换。虽然道理上是这样，但是还是有些绕，要是通过推理就是搞不明白怎么办，没关系，用随机模拟就可以轻松得到答案：

import numpy.random as random

random.seed(42)

# 做10000次实验
n_tests = 10000

# 生成每次实验的奖品所在的门的编号
# 0表示第一扇门，1表示第二扇门，2表示第三扇门
winning_doors = random.randint(0, 3, n_tests)

# 记录如果换门的中奖次数
change_mind_wins = 0

# 记录如果坚持的中奖次数
insist_wins = 0

# winning_door就是获胜门的编号
for winning_door in winning_doors:

    # 随机挑了一扇门
    first_try = random.randint(0, 3)

    # 其他门的编号
    remaining_choices = [i for i in range(3) if i != first_try]

    # 没有奖品的门的编号，这个信息只有主持人知道
    wrong_choices = [i for i in range(3) if i != winning_door]

    # 一开始选择的门主持人没法打开，所以从主持人可以打开的门中剔除
    if first_try in wrong_choices:
        wrong_choices.remove(first_try)

    # 这时wrong_choices变量就是主持人可以打开的门的编号
    # 注意此时如果一开始选择正确，则可以打开的门是两扇，主持人随便开一扇门
    # 如果一开始选到了空门，则主持人只能打开剩下一扇空门
    screened_out = random.choice(wrong_choices)
    remaining_choices.remove(screened_out)

    # 所以虽然代码写了好些行，如果策略固定的话，
    # 改变主意的获胜概率就是一开始选错的概率，是2/3
    # 而坚持选择的获胜概率就是一开始就选对的概率，是1/3

    # 现在除了一开始选择的编号，和主持人帮助剔除的错误编号，只剩下一扇门
    # 如果要改变注意则这扇门就是最终的选择
    changed_mind_try = remaining_choices[0]

    # 结果揭晓，记录下来
    change_mind_wins += 1 if changed_mind_try == winning_door else 0
    insist_wins += 1 if first_try == winning_door else 0

# 输出10000次测试的最终结果，和推导的结果差不多：
# You win 6616 out of 10000 tests if you changed your mind
# You win 3384 out of 10000 tests if you insist on the initial choice
print(
    'You win {1} out of {0} tests if you changed your mind\n'
    'You win {2} out of {0} tests if you insist on the initial choice'.format(
        n_tests, change_mind_wins, insist_wins
        )
)

You win 6616 out of 10000 tests if you changed your mind
You win 3384 out of 10000 tests if you insist on the initial choice