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]]
五、NumPy中的数据统计与分析
在NumPy中，数组运算更为简洁而快速，通常比等价的Python方式快很多，尤其在处理数组统计计算与分析的情况下。
5.1 排序
NumPy 的排序方式有直接排序和间接排序。直接排序是对数据直接进行排序，间接排序是指根据一个或多个键值对数据进行排序。在NumPy中，直接排序使用函数sort，间接排序使用argsort函数和lexsort函数。
-
Sort函数对数据直接进行排序，调用改变原始数组，无返回值。
格式：numpy.sort(a, axis, kind, order)
主要参数及其说明见下表：
| 参数 |
使用说明 |
| a |
要排序的数组 |
| kind |
排序算法，默认为’quicksort’ |
| order |
排序的字段名，可指定字段排序，默认为None |
| axis |
使用sort函数可以沿着指定轴对数据集进行排序，axis = 1 为沿横轴排序，axis = 0 为沿纵轴排序，axis = None，将数组平坦化之后排序 |
例1：使用sort 函数进行排序。
kk = np.array([1,4,3,2,5,6,7,8,9])
print("原数组：",kk)
kk.sort()
print("排序后的数组：",kk)
#Output
#原数组： [1 4 3 2 5 6 7 8 9]
#排序后的数组： [1 2 3 4 5 6 7 8 9]
例2：带轴向参数的sort 排序。
kk = np.array([[4,2,9,5],[6,4,8,3],[1,6,2,4]])
print("原数组：",kk)
kk.sort(axis=1) #沿横向排序
print("排序后的数组：",kk)
#Output
# 原数组： [[4 2 9 5]
# [6 4 8 3]
# [1 6 2 4]]
# 排序后的数组： [[2 4 5 9]
# [3 4 6 8]
# [1 2 4 6]]
np.argsort函数和np.lexsort函数根据一个或多个键值对数据集进行排序。
- np.argsort(): 返回的是数组值从小到大的索引值。
- np.lexsort(): 返回值是按照最后一个传入数据排序的结果。
例3：使用argsort 函数进行排序。
kk = np.array([1,4,3,2,5,6,7,8,9])
print("原数组：",kk)
ll = kk.argsort()
print("排序后的数组：",kk)
print("数组下标：",ll) #返回值为数组排序后的下标排列
#Output
#原数组： [1 4 3 2 5 6 7 8 9]
#排序后的数组： [1 4 3 2 5 6 7 8 9]
#数组下标： [0 3 2 1 4 5 6 7 8]
可以看出来，argsort 函数仅仅只是将排序后数组的的下标进行展示，而原有数组不受影响。
例4：使用lexsort 函数进行排序。
a = [2,5,8,4,3,7,6]
b = [9,4,0,4,0,2,1]
c = np.lexsort((a,b))
print(c)
#Output
#[4 2 6 5 3 1 0]
lexsort()分为三个步骤
1.将索引与之一一对应。（a,b同时对应即可）
2. 因为lexsort((a,b))中，以b为基准，所以将b排序，再用索引与之对应。
3. 当索引遇见相同元素时，以a中元素的大小顺序排序。
5.2 重复数据与去重
在数理统计分析中，需要提前将重复数据剔除，在NumPy中，可以通过unique 函数找到数组中的唯一值并返回已排序的结果。
数组内数据去重。（unique(a)）
a = np.array(['red','blue','yellow','red','red','white'])
print("原数组：",a)
print("去重后的数组：",np.uni
#Output
#原数组： ['red' 'blue' 'yellow' 'red' 'red' 'white']
#去重后的数组： ['blue' 'red' 'white' 'yellow']
统计分析中有时候需要把一个数据重复若干次，使用tile和repeat函数即可实现此功能。
- tile函数的格式：np.tile(A, reps)
其中，参数A表示要重复的数组，reps表示重复次数。
- repeat函数的格式：np.repeat(A, reps, axis = None)
其中， “a”: 是需要重复的数组元素，“repeats”: 是重复次数， “axis”: 指定沿着哪个轴进行重复，axis = 0表示按行进行元素重复；axis = 1表示按列进行元素重复。
#使用tile 函数实现数据重复。
kk = np.array([1,2,3])
print(kk)
ll = np.tile(kk,3) #将kk数组重复三次
print(ll)
#Output
#[1 2 3]
#[1 2 3 1 2 3 1 2 3]
#使用repeat 函数实现数据重复。
kk = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(kk)
print('------------')
# ll = np.tile(kk,3) #将kk数组重复三次
# print(ll)
ll = np.repeat(kk,2,axis=1)
print(ll)
print('------------')
ss = np.repeat(kk,2,axis=0)
print(ss)
#Output
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
# ------------
# [[1 1 2 2 3 3] #按列进行重复
# [4 4 5 5 6 6]
# [7 7 8 8 9 9]]
# ------------
# [[1 2 3] #按行进行重复
# [1 2 3]
# [4 5 6]
# [4 5 6]
# [7 8 9]
# [7 8 9]]
5.3 常用统计函数
NumPy中提供了很多用于统计分析的函数，常见的有sum、mean、std、var、min和max等。
几乎所有的统计函数在针对二维数组的时候需要注意轴的概念。axis=0时表示沿着纵轴进行计算，axis=1时沿横轴进行计算。用法:np.函数(数组)
| 函数 |
说明 |
| np.sum(a) |
数组的和 |
| np.sum(a,axis = 0) |
数组纵轴的和 |
| np.sum(a,axis = 0) |
数组横轴的和 |
| np.mean(a) |
数组的均值 |
| np.mean(a,axis = 0) |
数组纵轴的均值 |
| np.mean(a,axis = 1) |
数组横轴的均值 |
| np.std(a) |
数组的标准差 |
| np.var(a) |
数组的标准差 |
| np.average(a) |
数组的加权平均值 |
| np.percentile(a) |
数组的分位数 |
| np.ptp(a) |
数组的极差值 |
| np.median(a) |
数组的中位数 |
