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