Numpy是pythoon进行数值计算的一个第三方包，原名叫做Numerical Python，其实就是数组、矩阵啦。
Numpy的基础数据结构
Numpy主要通过封装一个n维数组来作为数据类型
称为Ndarray。
载入Numpy包和基本用法
import numpy as np
array = np.array([1,2,3,4,5,6,7])
print(ar) # 输出数组 元素之间没有逗号（和列表区分）
[1 2 3 4 5 6 7]
print(ar.ndim) # 输出数组维度的个数,也是秩
1
print(ar.shape) # 数组的维度，对于n行m列的数组，shape为（n，m）
(7,1)
print(ar.size) # 数组的元素总数，对于n行m列的数组，元素总数为n*m
7
print(ar.dtype) # 数组中元素的类型，类似type()（type()是函数，.dtype是方法）
int32
print(ar.itemsize) # 数组中每个元素的字节大小，int32类型字节为4，float64的字节为8
4
print(ar.data) # 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。
<memory at 0x0000000005927108>
print(np.random.rand(10).reshape(2,5)) # 生成10个随机数，并重组为2行5列的矩阵。
创建数组的三种方式
方法一： array()
array()函数，括号内可以是列表、元组、数组、生成器等。
ar1 = np.array(range(10)) # 整型
ar2 = np.array([1,2,3.14,4,5]) # 浮点型
ar3 = np.array([[1,2,3],('a','b','c')]) # 二维数组：嵌套序列（列表，元祖均可）
ar4 = np.array([[1,2,3],('a','b','c','d')]) # 注意嵌套序列数量不一会怎么样
print(ar1,type(ar1),ar1.dtype) #输出：[0 1 2 3 4 5 6 7 8 9] <class 'numpy.ndarray'> int32
print(ar2,type(ar2),ar2.dtype) #输出：[ 1. 2. 3.14 4. 5. ] <class 'numpy.ndarray'> float64
print(ar3,ar3.shape,ar3.ndim,ar3.size) # 二维数组，共6个元素 输出：[['1' '2' '3'] ['a' 'b' 'c']] (2, 3) 2 6
print(ar4,ar4.shape,ar4.ndim,ar4.size) # 一维数组，共2个元素 输出：[[1, 2, 3] ('a', 'b', 'c', 'd')] (2,) 1 2
方法二：linspace()
linspace()：返回在间隔[开始，停止]上计算的num个均匀间隔的样本。
ar1 = np.linspace(2.0, 3.0, num=5)
ar2 = np.linspace(2.0, 3.0, num=5, endpoint=False)
ar3 = np.linspace(2.0, 3.0, num=5, retstep=True)
print(ar1,type(ar1)) #输出：[ 2. 2.25 2.5 2.75 3. ] <class 'numpy.ndarray'>
print(ar2) #输出：[ 2. 2.2 2.4 2.6 2.8]
print(ar3,type(ar3)) #输出：(array([ 2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) <class 'tuple'>
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
start：起始值，stop：结束值
num：生成样本数，默认为50
endpoint：如果为真，则停止是最后一个样本。否则，不包括在内。默认值为True。
retstep：如果为真，返回（样本，步骤），其中步长是样本之间的间距 → 输出为一个包含2个元素的元祖，第一个元素为array，第二个为步长实际值
方法三：eye()
eye()：创建一个正方的N*N的单位矩阵，对角线值为1，其余为0。
print(np.eye(5))
输出：[[ 1. 0. 0. 0. 0.]
[ 0. 1. 0. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 1.]]
Ndarray的数据类型
| type | substance | value |
|---|---|---|
| bool | 用一个字节存储的布尔类型 | True或False |
| inti | 由所在平台决定其大小的整数 | |
| int8 | 一个字节大小 | -128 ~127 |
| int16 | 整数 | -32768 ~ 32767 |
| int32 | 整数 | -2^(31) ~ 2^(32) -1 |
| int64 | 整数 | -2^(63) ~ 2^(63) -1 |
| uint8 | 无符号整数 | 0 ~ 255 |
| uint16 | 无符号整数 | 0 ~ 65535 |
| uint32 | 无符号整数 | 0 ~ 2^(32) - 1 |
| uint64 | 无符号整数 | 0 ~ 2^(64) - 1 |
| float16 | 半精度浮点数：16位，正负号1位，指数5位，精度10位 | |
| float32 | 单精度浮点数：32位，正负号1位，指数8位，精度23位 | |
| float64、float | 双精度浮点数：64位，正负号1位，指数11位，精度52位 | |
| complex64 | 复数，分别用两个32位浮点数表示实部和虚部 | |
| complex128、complex | 复数，分别用两个64位浮点数表示实部和虚部 |
Numpy通用函数
主要从数组的形状、复制、类型转换、堆叠、拆分、简单运算进行说明。
数组形状：reshape()、resize()
.T方法转置
ar1 = np.arange(10)
ar2 = np.ones((3,2))
print(ar1,'\n',ar1.T) #输出：[0 1 2 3 4 5 6 7 8 9] [0 1 2 3 4 5 6 7 8 9]
print(ar2,'\n',ar2.T)
#输出：[[ 1. 1.]
# [ 1. 1.]
# [ 1. 1.]]
#[[ 1. 1. 1. 1. 1.]
#[ 1. 1. 1. 1. 1.]]
# .T方法：转置，例如原shape为(3,4)/(2,3,4)，转置结果为(4,3)/(4,3,2) → 所以一维数组转置后结果不变
reshape()
ar3 = ar1.reshape(2,5) # 用法1：直接将已有数组改变形状
ar4 = np.zeros((4,6)).reshape(3,8) # 用法2：生成数组后直接改变形状
ar5 = np.reshape(np.arange(12),(3,4)) # 用法3：参数内添加数组，目标形状
print(ar1,'\n',ar3)
#输出：[0 1 2 3 4 5 6 7 8 9] =ar1
# [[0 1 2 3 4] =ar3
# [5 6 7 8 9]]
print(ar4)
#输出：由4,6 转型为3,8
#[[ 0. 0. 0. 0. 0. 0. 0. 0.]
#[ 0. 0. 0. 0. 0. 0. 0. 0.]
#[ 0. 0. 0. 0. 0. 0. 0. 0.]]
print(ar5)
#输出：[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# numpy.reshape(a, newshape, order='C')：为数组提供新形状，而不更改其数据，所以元素数量需要一致！！
ar6 = np.resize(np.arange(5),(3,4))
print(ar6)
#输出：[[0 1 2 3]
# [4 0 1 2]
# [3 4 0 1]]
numpy.resize(a, new_shape)：返回具有指定形状的新数组，如有必要可重复填充所需数量的元素。
数组的复制 .copy()
ar1 = np.arange(10)
ar2 = ar1
print(ar2 is ar1) #True
ar1[2] = 9
print(ar1,ar2) #[0 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
# 回忆python的赋值逻辑：指向内存中生成的一个值 → 这里ar1和ar2指向同一个值，所以ar1改变，ar2一起改变
ar3 = ar1.copy()
print(ar3 is ar1) #False
ar1[0] = 9
print(ar1,ar3) #输出：[9 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
# copy方法生成数组及其数据的完整拷贝
# 再次提醒：.T/.reshape()/.resize()都是生成新的数组！！！
数组类型转换 dtype
ar1 = np.arange(10,dtype=float)
print(ar1,ar1.dtype) #输出：[ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64
# 可以在参数位置设置数组类型
ar2 = ar1.astype(np.int32)
print(ar2,ar2.dtype) #输出：[0 1 2 3 4 5 6 7 8 9] int32
print(ar1,ar1.dtype) #输出：[ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64
# a.astype()：转换数组类型
# 注意：养成好习惯，数组类型用np.int32，而不是直接int32
数组堆叠 hstack、vstack
a = np.arange(5) # a为一维数组，5个元素
b = np.arange(5,9) # b为一维数组,4个元素
ar1 = np.hstack((a,b)) # 注意:((a,b))，这里形状可以不一样
print(a,a.shape) #输出：[0 1 2 3 4] (5,)
print(b,b.shape) #输出：[5 6 7 8] (4,)
print(ar1,ar1.shape) #输出：[0 1 2 3 4 5 6 7 8] (9,)
a = np.array([[1],[2],[3]]) # a为二维数组，3行1列
b = np.array([['a'],['b'],['c']]) # b为二维数组，3行1列
ar2 = np.hstack((a,b)) # 注意:((a,b))，这里形状必须一样
print(a,a.shape)
#输出：[[1]
# [2]
# [3]] (3, 1)
print(b,b.shape)
#输出：[['a']
# ['b']
# ['c']] (3, 1)
print(ar2,ar2.shape)
#输出：[['1' 'a']
# ['2' 'b']
# ['3' 'c']] (3, 2)
# numpy.hstack(tup)：水平（按列顺序）堆叠数组
a = np.arange(5)
b = np.arange(5,10)
ar1 = np.vstack((a,b))
print(a,a.shape) #输出：[0 1 2 3 4] (5,)
print(b,b.shape)输出：[5 6 7 8 9] (5,)
print(ar1,ar1.shape)
#输出：[[0 1 2 3 4]
# [5 6 7 8 9]] (2, 5)
a = np.array([[1],[2],[3]])
b = np.array([['a'],['b'],['c'],['d']])
ar2 = np.vstack((a,b)) # 这里形状可以不一样
print(a,a.shape)
#输出：[[1]
# [2]
# [3]] (3, 1)
print(b,b.shape)
#输出：[['a']
# ['b']
# ['c']
# ['d']] (4, 1)
print(ar2,ar2.shape)
#输出：[['1']
# ['2']
# ['3']
# ['a']
# ['b']
# ['c']
# ['d']] (7, 1)
# numpy.vstack(tup)：垂直（按列顺序）堆叠数组
a = np.arange(5)
b = np.arange(5,10)
ar1 = np.stack((a,b))
ar2 = np.stack((a,b),axis = 1)
print(a,a.shape) #输出：[0 1 2 3 4] (5,)
print(b,b.shape) #输出：[5 6 7 8 9] (5,)
print(ar1,ar1.shape)
#输出：[[0 1 2 3 4]
# [5 6 7 8 9]] (2, 5)
print(ar2,ar2.shape)
#输出：[[0 5]
# [1 6]
# [2 7]
# [3 8]
# [4 9]] (5, 2)
# numpy.stack(arrays, axis=0)：沿着新轴连接数组的序列，形状必须一样！
# 重点解释axis参数的意思，假设两个数组[1 2 3]和[4 5 6]，shape均为(3,0)
# axis=0：[[1 2 3] [4 5 6]]，shape为(2,3)
# axis=1：[[1 4] [2 5] [3 6]]，shape为(3,2)
数组拆分 reshape()
ar = np.arange(16).reshape(4,4)
ar1 = np.hsplit(ar,2)
print(ar)
#输出：[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]
# [12 13 14 15]]
print(ar1,type(ar1))
#输出：[array([[ 0, 1],
# [ 4, 5],
# [ 8, 9],
# [12, 13]]),
# array([[ 2, 3],
# [ 6, 7],
# [10, 11],
# [14, 15]])] <class 'list'>
numpy.hsplit(ary, indices_or_sections)：将数组水平（逐列）拆分为多个子数组 → 按列拆分
# 输出结果为列表，列表中元素为数组
ar2 = np.vsplit(ar,4)
print(ar2,type(ar2))
#输出：[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]]), array([[12, 13, 14, 15]])] <class 'list'>
numpy.vsplit(ary, indices_or_sections)：:将数组垂直（行方向）拆分为多个子数组 → 按行拆分
数组简单运算
ar = np.arange(6).reshape(2,3)
#ar = [[0 1 2]
# [3 4 5]]
print(ar + 10) # 加法
#输出：[[10 11 12]
# [13 14 15]]
print(ar * 2) # 乘法
#输出：[[ 0 2 4]
# [ 6 8 10]]
print(1 / (ar+1)) # 除法
#输出：[[ 1. 0.5 0.33333333]
# [ 0.25 0.2 0.16666667]]
print(ar ** 0.5) # 幂
#输出：[[ 0. 1. 1.41421356]
# [ 1.73205081 2. 2.23606798]]
# 与标量的运算
print(ar.mean()) # 求平均值 2.5
print(ar.max()) # 求最大值 5
print(ar.min()) # 求最小值 0
print(ar.std()) # 求标准差 1.70782512766
print(ar.var()) # 求方差 2.91666666667
print(ar.sum(), np.sum(ar,axis = 0)) # 求和，np.sum() → axis为0，按列求和；axis为1，按行求和
#输出：15 [3 5 7]
print(np.sort(np.array([1,4,3,2,5,6]))) # 排序常用函数
#输出：[1 2 3 4 5 6]