[转载] python中numpy库的使用

参考链接： Python中的numpy.amin

numpy支持的数据类型： bool_ 布尔型数据类型（True 或者 False） int_ 默认的整数类型（类似于 C 语言中的 long，int32 或 int64） intc 与 C 的 int 类型一样，一般是 int32 或 int 64 intp 用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64） int8 字节（-128 to 127） int16 整数（-32768 to 32767） int32 整数（-2147483648 to 2147483647） int64 整数（-9223372036854775808 to 9223372036854775807） uint8 无符号整数（0 to 255） uint16 无符号整数（0 to 65535） uint32 无符号整数（0 to 4294967295） uint64 无符号整数（0 to 18446744073709551615） float_ float64 类型的简写 float16 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位 float32 单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位 float64 双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位 complex_ complex128 类型的简写，即 128 位复数 complex64 复数，表示双 32 位浮点数（实数部分和虚数部分） complex128 复数，表示双 64 位浮点数（实数部分和虚数部分）使用np.dtype表示数据类型 int8, int16, int32, int64 四种数据类型可以使用字符串 ‘i1’, ‘i2’,‘i4’,‘i8’ 代替结构化数据类型 dt = np.dtype([(‘age’,np.int8)]) a = np.array([(10,),(20,),(30,)], dtype = dt) print(a) 输出为 [(10,) (20,) (30,)] 类型字段名可以用于存取实际的 age 列 import numpy as np dt = np.dtype([(‘age’,np.int8)]) a = np.array([(10,),(20,),(30,)], dtype = dt) print(a[‘age’]) 则可以取出a这个数组的age列 student = np.dtype([(‘name’,‘S20’), (‘age’, ‘i1’), (‘marks’, ‘f4’)]) print(student) [(‘name’, ‘S20’), (‘age’, ‘i1’), (‘marks’, ‘f4’)] import numpy as np student = np.dtype([(‘name’,‘S20’), (‘age’, ‘i1’), (‘marks’, ‘f4’)]) a = np.array([(‘abc’, 21, 50),(‘xyz’, 18, 75)], dtype = student) print(a) [(‘abc’, 21, 50.0), (‘xyz’, 18, 75.0)] 每个内建类型都有一个唯一对应的字符代码，如下： b 布尔型 i (有符号) 整型 u 无符号整型 integer f 浮点型 c 复数浮点型 m timedelta（时间间隔） M datetime（日期时间） O (Python) 对象 S, a (byte-)字符串 U Unicode V 原始数据 (void) axis为numpy中的维度和轴，axis=0为对每一列进行操作，axis为对每一行操作。属性说明 ndarray.ndim 秩，即轴的数量或维度的数量 ndarray.shape 数组的维度，对于矩阵，n 行 m 列 ndarray.size 数组元素的总个数，相当于 .shape 中 n*m 的值 ndarray.dtype ndarray 对象的元素类型 ndarray.itemsize ndarray 对象中每个元素的大小，以字节为单位 ndarray.flags ndarray 对象的内存信息 ndarray.real ndarray元素的实部 ndarray.imag ndarray 元素的虚部 ndarray.data 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。 a = np.arange(24) print (a.ndim) # a 现只有一个维度 b = a.reshape(2,4,3) # b 现在拥有三个维度 a为0到23的数字依次递增1 改变形状后为 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]]]) 先分为2个再分为3个，一维数组中有3个元素 shape表示此数组的维度 b.shape = （2，4，3）且利用shape和reshape可以改变数组大小和形状。 b.shape= (4,6) b 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]]) 或者b.reshape(3,8) b.reshape(3,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]]) b.itemsize返回每个元素的值的大小 b.flags返回该数组的内存信息，包含一下属性： C_CONTIGUOUS © 数据是在一个单一的C风格的连续段中 F_CONTIGUOUS (F) 数据是在一个单一的Fortran风格的连续段中 OWNDATA (O) 数组拥有它所使用的内存或从另一个对象中借用它 WRITEABLE (W) 数据区域可以被写入，将该值设置为 False，则数据为只读 ALIGNED (A) 数据和所有元素都适当地对齐到硬件上 UPDATEIFCOPY (U) 这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新 b = np.empty（[size],dtype=…）同理可创建全为1的数组或全为1的数组 //默认为浮点数，但是可以设置元素种类，比如 np.int或者自定义类型 dtype=[(‘x’,‘i4’),(‘y’,‘i4’)] numpy从已有数组创建数组 numpy.asarray(a, dtype = None, order = None) a 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组 dtype 数据类型，可选 order 可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 numpy.fromiter可以在可迭代对象中创建ndarray对象，返回一维数组 numpy.fromiter(iterable,dtype,count=-1) iterable 可迭代对象 dtype 返回数组的数据类型 count 读取的数据数量，默认为-1，读取所有数据

list=range(5)

>>> it=iter(list)

>>> it

<range_iterator object at 0x000001CAE9215DD0>

>>> x=np.fromiter(it,float)

>>> x

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

numpy.arange(start,stop,step,dtype) numpy.linspace创建一个一维数组，且为等差数列构成的 np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) start 序列的起始值 stop 序列的终止值，如果endpoint为true，该值包含于数列中 num 要生成的等步长的样本数量，默认为50 endpoint 该值为 true 时，数列中包含stop值，反之不包含，默认是True。 retstep 如果为 True 时，生成的数组中会显示间距，反之不显示。 dtype ndarray 的数据类型

>>>a = np.linspace(1,3,23,True,True)

>>> a

(array([1. , 1.09090909, 1.18181818, 1.27272727, 1.36363636,

1.45454545, 1.54545455, 1.63636364, 1.72727273, 1.81818182,

1.90909091, 2. , 2.09090909, 2.18181818, 2.27272727,

2.36363636, 2.45454545, 2.54545455, 2.63636364, 2.72727273,

2.81818182, 2.90909091, 3. ]), 0.09090909090909091)

>>>

可以看出此为等差数列，最后一项为步长 numpy.logspace 函数用于创建一个于等比数列。格式如下： np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

>>> a = np.logspace(1,2,10)

>>> a

array([ 10. , 12.91549665, 16.68100537, 21.5443469 ,

27.82559402, 35.93813664, 46.41588834, 59.94842503,

77.42636827, 100. ])

>>> a = np.logspace(0,5,10,base = 2)

>>> a

array([ 1. , 1.46973449, 2.16011948, 3.1748021 , 4.66611616,

6.85795186, 10.0793684 , 14.8139954 , 21.77264 , 32. ])

>>>

numpy切片和索引切片可以利用内置的slice函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。

>>> a = np.arange(10)

>>> s=slice(2,8,3)

>>> a[s]

array([2, 5])

>>> b = a[2:8:3]

>>> b

array([2, 5])

还有下面几种索引方式：

>>> a = np.array([[1,2,3],[2,2,2],[1,8,9]])

>>> print(a[...,1])

[2 2 8]

>>> print(a[1,...])

[2 2 2]

>>> print(a[1:,...])

[[2 2 2]

[1 8 9]]

>>> print(a[...,1:])

[[2 3]

[2 2]

[8 9]]

根据矩阵可以很明显看出这几种索引的不同。整数数组索引：

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

>>> y = x[[0,1,2],[0,1,1]]

>>> y

array([1, 4, 6])

这个分为行索引和列索引，表示找到(0,0)(1,1)(2,1)处的元素布尔索引：

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

>>>> print(x[x>3])

[4 5 6]

或可以使用~来表示非，例如：

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

>>> print(~np.isnan(a))

[False True True False True True True]

>>> print(a[~np.isnan(a)])

[1. 2. 3. 4. 5.]

还可以过滤复数：

>>> a = np.array([1, 2+1j ,3,9j])

>>> print(a[np.iscomplex(a)])

[2.+1.j 0.+9.j]

花式索引指的是利用整数数组进行索引，例如：

>>> x

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

>>> print(x[[4,2,1,7]])

[[16 17 18 19]

[ 8 9 10 11]

[ 4 5 6 7]

[28 29 30 31]]

传入倒序索引数组，例如：

>>> print(x[[-4,-2,-1,-7]])

[[16 17 18 19]

[24 25 26 27]

[28 29 30 31]

[ 4 5 6 7]]

传入多个索引数组（要使用np.ix_），例如：

>>> print(x[np.ix_([1,5,7,2],[0,3,1,2])])

[[ 4 7 5 6]

[20 23 21 22]

[28 31 29 30]

[ 8 11 9 10]]

ix_产生笛卡尔积，得到（1,0）,(1,3),(1,1)…以此类推。 numpy广播是numpy对不同形状的数组进行数值计算的方式。例如：

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

>>> b = np.array([10,20,30,40])

>>> c =a * b

>>> c

array([ 10, 40, 90, 160])

当两个数组形状不同时，numpy将自动触发广播机制。例如：

>>> a = np.array([[ 0, 0, 0],

... [10,10,10],

... [20,20,20],

... [30,30,30]])

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

>>> a+b

array([[ 1, 2, 3],

[11, 12, 13],

[21, 22, 23],

[31, 32, 33]])

当两者不能进行正常相加减的时候就会触发广播机制，这与下面的效果是等价的，例如：

>>> bb=np.tile(b,(4,1))

>>> a+bb

array([[ 1, 2, 3],

[11, 12, 13],

[21, 22, 23],

[31, 32, 33]])

tile函数是将原矩阵横向纵向的复制。 tile(mat,(1,4)) 将列复制为原来的四倍

>>> np.tile(b,4)

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

>>> np.tile(b,(1,4))

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

numpy迭代数组可以使用numpy.nditer()来创建一个迭代器，例如下面的：

>>> for x in np.nditer(bb):

... print(x)

output = 1 2 3 1 2 3 1 2 3 1 2 3

a和a的转置遍历顺序相同，他们在内存中的存储数据也是一样的。因此迭代顺序二者相同。但是a.T.copy(order = ‘C’)它默认是按行访问，它与前两种存储方式不同。或者加入order='C/F’表示按行访问或者按列访问。修改数组中的值有个可选参数op_flags。默认情况下是只读对象，可以将其设置为read-write或者write-only. 使用外部循环，nditer类的构造器有多个flags参数，可以接受以下的值： c_index 可以跟踪 C 顺序的索引 f_index 可以跟踪 Fortran 顺序的索引 multi-index 每次迭代可以跟踪一种索引类型 external_loop 给出的值是具有多个值的一维数组，而不是零维数组例如下面的例子：

>>> for i in np.nditer(a, flags= ['external_loop'],order = 'F'):

... print(i,end =',')

...

[0 9],[ 3 12],[ 6 15],

广播迭代： nditer可以同时迭代两个不同的数组，例如下面的式子：

>>> a = np.arange(0,60,5)

>>> a = a.reshape(3,4)

>>> a

array([[ 0, 5, 10, 15],

[20, 25, 30, 35],

[40, 45, 50, 55]])

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

>>> for x,y in np.nditer([a,b]):

... print("%d:%d" % (x,y),end=",")

...

0:1,5:2,10:3,15:4,20:1,25:2,30:3,35:4,40:1,45:2,50:3,55:4,

numpy数组操作： reshape 不改变数据的条件下修改形状 flat 数组元素迭代器 flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组 ravel 返回展开数组

>>> a = np.arange(0,60,5)

>>> a

array([ 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55])

>>> a = a.reshape(3,4)

>>> a

array([[ 0, 5, 10, 15],

[20, 25, 30, 35],

[40, 45, 50, 55]])

>>> for i in a:

... print(i)

...

[ 0 5 10 15]

[20 25 30 35]

[40 45 50 55]

>>> for element in a.flat:

... print(element)

...

>>> np.ravel(a,'C')

array([ 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55])

翻转数组： transpose 对换数组的维度 ndarray.T 和 self.transpose() 相同 rollaxis 向后滚动指定的轴 swapaxes 对换数组的两个轴

>>> np.transpose(a)

array([[ 0, 20, 40],

[ 5, 25, 45],

[10, 30, 50],

[15, 35, 55]])

>>> a.T

array([[ 0, 20, 40],

[ 5, 25, 45],

[10, 30, 50],

[15, 35, 55]])

np.swapaxes(0,2)，即轴0和轴1交换。比如第一个元素arr[0,0,0]，交换后仍是arr[0,0,0]；第二个元素arr[0,0,1]，交换后则为arr[1,0,0]；…；最后一个元素arr[1,1,2]，交换后为arr[2,1,1]。

>>> a

array([[[0, 1],

[2, 3]],

[[4, 5],

[6, 7]]])

>>> np.swapaxes(a,2,0)

array([[[0, 4],

[2, 6]],

[[1, 5],

[3, 7]]])

numpy数学函数：提供了标准的三角函数，sin（），cos（），tan（）。并且可以通过np.pi/180来转化角度。例如：

>>> a = np.array([0,30,45,60,90])

>>> print(np.sin(a*np.pi/180))

[0. 0.5 0.70710678 0.8660254 1. ]

>>> inv = np.arcsin(0.5)

>>> np.degrees(inv)

30.000000000000004

舍入函数： numpy.around() 函数返回指定数字的四舍五入值。 numpy.around(a,decimals)例如：

>>> a = np.array([17.8, 11, 0, 5.55, 0.567, 25.532])

>>> np.around(a,1)

array([17.8, 11. , 0. , 5.6, 0.6, 25.5])

>>> np.around(a,0)

array([18., 11., 0., 6., 1., 26.])

>>> np.around(a,-1)

array([20., 10., 0., 10., 0., 30.])

向下取整，向上取整： numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。例如：

>>> np.floor(a)

array([-2., 1., -1., 0., 10.])

>>> np.ceil(a)

array([-1., 2., -0., 1., 10.])

numpy算术函数： NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。

需要注意的是数组必须具有相同的形状或符合数组广播规则。例如：

>>> a = np.arange(9, dtype=np.float_).reshape(3,3)

>>> a

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

[3., 4., 5.],

[6., 7., 8.]])

>>> b = np.array([10,10,10])

>>> np.add(a,b)

array([[10., 11., 12.],

[13., 14., 15.],

[16., 17., 18.]])

>>> np.subtract(a,b)

array([[-10., -9., -8.],

[ -7., -6., -5.],

[ -4., -3., -2.]])

>>> np.subtract(b,a)

array([[10., 9., 8.],

[ 7., 6., 5.],

[ 4., 3., 2.]])

>>> np.multiply(a,b)

array([[ 0., 10., 20.],

[30., 40., 50.],

[60., 70., 80.]])

>>> np.divide(a,b)

array([[0. , 0.1, 0.2],

[0.3, 0.4, 0.5],

[0.6, 0.7, 0.8]])

numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。

>>> np.reciprocal([0.25,1.33])

array([4. , 0.7518797])

numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。例如：

>>> a = np.array([10,4,5])

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

>>> np.power(a,b)

array([ 10, 16, 125], dtype=int32)

但是它必须符号广播的条件，否则就会出错。

>>> np.power(a,[1,2])

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: operands could not be broadcast together with shapes (3,) (2,)

numpy.mod() 计算输入数组中相应元素的相除后的余数。函数 numpy.remainder() 也产生相同的结果。例如：

>>> a = np.array([10,4,5])

>>> b = np.array([10,10,10])

>>> np.mod(a,b)

array([0, 4, 5], dtype=int32)

>>> np.mod(b,a)

array([0, 2, 0], dtype=int32)

numpy统计函数： numpy.amin() 用于计算数组中的元素沿指定轴的最小值。

numpy.amax() 用于计算数组中的元素沿指定轴的最大值。例如：

>>> a

array([[3, 7, 5],

[8, 4, 3],

[2, 4, 9]])

>>> np.amin(a,1)

array([3, 3, 2])

>>> np.amin(a,0)

array([2, 4, 3])

>>> np.amax(a,0)

array([8, 7, 9])

>>> np.amax(a,1)

array([7, 8, 9])

numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。

>>> a

array([[3, 7, 5],

[8, 4, 3],

[2, 4, 9]])

>>> np.ptp(a)

>>> np.ptp(a,1)

array([4, 5, 7])

>>> np.ptp(a,0)

array([6, 3, 6])

标准差： np.std([1,2,3,4])

>>> np.std([1,2,3,4])

1.118033988749895

方差：np.var([1,2,3,4])

>>> np.var([1,2,3,4])

1.25

numpy排序种类速度最坏情况工作空间稳定性 ‘quicksort’（快速排序） 1 O(n^2) 0 否 ‘mergesort’（归并排序） 2 O(nlog(n)) ~n/2 是 ‘heapsort’（堆排序） 3 O(nlog(n)) 0 否 numpy.sort() 函数返回输入数组的排序副本。函数格式如下： numpy.sort(a, axis, kind, order) numpy.argsort() 函数返回的是数组值从小到大的索引值。 numpy线性代数： dot 两个数组的点积，即元素对应相乘。 vdot 两个向量的点积 inner 两个数组的内积 matmul 两个数组的矩阵积 determinant 数组的行列式 solve 求解线性矩阵方程 inv 计算矩阵的乘法逆矩阵矩阵的内积为对应位置的乘积加起来维度不变。例如：

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

>>> b = np.array([[11,12],[13,14]])

>>> np.dot(a,b)

array([[37, 40],

[85, 92]])

计算式为：

[[111+213, 112+214],[311+413, 312+414]] numpy.vdot() 函数是两个向量的点积。如果第一个参数是复数，那么它的共轭复数会用于计算。如果参数是多维数组，它会被展开。例如：

>>> np.vdot(a,b)

130

计算式为： 111 + 212 + 313 + 414 = 130 numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积。例如： numpy.matmul 函数返回两个数组的矩阵乘积。虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。

另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。

对于二维数组，它就是矩阵乘法：

>>> a = [[1,0],[0,1]]

>>> b = [[2,3],[1,4]]

>>> np.matmul(a,b)

array([[2, 3],

[1, 4]])

numpy.linalg.det() 函数计算输入矩阵的行列式。例如：

>>> np.linalg.det(a)

1.0

numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵。例如：

>>> a = [[1,0],[0,1]]

>>> np.linalg.inv(a)

array([[1., 0.],

[0., 1.]])

Matplotlib 是 Python 的绘图库。它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案。它也可以和图形工具包一起使用，如 PyQt 和 wxPython。例如下面的使用：

>>> from matplotlib import pyplot as plt

>>> x = np.arange(1,11)

>>> y = x * 2 +5

>>> plt.title("Demo")

Text(0.5,1,'Demo')

>>> plt.xlabel("x axis caption")

Text(0.5,0,'x axis caption')

>>> plt.ylabel("y axis caption")

Text(0,0.5,'y axis caption')

>>> plt.plot(x,y)

[<matplotlib.lines.Line2D object at 0x000001FB5EFB7FD0>]

>>> plt.show()

显示为：具体python的数据可视化需要下来自己补充学习，这里就不赘述了。参考地址：https://www.runoob.com/numpy/numpy-tutorial.html

[转载] python中numpy库的使用相关推荐

[转载] python中numpy库的使用举例
参考链接: Python Numpy 1.矩阵的创建 1.1 利用np.array()创建一个矩阵,注意array()里面是一个python列表或者元组 1.2 利用np.zeros()创建矩阵 1. ...
[转载] Python里面numpy库中zeros()的一些问题
参考链接: Python中的numpy.zeros Python里面numpy库中zeros函数的一些问题定义本文记录了在使用numpy库中的zeros函数时遇到的一些问题定义用法:zeros ...
[转载] Python中numpy.clip()；numpy.fabs()的用法；以及math.pow()的说明
参考链接: Python中的numpy.absolute 在看一些关于关于数据分析的Python代码时,时常会出现一些方法不懂其意思,今天做个小小的说明关于: python中numpy.clip()方 ...
[转载] python中numpy.concatenate()函数的使用
参考链接: Python中的numpy.append numpy库数组拼接np.concatenate 原文:https://blog.csdn.net/zyl1042635242/article/d ...
[转载] Python中NumPy简介及使用举例
参考链接: Python中的numpy.invert NumPy是Python语言的一个扩展包.支持多维数组与矩阵运算,此外也针对数组运算提供大量的数学函数库.NumPy提供了与Matlab相似的功能 ...
[转载] [转载] python 中NumPy和Pandas工具包中的函数使用笔记（方便自己查找）
参考链接: Python中的numpy.sinh 参考链接: Python中的numpy.less_equal 二.常用库 1.NumPy NumPy是高性能科学计算和数据分析的基础包.部分功能如下: ...
[转载] python 中NumPy和Pandas工具包中的函数使用笔记（方便自己查找）
参考链接: Python中的numpy.less_equal 二.常用库 1.NumPy NumPy是高性能科学计算和数据分析的基础包.部分功能如下: ndarray, 具有矢量算术运算和复杂广播能力 ...
[转载] python中numpy模块的around方法_更好地舍入Python的NumPy.around：舍入numpy的数组
参考链接: Python中的numpy.round_ I am looking for a way to round a numpy array in a more intuitive fashion ...
[转载] Python中Numpy包的用法
参考链接: Python中的Numpy.prod 一.数组方法创建数组:arange()创建一维数组:array()创建一维或多维数组,其参数是类似于数组的对象,如列表等反过来转换则可以使用num ...

[转载] python中numpy库的使用

[转载] python中numpy库的使用相关推荐

最新文章

热门文章