Numpy库的使用

创建数组对象

axis为轴，n维数组有n个轴，axis的取值为1,2,3,4…,n

1、数组属性

属性	说明
ndim	表示数组的维度
shape	表示数组的尺寸,(n,m)
size	返回数组的元素总数
dtype	描述数组中元素的类型
itemsize	表示数组的每个元素的大小（以字节为单位）
arr.astype(‘数组类型’)	转换数组类型
arr.astype(np.数组类型)	转换数组类型

2、数组创建

array

numpy.array(object,dtype=None,copy=True,order='k',subok=False,ndmin=0)

参数名称	说明
object	接收array,表示想要创建的数组
dtype	接受data-type,表示数组所需的数据类型
ndmin	接受int,指定生成数组应该具有的最小维数

import numpy as np
arr1 = np.array([1,2,3,4]) #创建一维数组
arr2 = np.array([[1,2,3],[4,5,6],[7,8,9]]) #创建二维数组
In [6]: print('数组维度为：',arr2.shape)
数组维度为： (3, 3)
In [7]: print('数组类型为：',arr2.dtype)
数组类型为： int32
In [8]: print('数组元素个数为：',arr2.size)
数组元素个数为： 9
In [9]: print('数组元素大小为：',arr2.itemsize)
数组元素大小为： 4

一维数组的创建

arange

In [10]: np.arange(0,1,0.1)
Out[10]: array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])

linspace

#创建等差数列，包含终点值
In [14]: np.linspace(0,1,5,endpoint=True, retstep=False, dtype=None)
Out[14]: array([0.  , 0.25, 0.5 , 0.75, 1.  ])

logspace

#创建等比数列,生成5个10^0~10^2等比数
In [18]: np.logspace(0,2,5)
Out[18]:
array([  1.        ,   3.16227766,  10.        ,  31.6227766 ,
       100.        ])

zeros,eye,diag,ones

#创建特殊矩阵
np.zeros((2,3))  #2行3列的0矩阵
np.eye(3)        #3行3列的单位矩阵
np.diag([1,2,3,4])   #生成对角矩阵  
np.ones((5,3))   #5行3列的1矩阵

3、数组数据类型

可用于作数据预处理

类型	描述
bool	布尔型
inti	由所在平台决定其精度
int8(16、32、64)	整型
uint8(16、32、64)	无符号整型
float(16、32、64)	浮点数
complex(64、128)	复数

4、生成随机数组

函数	描述
np.random.random(n)	n个随机数构成的一维数组
np.random.rand(n,m)	服从均匀分布的n行m列矩阵
np.random.randn(n,m)	服从正态分布的n行m列矩阵
np.random.randint(low,high=None,size=None)	数组尺寸为size，元素范围在low~high的矩阵

常用随机数生成函数

函数	描述
seed	随机数种子
permutation	返回序列的一个随机排列或范围
Shuffle	对序列进行随机排序
binomial	产生二项分布的随机数
normal	产生正态分布的随机数
beta	产生beta分布的随机数
chisquare	产生卡方分布的随机数
gamma	产生gamma分布的随机数
uniform	产生在[0,1]中均匀分布的随机数

5、数组索引

一维数组

arry[n :m :h] #从n~m-1以h为步长

二维数组

arry[row,col] #row为行，col为列

arry[[(0,1,2),(1,2,3)]] #索引对应行对应列的元素

arry[1:,(0,2,3)] #索引2、3行对应的023列元素

6、变换数组的形态

改变数组形状

arr = np.arange(12)  #创建一维数组
arr1 = arr.reshapde(3,4)
arr2 = arr1*3
arr3 = np.arange(16).reshape(4,4)

函数	描述
arr.reshape(n,m)	将一维数组变成n行m列数组，不改变原有数组
arr1.ravel()、arr1.flatten()	横向展平数组
arr1.flatten(‘F’)	纵向展平数组
np.hstack((arr1,arr2))	两个数组横向组合
np.vstack((arr1,arr2))	两个数组纵向组合
np.concatenate((arr1,arr2),axis=1)	axis为1时横向组合，axis为0时纵向组合
np.hsplit(arr3,2)	横向分割arr3，左右分开
np.vsplit(arr3,2)	纵向分割arr3，上下分开
np.split(arr3,2,axis=1)	axis为1时横向分割，axis为0时纵向分割
arr.shape=(m,n)	将数组arr变为(m,n)的数组，改变原有数组

数据的分裂

• 将一个数组分成几个较小的数组
• 既然可以将多个数组进行对堆叠，自然也可以将一个数组拆分成多个小数组。
• 和拼接有以下对应关系：
  • split —>concatenate
  • hsplit—>hstack
  • vsplit—>vstack
• 使用hsplit，可以沿其水平轴拆分数组，通过指定要返回的均匀划分的数组数量，或通过指定要在其后进行划分的列：

1、np.split()

• 语法：np.split（ary，indices_or_sections，axis = 0）
• 作用：将数组拆分为多个子数组。
  - ary：ndarray。
  - indices_or_sections：int或1-D数组。
  - 如果indices_or_sections是一个整数N，则数组将被分割沿着’轴’进入N个相等的数组。
  - 如果indices_or_sections是排序整数的1-D数组，则为条目指示数组被分割的“轴”的位置。
  - 如果索引超过沿“轴”的数组维度，相应地返回一个空的子数组。
• axis：int，可选。要拆分的轴，默认为0。

1. 如果indices_or_sections是一个整数N，则数组将被分割沿着’轴’进入N个相等的数组

   #如果indices_or_sections是一个整数N，则数组将被分割沿着'轴'进入N个相等的数组
   import numpy as np
   a=np.ones((2,2),dtype='int')
   b=np.zeros((2,2),dtype='int')
   c=np.concatenate([a,b],axis=0)
   c
   np.split(c,2,axis=0)  #返回的对象其实是子阵列表
   #返回的对象其实是子阵列表,因此是可以进行索引操作的
   np.split(c,2,axis=0)[0]
   
   

2. 如果indices_or_sections是排序整数的1-D数组，则为条目指示数组被分割的“轴”的位置。

   #如果indices_or_sections是排序整数的1-D数组，则为条目指示数组被分割的“轴”的位置。 
   d=np.array([[1, 1],
               [1, 1],
               [2, 2],
               [2, 2],
               [3, 3],
               [3, 3],
               [4, 4],
               [4, 4]]) 
   np.split(d,[5],axis=0)
   #将数组切分成三份(两到三段)
   np.split(d,[3,6],axis=0)  #注意这里不要写切片的冒号
   #将数组切分成四份(三刀四段)
   np.split(d,[2,4,6],axis=0)  
   

2、np.vsplit()

• 语法：np.vsplit（ary，indices_or_sections）
• 作用：将数组垂直拆分为多个子数组（按行）。
• ‘vsplit’相当于’split’用’axis = 0’来’拆分’，数组总是沿着第一个轴分开,无论数组尺寸如何。

3、np.hsplit()

• 语法：np.hsplit（ary，indices_or_sections）
• 作用：将数组水平拆分为多个子数组（按列）。
• ‘hsplit’相当于’split’用’axis = 1’来’拆分’，数组总是沿着第二个分开,轴与阵列尺寸无关。

7、复制和视图

简单赋值

简单赋值不会创建数组对象或其数据的拷贝。

In [8]: a = np.arange(6)

In [9]: b = a

In [10]: id(a),id(b)
Out[10]: (2562742930128, 2562742930128)

视图

a.view()

• 不同的数组对象可以共享相同的数据。view方法创建一个新数组对象，该对象看到相同的数据。
• 新数组数据更改后，会影响原始数据。

In [14]: a = np.arange(0, 12, 1).reshape(6, 2)^M
    ...: c = a.view()

In [15]: id(a),id(c)
Out[15]: (2562742848848, 2562743600592)

新数组数据更改后，会影响原始数据。类似于原生python中的浅复制：

In [16]: a[0,1]=11^M
    ...: ^M
    ...: a^M
    ...: c  #c = a.view()
Out[16]:
array([[ 0, 11],
       [ 2,  3],
       [ 4,  5],
       [ 6,  7],
       [ 8,  9],
       [10, 11]])

数组副本

也可以通过.copy()方法创建一个副本，类似于原生python的深复制。

import numpy
a = np.random.randint(2, size=(3, 4)) # 二维数组
b = a.copy()
a
b
id(a),id(b)
a[0, 0]= 8888
a
b

Numpy矩阵与通用函数

1、创建Numpy矩阵

函数	描述
np.mat(‘1 2 3;4 5 6;7 8 9’)	创建矩阵
np.matrix([[1,2,3],[4,5,6],[7,8,9]])	创建矩阵
np.bmat(‘arr1 arr2;arr2 arr1’)	分块矩阵组合

矩阵运算

import numpy as np
matr1 = np.mat('1 2 3;4 5 6; 7 8 9')
matr2 = matr1*3  #矩阵与数相乘

matr1+matr2	矩阵相加
matr1-matr2	矩阵相减
matr1*matr2	矩阵相乘
np.multiply(matr1,matr2)	矩阵对应元素相乘

• 需要注意的是，乘法运算符*的运算在NumPy数组中也是元素级别的。
• 如果想要执行矩阵乘积，可以使用dot函数：
• dot(a, b, out=None)
  • 如果’a’和’b’都是1-D数组，它就是向量的内积。
  • 如果’a’和’b’都是二维数组，那就是矩阵乘法。
  • 如果’a’或’b’是0-D（标量），它相当于’numpy.multiply（a，b）'或’a * b’是首选。
  • 如果’a’是N-D数组而’b’是1-D数组，则它是和的乘积’a’和’b’的最后一个轴。

c = np.array( [[1,1], [0,1]] )
d = np.array( [[2,0], [3,4]] )
c.dot(d)  
np.dot(c,d)
array([[5, 4],
       [3, 4]])

矩阵特有属性

属性	说明
T	返回自身的转置
H	返回自身的共轭转置
I	返回自身的逆矩阵
A	返回自身数据的二维数组的视图

matr1 = np.mat("1 2 3;4 5 6;7 8 9")
In [15]: matr1.T
Out[15]:
matrix([[1, 4, 7],
        [2, 5, 8],
        [3, 6, 9]])

2、ufunc(通用)函数

常用的ufunc函数运算

• 四则运算：+、-、*、/、**，支持全部四则运算，与数值运算方式一样，且运算的两个数组的形状必须相同
• 比较运算：>、<、==、>=、<=、!=，返回数组每个元素比较后的结果，结果为bool类型
• 逻辑运算：np.all()表示逻辑and、np.any()表示逻辑or

基本函数运算

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0oKCXBbp-1577094608504)(F:\python\笔记\（0）AI学习\图片\numpy（1）.png)]

通用函数广播机制

广播指不同形状的数组之间执行算术运算的方式。（一维数组加二维数组）

In [1]: import numpy as np
In [2]: arr1 = np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
In [3]: arr2 = np.array([1,2,3])
In [4]: arr1+arr2
Out[4]:
array([[1, 2, 3],
       [2, 3, 4],
       [3, 4, 5],
       [4, 5, 6]])
In [18]: arr1 = np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
In [19]: arr3 = np.array([1,2,3,4]).reshape((4,1))
In [20]: arr1+arr3
Out[20]:
array([[1, 1, 1],
       [3, 3, 3],
       [5, 5, 5],
       [7, 7, 7]])

####广播规则

规则1：如果两个数组的维度数不相同，那么小维度数组的形状将会补齐

import numpy as np
np.ones((3,3))+np.arange(3)
np.ones((3,3))+np.ones((3,1))
np.ones((3,3))+np.ones((2,3))##会报错

规则2：如果两个数组的形状在任何一个维度都不匹配，数组的形状会沿着维度为1的维度扩展，以匹配另外一个数组形状。

np.arange(3).reshape(3,1)+np.arange(3)

规则3：如果两个数组的形状在任何一个维度上都不匹配并且没有任何一个维度等于1，会广播错误。

##会报错
np.arange(3).reshape(3,2)
np.arange(3)

np.arange(3).reshape(3,2)+np.arange(3)

函数的向量化

1、frompyfunc 函数

frompyfunc（func，nin，nout）

• 采用任意Python函数并返回NumPy ufunc。
• 例如，可以用于向内置Python添加广播功能。
• 参数
  • func：Python函数对象，任意Python函数。
  • nin：int，输入参数的数量。
  • nout：int，'func’返回的对象数。（NumPy通用函数（ufunc）对象。）

2、vectorize 函数

np.vectorize([‘pyfunc’，‘otypes = None’）

• 定义一个矢量化函数，它接受一组嵌套的对象或numpy数组作为输入并返回单个numpy数组或元组输出。
  • pyfunc：可调用python函数或方法。
  • otypes：str或dtypes列表，可选输出数据类型。必须将其指定为字符串typecode字符或数据类型说明符列表。应该是每个输出的一个数据类型说明符。
• 需要注意的是，vectorize函数主要作用是提供便利，而不是性能。它的实现本质上是for循环。

def fun(x,y):
    if x>y:
        return 1
    else:
        return 2
a=np.array([1,12,5,6,7,9])
b=np.array([5,6,7,8,9,12])
fun_array = np.vectorize(fun,otypes=[float])       #这里只是将上一节的np.frompyfunc改成np.vectorize
fun_array(a,b)

3、判断符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-akj3sHXx-1577094608509)(F:\python\笔记\（0）AI学习\图片\numpy（2）.png)]

In [3]: import numpy as np

In [4]: a=np.array([1,2,3])^M
   ...: b=np.array([True,False,True])^M
   ...: ^M
   ...: a[b]
Out[4]: array([1, 3])
    
In [5]: np.random.seed(0)
   ...: a=np.random.randint(10,size=(3,3))
   ...: a
   ...: a>5
   ...: a[a>5]
Out[5]: array([7, 9])

Numpy进行统计分析

1、读/写文件

文件的读/写主要有二进制的文件读/写和文件列表形式的数据读/写两种形式。

二进制文件

函数	说明
np.save(file_path,arr,allow_pickle=True,fix_imports=True)	以二进制的格式保存数据
np.savez(file_path,arr1,arr2)	多个数组存储
np.load(“file_path.npy”)	读取单个数组的文件
np.load(“file_path.npz”)	读取多个数组的文件

文本文件

函数	说明
np.savetxt(fname,X,fmt=’%.18e’,delimiter=’ ,’,mewline=’\n’,header=’’,footer=’’,comments=’#’)	保存为文本文件
np.loadtxt(‘file_path’,delimiter=’,’)	读入文件
np.genfromtxt(file_path,delimiter=’,’)	读取，输出一组结构化数据

2、简单的统计分析

numpy的快速排序

函数	说明
arr.sort()	直接排序
arr.sort(axis=1)	1为横轴排序，0为纵轴排序
arr.argsort()	返回排序后值对应的下标
np.lexsort((a,b,c))	a,b,c为数组，多个键值排序时，按照最后一个传入的数组进行排序
np.unique()	去重
np.tile(arr,n)	将arr数组重复n次
np.repeat(arr,n,axis=None)	将arr数组重复n次,axis指沿哪个轴进行重复

tile函数是对数组进行重复操作，repeat函数是对数组中的每个元素进行重复操作

import numpy as np
arr = np.array([2,3,6,8,0,7])
print(arr.argsort())


a = np.array([3,2,6,4,5])
b = np.array([50,30,40,20,10])
c = np.array([400,300,600,100,200])
d = np.lexsort((a,b,c))
print(list(zip(a[d],b[d],c[d])))

#输出结果
[4 0 1 2 5 3]
[(4, 20, 100), (5, 10, 200), (2, 30, 300), (3, 50, 400), (6, 40, 600)]

数组的交并差，唯一

方法	说明
unique(x)	计算x中的唯一元素，并返回有序结果
intersect1d(x,y)	计算x和y的公共元素，并返回有序结果。
union1d（x,y）	计算x和y的并集，并返回有序结果。
in1d(x,y)	得到一个表示“x的元素是否包含于y”的布尔型数组。
setdiff1d(x,y)	集合的差，即元素在x中且不在y中。
setxor1d(x,y)	集合的对称性，即存在于一个数组中但不同时存在于两个数组中的元素

3、常用统计函数

np.sum(arr)	计算数组的和
arr.sum(axis=0)	0代表沿纵轴求和，1代表沿横轴求和
np.mean(arr)	计算数组的均值
arr.mean(axis=0)	0代表沿纵轴求均值，1代表沿横轴求均值
np.std(arr)	计算数组标准差
np.var(arr)	计算数组方差
np.max(arr)	计算数组最大值
np.min(arr)	计算数组最小值
np.argmin(arr)	返回数组最小元素的索引
np.argmax(arr)	返回数组最大元素的索引
np.cumsum(arr)	计算所有元素的累计和
np.cumprod(arr)	计算所有元素的累计积

>>> arr = np.arange(2,10)
>>> np.cumsum(arr)
array([ 2,  5,  9, 14, 20, 27, 35, 44], dtype=int32)
>>> np.cumprod(arr)
array([     2,      6,     24,    120,    720,   5040,  40320, 362880],dtype=int32)

Numpy的一些操作

np.max(arr) | 计算数组最大值 |
| np.min(arr) | 计算数组最小值 |
| np.argmin(arr) | 返回数组最小元素的索引 |
| np.argmax(arr) | 返回数组最大元素的索引 |
| np.cumsum(arr) | 计算所有元素的累计和 |
| np.cumprod(arr) | 计算所有元素的累计积 |

>>> arr = np.arange(2,10)
>>> np.cumsum(arr)
array([ 2,  5,  9, 14, 20, 27, 35, 44], dtype=int32)
>>> np.cumprod(arr)
array([     2,      6,     24,    120,    720,   5040,  40320, 362880],dtype=int32)

Numpy的一些操作