numpy 基本操作

最新推荐文章于 2024-07-24 23:27:06 发布

@bigfive

最新推荐文章于 2024-07-24 23:27:06 发布

阅读量405

点赞数

分类专栏： python 文章标签： numpy

本文链接：https://blog.csdn.net/qq_41636123/article/details/87906852

版权

python 专栏收录该内容

2 篇文章 1 订阅

订阅专栏

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