python中numpy数组的计算_Numpy数组计算

z介绍

Numpy高性能科学计算和数据分析的基础包：

ndarray，一个多维数组结构，高效且节省空间

无需循环对整组数据进行快速运算的数学函数

*读写磁盘数据的工具以及用于操作内存映射文件的工具

*线性代数、随机数生成和傅里叶变换功能

*用于集成C、C++等代码的工具

安装

1 pip install numpy

基本使用

1.创建

array函数：接收一个普通的python序列，并将其转换为ndarray

#! -*- coding=utf-8 -*-

importnumpy as np#创建

# 通过列表创建

arr = np.array([1, 2, 4, 5])print(arr)#通过元祖创建

arr1 = np.array((3, 4, 5, 6))print(arr1)#创建多维数组

arr2= np.array([

[1, 2, 3],[2, 3, 4]

])print(arr2)

arr3= np.array([

[

[1,2,3,4],[2,3,4,5],[5,6,7,8]

],[

[10,20,30,40],[20,30,40,50],[50,60,70,80]

]

])print(arr3)

zeros函数：创建指定长度或者形状的全零数组。

ones函数：创建指定长度或者形状的全1数组。

empty函数：创建一个没有任何具体值的数组(准确地说是创建一些未初始化的ndarray多维数组)

#! -*- coding=utf-8 -*-

importnumpy as np

zero_arr= np.zeros((3,3))print(zero_arr)

one_arr= np.ones((3,3))print(one_arr)

em_arr= np.empty((3,3))print(em_arr)

2.其它方式创建

arange函数: 类似python的range函数，通过指定开始值、终值和步长来创建一个一维数组，注意：最终创建的数组不包含终值

#! -*- coding=utf-8 -*-

importnumpy as np#0-19的数组

arr = np.arange(20)print(arr)#10-19的数组

arr1 = np.arange(10,20)print(arr1)#10-19，步长2的数组

arr2 = np.arange(10,20,2)print(arr2)#20-11降序，步长-1

arr3 = np.arange(20,10,-1)print(arr3)

linspace函数：等差数组，通过指定开始值、终值和元素个数来创建一个一维数组，数组的数据元素符合等差数列，可以通过endpoint关键字指定是否包含终值，默认包含终值

#! -*- coding=utf-8 -*-

importnumpy as np#等差数组，0-10的五个等差元素差值2.5

# [ 0. 2.5 5. 7.5 10. ]

arr = np.linspace(0,10,5)print(arr)

logspace函数：和linspace函数类似，不过创建的是等比数列数组

#! -*- coding=utf-8 -*-

importnumpy as np#0表示10的零次方，2表示10的二次方，表示最终生成五个元素，base参数可以设定底数,m默认是10

arr = np.logspace(0,2,5, base=10.)print(arr)

使用随机数填充数组，即使用numpy.random中的random()函数来创建0-1之间的随机元素，数组包含的元素数量由参数决定

#! -*- coding=utf-8 -*-

importnumpy as np#三行两列三维

arr = np.random.random((3,2,3))print(arr)#返回9个0-1的随机数

arr1 = np.random.rand(9)print(arr1)#1-9整数，3行三列数组

arr2 = np.random.randint(1,9,size=(3,3))print(arr2)#返回一个标准的正态分布数组

arr3 = np.random.randn(3,3)print(arr3)

ndarray数组的属性

ndim 数组轴(维度)的个数，轴的个数被称作秩

shape 数组的维度, 例如一个2排3列的矩阵，它的shape属性将是(2,3),这个元组的长度显然是秩，即维度或者ndim属性 size 数组元素的总个数，等于shape属性中元组元素的乘积。

dtype 一个用来描述数组中元素类型的对象，可以通过创造或指定dtype使用标准Python类型。不过NumPy提供它自己的数据类型。

itemsize 数组中每个元素的字节大小。例如，一个元素类型为float64的数组itemsiz属性值为8(=64/8),又如，一个元素类型为complex32的数组item属性为4(=32/8).

#! -*- coding=utf-8 -*-

importnumpy as np

arr= np.random.randint(1,9,(3,3))print(arr.ndim) #2

print(arr.shape) #(3, 3)

print(arr.size) #9

print(arr.dtype) #int32

print(arr.size) #9

dtype类型

数值型dtype的命名方式为：一个类型名称(eg:int、float等)，后接一个表示各个元素位长的数字 比如Python的float数据类型(双精度浮点值)，需要占用8个字节(64位)，因此在NumPy中记为float64 每个数据类型都有一个类型代码，即简写方式 如果需要更改一个已经存在的数组的数据类型，可以通过astype方法进行修改从而得到一个新数组。

#! -*- coding=utf-8 -*-

importnumpy as np

arr= np.random.randint(1,9,(3,3))print(arr.dtype) #int32

arr2= arr.astype(float)print(arr2.dtype) #float64

print(arr2)

基本数据类型

修改数组形状

对于一个已经存在的ndarray数组对象而言，可以通过修改形状相关的参数/方法从而改变数组的形状。 直接修改数组ndarray的shape值, 要求修改后乘积不变。 直接使用reshape函数创建一个改变尺寸的新数组，原数组的shape保持不变，但是新数组和原数组共享一个内存空间，也就是修改任何一个数组中的值都会对另外一个产生影响，另外要求新数组的元素个数和原数组一致(还可以降维操作)。 当指定某一个轴为-1的时候，表示将根据数组元素的数量自动计算该轴的长度值。

#! -*- coding=utf-8 -*-

importnumpy as np

arr= np.arange(0,20,2)

brr= arr.reshape(2,5)print(arr) #[ 0 2 4 6 8 10 12 14 16 18]

brr[0,1] = 100

print(arr) #[ 0 100 4 6 8 10 12 14 16 18]

print(brr) #[[ 0 100 4 6 8],[ 10 12 14 16 18]]

# 指定五列

print(arr.reshape(-1,5))#指定五行

print(arr.reshape(5,-1))

基本操作

数组与标量、数组之间的运算

数组不用循环即可对每个元素执行批量的算术运算操作，这个过程叫做矢量化，即用数组表达式代替循环的做法。 矢量化数组运算性能比纯Python方式快上一两个数据级。 大小相等的两个数组之间的任何算术运算都会将其运算应用到元素级上的操作。 元素级操作：在NumPy中，大小相等的数组之间的运算，为元素级运算，即只用于位置相同的元素之间，所得的运算结果组成一个新的数组，运算结果的位置跟操作数位置相同

#! -*- coding=utf-8 -*-

importnumpy as np

arr= np.array([1,2,3,4,5])print(arr)print(arr+4)print(arr*5)print(arr-3)print(arr/2.0)print(1.0/arr)print(arr**2)print(2**arr)"""运行结果

[1 2 3 4 5]

[5 6 7 8 9]

[ 5 10 15 20 25]

[-2 -1 0 1 2]

[0.5 1. 1.5 2. 2.5]

[1. 0.5 0.33333333 0.25 0.2 ]

[ 1 4 9 16 25]

[ 2 4 8 16 32]"""arr1= np.array([[1,2,3], [4,5,6]])

arr2= np.array([[1.0,1.1,1.2],[2.0,2.1,2.2]])print(arr1+arr2)print(arr1-arr2)print(arr1*arr2)print(arr1/arr2)

arr3= np.random.randint(1,9,(2,3))

arr4= np.array([2,3,4])print(arr3)print(arr4)print(arr3.shape)print(arr4.shape)print(arr3+arr4)

数组的矩阵积(matrix product)

#! -*- coding=utf-8 -*-

importnumpy as np

arr1= np.array([

[120,60,220],[115,23,201],[132,48,230]

])

arr2= np.array([

[12.34,0.04],[204.56,2.34],[9.89,0.45]

])print(arr1.dot(arr2))print(np.dot(arr1,arr2))

数组的索引与切片

索引

#! -*- coding=utf-8 -*-

importnumpy as np

arr= np.random.randint(1,9,(4,2,4))print(arr)print('*'*50)print(arr[3])print('*'*50)print(arr[3][1])print('*'*50)print(arr[3][1][2])#可以简写

print(arr[3,1,2])

切片

花式索引

花式索引(Fancy indexing)指的是利用整数数组进行索引的方式

#! -*- coding=utf-8 -*-

importnumpy as np

arr= np.arange(32).reshape(8,4)print(arr)print('*'*50)##获取0,3,5行数据

print(arr[[0,3,5]])print('*'*50)## 获取(0,0),(3,2),(5,3)索引的数据

print(arr[[0,3,5],[0,2,3]])#获取第0,3,5行的第0,2,3列数据

print(arr[[0,3,5]].T[[0,2,3]].T)print('*'*50)print(arr[np.ix_([0,3,5],[0,2,3])])

布尔索引

#! -*- coding=utf-8 -*-

importnumpy as np#arr = np.random.random((4,4))

# print(arr)

# print(arr<0.5)

# print(arr[arr<0.5])

# 练习

names= np.array(['joe', 'tom', 'anne'])

scores= np.array([

[70,80,90],[77,88,91],[80,90,70]

])

classes= np.array(['语文','数学','英语'])print(names=='joe')print(scores[names=='joe'])#输出joe的成绩

print(scores[names=='joe'].reshape(-1)[classes=='数学'])#输出joe的数学成绩

print(scores[names=='joe',classes=='数学'])#输出Joe和anne的成绩

print((names=='joe')|(names=='anne'))print(scores[(names=='joe')|(names=='anne')])#输出非joe和anne的成绩

print(scores[(names!='joe')&(names!='anne')])

数组的转置与轴对换

数组转置是指将shape进行重置操作，并将其值重置为原始shape元组的倒置，比如原始的shape值为:(2,3,4)，那么转置后的新元组的shape的值为: (4,3,2) 对于二维数组而言(矩阵)数组的转置其实就是矩阵的转置 可以通过调用数组的transpose函数或者T属性进行数组转置操作

#! -*- coding=utf-8 -*-

importnumpy as np

arr= np.arange(40).reshape(5,-1)#转置前

print(arr.shape)#转置后

print(arr.transpose().shape)print(arr.T.shape)

arr1= np.random.randint(0,10,(4,3,2))print(arr1.shape) #(4, 3, 2)

print('*'*50)#(3, 2, 4) 1，2,0参数是对shape元祖的索引重新排列的到的新元祖

# arr1.transpose(1,2,0) ==> shape = (3,2,4)

print(arr1.transpose(1,2,0).shape)

数组的拉伸与合并

数组拉伸np.tile(A，rep)函数可以将数组A进行拉伸，沿着A的维度重复rep次 对于ndarray数组而言，多个数组可以执行合并操作，合并的方式有多种。

Stack(arrays,axis=0):沿着新的轴加入一系列数组

vstack()：堆栈数组垂直顺序(行)

hstack()：堆栈数组水平顺序(列)

#! -*- coding=utf-8 -*-

importnumpy as np

arr= np.array([[3,9],[4,6]])print(arr)#横向拉伸2倍

print(np.tile(arr,2))"""[[3 9 3 9]

[4 6 4 6]]"""纵向拉伸3倍，横向拉伸2倍print(np.tile(arr, (3,2)))"""[[3 9 3 9]

[4 6 4 6]

[3 9 3 9]

[4 6 4 6]

[3 9 3 9]

[4 6 4 6]]"""

#合并

# stack vstack hstack

e = [1,2,3]

f= [4,5,6]

a= [6,7,8]#默认axis=0

print(np.stack((e,)))print(np.stack((e,f)))print(np.stack((f,e), axis=1))print(np.stack((f,), axis=1))print(np.stack((e,f), axis=1))print(np.stack((e,f,a), axis=1))print(np.hstack((e,f))) #[1 2 3 4 5 6]

print(np.vstack((e,f)))'''[[1 2 3]

[4 5 6]]'''

stack的用法：

axis = 0

axis = 1

即将每个矩阵的每一行进行堆叠，放在一个矩阵里(一行对应一个矩阵)就是下图的红色的放一起，绿色的放一起

axis = 2

即将每行的进行竖排，放在一个矩阵里(一行对应一个矩阵)

通用函数：快速的元素级数组成函数

ndarray-通用函数/常用函数(一元函数)

#! -*- coding=utf-8 -*-

importnumpy as np

arr= np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])print('arr=',arr)print('-'*50)print('绝对值np.abs=',np.abs(arr))print('-'*50)print('非复数绝对值更快np.fabs=', np.fabs(arr))print('-'*50)print('平方根np.sqrt=',np.sqrt(np.fabs(arr)))print('-'*50)print('平方np.square=', np.square(arr))print('-'*50)print('指数e的次方np.exp=', np.exp(arr))print('-'*50)

log_arr= np.fabs(arr)+1

print('自然对数np.log=', np.log(log_arr))print('-'*50)print('底数10的log np.log10=', np.log10(log_arr))print('-'*50)print('底数2的log np.log2=', np.log2(log_arr))print('-'*50)print('底数(x+1)np.log1p=', np.log1p(log_arr))print('-'*50)print('正负号np.sign=', np.sign(arr))print('-'*50)print('向上取整np.ceil=', np.ceil(arr))print('-'*50)print('向下取整np.floor=', np.floor(arr))print('-'*50)print('取最近的整数np.rint=', np.rint(arr))print('-'*50)print('整数位和小数位分离两个数组np.modf=',np.modf(arr))print('-'*50)print('是否是NaN np.isnan=', np.isnan(arr))print('-'*50)print('是否是有穷 np.isfinite=', np.isfinite(arr))print('-'*50)print('是否是无穷 np.isinf=', np.isinf(arr))print('-'*50)print('三角函数 np.cos=', np.cos(arr))print('-'*50)print('三角函数 np.cosh=', np.cosh(arr))print('-'*50)print('反三角函数 np.arccos=', np.arccos(np.cos(arr)))print('-'*50)print('反三角函数 np.arccosh=', np.arccosh(np.cosh(arr)))

二元函数

#! -*- coding=utf-8 -*-

importnumpy as np

arr1= np.array([1,2,8,1])

arr2= np.array([4,5,6,0])print('取模np.mod=', np.mod(arr2,arr1))print('点积np.dot=', np.dot(arr1,arr2))print('大于np.greater=', np.greater(arr1,arr2))print('大于等于np.greater_equal=', np.greater_equal(arr1,arr2))print('小于np.less=', np.less(arr1,arr2))print('等于np.equal=', np.equal(arr1,arr2))print('不等于np.not_equal=', np.not_equal(arr1,arr2))print('逻辑与np.logical_and=', np.logical_and(arr1,arr2))print('逻辑或np.logical_or=', np.logical_or(arr1,arr2))print('逻辑非np.logical_xor=', np.logical_xor(arr1,arr2))print('指定指数np.power=', np.power(arr1,3))

聚合函数

聚合函数是对一组值(eg一个数组)进行操作，返回一个单一值作为结果的函数。当然聚合函数也可以指定对某个具体的轴进行数据聚合操作；常见的聚合操作有：平均值、最大值、最小值、总体标准偏差等等

一维数组

#! -*- coding=utf-8 -*-

importnumpy as np

arr= np.random.randint(1,9,(2,3))print(arr)print('amin=',np.amin(arr))print('amax=',np.amax(arr))print('mean=',np.mean(arr))print('mean=',arr.mean())#方差，偏差的平方的平均值

arr1 = np.array([[5,2,3,4],[7,3,9,1]])print(np.mean(arr1-arr1.mean()**2))#标准差，偏差的平方的平均值的平方根

print(np.sqrt(np.mean((arr1-arr1.mean())**2)))print(np.std(arr1))

二维数组

#! -*- coding=utf-8 -*-

importnumpy as np"""二维数组的情况下，

axis=0表示对同列的数组进行聚合

axis=1表示对同行的数组进行聚合"""arr= np.array([

[1,3,5,9],[2,4,6,8],[-5,-6,-8,-2]

])print(arr)print(arr.mean(axis=0))print(arr.mean(axis=1))print(arr.sum(axis=1))print(arr.max(axis=1))print(arr.std(axis=1))

np.where函数

#! -*- coding=utf-8 -*-

importnumpy as np

xarr= np.array([-1.1,-1.2,-1.3,-1.4,-1.5])

yarr= np.array([-2.1,-2.2,-2.3,-2.4,-2.5,])

condition= xarr

# t = zip(xarr,yarr,condition)

# for i in t:

# print(i)

"""(-1.1, -2.1, False)

(-1.2, -2.2, False)

(-1.3, -2.3, False)

(-1.4, -2.4, False)

(-1.5, -2.5, False)"""result= [x if c else y for (x,y,c) in zip(xarr,yarr,condition)]print(result)

result1= np.where(condition,xarr,yarr)print(result1)

练习

将数组中的所有异常数字替换为0，比如将NaN替换为0

#! -*- coding=utf-8 -*-

importnumpy as np#练习：将数组中的所有异常数字替换为0，比如将NaN替换为0

arr= np.array([

[1,2,np.NaN,4],[4,5,6,np.NaN],[7,8,9,np.inf],[np.inf,np.e,np.pi,4]

])

condition= np.isnan(arr)|np.isinf(arr)print(condition)print(np.where(condition,0,arr))print('np.e=',np.e)print('np.pi',np.pi)

np.unique函数

np.unique函数的主要作用是将数组中的元素进行去重操作(也就是只保存不重复的数据)

#! -*- coding=utf-8 -*-

importnumpy as np

arr= np.array(['图书','数码','小吃','苹果','数码','女装','小吃','美食','男装'])#未去重

print('-'*50)for i in arr:

print(i, end='')print()#去重后

print('-'*50)

arr1= np.unique(arr)print(arr1)

总结：、

创建

创建ndarray：

array() 将列表转换为数组，可选择显式指定dtype

arange() range的numpy版，支持浮点数

linspace() 类似arange()，第三个参数为数组长度

zeros() 根据指定形状和dtype创建全0数组

ones() 根据指定形状和dtype创建全1数组

empty() 根据指定形状和dtype创建空数组(随机值)

eye() 根据指定边长和dtype创建单位矩阵

数据类型

ndarray数据类型：dtype：

布尔型：bool_

整型：int_ int8 int16 int32 int64

无符号整型：uint8 uint16 uint32 uint64

浮点型：float_ float16 float32 float64

复数型：complex_ complex64 complex128

常用方法

array.shape array的规格

array.ndim

array.dtype array的数据规格

numpy.zeros(dim1,dim2) 创建dim1*dim2的零矩阵

numpy.arange

numpy.eye(n) /numpy.identity(n) 创建n*n单位矩阵

numpy.array([…data…], dtype=float64 )

array.astype(numpy.float64) 更换矩阵的数据形式

array.astype(float) 更换矩阵的数据形式

array*array 矩阵点乘

array[a:b] 切片

array.copy() 得到ndarray的副本，而不是视图

array [a] [b]=array [ a,b ] 两者等价

name=np.array(['bob','joe','will']) res=name==’bob’ res= array([ True, False, False], dtype=bool)

data[True,False,…..] 索引，只索取为True的部分，去掉False部分

通过布尔型索引选取数组中的数据，将总是创建数据的副本。

data[ [4,3,0,6] ] 索引，将第4,3,0,6行摘取出来，组成新数组

data[-1]=data[data.__len__()-1]

numpy.reshape(a,b) 将a*b的一维数组排列为a*b的形式

array([a,b,c,d],[d,e,f,g]) 返回一维数组，分别为[a,d],[b,e],[c,f],[d,g]

array[ [a,b,c,d] ][:,[e,f,g,h] ]=array[ numpy.ix_( [a,b,c,d],[e,f,g,h] ) ]

array.T array的转置

numpy.random.randn(a,b) 生成a*b的随机数组

numpy.dot(matrix_1,matrix_2) 矩阵乘法

array.transpose( (1,0,2,etc.) ) 对于高维数组，转置需要一个由轴编号组成的元组

索引和切片

1、数组和标量之间的运算

a+1 a*3 1//a a**0.5

2、同样大小数组之间的运算

a+b a/b a**b3、数组的索引：

一维数组：a[5]

多维数组：

列表式写法：a[2][3]

新式写法：a[2,3] (推荐)

数组的切片：

一维数组：a[5:8] a[4:] a[2:10] = 1多维数组：a[1:2, 3:4] a[:,3:5] a[:,1]4、强调：与列表不同，数组切片时并不会自动复制，在切片数组上的修改会影响原数组。 【解决方法：copy()】

一元函数

numpy.sqrt(array) 平方根函数

numpy.exp(array) e^array[i]的数组

numpy.abs/fabs(array) 计算绝对值

numpy.square(array) 计算各元素的平方 等于array**2numpy.log/log10/log2(array) 计算各元素的各种对数

numpy.sign(array) 计算各元素正负号

numpy.isnan(array) 计算各元素是否为NaN

numpy.isinf(array) 计算各元素是否为NaN

numpy.cos/cosh/sin/sinh/tan/tanh(array) 三角函数

numpy.modf(array) 将array中值得整数和小数分离，作两个数组返回

numpy.ceil(array) 向上取整,也就是取比这个数大的整数

numpy.floor(array) 向下取整,也就是取比这个数小的整数

numpy.rint(array) 四舍五入

numpy.trunc(array) 向0取整

numpy.cos(array) 正弦值

numpy.sin(array) 余弦值

numpy.tan(array) 正切值

二元函数

numpy.add(array1,array2) 元素级加法

numpy.subtract(array1,array2) 元素级减法

numpy.multiply(array1,array2) 元素级乘法

numpy.divide(array1,array2) 元素级除法 array1./array2

numpy.power(array1,array2) 元素级指数 array1.^array2

numpy.maximum/minimum(array1,aray2) 元素级最大值

numpy.fmax/fmin(array1,array2) 元素级最大值，忽略NaN

numpy.mod(array1,array2) 元素级求模

numpy.copysign(array1,array2) 将第二个数组中值得符号复制给第一个数组中值

numpy.greater/greater_equal/less/less_equal/equal/not_equal (array1,array2)

元素级比较运算，产生布尔数组

numpy.logical_end/logical_or/logic_xor(array1,array2)元素级的真值逻辑运算

数学和统计方法

sum 求和

cumsum 求前缀和

mean 求平均数

std 求标准差

var 求方差

min 求最小值

max 求最大值

argmin 求最小值索引

argmax 求最大值索引

随机数

随机数生成函数在np.random子包内

常用函数

rand给定形状产生随机数组(0到1之间的数)

randint给定形状产生随机整数

choice给定形状产生随机选择

shuffle与random.shuffle相同

uniform给定形状产生随机数组