numpy 基本操作
NumPy库入门
ndarray对象
- 生成一个ndarray数组
In [1]: import numpy as np
In [2]: a = np.array([[0,1,2,3,4],
...: [9,8,7,6,5]])
...:
In [3]: a
Out[3]:
array([[0, 1, 2, 3, 4],
[9, 8, 7, 6, 5]])
In [4]: print(a)
[[0 1 2 3 4]
[9 8 7 6 5]]
- ndarray对象的属性
| 属性 | 说明 |
|---|---|
| .ndim | 维度的数量 |
| .shape | ndarray对象的尺寸，对于矩阵，n行m列 |
| .size | ndarray对象元素的个数 |
| .dtype | ndarray对象元素类型 |
| .itemsize | ndarray对象中每个元素的大小，以字节为单位 |
In [5]: a.ndim
Out[5]: 2
In [6]: a.shape
Out[6]: (2, 5)
In [7]: a.dtype
Out[7]: dtype('int32')
In [8]: a.itemsize
Out[8]: 4
- 非同质的ndarray对象
非同质的ndarray对象的类型为Object
In [9]: x = np.array([[0,1,2,3,4],
...: [9,8,7,6] ])
...:
In [10]: x.shape
Out[10]: (2,)
In [11]: x.dtype
Out[11]: dtype('O')
In [12]: x
Out[12]: array([list([0, 1, 2, 3, 4]), list([9, 8, 7, 6])], dtype=object)
In [13]: x.itemsize
Out[13]: 8
In [14]: x.size
Out[14]: 2
ndarray数组的创建方法
(1)从Pyhton中的列表、元组等类型
x = np.array(list/tuple)
x = np.array(list/typle, dtype=np.float32)
当np.array()不指定dtype时，numpy将根据数据情况关联一个dtype类型。
In [15]: x = np.array([0,1,2,3]) # 从列表类型创建
In [16]: print(x)
[0 1 2 3]
In [17]: x = np.array((4,5,6,7)) # 从元组类型创建
In [18]: print(x)
[4 5 6 7]
In [19]: x = np.array([[1,2],[9,8],(0.1, 0.2)]) # 从列表和元组混合类型创建
In [20]: print(x)
[[ 1. 2. ]
[ 9. 8. ]
[ 0.1 0.2]]
(2)使用numpy中函数创建ndarray数组
| 函数 | 说明 |
|---|---|
| np.arange(n) | 类似range()函数，返回ndarray类型，元素从0到n-1 |
| np.ones(shape) | 根据shape生成一个全1数组，shape是元组类型 |
| np.zeros(shape) | 根据shape生成一个全0数组，shape是元组类型 |
| np.full(shape, val) | 根据shape生成一个数组，每个元素值都是val |
| np.eye(n) | 创建一个正方形的n*n单位矩阵，对角线为1，其余为0 |
| np.ones_like(a) | 根据数组a的形状生成一个全1数组 |
| np.zeros_like(a) | 根据数组a的形状生成一个全0数组 |
| np.full_like(a, val) | 根据数组a形状生成一个数组，每个元素值都是val |
| np.linspace() | 根据起止数据等间距地填充数据，形成数组 |
| np.concatenate() | 将两个或多个数组合并成一个新的数组 |
In [21]: np.arange(10)
Out[21]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [22]: np.ones((3,6))
Out[22]:
array([[ 1., 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1., 1.]])
In [23]: np.zeros((3,6),dtype=np.int32)
Out[23]:
array([[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0]])
In [24]: np.eye(5)
Out[24]:
array([[ 1., 0., 0., 0., 0.],
[ 0., 1., 0., 0., 0.],
[ 0., 0., 1., 0., 0.],
[ 0., 0., 0., 1., 0.],
[ 0., 0., 0., 0., 1.]])
In [25]: x = np.ones((2,3,4))
In [26]: print(x)
[[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]
[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]]
In [27]: x.shape
Out[27]: (2, 3, 4)
In [28]: a = np.linspace(1, 10, 4)
In [29]: a
Out[29]: array([ 1., 4., 7., 10.])
In [30]: b = np.linspace(1, 10, 4, endpoint=False)
In [31]: b
Out[31]: array([ 1. , 3.25, 5.5 , 7.75])
In [32]: c = np.concatenate((a,b))
In [33]: c
Out[33]: array([ 1. , 4. , 7. , 10. , 1. , 3.25, 5.5 , 7.75])
(3)从字节流（raw bytes）中创建ndarray数组
(4)从文件中读取特定格式，创建ndarray数组
ndarray数组的变换
- ndarray数组的维度变换
方法 说明 .reshape(shape) 不改变数组元素，返回一个shape形状的数组，原数组不变 .resize(shape) 与.reshape()功能一致，但原数组改变 .swapaxes(ax1, ax2) 将数组n个维度中两个维度进行调换 .flatten() 对数组进行降维，返回折叠后的一维数组，原数组不变
In [34]: a = np.ones((2,3,4), dtype=np.int32)
In [35]: a.reshape((3,8))
Out[35]:
array([[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1]])
In [36]: a
Out[36]:
array([[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]],
[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]]])
In [37]: a.resize((3,8))
In [38]: a
Out[38]:
array([[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1]])
In [39]: a = np.ones((2,3,4), dtype=np.int32)
In [40]: a.flatten()
Out[40]:
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
In [41]: a
Out[41]:
array([[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]],
[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]]])
In [42]: b = a.flatten()
In [43]: b
Out[43]:
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
- ndarray数组的类型变换
new_a = a.astype(new_type)
astype()方法一定会创建新的数组（原始数据的一个拷贝），即使两个类型一致。
In [44]: a = np.ones((2,3,4), dtype=np.int)
In [45]: a
Out[45]:
array([[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]],
[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]]])
In [46]: b = a.astype(np.float)
In [47]: b
Out[47]:
array([[[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.]],
[[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.]]])
- ndarray数组向列表的转换
ls = a.tolist()
In [48]: a = np.full((2,3,4), 25, dtype=np.int32)
In [49]: a
Out[49]:
array([[[25, 25, 25, 25],
[25, 25, 25, 25],
[25, 25, 25, 25]],
[[25, 25, 25, 25],
[25, 25, 25, 25],
[25, 25, 25, 25]]])
In [50]: a.tolist()
Out[50]:
[[[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]],
[[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]]]
ndarray数组的操作
- 一维数组的索引和切片
与python的列表相似
In [51]: a = np.array([9,8,7,6,5])
In [52]: a[2]
Out[52]: 7
In [53]: a[1:4:2] # 起始编号 : 终止编号（不含） : 步长（3元素冒号分割），编号0开始从左递增，或-1开始从右递减
Out[53]: array([8, 6])
- 多维数组的索引
In [54]: a = np.arange(24).reshape((2,3,4))
In [55]: a
Out[55]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
In [56]: a[1,2,3] # 每个维度一个索引值，逗号分割
Out[56]: 23
In [57]: a[0,1,2]
Out[57]: 6
In [58]: a[-1,-2,-3]
Out[58]: 17
- 多维数组的切片
In [59]: a[: , 1, -3] # 选取一个维度用
Out[59]: array([ 5, 17])
In [60]: a[: , 1:3, :] # 每个维度切片方法与一维数组相同
Out[60]:
array([[[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[16, 17, 18, 19],
[20, 21, 22, 23]]])
In [61]: a[: , :, ::2] # 每个维度可以使用步长跳跃切片
Out[61]:
array([[[ 0, 2],
[ 4, 6],
[ 8, 10]],
[[12, 14],
[16, 18],
[20, 22]]])
ndarray数组的运算
- numpy一元函数
对ndarray中的数据执行元素级运算的函数
| 函数 | 说明 |
|---|---|
| np.abs(x), np.fabs(x) | 计算数组各元素的绝对值 |
| np.sqrt(x) | 计算数组各元素的平方根 |
| np.square(x) | 计算数组各元素的平方 |
| np.log(x), np.log10(x), np.log2(x) | 计算数组各元素的自然对数、10底对数和2底对数 |
| np.ceil(x), np.floor(x) | 计算数组各元素的ceiling值或floor值 |
| np.rint(x) | 计算数组各元素的四舍五入值 |
| np.modf(x) | 将数组各元素的小数和整数部分以两个独立数组形式返回 |
| np.cos(x), np.cosh(x),np.sin(x), np.sinh(x),np.tan(x), np.tanh(x) | 计算数组各元素的普通型和双曲型三角函数 |
| np.exp(x) | 计算数组各元素的指数值 |
| np.sign(x) | 计算数组各元素的符号值，1(+),0,-1(-) |
In [65]: a = np.arange(24).reshape((2,3,4))
In [66]: np.square(a)
Out[66]:
array([[[ 0, 1, 4, 9],
[ 16, 25, 36, 49],
[ 64, 81, 100, 121]],
[[144, 169, 196, 225],
[256, 289, 324, 361],
[400, 441, 484, 529]]], dtype=int32)
In [67]: a = np.sqrt(a)
In [68]: a
Out[68]:
array([[[ 0. , 1. , 1.41421356, 1.73205081],
[ 2. , 2.23606798, 2.44948974, 2.64575131],
[ 2.82842712, 3. , 3.16227766, 3.31662479]],
[[ 3.46410162, 3.60555128, 3.74165739, 3.87298335],
[ 4. , 4.12310563, 4.24264069, 4.35889894],
[ 4.47213595, 4.58257569, 4.69041576, 4.79583152]]])
In [69]: np.modf(a)
Out[69]:
(array([[[ 0. , 0. , 0.41421356, 0.73205081],
[ 0. , 0.23606798, 0.44948974, 0.64575131],
[ 0.82842712, 0. , 0.16227766, 0.31662479]],
[[ 0.46410162, 0.60555128, 0.74165739, 0.87298335],
[ 0. , 0.12310563, 0.24264069, 0.35889894],
[ 0.47213595, 0.58257569, 0.69041576, 0.79583152]]]),
array([[[ 0., 1., 1., 1.],
[ 2., 2., 2., 2.],
[ 2., 3., 3., 3.]],
[[ 3., 3., 3., 3.],
[ 4., 4., 4., 4.],
[ 4., 4., 4., 4.]]]))
- numpy二元函数
| 函数 | 说明 |
|---|---|
| + - * / ** | 两个数组各元素对应运算 |
| np.maximum(x,y), np.fmax(), np.minimum(x,y), np.fmin() | 元素级的最大值/最小值计算 |
| np.mod(x,y) | 元素级的模运算 |
| np.copysign(x,y) | 将数组y中各元素值的符号赋值给数组x对应元素 |
| > < >= <= == != | 算术比较，产生布尔型数组 |
In [70]: a = np.arange(24).reshape((2,3,4))
In [71]: b = np.sqrt(a)
In [72]: a
Out[72]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
In [73]: b
Out[73]:
array([[[ 0. , 1. , 1.41421356, 1.73205081],
[ 2. , 2.23606798, 2.44948974, 2.64575131],
[ 2.82842712, 3. , 3.16227766, 3.31662479]],
[[ 3.46410162, 3.60555128, 3.74165739, 3.87298335],
[ 4. , 4.12310563, 4.24264069, 4.35889894],
[ 4.47213595, 4.58257569, 4.69041576, 4.79583152]]])
In [74]: np.maximum(a,b)
Out[74]:
array([[[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]],
[[ 12., 13., 14., 15.],
[ 16., 17., 18., 19.],
[ 20., 21., 22., 23.]]])
In [75]: a > b
Out[75]:
array([[[False, False, True, True],
[ True, True, True, True],
[ True, True, True, True]],
[[ True, True, True, True],
[ True, True, True, True],
[ True, True, True, True]]], dtype=bool)
numpy数据存取与函数
数据的csv文件存取
np.savetxt(frame,array,fmt='%.18e',delimiter=None)
- frame：文件、字符串或产生器，可以是.gz或.bz2的压缩文件。
- array：存入文件的数组。
- fmt：写入文件的格式，例如：%d %.2f %.18e。
- delimiter：分割字符串，默认是任何空格。
In [1]: import numpy as np
In [2]: a = np.arange(100).reshape(5,20)
In [3]: np.savetxt('a.csv', a, fmt='%d', delimiter=',')
In [4]: np.savetxt('a1.csv', a, fmt='%.1f', delimiter=',')
np.loadtxt(frame,dtype=np.float,delimiter=None,unpack=False)
- frame：文件、字符串或产生器，可以是.gz或.bz2的压缩文件。
- dtype：数据类型，可选。
- delimiter：分割字符串，默认是任何空格。
- unpack:如果True，读入属性将分别写入不同变量。
In [5]: b = np.loadtxt('a1.csv', delimiter=',')
In [6]: b
Out[6]:
array([[ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.,
11., 12., 13., 14., 15., 16., 17., 18., 19.],
[ 20., 21., 22., 23., 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.]])
In [7]: b = np.loadtxt('a1.csv', dtype=np.int, delimiter=',')
In [8]: b
Out[8]:
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19],
[20, 21, 22, 23, 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]])
- csv文件的局限性：
CSV只能有效存储一维和二维数组。np.savetxt()、np.loadtxt()只能有效存取一维和二维数组。
多维数据的存取
a.tofile(frame, sep='', format='%s')
- frame：文件、字符串。
- sep：数据分割字符串，如果是空串，写入文件为二进制。
- format：写入数据的格式。
In [9]: a = np.arange(100).reshape(5,10,2)
In [10]: a.tofile('b.dat', sep=',', format='%d')
In [11]: a.tofile('b1.dat', format='%d')
np.fromfile(frame, dtype=float, count=-1, sep='')
- frame：文件、字符串。
- dtype：读取的数据类型。
- count：读取元素个数，-1表示读入整个文件。
- sep：数据分割字符串，如果是空串，写入文件为二进制。
In [9]: c = np.fromfile('b.dat', dtype=np.int, sep=',')
In [10]: c
Out[10]:
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 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])
In [11]: c = np.fromfile('b.dat', dtype=np.int, sep=',').reshape(5,10,2)
- 需要注意：
该方法需要读取时知道存入文件时数组的维度和元素类型。a.tofile()和np.fromfile()需要配合使用。可以通过元素据文件来存储额外信息。也可以通过文件名来保存数组维度和元素类型（例：b1_int_5_10_2.dat）
numpy的便捷文件存取
np.save(frame, array) 或 np.savez(fname, array)
np.load(frame)
- fname：文件名，以.npy为扩展名，压缩扩展名为.npz
- array：数组变量
numpy 的随机数函数
numpy的random子库
基本格式：np.random.*
np.random.rand()、np.random.randn()…
| 函数 | 说明 |
|---|---|
| rand(d0,…dn) | 根据d0 - dn 创建随机数组，浮点数，[0,1)，均匀分布 |
| randn(d0,…dn) | 根据d0 - dn创建随机数组，标准正态分布 |
| randint(low,hign,shape) | 根据shape创建随机整数或整数数组，范围是[low,high] |
| seed(s) | 随机数种子，s是给定的种子值 |
In [18]: a = np.random.rand(3,4,5)
In [19]: a
Out[19]:
array([[[ 0.97845512, 0.90466706, 0.92576248, 0.77775142, 0.84334893],
[ 0.39599821, 0.31917683, 0.7961439 , 0.01324569, 0.97660396],
[ 0.5049603 , 0.80952265, 0.67359257, 0.89334316, 0.94496225],
[ 0.04840473, 0.04665257, 0.20956817, 0.62255095, 0.36600489]],
[[ 0.58059326, 0.28464266, 0.23596248, 0.16677631, 0.86467069],
[ 0.14691968, 0.60863245, 0.71725038, 0.69206766, 0.18301705],
[ 0.73197901, 0.99051723, 0.10489076, 0.33979432, 0.0354286 ],
[ 0.73696453, 0.48268632, 0.99294233, 0.06285961, 0.93090147]],
[[ 0.07853777, 0.827061 , 0.66325364, 0.52289669, 0.96894828],
[ 0.41912388, 0.01883408, 0.80978245, 0.93082898, 0.98095581],
[ 0.58614214, 0.55996867, 0.37734444, 0.79280598, 0.03626233],
[ 0.233132 , 0.22514788, 0.32245147, 0.13739658, 0.18866422]]])
In [20]: sn = np.random.randn(3,4,5)
In [21]: sn
Out[21]:
array([[[-0.54821321, 0.35733947, 0.74102173, -1.26679716, -0.75072289],
[ 0.13182283, 2.32578442, -0.52208189, 2.5041796 , -0.96995644],
[ 1.00171095, 0.97037733, 1.55386206, -0.94515087, 0.75707273],
[-1.2481768 , 0.53095038, 0.92527818, -0.17261088, -0.13667463]],
[[ 2.18760173, -0.93813162, 0.19032109, -1.59605908, -0.96802666],
[ 0.30649913, 1.32375007, 0.72547761, -1.59253182, -0.72385311],
[-2.22923637, -1.05462649, 1.82672301, 0.47343961, -0.9786459 ],
[-0.36857965, 0.59003624, 1.80140997, 1.00965744, 1.9037593 ]],
[[ 0.36273071, -0.0447364 , 1.27120325, 0.21076423, -0.40820945],
[-1.22315321, -1.94670543, 0.17959233, -1.1020581 , 0.17423733],
[-1.16368644, 0.00589158, 1.19701291, -0.4255035 , -0.7508364 ],
[-1.61788168, 0.50386607, 0.15993032, 0.36881486, -0.41457221]]])
In [22]: b = np.random.randint(100,200,(3,4))
In [23]: b
Out[23]:
array([[163, 171, 163, 168],
[166, 127, 160, 109],
[135, 111, 196, 190]])
In [24]: np.random.seed(10)
In [25]: np.random.randint(100,200,(3,4))
Out[25]:
array([[109, 115, 164, 128],
[189, 193, 129, 108],
[173, 100, 140, 136]])
In [26]: np.random.seed(10)
In [27]: np.random.randint(100,200,(3,4))
Out[27]:
array([[109, 115, 164, 128],
[189, 193, 129, 108],
[173, 100, 140, 136]])
| 函数 | 说明 |
|---|---|
| shuffle(a) | 根据数组a的第1轴进行随机排列，改变数组x |
| permutation(a) | 根据数组a的第1轴产生一个新的乱序数组，不改变数组x |
| choice(a,size,replace,p) | 从一维数组a中以概率p抽取元素，形成size形状新数组 |
| replace表示是否可以重用元素，默认为False |
In [28]: a = np.random.randint(100,200,(3,4))
In [29]: a
Out[29]:
array([[116, 111, 154, 188],
[162, 133, 172, 178],
[149, 151, 154, 177]])
In [30]: np.random.shuffle(a)
In [31]: a
Out[31]:
array([[116, 111, 154, 188],
[149, 151, 154, 177],
[162, 133, 172, 178]])
In [32]: np.random.shuffle(a)
In [33]: a
Out[33]:
array([[162, 133, 172, 178],
[116, 111, 154, 188],
[149, 151, 154, 177]])
In [34]: a = np.random.randint(100,200,(3,4))
In [35]: a
Out[35]:
array([[113, 192, 186, 130],
[130, 189, 112, 165],
[131, 157, 136, 127]])
In [36]: np.random.permutation(a)
Out[36]:
array([[113, 192, 186, 130],
[130, 189, 112, 165],
[131, 157, 136, 127]])
In [37]: a
Out[37]:
array([[113, 192, 186, 130],
[130, 189, 112, 165],
[131, 157, 136, 127]])
In [38]: b = np.random.randint(100,200,(8,))
In [39]: b
Out[39]: array([177, 122, 123, 194, 111, 128, 174, 188])
In [40]: np.random.choice(b,(3,2))
Out[40]:
array([[122, 188],
[123, 177],
[174, 188]])
In [41]: np.random.choice(b,(3,2),replace=False)
Out[41]:
array([[123, 111],
[128, 188],
[174, 122]])
In [42]: np.random.choice(b,(3,2),p= b/np.sum(b))
Out[42]:
array([[174, 122],
[188, 194],
[174, 123]])
| 函数 | 说明 |
|---|---|
| uniform(low,high,size) | 产生具有均匀分布的数组，low起始值，high结束值，size形状 |
| normal(loc,scale,size) | 产生具有正态分布的数组，loc均值，scale标准差，size形状 |
| poisson(lam,size) | 产生具有泊松分布的数组，lam随机事件发生率，size形状 |
In [43]: u = np.random.uniform(0,10,(3,4))
In [44]: u
Out[44]:
array([[ 8.8393648 , 3.25511638, 1.65015898, 3.92529244],
[ 0.93460375, 8.21105658, 1.5115202 , 3.84114449],
[ 9.44260712, 9.87625475, 4.56304547, 8.26122844]])
In [45]: n = np.random.normal(10,5,(3,4))
In [46]: n
Out[46]:
array([[ 12.8882903 , 2.6251256 , 10.39394227, 14.59206826],
[ 7.5365132 , 10.48231186, 6.73620032, 8.89118781],
[ 4.65856717, 3.86153973, 1.00713488, 6.5739633 ]])
numpy统计函数
| 函数 | 说明 |
|---|---|
| .sum(a,axis=None) | 根据给定轴axis计算数组a相关元素之和，axis整数或元组 |
| .mean(a,axis=None | 根据给定轴axis计算数组a相关元素的期望，axis整数或元组 |
| .average(a,axis=None,weights=None) | 根据给定轴axis计算数组a相关元素的加权平均值 |
| .std(a,axis=None | 根据给定轴axis计算数组a相关元素的标准差 |
| .var(a,axis=None | 根据给定轴axis计算数组a相关元素的方差 |
In [47]: a = np.arange(15).reshape(3,5)
In [48]: a
Out[48]:
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
In [49]: np.sum(a)
Out[49]: 105
In [50]: np.mean(a,axis=1) # 2. = (0+5+10)/3
Out[50]: array([ 2., 7., 12.])
In [51]: np.mean(a,axis=0)
Out[51]: array([ 5., 6., 7., 8., 9.]) # 7. = (2+7+12)/3
In [52]: np.average(a, axis=0, weights=[10,5,1]) # 加权平均： 4.1875 = (2*10+7*5+1*12)/(10+5+1)
Out[52]: array([ 2.1875, 3.1875, 4.1875, 5.1875, 6.1875])
In [53]: np.std(a)
Out[53]: 4.3204937989385739
In [54]: np.var(a)
Out[54]: 18.666666666666668
| 函数 | 说明 |
|---|---|
| .min(a), .max(a) | 计算数组a中元素的最小值、最大值 |
| .argmin(a), .argmax(a) | 计算数组a中元素最小值、最大值的降一维后下标 |
| .unravel_index(index,shape) | 根据shape将一维下标index转换成多维下标 |
| .ptp(a) | 计算数组a中元素最大值与最小值的差 |
| .median(a) | 计算数组a中元素的中位数（中值） |
In [55]: b = np.arange(15,0,-1).reshape(3,5)
In [56]: b
Out[56]:
array([[15, 14, 13, 12, 11],
[10, 9, 8, 7, 6],
[ 5, 4, 3, 2, 1]])
In [57]: np.max(b)
Out[57]: 15
In [58]: np.argmax(b) # 扁平化后的下标
Out[58]: 0
In [59]: np.unravel_index(np.argmax(b), b.shape) # 重塑成多维下标
Out[59]: (0, 0)
In [60]: np.ptp(b)
Out[60]: 14
In [61]: np.median(b)
Out[61]: 8.0
numpy的梯度函数
| 函数 | 说明 |
|---|---|
| np.gradient(a) | 返回数组a中元素的梯度，当a为多维度时，返回每个维度梯度 |
梯度：连续值之间的变化率，即斜率。 XY坐标轴连续X坐标对应的Y轴值：a,b,c，其中b的梯度是：(c-a)/2
In [62]: a = np.random.randint(0,20,(5))
In [63]: a
Out[63]: array([14, 16, 10, 17, 0])
In [64]: np.gradient(a) # 存在两侧值：-2. = (10-14)/2
Out[64]: array([ 2. , -2. , 0.5, -5. , -17. ])
In [65]: b = np.random.randint(0,20,(5))
In [66]: b
Out[66]: array([17, 9, 16, 9, 12])
In [67]: np.gradient(b) # 只有一侧值：-8. = (9-17)/1
Out[67]: array([-8. , -0.5, 0. , -2. , 3. ])
In [68]: c = np.random.randint(0, 50, (3,5))
In [69]: c
Out[69]:
array([[30, 17, 17, 16, 0],
[31, 37, 9, 0, 38],
[22, 32, 2, 3, 31]])
In [70]: np.gradient(c)
Out[70]:
[array([[ 1. , 20. , -8. , -16. , 38. ],
[ -4. , 7.5, -7.5, -6.5, 15.5],
[ -9. , -5. , -7. , 3. , -7. ]]),
array([[-13. , -6.5, -0.5, -8.5, -16. ],
[ 6. , -11. , -18.5, 14.5, 38. ],
[ 10. , -10. , -14.5, 14.5, 28. ]])]
PIL库
简单使用
In [1]: from PIL import Image
In [2]: import numpy as np
In [3]: im = np.array(Image.open("img.jpg"))
In [4]: print(im.shape,im.dtype)
(435, 428, 3) uint8
In [5]: b = [255,255,255] - im
In [6]: new_im = Image.fromarray(b.astype('uint8'))
In [7]: new_im.save("img.jpg")
In [8]: a = np.array(Image.open("img.jpg").convert('L')) # 使用灰度表示图像
In [9]: b = 255 - a
In [10]: im = Image.fromarray(b.astype('uint8'))
In [11]: im.save("img.jpg")
In [12]: c = (100/255)*a +150 # 区间变换
In [13]: im = Image.fromarray(c.astype('uint8'))
In [14]: im.save("img.jpg")
In [15]: d = 255 * (a/255)**2 # 像素平方
In [16]: im = Image.fromarray(d.astype('uint8'))
In [17]: im.save("img.jpg")
图像手绘效果
手绘效果特征：
- 黑白灰色
- 黑白灰色
- 边界线条较重
- 相同或相近色彩趋于白色
- 略有光源效果
完整代码：
from PIL import Image
import numpy as np
a = np.asarray(Image.open('img.png').convert('L')).astype('float')
depth = 10. # (0-100)
grad = np.gradient(a) #取图像灰度的梯度值
grad_x, grad_y = grad #分别取横纵图像梯度值
grad_x = grad_x*depth/100.
grad_y = grad_y*depth/100.
A = np.sqrt(grad_x**2 + grad_y**2 + 1.)
uni_x = grad_x/A
uni_y = grad_y/A
uni_z = 1./A
vec_el = np.pi/2.2 # 光源的俯视角度，弧度值
vec_az = np.pi/4. # 光源的方位角度，弧度值
dx = np.cos(vec_el)*np.cos(vec_az) #光源对x 轴的影响
dy = np.cos(vec_el)*np.sin(vec_az) #光源对y 轴的影响
dz = np.sin(vec_el) #光源对z 轴的影响
b = 255*(dx*uni_x + dy*uni_y + dz*uni_z) #光源归一化
b = b.clip(0,255)
im = Image.fromarray(b.astype('uint8')) #重构图像
im.save('img2.jpg')