Numpy基础学习
什么是Numpy
Numpy是Python的一个科学计算库,提供了矩阵运算的功能,通常与scipy和matplotlib一起使用,用来替代matlab.
Ndarray对象
Ndarray是Numpy中定义的最重要的一个对象,它描述了相同类型的“items”的集合. 可以使用例如整数的N来索引项目中的items.
Ndarray中的每个项在内存中使用相同大小的块,并且Ndarray中每个块都是以完全相同的方式(即相同的数据类型对象data-type)进行解释的.而解释数组中的每个项的数据类型对象是单独存放的.
从数组中提取的项则是由类型为阵列标量的python对象表示的,
Ndarray的基本创建
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
参数 | 描述 |
---|---|
object | 任何暴露数组接口方法的对象都会返回一个数组或任何(嵌套)序列 |
dtype | 数组的所需数据类型,可选 |
copy | 对象是否被复制,默认为true,可选 |
order | C(按行), F(按列), A(任意,默认) |
subok | 默认情况下,返回的数组被强制为基类数组,如果为true,则返回子类 |
ndmin | 指定返回数组的最小维数 |
接下来我们看几个例子
>>> a = np.array([1,2,3])
>>> print(a)
[1 2 3]
>>> a = np.array([[1,2], [3,4]])
>>> print(a)
[[1 2]
[3 4]]
>>> a = np.array([1,2,3], dtype = complex)
>>> print(a)
[1.+0.j 2.+0.j 3.+0.j]
>>> a = np.array([1,2,3,4,5], ndmin = 3)
>>> print(a)
[[[1 2 3 4 5]]]
numpy的数据类型
Numpy支持比python更多的数字类型,这里显示的是哪些是可用的,以及如何修改数组的数据类型.
数据类型 | 描述 |
---|---|
bool_ | 布尔(True或False),存储为一个字节 |
int_ | 默认整数类型(与C中的long相同;通常是int64或int32) |
intc | 与C中int相同(通常为int32或int64) |
intp | 用于索引的整数(与C中ssize_t相同;通常是int32或int64) |
int8 | 字节(-128至127) |
int16 | 整数(-32768至32767) |
int32 | 整数(-2147483648至2147483647) |
int64 | 整数(-9223372036854775808至9223372036854775807 |
uint8 | 无符号整数(0到255) |
uint16 | 无符号整数(0到65535) |
uint32 | 无符号整数(0到4294967295) |
uint64 | 无符号整数(0到18446744073709551615) |
float_ | float64的简写 |
float16 | 半精度浮点:符号位,5位指数,10位尾数 |
float32 | 单精度浮点数:符号位,8位指数,23位尾数 |
float64 | 双精度浮点:符号位,11位指数,52位尾数 |
complex_ | complex128的简写 |
complex64 | 复数,由两个32位浮点数(实部和虚部) |
complex128 | 复数,由两个64位浮点数(实部和虚部) |
Numpy数值类型是dtype(data-type)对象的实例,每个类型都具有唯一的特征.这些类型可以通过np.bool_, np.float32等方式来访问.
注:int8,int16,int32,int64可以替换成等价的字符串'i1','i2','i4','i8'.
数据类型对象(dtype)
数据类型对象描述了对应于数组的固定内存块的解释,取决与以下方面:
1.数据类型
2.数据大小
3.字节序(大端或者小端)
dtype的构造:
numpy.dtype(object, align, copy)
参数 | 描述 |
---|---|
object | 被转换为数据类型的对象 |
align | 为True时向字段中添加间隔,使它类似C的结构体 |
copy | 为True时生成dtype对象的新副本,为False时,为该数据类型对象的引用 |
示例:
>>> dt = np.dtype(np.int32)
>>> print(dt)
int32
>>> dt = np.dtype(np.'i4')
>>> print(dt)
int32
>>> dt = np.dtype('>i4')
>>> print(dt)
i4
>>> dt = np.dtype([('age', np.int8)])
>>> print(dt)
[('age', 'i1')]
>>> dt = np.dtype([('age', np.int8)])
>>> a = np.array([(10,),(20,),(30,)], dtype = dt)
>>> print(a)
[(10,) (20,) (30,)]
>>> dt = np.dtype([('age', np.int8)])
>>> a = np.array([(10,),(20,),(30,)], dtype = dt)
>>> print(a['age'])
[10 20 30]
>>> student = np.dtype([('name', 'S20'), ('age', 'i1'), ('marks', 'f4')])
>>> print(student)
[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')]
>>> student = np.dtype([('name', 'S20'), ('age', 'i1'), ('marks', 'f4')])
>>> a = np.array([('tom', 21, 50), ('alice', 18, 86)], dtype = student)
>>> print(a)
[(b'tom', 21, 50.) (b'alice', 18, 86.)]
每个内置类型都有一个与它对应的字符码:
字符码 | 内置类型 |
---|---|
'b' | 布尔值 |
'i' | 符号整数 |
'u' | 无符号整数 |
'f' | 浮点数 |
'c' | 复数浮点 |
'm' | 时间间隔 |
'M' | 日期时间 |
'O' | python对象 |
'S', 'a' | 字符串 |
'U' | Unicode |
'V' | 原始数据(void) |
Numpy数组属性
这里我们会介绍numpy的多种数组属性.
ndarray.shape
这一数组属性返回一个包含数组维度的元组,它也可以用于调整数组大小.
示例:
>>> a = np.array([(1,2,3), (4,5,6)])
>>> print(a.shape)
(2, 3)
>>> a = np.array([(1,2,3), (4,5,6)])
>>> a.shape = (3,2)
>>> print(a)
[[1 2]
[3 4]
[5 6]]
这里,reshape()同样可以实现该功能
>>> a = np.array([(1,2,3), (4,5,6)])
>>> b = a.reshape(3,2)
>>> print(b)
[[1 2]
[3 4]
[5 6]]
ndarray.ndim
这一数组属性返回数组的维数
示例:
>>> a = np.arange(12)
>>> print(a)
[0 1 2 3 4 5 6 7 8 9 10 11]
>>> a = np.arange(12)
>>> print(a.ndim)
1
>>> a = np.arange(12)
>>> b = a.reshape(2,3,2)
>>> print(b)
[[[ 0 1]
[ 2 3]
[ 4 5]][[ 6 7]
[ 8 9]
[10 11]]]
numpy.itemsize
该数组属性返回数组中每一个元素的字节单位长度
示例:
>>> x = np.array([1,2,3,4,5], dtype = np.int8)
>>> print(x.itemsize)
1
>>> x = np.array([1,2,3,4,5], dtype = np.float32)
>>> print(x.itemsize)
4
numpy.flags
它会返回当前对象的以下所有属性
属性 | 描述 |
---|---|
C_CONTIGUOUS (C) | 数组位于单一的,C风格的连续区段内 |
F_CONTIGUOUS (F) | 数组位于单一的,Fortran风格的连续区段内 |
OWNDATA (O) | 数组的内存从其它对象处借用 |
WRITEABLE (W) | 数据区域可写入,将它设置为false会锁定数据,使其为只读 |
ALIGNED (A) | 数据和任何元素会为硬件适当对齐 |
UPDATEIFCOPY (U) | 这个数组是另一个数组的副本,当这个数组释放时,源数组会由这个数组中的元素更新 |
示例:
>>> x = np.array([1,2,3,4,5])
>>> print(x.flags)
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
Numpy数组创建例程
新的ndarray对象可以通过如下方法或用低级的ndarray构造函数构造.
numpy.empty
它创建指定形状和dtype的未初始化数组.它使用如下的构造函数:
numpy.empty(shape, dtype, order)
它的参数解释如下:
参数 | 描述 |
---|---|
shape | 空数组的形状,整数或着元组 |
dtype | 所需的输出数组类型,可选 |
order | 'C'为按行的C风格数组, 'F'为按列的Fortran风格数组 |
示例:
>>> x = np.empty([3,2], dtype = int)
>>> print(x)
[[139780398185496 139780398179960]
[139780398199304 139780398165808]
[139780398165880 139780398199368]]
这里数组元素为随机值,因为未初始化
numpy.zeros
和numpy.empty类似,创建指定大小的数组,但是以0填充数组
numpy.zeros(shape, dtype, order)
构造器的参数及描述如下:
参数 | 描述 |
---|---|
shape | 空数组的形状,整数或元组 |
dtype | 所需的输出数组类型,可选 |
order | 'C'为按行的C风格数组, 'F'为按列的Fortran风格数组 |
实例:
>>> x = np.zeros(5)
>>> print(x)
[0. 0. 0. 0. 0.]
>>> x = np.zeros((5,), dtype = np.int)
>>> print(x)
[0 0 0 0 0]
>>> x = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])
>>> print(x)
[[(0, 0) (0, 0)]
[(0, 0) (0, 0)]]
numpy.ones
同上,创建指定大小数组,以1填充
numpy.ones(shape, dtype, order)
参数及描述:
参数 | 描述 |
---|---|
shape | 空数组的形状,整数或元组 |
dtype | 所需的输出数组类型,可选 |
order | 'C'为按行的C风格数组, 'F'为按列的Fortran风格数组 |
示例:
>>> x = np.ones([2,2], dtype = int)
>>> print(x)
[[1 1]
[1 1]]
numpy 以现有数据创建数组
numpy.asarray
此函数类似于numpy.array,除了有较少的参数.此例程对于将python序列转换成ndarray很有帮助.
numpy.asarray(a, dtype, order)
参数即描述:
参数 | 描述 |
---|---|
a | 任意形式输入参数,如列表,元组,或者相互嵌套等 |
dtype | 会应用到返回的ndarray |
order | 'C'为按行的C风格数组, 'F'为按列的Fortran风格数组 |
示例:
>>> x = [1,2,3]
>>> a = np.asarray(x)
>>> print(a)
[1 2 3]
>>> x = [1,2,3]
>>> a = np.asarray(x,dtype = float)
>>> print(a)
[1. 2. 3.]
numpy.frombuffer(不常用)
此函数将缓冲区解释为一维数组,暴露缓冲区接口的任何对象都可用做参数来返回ndarray
numpy.frombuffer(buffer,dtype,count,offset)
参数及描述:
参数 | 描述 |
---|---|
buffer | 任何暴露缓冲区接口的对象 |
dtype | 任何返回数组的数据类型,默认为float |
count | 需要读取的数据数量,默认为-1,即读取所有数据 |
offset | 需要读取的起始位置,默认为0 |
示例:
>>> s = b'hello world'
>>> a = np.frombuffer(s, dtype = 'S1')
>>> print(a)
[b'h' b'e' b'l' b'l' b'o' b' ' b'w' b'o' b'r' b'l' b'd']
这里python3中默认字符串是Unicode的,所以前面要加个b转成bytestrings,其实这个方法平常也不怎么用,就不必在这里死扣细节.
numpy.fromiter
此方法可从迭代对象构建一个ndarray对象,并返回一个新的一维数组
numpy.fromiter(iterable, dtype, count)
参数即描述:
参数 | 描述 |
---|---|
iterable | 任何可迭代的对象 |
dtype | 返回数组的数据类型 |
count | 需要读取的数据量,默认为-1,即读取所有数据 |
示例:
>>> list = range(5)
>>> it = iter(list)
>>> x = np.fromiter(it, dtype = float)
>>> print(x)
[0. 1. 2. 3. 4.]
Numpy来自数值范围的数组
这里将会介绍如何从数值范围创建数组
numpy.arange
该方法返回ndarray对象,包含给定范围内的等间隔的值
numpy.arange(start,stop,step,dtype)
参数及解释:
参数 | 描述 |
---|---|
start | 范围的起始值,默认为0 |
stop | 范围的终止值,必须包含 |
step | 两个值间的间隔,即步长,默认为1 |
dtype | 返回ndarray的数据类型,默认为输入数据的类型 |
示例:
>>> x = np.arange(5,10,2,dtype = float)
>>> print(x)
[5. 7. 9.]
numpy.linspace
此方法类似numpy.arange,但是是指定数组中元素的数量而非步长
numpy.linspace(start,stop,num,endpoint,retstep,dtype)
参数及描述:
参数 | 描述 |
---|---|
start | 序列的起始值 |
stop | 序列的终止值,endpoint为true则是闭区间,否则为开区间 |
num | 要生成的数组元素数量 |
endpoint | 序列是否包含end,即右区间是开是闭,默认为true |
retstep | 若为true,返回样例和步长组成的元组 |
dtype | 返回的ndarray的数据类型 |
示例:
>>> x = np.linspace(10,20,5,endpoint = False)
>>> print(x)
[10. 12. 14. 16. 18.]
>>> x = np.linspace(1,2,5,retstep = True)
>>> print(x)
(array([1. , 1.25, 1.5 , 1.75, 2. ]), 0.25)
Numpy的切片和索引
ndarray对象的内容也可以通过索引和切片来访问和修改.
基本索引和切片:
基本切片是python中基本切片概念扩展到n维,通过向slice函数提供参start,stop,step来构造一个python的slice对象,此slice对象再传递给数组来提取数组的一部分.
示例:
>>> a = np.arange(10)
>>> s = slice(2,7,2)
>>> print(a[s])
[2 4 6]
这里还有一种更为方便的切片方法:
即直接将切片参数以start:stop:step的形式直接提供给ndarray对象;其中参数也可部分省略;
示例:
>>> a = np.arange(10)
>>> b = a[5]
>>> print(b)
5
>>> a = np.arange(10)
>>> b = a[2:]
>>> print(b)
[2 3 4 5 6 7 8 9]
>>> a = np.arange(10)
>>> b = a[2:7:2]
>>> print(b)
[2 4 6]
上述方法对多维的ndarray也同样适用,
示例:
>>> a = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> b = a[1:]
>>> print(b)
[[4 5 6]
[7 8 9]]
>>> a = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> b = a[1,...]
>>> print(b)
[4 5 6]
>>> a = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> b = a[...,1]
>>> print(b)
[2 5 8]
>>> a = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> b = a[...,1:]
>>> print(b)
[[2 3]
[5 6]
[8 9]]
高级索引和切片
高级索引始终返回数据的副本,切片则只提供了一个视图
高级索引分为两种:整数和布尔
整数索引
这种机制有助于基于n维索引来获取数组中的任意元素,每个整数数组表示该维度下的对应下标值.
示例:
>>> x = np.array([[1,2], [3,4], [5,6]])
>>> y = x[[0,1,2],[0,1,0]]
>>> print(y)
[1 4 5]
这里分别获取了二维数组中的(0,0),(1,1),(2,0)这三个元素
>>> 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]]
和之前的那个的区别就是那个只能创建一维的数组,而这里创建了二维数组,其实我觉得这里不太好理解.可以这样看:rows中第i个子数组和cols中第i个子数组中数字对应组成结果中第i行的元素,即一个子数组中的元素个数作为一共有列,然后rows或cols中一共多少个子数组就一共有多少行.
接下来是一些其他示例:
>>> x = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
>>> y = x[1:4,1:3]
>>> print(y)
[[ 4 5]
[ 7 8]
[10 11]]
>>> x = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
>>> y = x[1:4,[1,2]]
>>> print(y)
[[ 4 5]
[ 7 8]
[10 11]]
布尔索引
当结果对象是布尔运算的结果时,将使用此类型的高级索引.
示例:
>>> x = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
>>> y = x[x>5]
>>> print(y)
[ 6 7 8 9 10 11]
>>> a = np.array([1, 2+6j, 5, 5+5j])
>>> b = a[np.iscomplex(a)]
>>> print(b)
[2.+6.j 5.+5.j]
Numpy广播
术语广播指的是Numpy在算数运算期间处理不同形状数组的能力.数组的算数运算通常是对在相对应位置上的元素进行的.如果两个数组有着完全相同的形状,则这些操作可以无缝地执行.
示例:
>>> a = np.array([1,2,3,4])
>>> b = np.array([4,3,2,1])
>>> c = a * b
>>> print(c)
[4 6 6 4]
这个例子中两个数组有着相同的形状,所以对其进行操作完全没问题.
那么如果两个数组维数不同时怎么办呢?
这里就用到了Numpy的广播功能,即将较小的数组广播到较大的数组的大小,以使他们的形状可兼容.
示例:
>>> a = np.array([[1,2],[3,4],[5,6]])
>>> b = np.array([2,2])
>>> c = a + b
>>> print(c)
[[3 4]
[5 6]
[7 8]]
Numpy数组上的迭代
Numpy 包中含有一个迭代器对象numpy.nditer。 它是一个多维迭代器对象,可以在数组上进行迭代。
基本迭代操作
示例:
>>> a = np.arange(0,60,5)
>>> a = a.reshape(3,4)
>>> for x in np.nditer(a):
... print(x, end=" ")
...
0 5 10 15 20 25 30 35 40 45 50 55
迭代的顺序匹配数组的内容布局,而不考虑特定的排序.这里你只要知道数组转置过后的迭代结果任和原来相同.
>>> a = np.arange(0,60,5)
>>> a = a.reshape(3,4)
>>> b = a.T
>>> for x in np.nditer(b):
... print(x, end = " ")
...
0 5 10 15 20 25 30 35 40 45 50 55
这里默认的输出是按C风格的,即一行一行地迭代,若改成F风格的话,则会一列一列地迭代:
>>> a = np.arange(0,60,5)
>>> a = a.reshape(3,4)
>>> b = a.copy(order="F")
>>> for x in np.nditer(b):
... print(x, end = " ")
...
0 20 40 5 25 45 10 30 50 15 35 55
换一种方法
>>> a = np.arange(0,60,5)
>>> a = a.reshape(3,4)
>>> for x in np.nditer(a, order = "F"):
... print(x, end = " ")
...
0 20 40 5 25 45 10 30 50 15 35 55
迭代器修改数组中的值
nditer对象有另一个可选参数op_flags.它的默认值为只读,但也可设置为读写或只写模式,这样便能使用迭代器来对数组中的元素进行修改.
示例:
>>> a = np.arange(0,60,5)
>>> a = a.reshape(3,4)
>>> for x in np.nditer(a, op_flags=['readwrite']):
... x*=2
...
>>> print(a)
[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]
外部循环
nditer类的构造器拥有flags参数,它可接受如下参数:
参数 | 描述 |
---|---|
c_index | 可以跟踪C顺序的索引 |
f_index | |
multi-index | 每次迭代可以跟踪一种索引类型 |
external_loo | 给出的值是具有多个元素的一维数组,而非多个元素 |
这里记下示例就好,等真正用到时在去查, | |
示例: |
>>> a = np.arange(0,60,5)
>>> a = a.reshape(3,4)
>>> for x in np.nditer(a, flags = ['external_loop'], order = "F"):
... print(x)
...
[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]
之前只设置order="F"时,输出的是一维数组,而这里输出的是二维数组,差别也就在于此
广播迭代
若两个数组是可广播的,则nditer组合对象可以同时迭代它们.
示例:
>>> a = np.arange(0,60,5)
>>> a = a.reshape(3,4)
>>> b = np.array([1,2,3,4], dtype = int)
>>> for x,y in np.nditer([a,b]):
... print("%d:%d " % (x,y))
...
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 数组操作
Numpy包中含有多个用于ndarray对象中元素的方法,大致可分为如下几种:
修改形状
方法 | 描述 |
---|---|
reshape | 不改变数据的条件下修改形状 |
flat | 数组上的一维迭代器 |
flatten | 返回折叠为一维的数组的副本 |
ravel | 返回连续展开的数组 |
现在来具体看看这四种方法:
numpy.reshape
这个在刚开始讲shape时其实提到过一点了,它是在不改变数据的条件下修改数组的形状.
numpy.reshape(a, newshape, order)
参数 | 描述 |
---|---|
a | 要改变形状的数组 |
newshape | 整数或者整数数组,新的形状应该兼容原有的形状 |
order | 'C'为C风格顺序,'F'为F风格顺序,'A'为保留原顺序 |
示例:
>>> a = np.arange(8)
>>> b = a.reshape(4,2)
>>> print(a)
[0 1 2 3 4 5 6 7]
>>> print(b)
[[0 1]
[2 3]
[4 5]
[6 7]]
numpy.ndarray.flat
该函数返回数组上的一维迭代器,行为类似于python内部的迭代器.
>>> a = np.arange(8)
>>> b = a.reshape(2,4)
>>> c = b.flat[5]
>>> print(c)
5
numpy.ndarray.faltten
该函数返回折叠为一维的数组副本.
ndarray.flatten(order)
参数 | 描述 |
---|---|
order | 'C'按行, 'F'按列, 'A'按原顺序, 'k'元素在内存中出现的顺序 |
示例:
>>> a = np.arange(8)
>>> a = a.reshape(2,4)
>>> b = a.flatten()
>>> print(b)
[0 1 2 3 4 5 6 7]
numpy.ravel
此函数返回一个展开的一维数组,并按需生成副本.返回的数组和输入的数组拥有相同的数据类型.
numpy.ravel(a, order)
参数 | 描述 |
---|---|
a | 输入数组 |
order | 'C'按行, 'F'按列, 'A'按原顺序, 'k'按元素在内存中的顺序 |
示例:
>>> a = np.arange(8).reshape(2,4)
>>> b = a.ravel()
>>> print(b)
[0 1 2 3 4 5 6 7]
###翻转操作
方法 | 描述 |
---|---|
transpose | 翻转数组的维度 |
ndarray.T | 转置,和self.transpose相同 |
rollaxis | 向后滚动指定的轴 |
swapaxes | 互换两个数组的两个轴 |
numpy.transpose
这个函数翻转给给定数组的维度,如果可以的话它会返回一个视图.
numpy.transpose(a, axes)
参数 | 描述 |
---|---|
a | 要转置的数组 |
axes | 整数的列表,对应维度,通常所有的维度都会反转 |
示例:
>>> a = np.arange(12).reshape(3,4)
>>> np.transpose(a)
array([[ 0, 4, 8],
[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11]])
numpy.ndarray.T
该类属于ndarray类,行为类似于numpy.transpose
示例:
>>> a = np.arange(12).reshape(3,4)
>>> a.T
array([[ 0, 4, 8],
[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11]])
numpy.rollaxis
该函数使数组向后滚动,直到一个特定的位置.
numpy.rollaxis(a, axis, start)
参数 | 描述 |
---|---|
a | 输入数组 |
axis | 要向后滚动的轴,其他轴的相对位置不会改变 |
start | 默认为0,表示完整的滚动,会滚动到特定的位置 |
示例:
>>> a = np.arange(8).reshape(2,2,2)
>>> np.rollaxis(a,2)
array([[[0, 2],
[4, 6]],[[1, 3], [5, 7]]])
这里是将轴二滚动到了轴零,也就是说原来索引一个数是a[x][y][z], 现在想要找到它的话就得是a[z][x][y],这样理解起来会好点.
####numpy.swapaxes 该函数交换数组的两个轴, ``` numpy.swapaxes(a, axis1, axis2) ```
参数 | 描述 |
---|---|
a | 输入数组 |
axis1 | 对应第一个轴的整数 |
axis2 | 对应第二个轴的整数 |
示例:
>>> a = np.arange(8).reshape(2,2,2)
>>> np.swapaxes(a,2,0)
array([[[0, 4],
[2, 6]],[[1, 5], [3, 7]]])
修改维度
方法 | 描述 |
---|---|
broadcast | 产生模仿广播的对象 |
broadcast_to | 将数组广播到新的形状 |
expand_dims | 扩展数组的形状 |
squeeze | 从数组的形状中删除单维条目 |
broadcast
前面已经说明了numpy的广播功能,而此方法就是模仿广播的机制,它返回一个对象,该对象封装了将一个数组广播到另一个数组的结果.
>>> x = np.array([[1],[2],[3]])
>>> y = np.array([4,5,6])
>>> b = np.broadcast(x,y)
>>> out = np.empty(b.shape)
>>> out.flat = [u+v for (u,v) in b]
>>> out
array([[5., 6., 7.],
[6., 7., 8.],
[7., 8., 9.]])
numpy.broadcast_to
此函数将数组广播到新形状.
numpy.broadcast_to(a, shape, subok)
示例;
>>> a = np.arange(4).reshape(1,4)
>>> np.broadcast_to(a,(4,4))
array([[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3]])
numpy.expand_dims
函数通过在指定位置插入新的轴来扩展数组形状.
numpy.expand_dims(a, axis)
参数 | 描述 |
---|---|
a | 输入数组 |
axis | 新轴要插入的位置 |
示例;
>>> x = np.array(([1,2],[3,4]))
>>> y = np.expand_dims(x, axis = 1)
>>> print(y)
[[[1 2]]
[[3 4]]]
numpy.squeeze
函数从指定数组的形状中删除一维条目.
numpy.squeeze(a, axis)
参数 | 描述 |
---|---|
a | 输入数组 |
axis | 整数或者整数元组,用于选择形状中单一维度条目的子集 |
示例:
>>> x = np.arange(9).reshape(1,3,3)
>>> y = np.squeeze(x)
>>> print(y)
[[0 1 2]
[3 4 5]
[6 7 8]]
数组的连接
方法 | 描述 |
---|---|
concatenate | 沿着现存的轴连接数据序列 |
stack | 沿着新轴连接数组序列 |
hstack | 水平堆叠序列中的数组(列方向) |
vstack | 竖直堆叠序列中的数组(行方向) |
numpy.concatenate
此函数用于沿指定轴连接相同形状的两个或多个数组
numpy.concatenate((a1,a2,...), axis)
参数 | 描述 |
---|---|
a1,a2,... | 相同类型的数组序列 |
axis | 沿着它连接数组的轴,默认为0 |
示例:
>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[5,6],[7,8]])
>>> np.concatenate((a,b))
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[5,6],[7,8]])
>>> np.concatenate((a,b),axis = 1)
array([[1, 2, 5, 6],
[3, 4, 7, 8]])
###numpy.stack 此函数沿着新轴连接数组序列. ``` numpy.stack(a, axis) ```
参数 | 描述 |
---|---|
a | 相同形状的数组序列 |
axis | 返回数组中的轴,输入的数组沿着它来堆叠 |
示例:
>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[5,6],[7,8]])
>>> np.stack((a,b),0)
array([[[1, 2],
[3, 4]],[[5, 6], [7, 8]]])
>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[5,6],[7,8]])
>>> np.stack((a,b),1)
array([[[1, 2],
[5, 6]],[[3, 4], [7, 8]]])
numpy.hstack
它是numpy.stack的一个变体,通过堆叠来生成水平的单个数组
示例:
>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[5,6],[7,8]])
>>> np.hstack((a,b))
array([[1, 2, 5, 6],
[3, 4, 7, 8]])
numpy.vstack
同样,它也是numpy.stack的变体,通过堆叠来生成竖直的单个数组.
示例:
>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[5,6],[7,8]])
>>> np.vstack((a,b))
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
数组分割
方法 | 描述 |
---|---|
split | 将一个数组分割为多个子数组 |
hsplit | 将一个数组水平分割为多个子数组(按列) |
vsplit | 将一个数组竖直分割为多个子数组(按行) |
numpy.split
该函数沿特定的轴将数组分割成子数组.
numpy.split(a, indices_or_sections, axis)
参数 | 描述 |
---|---|
a | 输入数组 |
indices_or_sections | 整数则为要创建的子数组的数量,一维数组则为要创建子数组的点 |
axis | 默认为0 |
示例:
>>> a = np.arange(9)
>>> b = np.split(a,3)
>>> print(b)
[array([0, 1, 2]), array([3, 4, 5]), >array([6, 7, 8])]
>>> a = np.arange(9)
>>> b = np.split(a,[4,7])
>>> print(b)
[array([0, 1, 2, 3]), array([4, 5, 6]), >array([7, 8])]
numpy.hsplit
同样,它是split的特例,其中轴为1表示水平分割,无论数组的维度是什么
示例:
>>> a = np.arange(16).reshape(4,4)
>>> b = np.hsplit(a,2)
>>> print(b)
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
numpy.vsplit
同样,vsplit也是split的一个特例,其中轴为0表示竖直分割,无论输入数组的维度是什么
示例:
>>> a = np.arange(16).reshape(4,4)
>>> b = np.vsplit(a,2)
>>> print(b)
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, >10, 11],
[12, 13, 14, 15]])]
添加/删除元素
方法 | 描述 |
---|---|
resize | 返回指定形状的新数组 |
append | 将值添加到数组末尾 |
insert | 沿着指定轴将值插入到指定下标之前 |
delete | 返回删除掉的某个轴的子数组的新数组 |
unique | 寻找数组内的唯一元素 |
numpy.resize
此函数返回指定大小的新数组,若新数组大小大于原始数组大小,则包含原始数组中元素的副本.
numpy.resize(a,shape)
参数 | 描述 |
---|---|
a | 输入数组 |
shape | 返回数组的新形状 |
示例:
>>> a = np.array([[1,2,3],[4,5,6]])
>>> b = np.resize(a,(3,2))
>>> print(b)
[[1 2]
[3 4]
[5 6]]
numpy.append
此函数在输入数组的末尾添加值,附加操作不是原地的,而是返回新的数组.
numpy.append(a, values, axis)
参数 | 描述 |
---|---|
a | 输入数组 |
values | 要向a中添加的值 |
axis | 沿着它完成操作的轴,若不提供该参数,则数组会被展开 |
示例:
>>> a = np.array([[1,2,3],[4,5,6]])
>>> np.append(a, [7,8,9])
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
这里就是由于未提供axis而被展开了
>>> a = np.array([[1,2,3],[4,5,6]])
>>> np.append(a, [[7,8,9]], axis=0)
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> a = np.array([[1,2,3],[4,5,6]])
>>> np.append(a, [[7,8,9], [10,11,12]], axis=1)
array([[ 1, 2, 3, 7, 8, 9],
[ 4, 5, 6, 10, 11, 12]])
numpy.insert
非原地操作,返回新数组,且同样未提供axis的话数组会被展开.
numpy.insert(a, obj, values, axis)
参数 | 描述 |
---|---|
a | 输入数组 |
obj | 索引,在其之前插入 |
values | 要插入的值 |
axis | 沿着它插入的轴,若没有则展开数组 |
示例:
>>> a = np.array([[1,2],[3,4],[5,6]])
>>> np.insert(a,3,[7,8])
array([1, 2, 3, 7, 8, 4, 5, 6])
未传入参数axis,数组被展开
>>> a = np.array([[1,2],[3,4],[5,6]])
>>> np.insert(a,1,[7],axis = 0)
array([[1, 2],
[7, 7],
[3, 4],
[5, 6]])
这里在插入的同时广播了
numpy.delete
此函数返回从输入数组中删除指定子数组后的新数组.
numpy.delete(a, obj, axis)
参数 | 描述 |
---|---|
a | 输入数组 |
obj | 可以是切片,整数或者整数数组,表示要从输入数组中删除的子数组 |
axis | 沿着它删除指定数组的轴,若未提供,则展开数组 |
示例:
>>> a = np.arange(12).reshape(3,4)
>>> np.delete(a,5)
array([ 0, 1, 2, 3, 4, 6, 7, 8, >9, 10, 11])
>>> a = np.arange(12).reshape(3,4)
>>> np.delete(a,1,axis=1)
array([[ 0, 2, 3],
[ 4, 6, 7],
[ 8, 10, 11]])
numpy.unique
此函数返回输入数组中的去重元素数组和相关索引的数组.
numpy.unique(a, return_index, return_inverse, return_counts)
参数 | 描述 |
---|---|
a | 输入数组,若不是一维数组则会被展开 |
return_index | 若为true,返回去重后剩下元素在输入数组中的下标 |
return_inverse | 若为true,返回原始数组中元素在去重数组中的下标 |
return_counts | 若为true,返回去重数组中的元素在原数组中的出现次数 |
示例:
>>> a = np.array([1,2,1,3,2,2,3])
>>> u = np.unique(a)
>>> print(u)
[1 2 3]
>>> a = np.array([1,2,1,3,2,2,3])
>>> u,indices = np.unique(a, return_index=True)
>>> print(indices)
[0 1 3]
>>> a = np.array([1,2,1,3,2,2,3])
>>> u,indices = np.unique(a, return_inverse=True)
>>> print(indices)
[0 1 0 2 1 1 2]
>>> a = np.array([1,2,1,3,2,2,3])
>>> u,indices = np.unique(a, return_counts=True)
>>> print(indices)
[2 3 2]
Numpy 位操作
Numpy 字符串操作
Numpy 算数函数
三角函数
舍入函数
Numpy算数运算
Numpy统计函数
Numpy中有很多有用的统计函数,用于从数组中查最小,最大元素,求标准差,方差等
numpy.amin()和numpy.amax()
从数组中的元素沿指定轴返回最大,最小值.
示例:
>>> a = np.array([[3,7,5],[8,4,3],[2,4,9]])
>>> np.amin(a,1)
array([3, 3, 2])
>>> a = np.array([[3,7,5],[8,4,3],[2,4,9]])
>>> np.amin(a,0)
array([2, 4, 3])
numpy.ptp()
该函数返回沿轴的值的范围(最大值-最小值)-是减去
示例:
>>> a = np.array([[3,7,5],[8,4,3],[2,4,9]])
>>> np.ptp(a)
7
>>> a = np.array([[3,7,5],[8,4,3],[2,4,9]])
>>> np.ptp(a, axis = 1)
array([4, 5, 7])
numpy.percentile()
百分位数是统计中使用的度量方法,表示小于这个百分比中的最大的数.
numpy.percentile(a, q, axis)
参数 | 描述 |
---|---|
a | 输入数组 |
q | 要计算的百分位数,在0-100之间 |
axis | 沿着它计算百分位数的轴 |
示例:
>>> a = np.array([[30,40,70],[80,20,10],[50,90,60]])
>>> np.percentile(a,50)
50.0
>>> a = np.array([[30,40,70],[80,20,10],[50,90,60]])
>>> np.percentile(a,50, axis = 0)
array([50., 40., 60.])
numpy.median()
中值定义为将数据样本的上半部分和下半部分分开的值.
示例:
>>> a = np.array([[30,65,70],[80,95,10],[50,90,60]])
>>> np.median(a)
65.0
>>> a = np.array([[30,65,70],[80,95,10],[50,90,60]])
>>> np.median(a, axis = 1)
array([65., 80., 60.])
numpy.mean()
算数平均值是沿轴的元素总和处以元素数量
示例:
>>> a = np.array([[30,65,70],[80,95,10],[50,90,60]])
>>> np.mean(a)
61.111111111111114
>>> a = np.array([[30,65,70],[80,95,10],[50,90,60]])
>>> np.mean(a, axis = 1)
array([55. , 61.66666667, >66.66666667])
numpy.average()
加权平均值是由每个分量乘以反映其重要性的因子得到的平均值.
示例:
>>> a = np.array([1,2,3,4])
>>> wts = np.array([4,3,2,1])
>>> np.average(a,weights = wts, returned = True)
(2.0, 10.0)
多维中可指定要计算的轴
>>> a = np.arange(6).reshape(3,2)
>>> wt = np.array([3,5])
>>> np.average(a, axis = 1, weights = wt, returned = True)
(array([0.625, 2.625, 4.625]), >array([8., 8., 8.]))
标准差
标准差是与均值的偏差的平方的平均值的平方根.
示例:
>>> print(np.std([1,2,3,4]))
2.1.118033988749895
方差
方差是偏差的平方的平均值,即标准差最后不开根号.
示例:
>>> print(np.var([1,2,3,4]))
1.25
Numpy排序,搜索,计数
numpy.sort()
该函数返回输入数组的排序副本.
numpy.sort(a, axis, kind, order)
参数 | 描述 |
---|---|
a | 待排序的数组 |
axis | 沿着它排序的数组的轴,没有则展开数组 |
kind | 默认为'quicksort',快排 |
order | 如果数组包含字段,则是要排序的字段 |
示例:
>>> a = np.array([[3,7],[9,1]])
>>> np.sort(a,axis = 0)
array([[3, 1],
[9, 7]])
>>> dt = np.dtype([('name', 'S10'), ('age', int)])
>>> a = np.array([('raju',21),('anil',25),('ravi',17),('amar',27)], dtype = dt)
>>> np.sort(a, order = 'name')
array([(b'amar', 27), (b'anil', 25), (b'raju', 21), (b'ravi', 17)],
dtype=[('name', 'S10'), ('age', '<i8')])
numpy.argsort()
该函数对输入数组沿给定轴执行间接排序,并使用指定的排序类型返回数据的索引数组.
numpy.argsort(a, axis=1, kind='quicksort', order=None)
参数 | 列表 |
---|---|
a | 输入数组 |
axis | 沿着它排序的数组的轴,没有则展开数组 |
kind | 'quicksort', 'mergesort', 'heapsort', 'stable' |
order | 如果数组包含字段,则是要排序的字段 |
示例:
>>> x = np.array([3,1,2])
>>> y = np.argsort(x)
>>> print(y)
[1 2 0]
numpy.lexsort()
numpy.argmax() numpy.argmin()
这两个函数分别沿给定轴返回最大元素和最小元素的索引
示例:
>>> a = np.array([[30,40,50],[80,20,10],[50,90,60]])
>>> np.argmax(a)
7
>>> a = np.array([[30,40,50],[80,20,10],[50,90,60]])
>>> np.argmin(a,axis = 1)
array([0, 2, 0])
numpy.nonzero()
该函数返回输入数组中非零元素的索引值
示例:
>>> a = np.array([[0,0,50],[80,0,10],[0,90,0]])
>>> np.nonzero(a)
(array([0, 1, 1, 2]), array([2, 0, 2, 1]))
numpy.where()
该函数返回输入数组中满足给定条件的元素的索引
示例:
>>> a = np.array([[0,0,50],[80,0,10],[0,90,0]])
>>> np.where(a>0)
(array([0, 1, 1, 2]), array([2, 0, 2, 1]))
numpy.extract()
该函数返回输入数组中满足给定条件的元素的值
示例:
>>> a = np.array([[0,0,50],[80,0,10],[0,90,0]])
>>> np.extract(a>0,a)
array([50, 80, 10, 90])
Numpy副本和视图
在执行函数时,其中一些返回输入数组的副本,而另一些则返回视图.当内容的物理存储在另外一个位置时,称为副本,反之,则称为视图.
无复制
简单的赋值不会创建数组对象的副本.
示例:
>>> a = np.arange(6)
>>> b = a
>>> print("%s %s" % (id(a),id(b)))
139766633551472 139766633551472
视图的浅复制
ndarray.view(),数组的切片也如此,会创建视图,修改元素两个都会修改,但修改形状时只改变修改的那个
视图的深复制
ndarray.copy(),创建深层副本,修改形状,元素都不会对原来的产生影响
Numpy矩阵库
Numpy线性代数
参考:
https://blog.csdn.net/a373595475/article/details/79580734