Numpy科学计算库基本使用方法

NumPy

是Python中科学计算的基础包。它是一个Python库，提供多维数组对象，各种派生对象（如掩码数组和矩阵），以及用于数组快速操作的各种例程，包括数学，逻辑，形状操作，排序，选择，I / O离散傅立叶变换，基本线性代数，基本统计运算，随机模拟等等。

NumPy包的核心是ndarray对象。这封装了同构数据类型的n维数组，许多操作在编译代码中执行以提高性能。NumPy数组和标准Python序列之间有几个重要的区别：

1. NumPy数组在创建时具有固定大小，与Python列表（可以动态增长）不同。更改ndarray的大小将创建一个新数组并删除原始数组。
2. NumPy数组中的元素都需要具有相同的数据类型，因此在内存中的大小相同。例外：可以有（Python，包括NumPy）对象的数组，从而允许不同大小的元素的数组。
3. NumPy数组有助于对大量数据进行高级数学和其他类型的操作。通常，与使用Python的内置序列相比，这些操作的执行效率更高，代码更少。
4. 越来越多的基于Python的科学和数学软件包正在使用NumPy数组; 虽然这些通常支持Python序列输入，但它们在处理之前将这些输入转换为NumPy数组，并且它们通常输出NumPy数组。换句话说，为了有效地使用当今大量（甚至大多数）基于Python的科学/数学软件，只知道如何使用Python的内置序列类型是不够的

• 还需要知道如何使用NumPy数组。

下面是我对于一些Numpy常用方法的总结：

1.导入Numpy包,给它重命名为np

 import numpy as np

2.读取TXT文件，调用np.genfromtxt()方法，第一个参数为文件地址，delimiter= ','表示以 ‘,’ 为分隔符来切分文件。 dtypr表示将读取的文件输出为字符格式。

world_alcohol = np.genfromtxt('world_alcohol.txt',delimiter=',',dtype=str)
print(type(world_alcohol))
print(world_alcohol)
print(help(np.genfromtxt))

3.调用array()方法生成一个一维相量，相当于将一个列表放在array()中，但array()中只能是同类型的数据。

vector = np.array([5,10,15,20]) 
vector

4.当改变一个数据的类型时，其他数据也会跟着改变

numbers = np.array([1,2,3,4.0]) 
print(numbers)
print(numbers.dtype)

5.调用array()方法生成一个二维矩阵，相当于将一个二维列表放在array()中

matrix = np.array([[5,10,15],
                   [20,25,30],
                   [35,40,45]])
matrix       

6.shape()方法比较常用，用来显示一个array数组是几行几列的,常用于debug

print(vector.shape)   
print(matrix.shape)

7.通过索引提取数据，行和列的索引都是从0开始 (skip_header=1 跳过原数据的第一行，从第二行开始显示)

world_alcohol = np.genfromtxt('world_alcohol.txt',delimiter=',',dtype=str,skip_header=1)
world_alcohol

8.切片索引,左闭右开

vector = np.array([5,10,15,20])     #提取某一行数据
print(vector[0:3])
matrix = np.array([             #提取某一列数据
                  [5,10,15],         
                  [20,25,30],
                  [35,40,45]
              ])
print(matrix[:,1])
print(matrix[:,0:2])       #提取某两列

9.Numpy计算，判断array数组是否等于某个值，结果返回值为布尔值（True/False)

vector = np.array([5,10,15,20])
print(vector)
print(vector == 10)
matrix = np.array([             
                  [5,10,15],         
                  [20,25,30],
                  [35,40,45]
              ])
print(matrix == 25)

10.将判断后的布尔值当作索引来提取数据

second_column_25 = (matrix == 25)
print(second_column_25)
print(matrix[second_column_25])

#将判断后的布尔值当作索引找出这个数据所在位置，并提取出该数据所在#的这一行数据
data_second_hang = (matrix[:,1] == 25)
print(data_second_hang)
print(matrix[data_second_hang,:])

11.比较运算中的与(&)、或(|)、非

#与(&),一个数不可能同时等于5和10
vector = np.array([5,10,15,20])
equal_to_ten = (vector == 10) & (vector == 5) 
print(equal_to_ten)
#或(|)
equal_to_ten2 = (vector == 10) | (vector == 5)
print(equal_to_ten2)
#通过比较找出返回的布尔值为True的值并给他赋值
equal_to_ten3 = (vector == 10) | (vector == 5)
vector[equal_to_ten3] = 50
print(vector)

12.给array中的数据转换数据类型，使用astype()方法，括号内写要改变成的数据类型。

vector2 = np.array(["1","2","3"])
print(vector2.dtype)
print(vector2)

vector2 = vector2.astype(float) #数据类型改变
print(vector2.dtype)
print(vector2)

13.求极值

#极小值和极大值
vector = np.array([5,10,15,20])
print(vector.min())
print(vector.max())
#求某一行或某一列的和，axis=1 表示行，axis=0 表示列
matrix = np.array([[5,10,15],
                   [20,25,30],
                   [35,40,45]])
print(matrix.sum(axis=1))  #按行求和
matrix = np.array([[5,10,15],
                   [20,25,30],
                   [35,40,45]])
matrix.sum(axis=0)  #按列求和

14.矩阵变换

np.arange(x) 生成[0,15]的一个相量，左包右闭
np.arange(x).reshape(a,b) 将之前生成的相量变换成a行b列的矩阵

print(np.arange(15))
a = np.arange(15).reshape(3,5)   #15=3*5
print(a)
print(a.shape)
print(a.ndim)        #返回当前矩阵的维数
print(a.dtype.name)  #返回矩阵的数据类型
print(a.size)        #返回矩阵中的元素个数

15.矩阵的初始化

#zeros()方法中必须要传入元组，否则会出错，其初始化全部赋值0
np.zeros((3,4))  
np.ones((2,3,4),dtype=np.int32)   #ones()方法初始化赋值全为1
np.arange(10,30,5)#调用单位函数构造的矩阵从5开始30结束，以5为步进

16.numpy中的随机模块

np.random.random((2,3)) #调用两次random,第一次先进random模块，
                      #第二次再调用random函数，随机数的范围[-1,1]

17.linspace(x,y,z)方法从某个区间上得到z个数，这z个数从区间[x,y]中平均去取,区间左包右包

from numpy import pi
np.linspace(0,2*pi,100)

18.numpy矩阵做数学运算

a = np.array([20,30,40,50])
b = np.arange(4)
print(a)
print(b)
#矩阵相加减,是两个矩阵相同的行和列两数进行加减
c = a + b
d = a - b
print(c)
print(d)
print(b**2)  #求平方

19.矩阵乘积

A*B 表示矩阵A和矩阵B相同行和列的数据相乘，矩阵的大小不变

A.dot(B)和np.dot(A,B) 表示矩阵A和B进行矩阵乘法，即一行乘以一列

A = np.array([[1,1],
              [0,1]])
B = np.array([[2,0],
              [3,4]])
print(A)
print('-------')
print(B)
print(A*B)
print(A.dot(B))
print('-------')
print(np.dot(A,B))

20. np.exp(x) 求e的x次幂

np.sqrt(x) 求根号x

np.floor() 向下取整,就是去最接近当前值的最大整数，例如3.14向下取整为3 ravel() 将矩阵变换成一个相量

a = np.array([20,30,40,50])
C = np.arange(3)
print(C)
print(np.exp(C))
print(np.sqrt(C))
a = np.floor(10*np.random.random((3,4)))
print(a)
print(a.ravel())

21.T 求矩阵的转置,行变列，列变行

a = np.array([20,30,40,50])
print(a.T)

# -1的意思是让程序自己取列数，因为行数一给，列数已经确定了
a.reshape(3,-1)  

22. 矩阵拼接

 np.stack() 为拼接操作；hstack()为横着按行拼接
 np.vstack() 为纵着按列拼接

a = np.floor(10*np.random.random((2,2)))
b = np.floor(10*np.random.random((2,2)))
print(a)
print('--------')
print(b)
print('--------')
print(np.hstack((a,b)))
print('--------')
print(np.vstack((a,b)))
print(np.stack((a,b)))

23.矩阵切分

np.hsplit(x,y) 将矩阵x平均切y份
np.vsplit(a,3) 将矩阵a按行平均切3份

a = np.floor(10*np.random.random((2,12)))
print(a)
print('--------')
print(np.hsplit(a,3))

#将矩阵a先从第3列切一刀，再从第4列切一刀分成三个小矩阵
print(np.hsplit(a,(3,4)))
print(np.vsplit(a,3))

24.复制

将a赋值给b，a和b的内存地址是相同的，改变a或b，另一个也会跟着改变

a = np.arange(12)
b = a
print(b is a)
b.shape = (3,4)
print(a.shape)
print(id(a))         #a,b的内存地址相同
print(id(b))

view() 浅复制，两数据的内存地址不同，但是改变一个，另一个也会跟着改变

c = a.view()
print(c is a)
c.shape = (2,6)
print(a.shape)
c[0,4] = 1234
print(a)
print(c)
print(id(a))
print(id(c))

copy() 深复制，两数据的内存地址不同，改变一个，另一个不会跟着改变

d = a.copy()
print(d is a)
d[0,0] = 9999
print(d)
print(a)
print(id(a))
print(id(d))

argmax(axis=0) 按列找出矩阵中每列的最大值索引(下标)

data = np.sin(np.arange(20)).reshape(5,4)
print(data)
ind = data.argmax(axis=0)     #按列找最大值的索引值（下标）
print(ind)
data_max = data[ind,range(data.shape[1])]  #通过下标再找出最大值
print(data_max)

np.tile(a,(x,y)) 矩阵扩展,再矩阵a上行扩展为原来的x倍，列扩展为原来的y倍

a = np.arange(0,40,10)
print(a)
b = np.tile(a,(2,3))
print(b)

25. 排序

np.sort(x,axis=1)或x.sort(axis=1) 排序,按行对x进行排序
np.argsort(x) 对x进行排序，每次返回最小值的索引(下标)

a = np.array([[4,3,5],
              [1,2,1]])
print(a)
print('--------')
b = np.sort(a,axis=1)
print(b)
a.sort(axis=1)
print('--------')
print(a)
a = np.array([4,3,1,2])
j = np.argsort(a)
print('--------')
print(j)
print('--------')
print(a[j])

26.Numpy广播(Broadcast)

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。
如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。

import numpy as np 
a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
print (c)

输出结果为：

[ 10  40  90 160]

当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。如：

import numpy as np 
 
a = np.array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = np.array([1,2,3])
print(a + b)

输出结果为：

[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]

下面的图片展示了数组 b 如何通过广播来与数组 a 兼容：

例：

import numpy as np 
 
a = np.array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = np.array([1,2,3])
bb = np.tile(b, (4, 1))  # 重复 b 的各个维度
print(a + bb)

输出结果为：

[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]

广播的规则:

• 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
• 输出数组的形状是输入数组形状的各个维度上的最大值。
• 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
• 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

简单理解：对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：

• 数组拥有相同形状。
• 当前维度的值相等。
• 当前维度的值有一个是 1。

若条件不满足，抛出 “ValueError: frames are not aligned” 异常。

以上为我自己对Numpy用法的部分总结。