numpy的使用(一)(reshape()有待研究)

numpy的使用

numpy简介

numpy是Python中用来处理大量的维度数组与矩阵运算的库,也针对数组运算提供了大量的数学函数库.
numpy主要哦用于数组计算,包含:

• 一个强大的N维数组对象ndarry
• 广播功能函数
• 整合C/C++/Fortran代码的工具
• 线性代数、傅里叶变换、随机数生成等功能
  numpy通常与SciPy(Scientific Python)和Matplotlib(绘图库)一起使用,这种组合广泛用于替代MATLAB.是一个强大的科学计算环境,有助于我们通过Python学习数据科学或者机器学习.
  SciPy是一个开源的Python算法库和数学工具包.
  SciPy包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算.
  Matplotlib是Python编程语言机器数值数学扩展包numpy的可视化操作界面.它为利用通用的图形用户界面工具包,如Tkinter,wxPython,Qt或者GTK+想应用程序嵌入式绘图提供了应用程序接口(API).

numpy的Ndarray对象

numpy最重要的一个特点是其N维数组对象ndarray,它是一系列同类型数据的集合,以0下标为开始进行集合中元素的索引.
ndarray对象是用于存放同类元素的多维数组.
ndarray中的每个元素在内存中都有相同存储大小的区域.
ndarray内部由以下内容组成:

• 一个指向数据(内存或内存映射文件中的一块数据)的指针;
• 数据类型或dtype:描述在数组中的固定大小值的个子;
• 一个表示数组形状(shape)的元组,表示各维度大小的元组;
• 一个跨度元祖(stride):其中的整数指的是为了前进道当前维度下一个元素需要"跨过"的字节数.
  注释:跨度可以是复数,这样会使数组在内存中后向移动,切片中obj[::-1]或者obj[:,::-1]就是如此
注释:ndarray是一个对象,而array是一个方法.

ndarray的创建

创建一个ndarray对象只需要调用Array函数即可:
numpy.array(object, dtype=None,copy=True, order=None,subok=False, ndmin=0)
参数说明:

名称	描述
object	数组或嵌套的数列
dtype	数组元素的数据类型,可选
copy	对象是否需要复制,可选
order	创建数组样式,C为行方向,F为列方向,A为任意方向(默认)
subok	默认返回一个与基类类型一致的数组
ndmin	指定生成数组的最小维度

ndarray对象由计算机内存的连续一维部分组成,并结合索引模式,将每个元素映射到内存块中的一个位置.内存块以行顺序(C样式)或列顺序(FORTRAN或MATLAB风格,即前述的F样式)来保存元素.

numpy的数据类型

numpy支持的数据类型比Python内置的类型要多很多,基本上可以和C语言的数据类型对应上,其中部分类型对应为Python内置的类型.下表列举了常用的Numpy基本类型.

名称	描述
bool_	布尔型数据类型(True或False)
int_	默认的整数类型(类似于C语言中的long,int32或int64)
intc	与C的int雷影一样,一般是int32或int64
intp	用于索引的整数类型(类似于C的ssize_t,一般情况下仍然是int32或int64)
int8	字节(-128 to127)
int16	字节(-216 to 216-1)
int32	同理
int64	同理
uint8	无符号整数(0 to 28)
unit16(32,64)	同理
float_	float64类型的简写
float16	半精度浮点数,包括1个符号位,5个指数位,10个尾数位
float32	单精度浮点数,包括1个符号位,8个指数位,23个尾数位
float64	双精度浮点数,包括1个符号位,11个指数位,52个尾数位
complex_	complex128的简写,即128位复数
complex64	复数,表示双32位浮点数(实数部分和虚数部分)
complex128	复数,表示双64位浮点数(实数部分和虚数部分)

numpy的数值类型实际上是dtype对象的实例,并对应唯一的字符,包括np.boo;_,np.int32,np.float32,等等

数据类型对象(dtype)

数据类型对象是用来描述与数组对应的内存区域如何使用,这依赖如下几个方面:

• 数据的类型(整数,浮点数或者Python对象)
• 数据的大小(例如,整数使用多少个字节存储)
• 数据的字节顺序(小端法或大端法)
• 在结构化类型的情况下,字段你的名称,每个字段的数据类型和每个字段所取的内存块的部分
• 如果数据类型是子数组,它的形状和数据类型
  字节顺序是通过对数据类型预先设定"<“或”>“来决定的.”<“以为这小端法(最小值存储在最小的地址,即低位组放在最前面).”>"意味着大端法(最重要的字节存储在最小的地址,即高位组放在最前面).
  dtype对象使用一下语法构造的:
  numpy.dtype(object, align, copy)
• object:要转换为的数据类型对象
• align:如果为true,填充字段时期类似C的结构体
• copy:复制dtype对象,如果为false,则是对内置数据类型对象的引用

注释:numpy.dtype对象是用来规范numpy.array创建的数据的数据类型的,可以将多个字段的不同类型放在dtype类型中

numpy中每个内建类型都有一个唯一定义它的字符代码,如下:

字符	对应类型
b	布尔型
i	(有符号)整型
u	无符号整型integer
f	浮点型
c	复数浮点型
m	timedelta(时间间隔)
M	datetime(日期时间)
O	Python对象
S,a	byte-字符串
U	Unicode
V	原石数据(void)

numpy的数组属性

numpy数组的维数称为秩(rank),秩就是轴的数量,即数组的维度,一维数组的秩为1,二维数组的秩为2,以此类推.
在numpy中,每一个线性的数组称为一个轴(axis),也就是维度(dimensions).比如说,二维数组相当于是两个一维数组,其中第一个一维数组中每个元素又是一个一维数组.所以一维数组就是numpy中的轴(axis),第一个轴相当于是底层数组,第二个轴是底层数组里的数组,而轴的数量—秩就是数组的维数.
很多时候可以声明axis,axis=0,表示沿着第0轴进行操作,即对每一列进行操作;axis=1,表示沿着第1轴进行操作,即对每一行进行操作.
numpy的数组中比较重要的ndarray对象属性有:

属性	说明
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	包含实际数组元素的缓冲区,由于一般通过数组的索引获取元素,所以通常不需要使用这个属性.

ndarray.ndim

ndarray.ndim用于返回数组的维数,等于秩.

ndarray.shape()

ndarray.shape()表示数组的维度,返回一个元组,这个元组的航都就是维度的数目,即ndim属性(秩).比如,一个二维数组,其维度表示"行数"和"列数".
ndarray.shape也可以用来调整数组大小.
numpy也提供了reshape()函数来调整数组大小.
ndarray.reshape()方法

import numpy as np

a = np.arange(24)
print(a)
print(a.ndim)
b = a.reshape(2, 4, 3)
print(b)
print(b.ndim)

结果如下:

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
1
[[[ 0  1  2]
  [ 3  4  5]
  [ 6  7  8]
  [ 9 10 11]]

 [[12 13 14]
  [15 16 17]
  [18 19 20]
  [21 22 23]]]
3

ndarray.itemsize

ndarray.itemsize以字节的形式返回数组中每一个元素的大小(占用内存的大小).
例如,一个元素类型为float64的数组itemsize属性值为8(8*8),又如,一个元素类型为complex32的数组item属性为4(8*4)
一个字节的长度为8,float64占用8个字节的长度,一个complex32占用4个字节的长度

ndarray.flags

属性	描述
C_CONTIFUOUS©	数据是在一个单一的C风格的连续段中
F_CONTIFUOUS(F)	数据是在一个单一的Fortran风格的连续段中
OWNDATA(O)	数组拥有它所使用的内存或从另一个对象中借用它
WRITEABLE(W)	数据区域可以被写入,将该值设置为False,则数据为只读
ALIGEND(A)	数据和所有元素都适当地对齐到硬件上
UPDATEIFCOPY(U)	这个数组是其他数组的一个副本,当这个数组被释放时,原数组的内容将被更新

numpy创建数组

ndarray数组除了可以使用底层的ndarray构造器来创建外,也可以通过以下几种方式来创建.

numpy.empty()

numpy.empty()方法用来创建一个指定形状(shape),数据类型(dtype)且未初始化的数组:
numpy.empty(shape, dtype=float, order='C')
参数说明"

参数	描述
shape	数组形状
dtype	数据类型,可选
order	有"C"和"F"两个选项,分别代表,行优先和列优先,在计算机内存中的存储元素的顺序.

使用numpy.empty()方法创建的数组元素为随机值,因为它们未初始化

numpy.zeros()

numpy.zeros()创建指定形状的数组,数组元素以0来填充
numpty.zeros(shape, dtype=float, order='C')
参数说明:
参数|描述
shape|数组形状
dtype|数据类型,可选
order|'C’用于C的航数组,或者’F’用于FORTRAN的列数组

numpy.ones()

numpy.ones()创建指定形状的数组,数组元素以1来填充:
numpy.ones(shape, dtype=None, order='C')
参数说明同numpy.zeros

numpy从已有的数组创建数组

numpy.asarray()

numpy.asarray()类似numpy.array(),但是numpy.asarray参数只有三个,比numpy.array少两个.
numpy.asarray(a, dtype=None, order=None)
参数说明:

参数	描述
a	任意形式的输入参数,可以是:列表,列表的元组,元组,元组的元组,元组的列表,多维数组
dtype	数据类型,可选
order	可选,有’C’和’F’两个选项,分别代表,行优先和列优先,在计算机内存中的存储元素的顺序

numpy.frombuffer()

numpy.frombuffer()用于实现动态数组
numpy.frombuffer()接受buffer输入参数,以流的形式读入转化成ndarray对象
numpy.frombuffer(buffer,dtype=float, count=-1, offset=0)
注意:buffer是字符串的时候,Python3默认str是Unicode类型,所以要转成bytestring在原str前加上b
参数说明:

参数	描述
buffer	可以使任意对象,会以流的形式读入
dtype	返回数组的数据类型
count	读取的数据数量,默认为-1,读取所有数据
offset	读取的起始位置,默认为0

numpy.fromiter()

numpy.fromiter()方法从可迭代对象中建立ndarray对象,返回一维数组
`numpy.fromiter(iterable, dtype, count=-1)
参数说明:

参数	描述
iterable	可迭代对象
dtype	返回数组的数据类型
count	读取的数据数量,默认为-1,读取所有数据

li = range(5)
print(li)
for i in li:
    print(i)
it = iter(li)
print(it)

range(0, 5)
0
1
2
3
4
<range_iterator object at 0x0000000009A8CFD0>

numpy从数值范围创建数组

numpy.arange()

numpy.arange()函数创建数值范围,并返回ndarray对象,函数格式如下:
numpy.arange(start, stop, step, dtype)
根据start与stop指定的范围以及step设定的步长,生成一个ndarray.
参数说明:

参数	描述
start	起始值,默认为0
stop	终止值(不包含)
step	步长,默认为1
dtype	返回ndarray的数据类型,如果没有提供,则会使用输入数据的类型

numpy.linspace()

numpy.linspace()函数用于创建一个一维数组,数组是一个等差数列构成的,格式如下:
numpy.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的数据类型

numpy.logspace()

numpy.logspace()函数用于创建一个等比数列,格式如下:
numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
base参数意思是取对数的时候log的下标
参数说明:

参数	描述
start	序列的起始值为:base**start
stop	序列的终止值为:base**stop.如果endpoint为true,该值包含于数列中
num	要生成 的等步长样本数量,默认为50
endpoint	该值为true时,数列中包含stop的值,反之不包含,默认是true
base	对数log的底数
dtype	ndarray的数据类型

numpy的切片和索引

ndarray对象的内容可以通过索引或切片来访问和修改,与Python中的list的切片操作一样.
ndarray数组可以基于0-n的下标进行索引,切片对象可以通过内置的slice()函数,并设置start,stop及step参数进行,从原数组中切割出一个新数组.
slice(start, stop, step) 或者使用冒号进行切片slice(start:stop:step)
注意:如果只放置一个参数,如[2],将返回与该索引相对应的单个元素.如果为[2:],表示从该索引开始以后的所有项都将被提取.如果使用了两个参数,如[2:7],那么提取两个索引(不包含终止索引)之间的元素.
切片还可以包括省略号…,来使选择元组的长度与数组的维度相同.如果在行位置使用省略号,它将返回包含行中元素的ndarray.即放在行位置代表所有行,放在列位置代表所有列.

numpy的高级索引

numpy比一般的Python序列提供更多的索引方式.除了之前看到的用整数和切片的索引外,数组可以由整数数组索引、布尔索引及花式索引。

整数数组索引

查看数组中(0,0),(1,1),(2,0)位置处的元素.

import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
y = tuple(zip((0, 0), (1, 1), (2, 0)))
z = x[y]
print(z)

结果显示:

[1 4 5]

注意:切片的时候要用tuple类型的数据而不能用list
获取二维数组中四个角的元素:最终返回的结果也是二维的,因此筛选条件也应该是二维的.代码如下:

import numpy as np
x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
rows = np.array([[0, 0], [3, 3]])
cols = np.array([[0, 2], [0, 2]])
y = x[rows, cols]
print(y)

结果如下:

[[ 0  2]
 [ 9 11]]

也可以使用与切片相结合的方法.

布尔索引

筛选出一个数组中大于5 的元素
y = x[x>5]
过滤数组中的Nan元素
a[~np.isnan(a)] "~"为取反
过滤数组中的非复数元素
a[np.iscomplex(a)]

花式索引

花式索引指的是利用整数数组进行索引.
花式索引根据索引数组的值作为目标数组的某个轴的下标来取值.对于使用一维整型数组作为索引,如果目标是一维数组,那么索引的结果就是对应位置的元素;如果目标是二维数组,那么就是对应下标的行.
花式索引跟切片不一样,它是将数据复制到新数组中.
支持倒序索引数组
支持多个索引数组,要用到np.ix_()方法,将多个数组打包,原理类似zip()

numpy广播(broadcast)

广播(broadcast)是numpy对不同形状(shape)的数组进行数值计算的方式,对数组的算数运算通常在相应的元素上进行.如果两个数组a和b的形状相同,即满足a.shape==b.shape,那么a*b的结果就是a与b数组对应位相乘.这要求维数相同,且各维度的长度相同.当运算中的2个数组的形状不同时,numpy将自动触发广播机制.
广播的规则:

• 让所有输入数组都向其中形状最长的数组看齐,形状中不足的部分都通过在前面加1补齐.
• 输出数组的形状是输入数组形状的各个维度上的最大值.
• 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为1时,这个数组能够用来计算,否则报错.
• 当输入数组的某个维度的长度为1时,沿着次维度运算时都用此维度上的第一组值.
  简单理解为:
• 对两个数组分别比较他们的每一个维度(若其中一个数组没有当前维度,则忽略),满足:
• 数组拥有相同形状.
• 当前维度的值相等
• 当前维度的值有一个是1
  若条件不满足时,抛出"ValueError:frames are not aligned"异常.
  广播机制参考文献:https://www.cnblogs.com/wjunneng/p/9096360.html

numpy的迭代数组

numpy的迭代器对象numpy.nditer提供了一种灵活访问一个或者多个数组元素的方式.
迭代器最基本的任务是可以完成对数组元素的访问.

控制遍历的顺序:

for x in np.nditer(a, order="F"): 列序优先
for x in np.nditer(a, order="C"): 行序优先
a是一个数组,遍历的结果是数组中的各个元素.

修改数组中元素的值

nditer对象有另一个可选参数op_flags.默认情况下,nditer将视待迭代遍历的数组为只读对象(read-only),为了在遍历数组的同时,实现对数组元素的修改,必须制定read-write或者write-only的模式.

import numpy as np
a = np.arange(0, 60, 5)
a = a.reshape(3, 4)
print('原始数组:', a)
for x in np.nditer(a, op_flags=['readwrite']):
    x[...] = 2*x
print('修改后的数组:', a)

最终结果:

原始数组: [[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]
修改后的数组: [[  0  10  20  30]
 [ 40  50  60  70]
 [ 80  90 100 110]]

使用外部循环

nditer类的构造器拥有flags参数,它可以接受下列值:

参数	描述
c_index	可以跟踪C顺序的索引
f_index	可以跟踪Fortran顺序的索引
multi-index	每次迭代可以跟踪一种索引类型
external_loop	给出的值是具有多个值的一维数组,而不是零维数组.

广播迭代

如果两个数组是可广播的,nditer组合对象能够同时迭代它们.假设数组a的维度是34,数组b的维度为14,则使用以下迭代器(数组b被广播到数组a)

import numpy as np
a = np.arange(0, 60, 5)
a = a.reshape(3, 4)
print('数组a:', a)
b = np.array([1, 2, 3, 4], dtype=int)
print('数组b:', b)
print([a, b])
for x, y in np.nditer([a, b]):
    print('%d:%d' % (x, y), end=',')
    print(x, y)

输出结果:

数组a: [[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]
数组b: [1 2 3 4]
[array([[ 0,  5, 10, 15],
       [20, 25, 30, 35],
       [40, 45, 50, 55]]), array([1, 2, 3, 4])]
0:1,0 1
5:2,5 2
10:3,10 3
15:4,15 4
20:1,20 1
25:2,25 2
30:3,30 3
35:4,35 4
40:1,40 1
45:2,45 2
50:3,50 3
55:4,55 4

numpy数组操作

numpy中包含了一些函数用于处理数组,大概可分为以下几类:

• 修改数组形状
• 翻转数组
• 修改数组维度
• 连接数组
• 分割数组
• 数组元素的添加和删除

修改数组形状

函数|描述
reshape|不改变数据的条件下修改形状
flat|数组元素迭代器
flatten|返回一份数组拷贝,对拷贝所做的修改不会影响原始数组
ravel|返回展开数组

numpy.shape()

numpy.shape()函数可以在不改变条件下,修改数组的形状,格式如下:
numpy.reshape(arr, newshape, order='C')

• arr:要修改形状的数组
• newshape:整数或者整数数组,新的形状应当兼容原有形状
• order:‘C’—按行, ‘F’—按列, ‘A’—按原顺序, ‘K’—元素在内存中出现的顺序

numpy.ndarray.flat

numpy.ndarray.flat是一个数组元素迭代器,迭代取出数组中的每一个元素

numpy.ndarray.flatten

numpy.ndarray.flatten返回一份数组拷贝,对拷贝所做的修改不会影响原始数组,格式如下:
ndarray.flattern(order='C')

• order:‘C’—按行,‘F’—按列, ‘A’—原顺序, ‘K’—元素在内存中的出现顺序

numpy.ravel()

numpy.reval()展平的数组元素,顺序通常是’C’,返回的是数组视图(view, 有点类似C/C++引用reference的意味), 修改会影响原始数组
格式如下:
numpy.reval(a, order='C')

• order:同上述参数说明

翻转数组

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

numpy.transpose()

numpy,transpose()函数用于对换数组的维度,格式如下:
numpy.transpose(arr, axes)
参数说明:

• arr:要操作的数组
• axes:整数列表,对应维度,通常所有维度都会对换

numpy.ndarray.T

类似于numpy.transpose()函数,一个是属性,一个是函数

numpy.rollaxis()

numpy.rollaxis()函数向后滚动特定的轴到一个特定的位置,格式如下:
numpy.rollaxis(arr, axis, start)
参数说明:

• arr: 数组
• axis:要向后滚动的轴,其他轴的相对位置不变
• start:默认为零,表示完整的滚动.会滚动到特定位置

import numpy as np
# 创建三维的ndarray
a = np.arange(24).reshape(4, 3, 2)  # reshape(2轴, 1轴, 0轴)
print('原数组:\n', a)
# 将轴2滚动到轴0(宽度到深度)
print('将轴2滚动到轴0:\n', np.rollaxis(a, 2))
print('将轴0滚动到轴1:\n', np.rollaxis(a, 2, 1))

结果如下:

原数组:
 [[[ 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滚动到轴0:
 [[[ 0  2  4]
  [ 6  8 10]
  [12 14 16]
  [18 20 22]]

 [[ 1  3  5]
  [ 7  9 11]
  [13 15 17]
  [19 21 23]]]
将轴0滚动到轴1:
 [[[ 0  2  4]
  [ 1  3  5]]

 [[ 6  8 10]
  [ 7  9 11]]

 [[12 14 16]
  [13 15 17]]

 [[18 20 22]
  [19 21 23]]]

numpy.swapaxes()

numpy.swapaxes()函数用于交换数组的两个 轴,格式如下:
numpy.swapaxes(arr, axis1, axis2)

• arr:输入的数组
• axis1:对应第一个轴的整数
• axis2:对应第二个轴的整数
• numpy.rollaxis()和numpy.swapaxes()函数的区别:rollaxis()是将一个轴转动到某一位置,而swapaxes()是将两个轴互换.

修改数组维度

函数	描述
broadcast	产生模仿广播的对象
broadcast_to	将数组广播到新形状
expand_dims	扩展数组的形状
squeeze	从数组的形状中删除一维条目

numpy.broadcast()

numpy.broadcast()用于模仿广播的对象,它返回一个对象,该对象封装了将一个数组广播到另一个数组的结果.该函数使用两个数组作为输入参数.
实例参考:https://www.runoob.com/numpy/numpy-array-manipulation.html

numpy.broadcast_to()

numpy.broadcast_to()函数将数组广播到新形状.它在原始数组上返回只读视图.它通常不连续,如果新兴庄不符合numpy的广播规则,该函数可能会抛出ValueError.格式如下:
numpy.broadcast_to(array, shape, subok)

numpy.expands_dims()

numpy.expands_dims()函数通过在指定位置插入新的轴来扩展数组形状.格式如下:
numpy.expand_dims(arr, axis)

numpy.squeeze()

numpy.squeeze()函数从给定数组的形状中删除一维的条目,格式如下:
numpy.squeeze(arr, axis)

连接数组

函数	描述
concatenate	连接沿现有轴的数组序列
stack	沿着新的轴加入一系列数组
hstack	水平堆叠序列中的数组(axis=1)
vstack	竖直堆叠序列中的数组( axis=0)

numpy.concatenate()

numpy.concatenate()函数用于沿指定轴连接相同形状的两个或多个数组,格式如下:
`numpy.concatenate((a1,a2,…),axis)
参数说明:

• a1,a2,…:想同类型的数组
• axis:沿着合并的轴,默认为0轴

numpy.stack()

numpy.stack()函数用于沿忻州连接数组序列,格式如下:
numpy.stack(arrays, axis)
numpy.concatenate()和numpy.stack()的区别:

• concatenate()是在一个已经存在的维度上连接数组,可以同时连接多个数组,并且不产生新的维度.
• stack()会生成一个新的维度,而且stack()使用的条件很局限,数组序列不需全部有相同的shape.

numpy.hstack()

numpy.hstack()是numpy.stack()的变体,它通过水平堆叠(axis=1)来生成数组.

numpy.vstack()

numpy.vstack()是numpy.stack()的变体,它通过垂直堆叠(axis=0)来生成数组

分割数组

函数	描述
split	将一个数组分割为多个子数组
hsplit	将一个数组水平分割为多个子数组
vsplit	将一个数组垂直分割为多个子数组

numpy.split()

numpy/split()函数沿特定的轴将数组分割为子数组,格式如下:
numpy.split(arr, indices_or_sections, axis)
参数说明:

• arr:被分割的数组
• indices_or_sections:如果是一个整数,就用该数平均切分,如果是一个数组,则为沿轴切分的索引(左开右闭)

numpy.hsplit()

numpy.vsplit()

数组元素的添加与删除

函数	描述
resize	返回指定形状的新数组
append	将值添加到数组末尾
insert	沿指定轴将值插入到指定下标前
delete	删掉某个轴的子数组,并返回删除后的新数组
unique	查找数组内的唯一元素

numpy.resize()

numpy.resize()函数返回指定shape的新数组,如果新数组的大小大于原始数组,则包含原始数组中的元素的副本
格式如下:
numpy.resize(arr,shape)
参数说明:

• arr:要切分的数组
• shape:新数组的shape,以元组的形式传递

numpy.append()

numpy.append()函数在数组的末尾添加值,追加操作会分配整个数组,并把原来的数组复制到新数组中.此外,输入数组的维度必须匹配否则将生成ValueError.append()函数返回的始终是一个一维的数组.格式如下:
numpy.append(arr, values, axis=None)
参数说明:

• arr:输入的数组
• values:要向arr添加的值,需要和arr形状相同(除了要添加的轴)
• axis:默认为None.当axis无定义时,是横向加成的,返回总是一维的数组.当axis有定义时,分别为0和1的时候.当为0时,列数要相同,当为1时,行数要相同.

numpy.insert()

numpy.insert()函数在给定索引之前,沿给定轴在输入数组中插入值.如果值的类型转换为要插入,则它与输入数组不同.插入没有原地的,函数会返回一个新数组.此外,如果未提供轴,则输入数组会被展开.格式如下:
numpy.insert(arr, obj, values, axis)
参数说明:

• arr:输入数组
• obj:在其之前插入值的索引
• values:要插入的值
• axis:沿着它插入的轴,如果未提供,则输入的数组会被展开

numpy.delete()

numpy.delete()函数返回从输入数组中删除指定子数组的新数组.与insert()函数的情况一样 ,如果未提供轴参数,则输入数组将展开.格式如下:
numpy.delete(arr, obj, axis)
参数说明:

• arr:输入数组
• obj:可以被切片,整数或者整数数组,表明要从输入数组删除的子数组
• axis:沿着它删除给定子数组的轴,如果未提供,则输入数组会被展开

a = np.arange(12).reshape(3, 4)
print(a)
print(np.delete(a, np.s_[::2]))

结果如下:

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[ 1  3  5  7  9 11]

注意:np.s_

numpy.unique()

numpy.unique()函数用于去除数组中的重复元素
numpy.unique(arr, return_index, return_inverse, return_counts)

• arr:输入数组,如果不是一味数组则会被展开
• return_index:如果为true,返回新列表元素在旧列表元素中的位置(索引),并以列表形式存储
• return_inverse:如果为true,返回旧列表元素在新列表中的位置(索引),并以列表形式存储
• return_counts:如果为true,返回去重数组中的元素在原数组中的出现次数

a = np.arange(12).reshape(3, 4)
print(a)
u = np.unique(a)
print(u)

结果如下:

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[ 0  1  2  3  4  5  6  7  8  9 10 11]

numpy位运算

numpy"bitwise_"开头的函数时位运算函数.numpy的位运算包括以下几个函数:

函数	描述
bitwise_and	对数组元素执行位与操作
bitwise_or	对数组元素执行位或操作
invert	按位取反
left_shift	向左移动二进制表示的位
right_shift	向右移动二进制表示的位

注意:也可用"&","|","~","^"等操作符进行计算.

numpy字符串函数

以下函数用于对dtype为numpy.string_或numpy.unicode_的数组执行向量化字符串操作.它们基于Python内置库中的标准字符串函数.这些函数在字符数组类(numpy.char)中定义.

函数	描述
add()	对两个数组的逐个字符串元素进行拼接
multiply()	返回按元素多重连接后的字符串
center()	居中字符串
capitalize()	将字符串第一个字母转换为大写
title()	将字符串的每个单词的第一个字母转换为大写
lower()	数组元素转换为小写
upper()	数组元素转换为大写
split()	指定分隔符对字符串进行分割,并返回数组列表
splitlines()	返回元素中的行列表,以换行符分割
strip()	移除元素开头或者结尾处的特定字符
join()	通过指定分隔符来连接数组中的元素
replace()	使用新字符串替换字符串中的所有子字符串
decode()	数组元素依次调用str.decode
encode()	数组元素依次调用str.encode

numpy.char.add()

numpy.char.add()函数一次对两个数组的元素进行字符串连接.

numpy.char.multiply()

numpy.char.multiply()函数执行多重连接.

numpy.char.center()

numpy.char.center()函数用于将字符串居中,并使用指定字符在左侧和右侧进行填充.

numpy.char.capitalize()

numpy.char.capitalize()函数将字符串的第一个字母转换为大写.

numpy.char.title()

numpy.char.title()函数将字符串的每个单词的第一个字母转换为大写.

numpy.char.lower()

numpy.char.lower()函数对数组的每个元素转换为小写.它对每个元素调用str.lower()

numpy.char.upper()

numpy.char.upper()函数对数组的每个元素转换为大写.他对每个元素调用str.upper()

numpy.char.split()

numpy.char.split()函数通过制定分隔符对字符串进行分割,并返回数组.默认情况下,分隔符为空格.

numpy.char.splitlines()

numpy.char.splitlines()函数以换行符作为分隔符来分割字符串,并返回数组.

numpy.char.strip()

numpy.char.strip()函数用于移除开头或结尾处的特定字符.

numpy.char.join()

numpy.char.join()函数通过制定分隔符来连接数组中的元素或字符串

numpy.char.replace()

numpy.char.replace()函数使用新字符串替换字符串中的所有子字符串.

numpy.char.encode()

numpy.char.encode()函数对数组中的每个元素调用str.encode()函数.默认编码是utf8,可以使用标准Python库中的编解码器.

numpy.char.decode()

numpy.char.decode()函数对编码的元素进行str.decode()解码.

numpy中的数学函数

numpy包含大量的各种数学运算的函数,包括三角函数,算数运算的函数,复数处理函数等.

三角函数

numpy提供了标准的三角函数:sin(),cos(),tan(),反三角函数.
注释:角度值通过(np.pi/180)求积换算成弧度值,用numpy.dgrees()将弧度值转换成角度值.

舍入函数

numpy.around()函数返回指定数字的四舍五入值.格式如下:
numpy.around(a, decimals)
参数说明:

• a:数组
• decimals:舍入的小数位数.默认值为0,如果为负,整数将四舍五入到小数点左侧的位置.

numpy.floor()

numpy.floor()返回小于或者等于指定表达式的最大整数,即向下取整.

numpy.ceil()

numpy.ceil()函数返回大于或者等于指定表达式的最小整数,即向上取整.

numpy的算数函数

numpy算数函数包括简单的加减乘除:add(),subtract(),multiply(),divide().
需要注意的是数组必须具有相同的形状或符合数组广播规则.

numpy.reciprocal()

numpy.reciprocal()函数返回参数各个元素的倒数.如1/4转为4/1.

numpy.power()

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

numpy.mod()

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

numpy的统计函数

numpy提供了很多统计函数,用于从数组中查找最小元素,最大元素,百分位标准差和方差等.函数说明如下:

numpy.admin()和numpy.amax()

numpy.admin()用于计算数组中的元素沿指定轴的最小值.
numpy.amax()用于计算数组中的元素沿指定轴的最大值.

numpy.ptp()

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

numpy.percentile()

numpy.percentile()百分位数是统计中使用的度量,表示小于这个值的观察值的百分比.函数numpy.percentile()接受以下参数:
numpy.percentile(a, q, axis)
参数说明:

• a:输入数组
• q:要计算的百分位数
• axis:沿着他计算百分位数的轴
• keepdims:是否保持原始维度(true or false)
  百分位数:样本中大于或等于x的元素的占比为n%.一般是给出占比,求出元素值.

numpy.median()

numpy.median()函数用于计算数组a中的中位数(中指).

numpy.mean()

numpy.mean()函数返回数组中元素的算数平均值.

numpy.average()

numpy.average()函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均数.
该函数可以接受一个轴参数.如果没有指定轴,数组将会被展开.
加权平均值即将各数值乘以相应的权数,然后加总求和得到总体值,再除以总的单位数.
考虑数组[1, 2, 3, 4]和相应的权重[4, 3, 2, 1],通过将响应元素的乘积相加,并将和除以权重的和,来计算加权平均值.

标准差和方差

标准差和方差是一组数据平均值的分散程度的一种度量.
标准差是方差的算数平方根.
标准差公式如下:
标准差:std=sqrt(mean((x-x.mean())**2))
方差:std=mean((x-x.mean())**2)

numpy排序、条件筛选函数

numpy提供了多种排序的方法.这些排序函数实现不同的排序算法,每个排序算法的特征在于执行速度,最坏情况性能,所需的工作空间和算法的稳定性.下面显示了三种排序算法的比较:

种类	速度	最坏情况	工作空间	稳定性
quicksort(快速排序)	1	0(n**2)	0	否
mergesort(归并排序)	2	0(n*log(n))	~n/2	是
heapsort(堆排序)	3	0(n*log(n))	0	否

numpy.sort()

numpy.sort()函数返回输入数组的排序副本.格式如下:
numpy.sort(a, axis, kind, order)
参数说明:

• a:要排序的数组
• axis:沿着它排序数组的轴,如果没有,数组会被展开.axis=0按列排序,axis=1按行排序.
• kind:排序类型,默认为快排
• order:如果数组包含字段,则是要排序的字段

numpy.argsort()

numpy.argsort()函数返回的是数组值从小到大的索引值

numpy.lexsort()

numpy.lexsort()用于对多个序列进行排序,返回的是元素的索引.把它想象成对电子表格进行排序,每一列代表一个序列,排序时优先照顾靠后的列,返回的是元素的索引.
msort/sirt_complex/partition/argpartition

函数	描述
msort(a)	数组按第一个轴排序,返回排序后的数组副本.np.msort相当于np.sort(a, axis=0)
sort_complax(a)	对复数按照先实部后虚部的顺序进行排序.
partition(a, kth[, axis, kind, order])	指定一个数,对数组进行分区
argpartition(a, kth(, axis, kind, order])	可以通过关键字kind指定算法沿着指定轴对数组进行分区

argpartition()函数的运行原理:
会先将要处理的数组的元素进行排序,然后找到kth的数,将原数组进行区分.但是被区分的数并不是排过序的.

numpy.argmax()和numpy.argmin()

numpy.argmax()和numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引.

numpy.nonzero()

numpy.nonzero()函数返回输入数组中非零元素的索引.

numpy.where()

numpy.where()函数返回数组中满足给定条件的元素的索引.

numpy.extract()

numpy.extract()函数根据某个条件从数组中抽取元素,返回满足条件的元素.

numpy字节交换

在几乎所有的机器上,多字节对象都被存储为连续的字节序列.字节顺序,是跨越多字节的程序对象的存储规则.

numpy的副本和视图

副本是一个数组的完整的拷贝,如果我们对副本进行修改,他不会影响到原始数据,物理内存不在统一位置.视图是一个数据的一个别称或引用,通过该别称或引用亦便可访问,操作原有数据,但原有数据不会产生拷贝.如果我们对视图进行修改,它会影响到原始数据,物理内存在同一位置.
视图一般发生在:

• numpy的切片操作返回原数据的视图
• 调用ndarray的view()函数产生一个视图.
  副本一般发生在:
• Python序列的切片操作,调用deepcopy()函数
• 调用ndarray的copy()函数产生一个副本

无复制

简单的赋值不会创建数组对象的副本,相反,它使用原始数组的相同ID()来访问它.ID()返回Python对象的通用标识符,类似于C中的指针.
此外,一个数组的任何变化都反映在另一个数组上.例如,一个数组的形状改变也会改变另一个数组的形状.

视图或浅拷贝

ndarray.view()函数会创建一个新的数组对象,该方法创建的新数组的维数更改不会更改原始数据的维数.

副本或深拷贝

ndarray.copy()函数创建一个副本,对副本数据进行修改,不会影响到原始数据,他们物理内存不在同一位置.

numpy的矩阵库

后期填坑

numpy的线性代数

后期填坑

numpy的I/O

numpy可以读写磁盘上的文本数据或二进制数据
numpy为ndarray对象引入了一个简单的文件格式.npy
npy文件用于存储重建ndarray所需的数据,图形,dtype和其他信息.
常用的I/O函数有:

• load()和save()函数时读写文件数组数据的两个主要函数,默认情况下,数组是以未压缩的原始二进制格式保存咋扩展名为.npy文件中.
• savez()函数用于将多个数组写入文件,默认情况下,数组是以未压缩的原始二进制格式保存在扩展名为.npz文件中
• loadtxt()和savetxt()函数处理正常的文本文件(.txt等)

numpy.save()

umpy.save()函数将数组保存到以.npy为扩展名的文件中.格式如下:
numpy.save(file, arr, allow_pickle=True, fix_imports=True)
参数说明:

• file:要保存的文件名,扩展名为.npy,如果文件路径末尾没有扩展名,则会自动添加;
• arr:要保存的数组
• allow_pickle:可选,布尔值,是否允许Pythonpickles保存对象数组.Python中的pickle用于在保存到磁盘文件或从磁盘文件读取之前,对对象进行序列化和反序列化.
• fix_imports:可选,为了方便Python2读取Python3保存的数据

numpy.savez()

后期填坑,可能不补

numpy.savetxt()

后期填坑,可能不补

numpy.loadtxt()

后期填坑,可能不补

numpy和matplotlib的组合使用

后期填坑

参考文献:https://www.runoob.com/numpy/numpy-tutorial.html