Python基础 NumPy数组详解
NumPy是Python的一种开源的数值计算扩展库，提供 数组支持以及相应的高效处理函数，它包含很多功能，如创建n维数组（）矩阵，对数组进行函数运算，数值积分，线性代数计算，傅里叶变换和随机数产生等。
Why NumPy?
标准的Python用List（列表）保存值，可以当作数组使用，但因为列表中的元素可以是任何对象，所以浪费了CPU的运算时间和内存。NumPy的诞生弥补了这些缺陷，它提供了两种基本的对象：
- ndarry（n-dimensional array object）：是存储单一数据类型的多维数组。
- ufunc（universal function object）：是一种能够对数组进行处理的函数。
NumPy常用导入格式：
import numpy as np
一、数组对象的创建
1、使用 array 函数来创建数组对象：
- array 函数的格式：
np.array(object,dtype,ndmin)
array 函数的主要参数及其使用说明如下表所示：
| 参数名称 | 说明 |
|---|---|
| object | 接收array,表示想要创建的数组 |
| dtype | 接收data-type，表示数组所需数据类型，未给定则选择保存数据对象所需的最小类型，默认为None。 |
| ndmin | 接收int,指定生成数组应该具有的最小维数，默认为None。 |
#创建ndarray数组：
import numpy as np
data1 = [1,3,5,7] #列表
w1 = np.array(data1)
print('w1:',w1)
data2 = (1,2,3,4) #元组
w2 = np.array(data2)
print('w2:',w2)
data3 = [[1,2,3,6],[5,6,7,8]] #多维数组
w3 = np.array(data3)
print('w3:',w3)
#Output
#w1: [1 3 5 7]
#w2: [1 2 3 4]
#w3: [[1 2 3 6]
# [5 6 7 8]]
在创建数组时，NumPy会为新建的数组推断出一个合适的数据类型，并保存在dtype中，当序列中有整数和浮点数时，dtype会被定义为浮点数类型。
import numpy as np
data1 = [1,3,5,7.3] #列表
w1 = np.array(data1)
print(w1.dtype)
print('w1:',w1)
#Output
#float64
#w1: [1. 3. 5. 7.3]
2、专门创建数组的函数
1）arrange函数
- arange函数：创建等差一维数组，arrange函数类似于Python的内置函数range，但是arrange主要用来创建数组。
格式：np.arange([start, ]stop, [step, ]dtype)
#使用arrange创建数组
kk = np.arange(10)
print(kk)
#Output
#[0 1 2 3 4 5 6 7 8 9]
arrange函数可以通过指定初始值、终值和步长创建一维数组，创建的数组不包含终值。
kk = np.arange(0,15,1.5)
print(kk)
#Output
#[ 0. 1.5 3. 4.5 6. 7.5 9. 10.5 12. 13.5]
2）linspace 函数
当arrange函数的参数是浮点型的时候，由于浮点的精度有限，通常不太可能预测或者数组元素的数量，由于这个原因，通常选用更好的函数linspace，它接收元素数量作为参数，通过指定初始值，终值和元素格式创建一维数组，默认包括终值。
- linspace 函数：创建等差一维数组，接收元素数量作为参数。
格式：np.linspace(start, stop, num, endpoint, retstep=False, dtype=None)
参数说明：
start: scalar(标量), 序列的起始点
stop: scalar, 依据endpoint会有变化, endpoint为True, 则包含显示, 当为False, 不包含(生成序列相当于原始num上加1按endpoint = True生成, 结果只显示第一个到倒数第二个)
num: int, optional(可选), 生成样本数量, 必须是非负数
endpoint: bool, optional, 如果是真，则包括stop，如果为False，则没有stop
retstep: bool, optional
dtype: dtype, optional
#使用linspace函数创建数组
kk = np.linspace(1,10,4)
print(kk)
#Output
#[ 1. 4. 7. 10.]
3）logspace 函数
- logspace 函数和linspace 函数类似，不同的是它所创建的是等比数列数组。
格式：np.logspace(start, stop, num, endpoint=True,
base=10.0, dtype=None))
logspace的参数中，**start, stop代表的是10的幂,**默认基数base为10，第三个参数元素个数。
#生成1~10的具有5个元素的等比数列数组
kk = np.logspace(0,1,5)
print(kk)
#Output
#[ 1. 1.77827941 3.16227766 5.62341325 10. ]
4）zeros 函数
- zeros函数：创建指定长度或形状的全0数组
格式：np.zeros(shape, dtype=float, order=‘C’)
#使用zeros函数创建全零矩阵。
ll = np.zeros(4)
print(ll)
print("-----------------------")
kk = np.zeros(4,float)
print(kk)
print("-----------------------")
cc = np.zeros([3,3],int)
print(cc)
#Output
#[0. 0. 0. 0.]
#-----------------------
#[0. 0. 0. 0.]
#-----------------------
#[[0 0 0]
# [0 0 0]
# [0 0 0]]
可以看出，zeros函数默认类型为float64。
5）ones 函数
- ones函数：创建指定长度或形状的全1数组
格式：np. ones(shape, dtype=None, order=‘C’)
6）diag 函数
- diag函数：创建一个对角阵。
格式：np.diag(v, k=0)
参数：v可以是一维或二维的矩阵,k<0表示斜线在矩阵的下方,k>0表示斜线在矩阵的上方。
kk = np.diag([1,2,3,4])
print(kk)
#Output
# [[1 0 0 0]
# [0 2 0 0]
# [0 0 3 0]
# [0 0 0 4]]
7）eye 函数
- eye(n) 函数可以创建一个对角线为1，其余全0的矩阵，即单位阵。n为单位阵的维数。
kk = np.eye(4)
print(kk)
#Output
#[[1. 0. 0. 0.]
# [0. 1. 0. 0.]
# [0. 0. 1. 0.]
# [0. 0. 0. 1.]]
3、ndarray对象的属性和数据转换
NumPy创建的ndarray对象属性，主要有shape、size等属性。具体如下表所示：
| 属性 | 说明 |
|---|---|
| ndim | 秩，即数据轴的个数 |
| shape | 数组的维数 |
| size | 数组元素个数 |
| dtype | 数据类型 |
| itemsize | 数组中每个元素的字节大小 |
NumPy - 数据类型：
| 序号 | 数据类型及描述 |
|---|---|
| 1 | bool_ 存储为一个字节的布尔值（真或假） |
| 2 | int_ 默认整数，相当于 C 的long，通常为int32或int64 |
| 3 | intc 相当于 C 的int，通常为int32或int64 |
| 4 | intp 用于索引的整数，相当于 C 的size_t，通常为int32或int64 |
| 5 | int8 字节（-128 ~ 127） |
| 6 | int16 16 位整数（-32768 ~ 32767） |
| 7 | int32 32 位整数（-2147483648 ~ 2147483647） |
| 8 | int64 64 位整数（-9223372036854775808 ~ 9223372036854775807） |
| 9 | uint8 8 位无符号整数（0 ~ 255） |
| 10 | uint16 16 位无符号整数（0 ~ 65535） |
| 11 | uint32 32 位无符号整数（0 ~ 4294967295） |
| 12 | uint64 64 位无符号整数（0 ~ 18446744073709551615） |
| 13 | float_ float64的简写 |
| 14 | float16 半精度浮点：符号位，5 位指数，10 位尾数 |
| 15 | float32 单精度浮点：符号位，8 位指数，23 位尾数 |
| 16 | float64 双精度浮点：符号位，11 位指数，52 位尾数 |
| 17 | complex_ complex128的简写 |
| 18 | |
| 19 | complex128 复数，由两个 64 位浮点表示（实部和虚部） |
二、生成随机数
在NumPy.random模块中，提供了多种随机数的生成函数。如randint函数生成指定范围的随机整数来构成指定形状的数组。
用法：np.random.randint(low, high = None, size = None)，表示生成随机的整数型矩阵，low 表示最小值， high表示最大值，size 是一个元组类型 size = shape。
#生成随机整数
kk = np.random.randint(100,200,size=(2,4)) #在100-200数据间生成一个2行4列的随机数数组
print(kk)
#Output
#[[167 189 168 135]
# [116 188 157 102]]
类似的，还有：
1). np.random.randn( )：生成标准的正太分布，没有固定的参数，每多加一个数字，代表多增加一个维度，高斯正太分布=高斯分布 ，分布：是统计学中的。标准的高斯分布 的中间值是0 ，最好的范围是1 -1，超出范围的都是异常值。
2). np.random.random(size)：生成0-1之间的元素数组，size 表形状，random随即生产的范围是0-1之间，每个随机数都是一个维度。
3). np.random.rand( )：生成0-1之间的元素数组，和 np.random.random有一样的功能，random 需要 size来描述形状，而rand只需要我们直接给值,通过值的数量来确定形状。
4). np.random.normal(loc,scale,size)：生成一个正太分布的数组，location 是定位的的值， scale 是波动值，size 是数据长度。
| 函数 | 说明 |
|---|---|
| seed | 确定随机数生成器的种子 |
| permutation | 返回一个序列的随机排列或返回一个随机排列的范围 |
| shuffle | 对一个序列进行随机排序 |
| binomial | 产生二项分布的随机数 |
| normal | 产生正态（高斯）分布的随机数 |
| beta | 产生beta分布的函数 |
| chisquare | 产生卡方分布的随机数 |
| gamma | 产生gamma分布的随机数 |
| uniform | 产生在[0,1]中均匀分布的随机数 |
三、数组变换
3.1.数组重塑
对于已定义好的数组，可以通过reshape方法改变其数组维度，传入的参数为新维度的元组。reshape的参数中的其中一个可以设置为-1，表示数组的维度可以通过数据本身来推断。
kk0 = np.arange(8)
print("kk0: ",kk0)
kk1 = kk0.reshape(2,4)
print("kk1: ",kk1)
#Output
#kk0: [0 1 2 3 4 5 6 7]
#kk1: [[0 1 2 3]
# [4 5 6 7]]
- reshape 中的一个参数可以设置为-1，表示数组的维度可以通过数据本身来判断。
kk0 = np.arange(15)
print("kk0: ",kk0)
kk1 = kk0.reshape(5,-1)
print("kk1: ",kk1)
#Output
#kk0: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
#kk1: [[ 0 1 2]
# [ 3 4 5]
# [ 6 7 8]
# [ 9 10 11]
# [12 13 14]]
- 与reshape相反的方法是数据散开（ravel）或数据扁平化（flatten）。
kk0 = np.arange(15)
print("kk0: ",kk0)
kk1 = kk0.reshape(5,-1)
print("kk1: ",kk1)
kk2 = kk1.ravel()
print("kk2: ",kk2)
kk3 = kk1.flatten()
print("kk3: ",kk3)
#Output
#kk0: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
#kk1: [[ 0 1 2]
# [ 3 4 5]
# [ 6 7 8]
# [ 9 10 11]
# [12 13 14]]
#kk2: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
#kk3: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
- 需要注意的是，数据重塑不会改变原来的数组。
3.2.数组合并
数组合并用于多个数组间的操作，NumPy使用hstack函数、vstack函数、concatenate函数：完成数组的合并。
- hstack函数：实现横向合并
- hstack函数：实现横向合并
- concatenate函数：可以实现数组的横向或纵向合并，参数axis=1时进行横向合并，axis=0时进行纵向合并。
#横向合并：
kk1 = np.arange(6).reshape(3,2)
print(kk1)
print("----------")
kk2 = kk1 * 2
print(kk2)
print("----------")
kk3 = np.hstack((kk1,kk2))
print(kk3)
#Output
#[[0 1]
# [2 3]
# [4 5]]
#----------
#[[ 0 2]
# [ 4 6]
# [ 8 10]]
#----------
#[[ 0 1 0 2]
# [ 2 3 4 6]
# [ 4 5 8 10]]
3.3.数组分割
与数组合并相反，NumPy提供了hsplit函数、vsplit函数和split函数分别实现数组的横向、纵向和指定方向的分割。
arr = np.arange(16).reshape(4,4)
print('横向分割为:\n',np.hsplit(arr,2))
print('纵向组合为:\n',np.vsplit(arr,2))
#Output
#横向分割为:
# [array([[ 0, 1],
# [ 4, 5],
# [ 8, 9],
# [12, 13]]), array([[ 2, 3],
# [ 6, 7],
# [10, 11],
# [14, 15]])]
#纵向组合为:
# [array([[0, 1, 2, 3],
# [4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
# [12, 13, 14, 15]])]
同样，split在参数axis = 1时实现数组的横向分割，axis = 0时则进行纵向分割。
3.4.数组转置和轴对换
数组转置是数组重塑的一种特殊形式，可以通过transpose方法进行转置。transpose 方法需要传入轴编号组成的元组。除了使用transpose外，也可以直接利用数组的T属性进行数组转置。
kk = np.arange(6).reshape(3,2)
print('矩阵：',kk)
print('-------------')
print('转置矩阵：',kk.transpose(1,0)) //# np.transpose(kk))
#Output
# 矩阵： [[0 1]
# [2 3]
# [4 5]]
# -------------
# 转置矩阵： [[0 2 4]
# [1 3 5]]
数组的T属性转置：
kk = np.arange(6).reshape(3,2)
print('矩阵：',kk)
print('-------------')
print('转置矩阵：',kk.T)
#Output
# 矩阵： [[0 1]
# [2 3]
# [4 5]]
# -------------
# 转置矩阵： [[0 2 4]
# [1 3 5]]
ndarray 的 swapaxes 方法实现轴对换：
kk = np.arange(6).reshape(3,2)
print('矩阵：',kk)
print('-------------')
print('轴对换：',kk.swapaxes(0,1))
#Output
# 矩阵： [[0 1]
# [2 3]
# [4 5]]
# -------------
# 轴对换： [[0 2 4]
# [1 3 5]]
四、数组的索引和切片
4.1 一维数组的索引
一维数组的索引类似Python中的列表。
kk = np.arange(10)
print(kk)
print(kk[2])
print(kk[-1])
print(kk[2:5])
#Output
# [0 1 2 3 4 5 6 7 8 9]
# 2
# 9
# [2 3 4]
数组的切片返回的是原始数组的视图，不会产生新的数据，如果需要的并非视图而是要复制数据，则可以通过copy方法实现。
kk = np.arange(10)
print(kk)
kk1 = kk[1:3].copy()
print(kk1)
#Output
#[0 1 2 3 4 5 6 7 8 9]
#[1 2]
4.2 多维数组的索引
- 对于多维数组，它的每一个维度都有一个索引，各个维度的索引之间用逗号分隔。
- 也可以使用整数函数和布尔值索引访问多维数组。
kk = np.arange(12).reshape(3,4)
print(kk)
print(kk[0,1:3]) #索引第0行中第1列到第2列的元素
print(kk[ :,2]) #索引第2列元素
print(kk[:1,:1]) #索引第0行第0列元素
#Output
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# [1 2]
# [ 2 6 10]
# [[0]]
4.3 访问多维数组
kk = np.arange(12).reshape(3,4)
print(kk)
print('索引结果1: ',kk[(0,1),(1,3)]) #从两个序列的对应位置取出两个整数来组成下标:kk[0,1],kk[1,3]
print('索引结果2: ',kk[1:2,(0,2,3)]) #索引第一行中的0、2、3列元素
#Output
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# 索引结果1: [1 7]
# 索引结果2: [[4 6 7]]