python三方库学习之Numpy学习

一、Numpy简介

NumPy 的全称是“ Numeric Python”，它是 Python 的第三方扩展包，主要用来计算、处理一维或多维数组。

在数组算术计算方面， NumPy 提供了大量的数学函数。NumPy 的底层主要用 C语言编写，因此它能够高速地执行数值计算。NumPy 还提供了多种数据结构，这些数据结构能够非常契合的应用在数组和矩阵的运算上。随着数据科学（Data Science，简称 DS，包括大数据分析与处理、大数据存储、数据抓取等分支）的蓬勃发展，像 NumPy、SciPy（Python科学计算库）、Pandas（基于NumPy的数据处理库） 等数据分析库都有了大量的增长，它们都具有较简单的语法格式。

NumPy 可以很便捷高效地处理大量数据，那么使用 NumPy 做数据处理有哪些优点呢？

• NumPy 是 Python 科学计算基础库；
• NumPy 可以对数组进行高效的数学运算；
• NumPy 的 ndarray 对象可以用来构建多维数组；
• NumPy 能够执行傅立叶变换与重塑多维数组形状；
• NumPy 提供了线性代数，以及随机数生成的内置函数。

二、Numpy内容

NumPy 定义了一个 n 维数组对象，简称 ndarray 对象，它是一个一系列相同类型元素组成的数组集合。数组中的每个元素都占有大小相同的内存块，您可以使用索引或切片的方式获取数组中的每个元素。

ndarray 对象有一个 dtype 属性，该属性用来描述元素的数据类型。ndarray 对象采用了数组的索引机制，将数组中的每个元素映射到内存块上，并且按照一定的布局对内存块进行排列，常用的布局方式有两种，即按行或者按列。

1、通过 NumPy 的内置函数 array() 可以创建 ndarray 对象，其语法格式如下：

numpy.array(object, dtype = None, copy = True, order = None,ndmin = 0)

参数说明

序号	参数	描述说明
1	object	表示一个数组序列。
2	dtype	可选参数，通过它可以更改数组的数据类型。
3	copy	可选参数，表示数组能否被复制，默认是 True。
4	order	以哪种内存布局创建数组，有 3 个可选值，分别是 C(行序列)/F(列序列)/A(默认)。
5	ndim	用于指定数组的维度。

2、NumPy 中每种数据类型都有一个唯一标识的字符码，如下所示：

数据类型标识码 

字符	对应类型
b	代表布尔型
i	带符号整型
u	无符号整型
f	浮点型
c	复数浮点型
m	时间间隔（timedelta）
M	datatime（日期时间）
O	Python对象
S,a	字节串（S）与字符串（a）
U	Unicode
V	原始数据（void）

3、NumPy 作为 Python 的扩展包，它提供了比 Python 更加丰富的数据类型

NumPy数据类型

1	bool_	布尔型数据类型（True 或者 False）
2	int_	默认整数类型，类似于 C 语言中的 long，取值为 int32 或 int64
3	intc	和 C 语言的 int 类型一样，一般是 int32 或 int 64
4	intp	用于索引的整数类型（类似于 C 的 ssize_t，通常为 int32 或 int64）
5	int8	代表与1字节相同的8位整数。值的范围是-128到127。
6	int16	代表 2 字节（16位）的整数。范围是-32768至32767。
7	int32	代表 4 字节（32位）整数。范围是-2147483648至2147483647。
8	int64	表示 8 字节（64位）整数。范围是-9223372036854775808至9223372036854775807。
9	uint8	代表1字节（8位）无符号整数。
10	uint16	2 字节（16位）无符号整数。
11	uint32	4 字节（32位）的无符号整数。
12	uint64	8 字节（64位）的无符号整数。
13	float_	float64 类型的简写。
14	float16	半精度浮点数，包括：1 个符号位，5 个指数位，10个尾数位。
15	float32	单精度浮点数，包括：1 个符号位，8 个指数位，23个尾数位。
16	float64	双精度浮点数，包括：1 个符号位，11 个指数位，52个尾数位。
17	complex_	复数类型，与 complex128 类型相同。
18	complex64	表示实部和虚部共享 32 位的复数。
19	complex128	表示实部和虚部共享 64 位的复数。
20	str_	表示字符串类型
21	string_	表示字节串类型

三、Numpy常用的函数属性

数组属性 ：Numpy 数组的常用属性如下

1. ndim查看数组维数。

2. reshape数组变纬。

3. ndarray.shape用来调整数组维度的大小。

4. ndarray.reshape()调整数组形状。

5. ndarray.ndim返回的是数组的维数。

6. ndarray.itemsize返回数组中每个元素的大小（以字节为单位）。

7. ndarray.flags返回 ndarray 数组的内存信息，如 ndarray 数组的存储方式，以及是否是其他数组的副本等。

8. numpy.empty() 创建未初始化的数组，可以指定创建数组的形状（shape）和数据类型（dtype）
    

   numpy.empty(shape, dtype = float, order = 'C')

9. numpy.zeros() 创建元素为0的数组，同时还可以指定被数组的形状
    

   numpy. zeros(shape,dtype=float,order="C")

   注意：“C”代表以行顺序存储，“F”则表示以列顺序存储

10. numpy.ones() 返回指定形状大小与数据类型的新数组，并且新数组中每项元素均用 1 填充。
     

11. numpy.asarray()  看似asarray() 与 array() 类似，但是它比 array() 更为简单。asarray() 能够将一个 Python 序列转化为 ndarray 对象。

12. numpy.frombuffer() 表示使用指定的缓冲区创建数组。

13. numpy.formiter() 该方法可以把迭代对象转换为 ndarray 数组，其返回值是一个一维数组。

区间数组，是指数组元素的取值位于某个范围内，并且数组元素之间可能会呈现某种规律，比如等比数列、递增、递减等。

• numpy.arrange() 在 NumPy 中，您可以使用 arange() 来创建给定数值范围的数组。其语法格式：

  numpy.arange(start默认是 0, stop终止值, step步长，默认为 1, dtype可选参数)

• numpy.linspace() 表示在指定的数值区间内，返回均匀间隔的一维等差数组，默认均分 50 份，语法格式如下：

  np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

        注意：endpoint：默认为 True，表示数列包含 stop 终止值，反之不包含；

                   retstep：默认为 True，表示生成的数组中会显示公差项，反之不显示

• numpy,logspace()  函数同样返回一个 ndarray 数组，它用于创建等比数组，语法格式如下：

  np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

  注意：base指对数函数的 log 底数，默认为10。

 四、Numpy索引和切片

在 NumPy 中，如果想要访问，或修改数组中的元素，您可以采用索引或切片的方式，比如使用从 0 开始的索引依次访问数组中的元素，这与 Python 的 list 列表是相同的。
NumPy 提供了多种类型的索引方式，常用方式有两种：基本切片与高级索引。

• 基本切片 

NumPy 内置函数 slice（）可以用来构造切片对象，该函数需要传递三个参数值分别是 start起始索引、stop终止索引 和 step步长，通过它可以实现从原数组的上切割出一个新数组。

import numpy as np
a = np.arange(10)
print(a)
#生成切片对象
s = slice(2,9,2)#从索引2开始到索引9停止，间隔时间为2
print(a[s])
b = a[2:9:2] #冒号来分割切片参数
print(b)

冒号切片做简单地说明：

1. 如果仅输入一个参数，则将返回与索引相对应的元素。 对于上述示例来说[3] 就会返回 3。
2. 如果在其前面插入 : 如[:9]，则会返回 0-8 的所有数字（不包含9）。
3. 如是 [2:] 则会返回 2-9 之间的数字。
4. 如果在两个参数之间，如[2:9]，则对两个索引值之间的所有元素进行切片（不包括停止索引）。

•  多维数组切片

import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
# 从[1:]索引处开始切割
print(a[1:])

注意：切片还可以使用省略号“…...”，如果在行位置使用省略号，那么返回值将包含所有行元素，反之，则包含所有列元素。

import numpy as np
#创建a数组
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
#返回数组的第二列
print (a[...,1]) 
#返回数组的第二行
print (a[1,...])
#返回第二列后的所有项
print (a[...,1:])

五、NumPy高级索引

NumPy 与 Python 的内置序列相比，它提供了更多的索引方式。比如整数数组索引、布尔索引以及花式索引。

高级索引返回的是数组的副本（深拷贝），而切片操作返回的是数组视图（浅拷贝）。

1、整数数组索引

 整数数组索引，它可以选择数组中的任意一个元素，比如，选择第几行第几列的某个元素。

import numpy as np
#创建二维数组
x = np.array([[1,  2],  [3,  4],  [5,  6]])
#[0,1,2]代表行索引;[0,1,0]代表列索引
y = x[[0,1,2],[0,1,0]] 
print (y)

import numpy as np
b = np.array([[ 0, 1, 2],
              [ 3, 4, 5],
              [ 6, 7, 8],
              [ 9,10,11]])
r = np.array([[0,0],[3,3]])
c = np.array([[0,2],[0,2]])
#获取四个角的元素
c = b[r,c]
print(c)

2、布尔数组索引

        当输出的结果需要经过布尔运算（如比较运算）时，此时会使用到另一种高级索引方式，即布尔数组索引。

#返回所有大于6的数字组成的数组
import numpy as np
x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]])
print (x[x > 6])

#可以使用补码运算符来去除 NaN（即非数字元素）
#~：这是逻辑非运算符
import numpy as np
a = np.array([np.nan, 1,2,np.nan,3,4,5])
print(a[~np.isnan(a)])

3、花式索引

        花式索引也可以理解为整数数组索引，但是它们之间又略有不同。

六、Numpy遍历数组

NumPy 提供了一个 nditer 迭代器对象，它可以配合 for 循环完成对数组元素的遍历。
在内存中，Numpy 数组提供了两种存储数据的方式，分别是 C-order（行优先顺序）与 Fortrant-order（列优先顺序）。那么 nditer 迭代器又是如何处理具有特定存储顺序的数组呢？其实它选择了一种与数组内存布局一致的顺序，之所以这样做，是为了提升数据的访问效率。

在默认情况下，当我们遍历数组中元素的时候，不需要考虑数组的存储顺序 

import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)#三行四列
#a的转置数组
b = a.T
print (b)#四行三列
for x in np.nditer(b):
   print(x，end=",")

#copy方法生成数组副本
for x in np.nditer(a.T.copy(order='C')):
    print (x, end=", " )

 1、指定遍历顺序

可以通过 nditer 对象的order参数来指定数组的遍历的顺序 

#行优先

for x in np.nditer(a, order = 'C'):

print (x,end=",")

#列优先

for x in np.nditer(a, order = 'F'):

print (x,end=",")

2、修改数组元素值

nditer 对象提供了一个可选参数op_flags，它表示能否在遍历数组时对元素进行修改。它提供了三种模式。

1、 read-only

只读模式，在这种模式下，遍历时不能修改数组中的元素。

 2、read-write

读写模式，遍历时可以修改元素值。

3、write-only

只写模式，在遍历时可以修改元素值。

具体代码实现：

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

在 NumPy 中，x[...]是一种特殊x的索引方式，被称为“椭圆”索引或全切片索引。它的作用是引用数组 x 的所有元素。

3、外部循环使用

nditer 对象的构造函数有一个“flags”参数，它可以接受以下参数值：

flags参数说明

参数值	描述说明
c_index	可以跟踪 C 顺序的索引。
f_index	可以跟踪 Fortran 顺序的索引。
multi_index	每次迭代都会跟踪一种索引类型。
external_loop	返回的遍历结果是具有多个值的一维数组。

import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print("原数组",a)
#修改后数组
for x in np.nditer(a, flags = ['external_loop'], order = 'F'):
   print(x)

七、NumPy相关数组操作

NumPy 中包含了一些处理数组的常用方法，大致可分为以下几类：

• 数组变维操作
• 数组转置操作
• 修改数组维度操作
• 连接与分割数组操作

1. 创建数组：NumPy提供了多种方法来创建数组，如使用numpy.array()函数，或者使用numpy.zeros()、numpy.ones()、numpy.empty()等函数来创建具有特定形状和值的数组。
2. 数组操作：NumPy提供了许多用于操作数组的方法，如加法、减法、乘法、除法等。此外，还有许多用于比较数组的方法，如numpy.equal()、numpy.not_equal()、numpy.greater()等。
3. 索引和切片：NumPy允许你使用索引和切片来访问和修改数组的元素。你可以使用整数索引、切片、布尔索引等来访问数组的元素。
4. 形状和大小：NumPy提供了许多方法来获取数组的形状和大小，如numpy.shape()和numpy.size()。
5. 元素级别的操作：NumPy提供了许多用于元素级别的操作的方法，如numpy.sum()、numpy.mean()、numpy.std()等。
6. 排序和搜索：NumPy提供了多种排序和搜索方法，如numpy.sort()、numpy.argsort()、numpy.where()等。
7. 统计：NumPy提供了许多用于统计的方法，如计算数组的元素个数、最大值、最小值等。
8. 线性代数：NumPy提供了许多用于线性代数操作的方法，如矩阵乘法、矩阵转置等。
9. 随机数生成：NumPy还提供了许多用于生成随机数的方法，如生成均匀分布的随机数、正态分布的随机数等。

 1、数组转置操作

数组转置操作

函数名称	说明
transpose	将数组的维度值进行对换，比如二维数组维度(2,4)使用该方法后为(4,2)。
ndarray.T	与 transpose 方法相同。
rollaxis	沿着指定的轴向后滚动至规定的位置。
swapaxes	对数组的轴进行对换。

numpy.transpose()

numpy.transpose() 用于对换多维数组的维度，比如二维数组使用此方法可以实现矩阵转置，语法格式如下：

numpy.transpose(arr, axes)

• arr：要操作的数组
• axes：可选参数，元组或者整数列表，将会按照该参数进行转置。

numpy.rollaxis()

该方法表示沿着指定的轴，向后滚动至一个特定位置。格式如下：

numpy.rollaxis(arr, axis, start)

• arr：要传入的数组；
• axis：沿着哪条轴向后滚动，其它轴的相对位置不会改变；
• start：默认以 0 轴开始，可以根据数组维度调整它的值。

numpy.swapaxes()

方法用于交换数组的两个轴。其语法格式如下：

numpy.swapaxes(arr, axis1, axis2) 

import numpy as np
# 创建一个 3x4 的数组
a = np.arange(12).reshape(3,4)
print(a)
# 交换第0和第1条轴
result = np.swapaxes(a, 0, 1)
print(result)

2、修改数组维度操作

修改数组维度的操作，主要有以下方法：

数组维度修改

函数名称	描述说明
broadcast	生成一个模拟广播的对象。
broadcast_to	将数组广播为新的形状。
expand_dims	扩展数组的形状。
squeeze	从数组的形状中删除一维项。

1、numpy.broadcast()

返回值是数组被广播后的对象，该函数以两个数组作为输入参数。

import numpy as np
a = np.array([[1], [2], [3]])
b = np.array([4, 5, 6]) 
# 对b广播a
d = np.broadcast(a,b) 
#d它拥有 iterator 属性
r,c = d.iters
print (next(r), next(c))
print (next(r), next(c))
# 使用broadcast将a与b相加
e = np.broadcast(a,b)
f=np.empty(e.shape)
f.flat=[x+y for (x,y) in e]
print(f)
print(a+b)

2、 numpy.broadcast_to()

该函数将数组广播到新形状中，它在原始数组的基础上返回一个只读视图。如果新形状不符合 NumPy 的广播规则，则会抛出 ValueError 异常。函数的语法格式如下：

numpy.broadcast_to(array, shape, subok)

import numpy as np
a = np.arange(4).reshape(1,4)
print(a)
print(np.broadcast_to(a,(3,4)))

3、numpy.expand_dims()

在指定位置插入新的轴，从而扩展数组的维度，语法格式如下:

numpy.expand_dims(arr, axis) 

参数说明：

• arr：输入数组
• axis：新轴插入的位置

import  numpy as np
x = np.array(([1,2],[3,4]))
print(x)
y = np.expand_dims(x,axis = 0)
print(y)
print(x.shape,y.shape)

4、numpy.squeeze()

删除数组中维度为 1 的项，例如，一个数组的 shape 是 (5,1)，经此函数后，shape 变为 (5,) 。其函数语法格式如下：

numpy.squeeze(arr, axis)

参数说明：

• arr：输入数的组；
• axis：取值为整数或整数元组，用于指定需要删除的维度所在轴，指定的维度值必须为 1 ，否则将会报错，若为 None，则删除数组维度中所有为 1 的项。

import numpy as np
a = np.arange(9).reshape(1,3,3) #1x3x3的三维数组
print (a)
b = np.squeeze(a) #删除数组中维度为 1 的项
print (b)

 3、连接与分割数组操作

连接与分割数组

类型	函数名称	描述说明
连接数组方法	concatenate	沿指定轴连接两个或者多个相同形状的数组
	stack	沿着新的轴连接一系列数组
	hstack	按水平顺序堆叠序列中数组（列方向）
	vstack	按垂直方向堆叠序列中数组（行方向）
分割数组方法	split	将一个数组分割为多个子数组
	hsplit	将一个数组水平分割为多个子数组（按列）
	vsplit	将一个数组垂直分割为多个子数组（按行）

 1、连接数组操作

numpy.concatenate() 沿指定轴连接相同形状的两个或多个数组

numpy.concatenate((a1, a2, ...), axis) 

注意：数组连接操作至少需要两个维度相同的数组，才允许对它们进行垂直或者水平方向上的操作。

在垂直方向堆叠数组

import numpy as np
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
#数组拼接
print(np.concatenate((a,b)))
#垂直堆叠
c = np.vstack((a,b))
print (c)

 2、分割数组操作

 numpy.split() 沿指定的轴将数组分割为多个子数组，语法格式如下：

numpy.split(ary, indices_or_sections, axis)

参数说明：

• ary：被分割的数组
• indices_or_sections：若是一个整数，代表用该整数平均切分，若是一个数组，则代表沿轴切分的位置（左开右闭）；
• axis：默认为0，表示横向切分；为1时表示纵向切分。

import numpy as np
a = np.arange(6)
print(a)
b = np.split(a,2)#将数组分为二个形状大小相等的子数组
print(b)
b= np.split(a,[3,4]) #将数组在一维数组中标明要位置分割
print(b)