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()

b.max()

b.mean()

2.5

c = [[1, 2], [3, 4]]  	# 二维列表

d = np.array(c)         	# 二维numpy数组

d.shape

(2, 2)

d.size

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

b1 = a[1, 1, 1]

b1

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

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])]

vstack 是指沿着纵轴拼接两个 array，vertical
hstack是指沿着横轴拼接两个 array，horizontal
更广义的拼接用 concatenate 实现，horizontal 后的两句依次等效于 vstack 和 hstack
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

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

0.0

np.linalg.matrix_rank(b)	# 求矩阵的秩，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

巴特西

NumPy 新知

增加一个维度：

广播

线性代数模块（linalg）

随机模块（random）

最新文章

热门文章