Python-Numpy 科学计算库

简单理了一下科学计算库，发现这是比较枯燥的，要记的东西很多，比较烦躁。

Numpy简介：NumPy数组是一个多维数组对象，称为ndarray。Numpy主要有两部分组成，如下：

• 实际的数据
• 描述这些数据的元数据

 

一、基础数据结构

1、创建数组：

1. array()函数，括号内可以是列表、元祖、数组、生成器
2. arange()，类似range()，在给定的间隔内返回均匀间隔的值
3. linespace()，返回在间隔上（前闭后闭）计算的num个均匀间隔的样本
4. zeros()/zeros_like()/ones()/ones_like()
5. eye(n)，创建一个正方的N*N矩阵，对角线值为1，其余为0

 

（1）array()函数

ar1 = np.array(range(10))   # range(10)产生10个从0开始的整数
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)
print(ar2,type(ar2),ar2.dtype)
print(ar3,ar3.shape,ar3.ndim,ar3.size)     # 二维数组，共6个元素
print(ar4,ar4.shape,ar4.ndim,ar4.size)     # 一维数组，共2个元素，两个一维数组

输出结果为：
[0 1 2 3 4 5 6 7 8 9] <class 'numpy.ndarray'> int32

[1.   2.   3.14 4.   5.  ] <class 'numpy.ndarray'> float64

[['1' '2' '3']
 ['a' 'b' 'c']] (2, 3) 2 6

[list([1, 2, 3]) ('a', 'b', 'c', 'd')] (2,) 1 2

（2) arange()

print(np.arange(10))    # 返回0-9，整型
print(np.arange(10.0))  # 返回0.0-9.0，浮点型
print(np.arange(5,12))  # 返回5-11
print(np.arange(5.0,12,2))  # 返回5.0-12.0，步长为2
print(np.arange(10000))  # 如果数组太大而无法打印，NumPy会自动跳过数组的中心部分，并只打印边角


输出：
[0 1 2 3 4 5 6 7 8 9]
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
[ 5  6  7  8  9 10 11]
[ 5.  7.  9. 11.]
[   0    1    2 ... 9997 9998 9999]

（3）linspace()   ——>返回在间隔[开始，停止]上计算的num个均匀间隔的样本。

用法：

# numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# start：起始值，stop：结束值
# num：生成样本数，默认为50
# endpoint：如果为真，则停止是最后一个样本。否则，不包括在内。默认值为True。
# retstep：如果为真，返回（样本，步骤），其中步长是样本之间的间距 → 输出为一个包含2个元素的元祖，第一个元素为array，第二个为步长实际值

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))
print(ar2)
print(ar3,type(ar3))

输出：
[2.   2.25 2.5  2.75 3.  ] <class 'numpy.ndarray'>
[2.  2.2 2.4 2.6 2.8]
(array([2.  , 2.25, 2.5 , 2.75, 3.  ]), 0.25) <class 'tuple'>

（4）zeros() 

用法：

# numpy.zeros(shape, dtype=float, order='C'):返回给定形状和类型的新数组，用零填充。
# shape：数组维度，二维以上需要用()，且输入参数为整数
# dtype：数据类型，默认numpy.float64
# order：是否在存储器中以C或Fortran连续（按行或列方式）存储多维数据。

ar1 = np.zeros(5)    #创建一个一维数组，元素为5个
ar2 = np.zeros((2,2), dtype = np.int)    #创建一个二维2*2的数组
print(ar1,ar1.dtype)
print(ar2,ar2.dtype)


输出：
[0. 0. 0. 0. 0.] float64
[[0 0]
 [0 0]] int32

（5）zeros_like() 

用法与zeros()一样

ar3 = np.array([list(range(5)),list(range(5,10))])
ar4 = np.zeros_like(ar3)
print(ar3)
print(ar4)

输出：
[[0 1 2 3 4]
 [5 6 7 8 9]]

[[0 0 0 0 0]
 [0 0 0 0 0]]

（6）ones()/ones_like() 

ar5 = np.ones(9)
ar6 = np.ones((2,3,4))
ar7 = np.ones_like(ar3)
print(ar5)
print(ar6)
print(ar7)


输出：
[1. 1. 1. 1. 1. 1. 1. 1. 1.]

[[[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]
 [[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]]


[[1 1 1 1 1]
 [1 1 1 1 1]]

（7）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.]]

（8）输出一些数组的方法：

.ndim	输出数组的秩，也称而维度的个数
.shape	数组的维度，对于n行m列的数组，shape(2,3)
.size	数组元素的总数，对于n行m列的数组，总数为n*m个
.dtype	数组中元素的类型，类似type()，但请注意，dtype是方法
.itemsize	数组中每个元素的字节大小，int32l类型字节为4，float64的字节为8
.data	包含实际数组元素的缓冲区，有于一般通过数组的索引获取元素，所以通常不需要使用这个属性

 

（9）ndarray数据类型  

类型	存储大小
bool	用一个字节存储的布尔类型
inti	由平台决定其大小的整数
int8	一个字节的大小，-128到127
int16	-32768到32767
int32	-2**31到2**31-1
int64	-2**63到2**63-1
uint8	0-255
uint16	0-65535
uint32	2-2**32-1
uint64	0-2**64-1
float16	半精度浮点数，16位，正负号一位，指数5位，精度10位
float32	单精度浮点数，32位，正负号一位，指数8位，精度23位
float64或float	双精度浮点数，64位，正负号一位，指数11位，精度52位
complex64	复数，分别用两个32位浮点数表示是不和虚部
complex128或complex	复数，分别用64位浮点数表示实部和虚部

 

 

二、Numpy的操作

1、索引及切片

• 一维数组的索引及切片
• 二维数组的索引及切片
• 三位数组的索引及切片
• 布尔类型的索引与切片

例：

一维数组的索引及切片

ar = np.arange(20)
print(ar)
print(ar[4])
print(ar[3:6])


输出结果为：
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]

4

[3 4 5]

二维数组的索引及切片

ar = np.arange(16).reshape(4,4)
print(ar, '数组轴数为%i' %ar.ndim)   # 4*4的数组
print(ar[2],  '数组轴数为%i' %ar[2].ndim)  # 切片为下一维度的一个元素，所以是一维数组
print(ar[2][1]) # 二次索引，得到一维数组中的一个值
print(ar[2,2])  # 切片数组中的第三行第三列 → 10，跟前面一个是一样的意思
print(ar[1:3],  '数组轴数为%i' %ar[1:3].ndim)  # 切片为两个一维数组组成的二维数组
print(ar[:2,1:])  # 切片数组中的1,2行、2,3,4列 → 二维数组


输出：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]] 数组轴数为2

[ 8  9 10 11] 数组轴数为1

9

10

[[ 4  5  6  7]
 [ 8  9 10 11]] 数组轴数为2

[[1 2 3]
 [5 6 7]]

三维数组的索引及切片

ar = np.arange(8).reshape(2,2,2)   #创建一个三维数组
print(ar, '数组轴数为%i' %ar.ndim)   # 2*2*2的数组
print(ar[0],  '数组轴数为%i' %ar[0].ndim)  # 三维数组的第一个维度的第一个元素 → 一个二维数组
print(ar[0][0],  '数组轴数为%i' %ar[0][0].ndim)  # 三维数组的第一个维度的第一个元素下的第一个元素 → 一个一维数组
print(ar[0][0][1],  '数组轴数为%i' %ar[0][0][1].ndim)  

输出：
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]] 数组轴数为3

[[0 1]
 [2 3]] 数组轴数为2

[0 1] 数组轴数为1

1 数组轴数为0

布尔类型的索引与切片：以布尔型的矩阵去做筛选，筛选出符合要求的数，很高效。例如：

ar = np.arange(12).reshape(3,4)    #创建一个3*4的二维数组
i = np.array([True,False,True])    #根据要求写出布尔类型的数组
j = np.array([True,True,False,False])   #一样，根据要求写出布尔类型的数组

print(ar)
print(i)
print(j)

print(ar[i,:])  # 在第一维度做判断，只保留True，这里第一维度就是行，ar[i,:] = ar[i]（简单书写格式）
print(ar[:,j])  # 在第二维度做判断，这里如果ar[:,i]会有警告，因为i是3个元素，而ar在列上有4个

m = ar > 5
print(m)  # 这里m是一个判断矩阵
print(ar[m])  # 用m判断矩阵去筛选ar数组中>5的元素 → 重点！后面的pandas判断方式原理就来自此处

输出：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

[ True False  True]

[ True  True False False]

[[ 0  1  2  3]
 [ 8  9 10 11]]

[[0 1]
 [4 5]
 [8 9]]

[[False False False False]
 [False False  True  True]
 [ True  True  True  True]]

[ 6  7  8  9 10 11]

 

 

2、数组的更改、复制

更改：一个标量赋值给一个索引/切片时，会自动改变/传播原始数组

ar = np.arange(10)  #创建一个一维数组
print(ar)
ar[5] = 100      #改变ar的第6个元素
ar[7:9] = 200    #改变ar第8.9个元素
print(ar)


输出：
[0 1 2 3 4 5 6 7 8 9]
[  0   1   2   3   4 100   6 200 200   9]

复制：

ar = np.arange(10)   #创建一个一维数组
b = ar.copy()        #b复制ar
b[7:9] = 200         #将b中第8、9个元素改变成200
print(ar)            #输出ar，看是否会改变，不过事实证明不会改变
print(b)


输出：
[0 1 2 3 4 5 6 7 8 9]      #输出结果不会因复制的改变而改变

[  0   1   2   3   4   5   6 200 200   9]

 

 

三、随机数生成 （np.random）

1、生成一个随机浮点数：（numpy.random.rand(d0, d1, ..., dn)：生成一个[0,1)之间的随机浮点数或N维浮点数组 —— 均匀分布)

a = np.random.rand()     # 生成一个随机浮点数
print(a,type(a)) 

b = np.random.rand(4)     # 生成形状为4的一维数组
print(b,type(b))  

c = np.random.rand(2,3)   # 生成形状为2*3的二维数组，注意这里不是((2,3)),会报错
print(c,type(c))  

samples1 = np.random.rand(1000)
samples2 = np.random.rand(1000)
plt.scatter(samples1,samples2)
# 生成1000个均匀分布的样本值

2、生成一个整数或N维整数数组：numpy.random.randint(low, high=None, size=None, dtype='l')：生成一个整数或N维整数数组

# 若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数，且high必须大于low 
# dtype参数：只能是int类型  

print(np.random.randint(2))
# low=2：生成1个[0,2)之间随机整数  

print(np.random.randint(2,size=5))
# low=2,size=5 ：生成5个[0,2)之间随机整数

print(np.random.randint(2,6,size=5))
# low=2,high=6,size=5：生成5个[2,6)之间随机整数  

print(np.random.randint(2,size=(2,3)))
# low=2,size=(2,3)：生成一个2x3整数数组,取数范围：[0,2)随机整数 

print(np.random.randint(2,6,(2,3)))
# low=2,high=6,size=(2,3)：生成一个2*3整数数组,取值范围：[2,6)随机整数  


输出：
1

[1 0 0 0 1]

[2 5 3 5 5]

[[0 0 0]
 [0 0 1]]

[[5 2 3]
 [2 5 3]]

3、随机种子：

作用：计算机实现的随机数生成通常为伪随机数生成器，为了使得具备随机性的代码最终的结果可复现，需要设置相同的种子值。

用法：np.random.RandomState → 随机数种子，对于一个随机数发生器，只要该种子（seed）相同，产生的随机数序列就是相同的。

例如：

rng = np.random.RandomState(1)  
xtrain = 10 * rng.rand(30)
ytrain = 8 + 4 * xtrain + rng.rand(30)

# 生成随机数据x与y
# 样本关系：y = 8 + 4*x

 

 

四、Numpy通用函数

1、数组形状：  .T/.reshape()/.resize()

• .T方法：转置，例如原shape为(3,4)/(2,3,4)，转置结果为(4,3)/(4,3,2) → 所以一维数组转置后结果不变
• 改变数组的行与列，比如原来是3*4，可以用这个函数改成2*6
• .resize(a, new_shape)：返回具有指定形状的新数组，如有必要可重复填充所需数量的元素。
• .T/.reshape()/.resize()都是生成新的数组，可以跟下面的赋值和复制一起记。

例如：

.T

ar1 = np.arange(10)    #生成一个一维数组
ar2 = np.ones((5,2))   #生成一个5*2的全为1数组
print(ar1,'\n',ar1.T)
print(ar2,'\n',ar2.T)

输出：
[0 1 2 3 4 5 6 7 8 9] 

 [0 1 2 3 4 5 6 7 8 9]

[[1. 1.]
 [1. 1.]
 [1. 1.]
 [1. 1.]
 [1. 1.]] 

 [[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]

.reshape()    ：numpy.reshape(a, newshape, order='C')：为数组提供新形状，而不更改其数据，所以元素数量需要一致！！

有三种用法：

1. 直接将已有数组改变形状
2. 生成数组后直接改变形状
3. 参数内添加数组，目标形状

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)
print(ar4)
print(ar5)

输出：
[0 1 2 3 4 5 6 7 8 9] 

 [[0 1 2 3 4]
 [5 6 7 8 9]]

[[0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0.]]

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

2、数组的复制与赋值：

赋值：指向内存中生成的一个值

ar1 = np.arange(10)  #创建一个一维数组
ar2 = ar1            #ar1赋值给ar2
print(ar2 is ar1)    #判断ar2跟ar1是否在同一个内存地址
ar1[2] = 9           #修改ar1的值
print(ar1,ar2)

输出：
True       ####有这个结果可以知道，赋值只是指向值的内存

[0 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]    ##改变原数组，会改变被赋值的数组

 

copy：copy()方法会生成数组及其数据的完整拷贝，我的理解是生成一个完全一样的东西。所以，在改变一个数组的时候，另一个数组不会改变。

ar3 = ar1.copy()   #复制ar1数组
print(ar3 is ar1)  #判断两个数组的id值是否相等，即判断是否指向同一个内存地址
ar1[0] = 9         #改变ar1的值，测试会不会对ar3有影响，但事实证明不会改变ar3
print(ar1,ar3)

输出：
False

[9 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]

我特地去查了下is的意思：is比较的是两个对象的id值是否相等，也就是比较两个对象是否为同一个实例对象，是否指向同一个内存地址。 

is 与 ==的区别：

• 同：is和==都是对对象进行比较判断作用的
• 异：is比较的是两个对象的id值是否相等，也就是比较两个对象是否为同一个实例对象，是否指向同一个内存地址。==比较的是两个对象的内容是否相等，默认会调用对象的__eq__()方法。

 

3、数组的类型转换

（1）、创建的时候在参数位置设置数组类型：

ar1 = np.arange(10,dtype=float)     #创建一个一维数组，并且定义类型为float
print(ar1,ar1.dtype)

输出：
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64

（2）、转换数组类型：

ar2 = ar1.astype(np.int32)   #将上面个ar1的数组元素的类型转换成int32.
                             #注意这里要养成好习惯，数组类型用np.int32,而不是直接int32
print(ar2,ar2.dtype)
print(ar1,ar1.dtype)

输出：
[0 1 2 3 4 5 6 7 8 9] int32
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64

 

4、数组的堆叠

• 水平堆叠（hstack()，这里注意行要有相同的行数，不然就不能实现这个）
• 竖直堆叠（vstack(),  这里注意列要有相同的行数，不然就不能实现这个)

（1）水平堆叠

a = np.arange(5)    # a为一维数组，5个元素
b = np.arange(5,9)  # b为一维数组,4个元素
ar1 = np.hstack((a,b))  # 注意:((a,b))，这里形状可以不一样
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)

输出：
[0 1 2 3 4] (5,)
[5 6 7 8] (4,)
[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)
print(b,b.shape)
print(ar2,ar2.shape)

输出：
[[1]
 [2]
 [3]] (3, 1)

[['a']
 ['b']
 ['c']] (3, 1)

[['1' 'a']
 ['2' 'b']
 ['3' 'c']] (3, 2)

（2）竖直堆叠：

a = np.arange(5)     #创建一个5个元素的一维数组
b = np.arange(5,10)  #创建一个5个元素的一位数组
ar1 = np.vstack((a,b))  #堆叠两个数组的列
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)

输出：
[0 1 2 3 4] (5,)

[5 6 7 8 9] (5,)

[[0 1 2 3 4]
 [5 6 7 8 9]] (2, 5)

a = np.array([[1],[2],[3]])     #一个3个元素的一维数组
b = np.array([['a'],['b'],['c'],['d']])    #一个4个元素的一维数组
ar2 = np.vstack((a,b))   # 这里形状可以不一样
print(a,a.shape)
print(b,b.shape)
print(ar2,ar2.shape)

输出：
[[1]
 [2]
 [3]] (3, 1)

[['a']
 ['b']
 ['c']
 ['d']] (4, 1)

[['1']
 ['2']
 ['3']
 ['a']
 ['b']
 ['c']
 ['d']] (7, 1)

（3）numpy.stack()：

用法：

numpy.stack(arrays, axis=0)：

• axis=0时是水平堆叠
• axis=1时是竖直堆叠

。。。。。。。。。。。。。。这种解释是错的。。。。。。。。。。。。。。。。。。

看例子：

# 假设两个数组[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)  #注意这也不是竖直堆叠

例如：

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)
print(b,b.shape)
print(ar1,ar1.shape)
print(ar2,ar2.shape)

输出：
[0 1 2 3 4] (5,)

[5 6 7 8 9] (5,)

[[0 1 2 3 4]
 [5 6 7 8 9]] (2, 5)

[[0 5]
 [1 6]
 [2 7]
 [3 8]
 [4 9]] (5, 2)

我觉得可以理解成1122334455，意义对应。

5、数组拆分

numpy.hsplit(ary, indices_or_sections)   ：将数组水平（逐列）拆分为多个子数组 → 按列拆分；输出结果为列表，列表中元素为数组。

ar = np.arange(16).reshape(4,4)
ar1 = np.hsplit(ar,2)
print(ar)
print(ar1,type(ar1))

输出：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), 
array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])] <class 'list'>

numpy.vsplit(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'>

 

6、数组的简单运算

加减乘除幂运算，这些运算都是对数组中没个元素，而不是一整个数组。与标量的运算相同

例如：

ar = np.arange(6).reshape(2,3)
print(ar)
print(ar + 10)   # 加法（减法也是一样的）
print(ar * 2)    # 乘法
print(1 / (ar+1))  # 除法
print(ar ** 0.5)   # 幂

输出：
[[0 1 2]
 [3 4 5]]

[[10 11 12]
 [13 14 15]]

[[ 0  2  4]
 [ 6  8 10]]

[[1.         0.5        0.33333333]
 [0.25       0.2        0.16666667]]

[[0.         1.         1.41421356]
 [1.73205081 2.         2.23606798]]

另外还有一些常用函数：

print(ar.mean())  # 求平均值
print(ar.max())   # 求最大值
print(ar.min())   # 求最小值
print(ar.std())   # 求标准差
print(ar.var())   # 求方差
print(ar.sum(), np.sum(ar,axis = 0))   # 求和，np.sum() → axis为0，按列求和；axis为1，按行求和
print(np.sort(np.array([1,4,3,2,5,6])))  # 排序