【Numpy学习】总结，一文速通Numpy

本文较适合
已经学习过一遍numpy或对numpy已经有一定认识的人在总体上回溯

核心 ndarray

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。ndarray 对象是用于存放同类型元素的多维数组。 ndarray 内部由以下内容组成：

• 一个指向数据（内存或内存映射文件中的一块数据）的指针。
• 数据类型或 dtype，描述在数组中的固定大小值的格子。
• 一个表示数组形状（shape）的元组，表示各维度大小的元组。
• 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。

ndarray 对象结合索引模式，将每个元素映射到内存块中的一个位置。内存块以行顺序(C样式)或列顺序(FORTRAN或MatLab风格，即前述的F样式)来保存元素。

索引与切片

基础切片

与python相似

标志是带有 :

a[0:2,2:4]
#对于二维数组，取0-1行且2-3列
a[:,2]
#所有行，第二列

布尔索引切片

以布尔值ndarray迭代引用

遵循广播原则

一维

a=np.arange(4)
b=a>=2#b为[False False True True]
print(a[b])#输出[2 3]
#####
a[a<2]=1#a中<2的值都赋值为1
a[a>=2]=5#a中>=2的值都赋值为5

二维

同一维

注意：下标引用返回一维数组

target
Out[74]: 
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
target[np.ix_([True, False, True], [True, False, True])]
Out[76]: 
array([[0, 2],
       [6, 8]])

target[np.ix_([1,2], [True, False, True])]
Out[77]: 
array([[3, 5],
       [6, 8]])

条件组合

与 & 或 |

a = np.arange(10)
print(a)
print("-"*30)
b= (a % 2 == 0) | (a < 7)
print(b)
print("-"*30)
print(a[b])

神奇索引

用数字列表引用数组

#对于一维数组，取下标为1 5 6 7的元素，而对二维数组，是取出行(也就是相对一维元素)
a[[1,5,6,7]]
#取二维坐标为[1,0],[5,3]的元素
a[[1,5],[0,3]]

创建数组

array与range创建

#迭代创建
a=np.array(可迭代对象)
#帮你迭代(内建函数)
b=np.arange(1,6)

ones与zeros

创建全是1或者0的数组

下面以ones为例

np.ones(shape,dtype=None,order='C')
#参数为shape,dtype,order
#order:选择规定返回数组元素在内存中的存储顺序:C(C语言);F(Fortran)
a=np.ones(3)#a为 [1. 1. 1.]
b=np.ones((2,3))#b为[[1. 1. 1.][1. 1. 1.]]
c=np.ones((5),dtype=np.int)#c为[1 1 1 1 1]

full

创建指定值的数组

np.full(shape,fill_value,dtype,order)
#fill_value:标量
np.full(3,520)#为[520 520 520]
np.full((2,1),520)#[[520] [520]]

ones_like与zeros_like与full_like

创建形状相同的数组

以full_like为例

np.ones_like(a,dtype=float,order='C',subok=True)
#a为需要模仿的数组
#subok:bool,可选。True:使用a内部的数据类型;反之

a=np.array([[0,1],[3,4]])
b=np.full_like(a,520)#[[520 520] [520 520]]

linspace平均分布

np.linespace(1,5,11)#起始，终止，样本个数

eye单位阵

np.eye(3)
'''([[1., 0., 0.],
     [0., 1., 0.],
     [0., 0., 1.]])'''
np.eye(3,k=1)
'''([[0., 1., 0.],
     [0., 0., 1.],
     [0., 0., 0.]])
'''

empty

空混乱数组

ndarray类基础属性方法

dtype

• 数据的类型（整数，浮点数或者 Python 对象）
• 数据的大小（例如， 整数使用多少个字节存储）
• 数据的字节顺序（小端法或大端法）
• 在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分
• 如果数据类型是子数组，那么它的形状和数据类型是什么。

numpy.dtype(object, align, copy)
#object - 要转换为的数据类型对象
#align - 如果为 true，填充字段使其类似 C 的结构体。
#copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

import numpy as np
###设置数据类型
#与C语言相近,类型自查
a=np.array(range(1,8),dtype='float32')
###查看数据类型
print(a.dtype)
#修改数据类型(会返回新对象，原本的不变)
a=a.astype(np.int8)
###开拓自己的类型(结构化数据类型)
下面的示例定义一个结构化数据类型 student，包含字符串字段 name，整数字段 age，及浮点字段 marks
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')]) 
print(student)#[('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)]

shape

返回一个元组，表示array的维度

ndim

返回一个数字，列向量维数

size

返回一个数字，为元素个数

reshape

所有元素拆开重排

返回新对象，原本不变

#传几维元组就转换为几维
a.reshape((3,4))

flatten

提取所有元素展开为1维

返回新对象，原本不变

r_ ，c_

对于二维数组而言， r_ 和 c_ 分别表示上下合并和左右合并

计算数组

nan 0除0结果

inf 无穷

广播原则

两个数组的后缘维度轴长相等 或者 其中一方的长度为1，则认为它们是兼容的，会把小的拼凑成大同型的进行运算

46 可与41、1*6

246 可与 46、41

加减乘除数字

对应元素直接加减乘除（不是矩阵算法）

加减为全加减

加减矩阵

直接加减

符合广播原则

轴概念与转置

Numpy的轴

有几个维度就有几个轴，从0轴开始

转置

传入所有轴信息，默认行列转置

ndarray.transpose()
ndarray.T

轴交换

swapaxes

传入两个轴号

交换两轴

a.swapaxes(1,0)#等价于行列转置

数组统计计算

统计

关于略过缺失值

必须使用nan*类型函数

所有统计函数都有对应的nan*函数

具体应该是在函数名前加nan

关于axis参数

它能够进行某一个维度下的统计特征计算

平均值

numpy.mean(arr, axis=None, dtype=None, out=None)

参数axis表示沿着哪个轴进行计算，默认为None，表示计算整个数组的平均值；例如[[1 2],[3,4]]沿0轴作和则返回[4 6]

dtype表示返回结果的数据类型，默认为float64；

out表示将结果存储在指定的数组中,一般情况下，传个数组进去就可以了，其他的用默认的就好了，其它的方法也是一样，

import numpy as np
data=[1,5,6,9]
mindle=np.mean(data)
print(mindle)

加权平均

np.average(arr,axis=None,weights=list[])

weights参数传入一个可迭代对象，数据小于1

方差

numpy.var(arr, axis=None, dtype=None, out=None)

标准差

numpy.std(arr, axis=None, dtype=None, out=None)

中位数

numpy.median(arr, axis=None, out=None):

import numpy as np
data=[1,5,6,9]
data1=np.median(data)
print(data1)

最小值

numpy.min(arr, axis=None, out=None)

最大值

numpy.max(arr, axis=None, out=None)

分位数

np.quantile(arr,分位)

协方差

np.cov(arr1,arr2)

相关系数

np.corrcoef(arr1,arr2)

计算

元素之和

numpy.sum(arr, axis=None, dtype=None, out=None)

元素乘积

numpy.prod(arr, axis=None, dtype=None, out=None)

累加和（前缀和）

返回ndarray

numpy.cumsum(arr, axis=None, dtype=None, out=None)

累积积

返回ndarray

np.cumprod(a)

累减差（差分）

返回ndarray，比原本长度少一

np.diff()

通用函数

一元

倒数

np.reciprocal()

平方根

np.sqrt(ndarray)

e^x

np.exp()

abs，fabs（非复数）

对数

log，log10，log2…

符号函数

np.sign()

顶与底

返回整数

ceil

floor

整数四舍五入

rint

拆分小数位和整数位

modf

判定

isnan

isfinite

isinf

索引

返回整数，不是坐标，而是元素排序位置

argmax

argmin

更多数学函数

cos

cosh…

二元

取模

计算输入数组中相应元素的相除后的余数函数

• np.mod(ndarray1,ndarray2)
• np.remainder()

maximum minimum

取最大or取最小

mod

比较运算

返回布尔型数组

逻辑运算

返回布尔值

• logical_and
• …

位运算

• numpy.bitwise_and(x1, x2)
• …

也可以使用 “&”、 “~”、 “|” “^”、“~”、“<<”、“>>” 等操作符进行计算

指数运算

• power

#三次幂
np.power(ndarray,3)

排序与条件计算

排序

sort()

修改原始数组

np.sort(a,axis=-1, kind='quicksort', order=None)
#axis默认为最后的轴
#kind为排序算法
#order：排序的字段名，可以指定字段排序

lexsort()

用于对多个序列进行排序 , 排序时优先照顾靠后的列

返回索引ndarray

布尔条件

用于判定布尔数组

all()

全真

any()

有一真

索引

返回索引的函数

np.argsort()

返回索引排序后的数组

np.argmax()

np.argmin()

np.nonzero()

非零处

np.where

a = np.array([[1,3,6],[9,3,2],[1,4,3]])
print(f'数组:\n{a}')
print('-'*30)
print(a>3)#布尔数组
print('-'*30)
print(np.where(a>3,520,1314))#大于3处改为520，否则1314

np.extract

感觉没什么用

唯一值 unique

去除重复，并排序

其它集合逻辑

• in1d

逐个检查是否存在于第一个参数中，返回布尔ndarray

a = np.array([6,0,0,3,2,5,6])
print(np.in1d(a,[2,3,6]))

• intersect1d

计算交集，并排序

• …

线性代数

NumPy 提供了线性代数函数库 linalg

NumPy 线性代数 | 菜鸟教程

乘积

• dot
• @ ：是一个经过重载的运算符，用于计算乘积

两个数组点积

• vdot

两个向量点积（与dot不同！！）

• inner

对于一维数组，它计算的是普通的向量内积；对于更高维度的数组，计算最后一个轴的内积，并将其余的轴进行广播

秩

• linalg.matrix_rank()

行列式

• linalg.det()

• determinant

解线性方程组

• linalg.solve()
• solve ()

Ax=B

第一个参数是A，第二个是B

逆

• linalg.inv()
• inv

范数

向量范数和矩阵范数： np.linalg.norm

在矩阵范数的计算中，最重要的是 ord 参数，可选值如下：

ord	norm for matrices	norm for vectors
None	Frobenius norm	2-norm
‘fro’	Frobenius norm	–
‘nuc’	nuclear norm	–
inf	max(sum(abs(x), axis=1))	max(abs(x))
-inf	min(sum(abs(x), axis=1))	min(abs(x))
0	–	sum(x != 0)
1	max(sum(abs(x), axis=0))	as below
-1	min(sum(abs(x), axis=0))	as below
2	2-norm (largest sing. value)	as below
-2	smallest singular value	as below
other	–	sum(abs(x)ord)(1./ord)

In [125]: matrix_target =  np.arange(4).reshape(-1,2)

In [126]: matrix_target
Out[126]: 
array([[0, 1],
       [2, 3]])

In [127]: np.linalg.norm(matrix_target, 'fro')
Out[127]: 3.7416573867739413

In [128]: np.linalg.norm(matrix_target, np.inf)
Out[128]: 5.0

In [129]: np.linalg.norm(matrix_target, 2)
Out[129]: 3.702459173643833
In [130]: vector_target =  np.arange(4)

In [131]: vector_target
Out[131]: array([0, 1, 2, 3])

In [132]: np.linalg.norm(vector_target, np.inf)
Out[132]: 3.0

In [133]: np.linalg.norm(vector_target, 2)
Out[133]: 3.7416573867739413

In [134]: np.linalg.norm(vector_target, 3)
Out[134]: 3.3019272488946263

numpy额外方法

round

取位数

返回新对象

ndarray对象 = np.round(ndarray对象,保留位数)

random

生成随机数（数组），返回ndarray对象

randn

N(0,1)正太分布

a=np.random.randn()#一个随机数
b=np.random.randn(3)#3个数
c=np.random(3,2)#3行2列的

rand

[0,1)对称概率分布

使用方法同上

randint

随机整数，范围自定

#随机1至10之间的整数  
b = np.random.randint(1,10)  
#随机1至10之间取5个元素组成一维数组{c}
c = np.random.randint(1,10,size=(5,))
#随机1至20之间取24个元素组成三维数组
e = np.random.randint(1,20,size=(2,3,4))

random

[0.0,1.0)和rand差不多

但是要size才能返回数组,否则返回浮点

#生成2行3列共6个数的0.0至1.0的随机数
a = np.random.random(size=(2,3))

choice

# 第一参数是一个1维数组，如果只有一个数字那就看成range(5)
# 第二参数是shape
a = np.random.choice(5,3)
print(f'从range(5)中拿随机数，生成只有3个元素的一维数组是：{a}')

shuffle

把一个ndarray进行随机排列

np.random.shuffle(a)

注意：多维数组随机排列只主元整个按随机，其余是不变的

permutation

把一个ndarray进行随机排列(不放回抽样)返回（不改变原本）

或者产生新随机

a = np.random.permutation(10)
b = np.random.permutation(a)

normal

正态分布

normal（平均值，标准差，shape）

a = np.random(1,10,10)

uniform

均匀分布

用法同normal

choice

可以从给定的列表中，以一定概率和方式抽取结果，当不指定概率时为均匀采样，默认抽取方式为有放回抽样

my_list = ['a', 'b', 'c', 'd']
np.random.choice(my_list, 2, replace=False, p=[0.1, 0.7, 0.1 ,0.1])
Out[51]: array(['b', 'a'], dtype='<U1')
np.random.choice(my_list, (3,3))
Out[52]: 
array([['a', 'c', 'b'],
       ['a', 'a', 'c'],
       ['b', 'a', 'b']], dtype='<U1')

seed

它能够固定随机数的输出结果

视图与副本

视图（浅拷贝）

• 1、numpy 的切片操作返回原数据的视图。
• 2、调用 ndarray 的 view() 函数产生一个视图。

副本（深拷贝）

• Python 序列的切片操作，调用deepCopy()函数。
• 调用 ndarray 的 copy() 函数产生一个副本。

文件（IO）

NumPy 为 ndarray 对象引入了一个简单的文件格式：npy

保存数组到文件

• save

numpy.save(file, arr, allow_pickle=True, fix_imports=True)
#file：要保存的文件名(.npy)
#arr：要保存的数组
np.save('my_array.npy', data)

• savez

numpy.savez(file, *args, **kwds)
#要保存的文件名(.npz)
#args: 要保存的数组(可以是多个)可以使用关键字参数为数组起一个名字，非关键字参数传递的数组会自动起名为 arr_0, arr_1, …　
#kwds: 要保存的数组使用关键字名称
a = np.array([[1,2,3],[4,5,6]])
b = np.arange(0, 1.0, 0.1)
c = np.sin(b)
# c 使用了关键字参数 sin_array
np.savez("x.npz", a, b, sin_array = c)
r = np.load("x.npz")  
print(r.files) # 查看各个数组名称
print(r["arr_0"]) # 数组 a
print(r["arr_1"]) # 数组 b
print(r["sin_array"]) # 数组 c

• savetxt()

savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。

np.savetxt('out.txt',a) 

加载数组

• load

loaded_data = np.load('my_array.npy')

• loadtxt

b = np.loadtxt('out.txt')  

本文部分内容摘自菜鸟教程
菜鸟教程