Numpy是Python的一种开源的数值计算扩展库，它提供了两种基本的对象:
ndarray:是存储单一数据类型的多维数组。
ufunc:是一种能够对数组进行处理的函数。
Numpy常用的导入格式：
import numpy as np
1.Numpy数组
1.1创建数组
（1）array函数
data1=[1,3,5,7] sz1=np.array(data1) print(sz1) #--------- [1 3 5 7]
（2）arange函数
w1=np.arange(10) print(w1) #--------------- [0 1 2 3 4 5 6 7 8 9]
（3）linspace函数
linspace函数通过指定起始值、终值、元素个数创建一维数组，默认包括终值。
w2=np.linspace(0,2,5) print(w2) #-------------------- [0. 0.5 1. 1.5 2. ]
（4）logspace函数
logspace函数的参数中，起始位和终止位代表的是10的幂。
w3=np.logspace(0,2,4) print(w3) #------------------- [ 1. 4.64158883 21.5443469 100. ]
（5）zeros函数
zeros函数可以创建指定长度或形状的全0数组。
w4=np.zeros([3,3]) print(w4) #------------------ [[0. 0. 0.] [0. 0. 0.] [0. 0. 0.]]
（6）ones函数
ones函数可以创建指定长度或形状的全1数组。
w5=np.ones([2,3]) print(w5.astype(np.int32)) #------------------------- [[1 1 1] [1 1 1]]
（7）diag函数
diag函数可以创建对角矩阵，即对角线元素为0或指定值，其他元素为0。
w6=np.diag([1,2,3]) print(w6) #-------------------- [[1 0 0] [0 2 0] [0 0 3]]
（8）eye函数
eye函数可创建一条对角线位置为1、其他位置全为0的矩阵。
w7=np.eye(3) print(w7.astype(np.int32)) #------------------------- [[1 0 0] [0 1 0] [0 0 1]]
（9）生成随机数
w8=np.random.randint(10,50,size=(2,4)) print(w8) #------------------------------------- [[15 29 37 13] [18 48 49 33]]
2.数组变换
2.1数组重塑
可以通过reshape方法改变其数组维度，其中的一个参数可以设置为-1，表示数组的维度可以通过数据本身来推断。
ar1=np.arange(12) print('ar1:',ar1) ar2=ar1.reshape(3,-1) print('ar2:',ar2) #-------------------- ar1: [ 0 1 2 3 4 5 6 7 8 9 10 11] ar2: [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]
数据散开（ravel）和数据扁平化(flatten)
ar3=ar2.ravel() print('ar3:',ar3) ar4=ar2.flatten() print('ar4:',ar4) #------------------ ar3: [ 0 1 2 3 4 5 6 7 8 9 10 11] ar4: [ 0 1 2 3 4 5 6 7 8 9 10 11]
2.2数组合并
hstack：数组横向合并
vstack：数组纵向合并
concatenate函数可以实现数组的横向合并和纵向合并，当axis=1时进行横向合并，当axis=0时，进行纵向合并。
ar5=np.arange(6).reshape(3,2) ar6=ar5*3 ar7=np.hstack((ar5,ar6)) print(ar7) ar8=np.vstack((ar5,ar6)) print(ar8) print('横向合并：\n',np.concatenate((ar5,ar6),axis=1)) print('纵向合并：\n',np.concatenate((ar5,ar6),axis=0)) #----------------------------------------------------- [[ 0 1 0 3] [ 2 3 6 9] [ 4 5 12 15]] [[ 0 1] [ 2 3] [ 4 5] [ 0 3] [ 6 9] [12 15]] 横向合并： [[ 0 1 0 3] [ 2 3 6 9] [ 4 5 12 15]] 纵向合并： [[ 0 1] [ 2 3] [ 4 5] [ 0 3] [ 6 9] [12 15]]
2.3数组分割
hsplit：实现数组的横向分割
vsplit：实现数组的纵向分割
split在参数axis=1时实现数组的横向分割，axis=0时实现数组的纵向分割
sz=np.arange(16).reshape(4,4) print('横向分割:\n',np.hsplit(sz,2)) print('纵向分割:\n',np.vsplit(sz,4)) print('横向分割:\n',np.split(sz,1,axis=1)) print('纵向分割:\n',np.split(sz,2,axis=0)) #----------------------------------------- 横向分割: [array([[ 0, 1], [ 4, 5], [ 8, 9], [12, 13]]), array([[ 2, 3], [ 6, 7], [10, 11], [14, 15]])] 纵向分割: [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]]), array([[12, 13, 14, 15]])] 横向分割: [array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11], [12, 13, 14, 15]])] 纵向分割: [array([[0, 1, 2, 3], [4, 5, 6, 7]]), array([[ 8, 9, 10, 11], [12, 13, 14, 15]])]
3.数组的运算
3.1常用的ufunc函数运算
（1）四则运算：加（+）、减（-）、乘（*）、除（/）、幂（**）。数组间的四则运算是对每个数组中的元素分别进行四则运算，所以形状必须相同。
（2）比较运算：>,<,==,>=,<=,!=。比较运算返回的结果是一个布尔数组，每个元素为每个数组对应元素的比较结果。
（3）逻辑运算：np.any函数表示逻辑“or”,np.all函数表示逻辑“and”,运算结果返回布尔值。
（4）ufunc函数的广播机制
广播是指不同形状的数组之间执行算术运算的方式。
aa1=np.array([[1,1,1],[2,2,2],[3,3,3]]) bb1=np.array([1,2,3]) print('aa1+bb1:\n',aa1+bb1) #--------------------------------------- aa1+bb1: [[2 3 4] [3 4 5] [4 5 6]]
4.排序
numpy的排序方式有直接排序和间接排序，直接排序经常用sort函数，间接排序经常用argsort函数和lexsort函数。
直接排序：
sss=np.array([[3,6,8,2],[1,7,4,9],[6,4,8,3]]) sss.sort(axis=1) print('横向排序：\n',sss) sss.sort(axis=0) print('纵向排序：\n',sss) #------------------------------------- 横向排序： [[2 3 6 8] [1 4 7 9] [3 4 6 8]] 纵向排序： [[1 3 6 8] [2 4 6 8] [3 4 7 9]]
argsort函数间接排序：
arr=np.array([7,8,6,2,9,4,3,1,5,3]) print('原数组：\n',arr) print('排序后：\n',arr.argsort())#返回值为数组排序后的下标序列 #---------------------------------------------------------- 原数组： [7 8 6 2 9 4 3 1 5 3] 排序后： [7 3 6 9 5 8 2 0 1 4]
lexsort间接排序：
a=[1,5,7,4,3,0,2] b=[9,5,2,0,6,8,7] ind=np.lexsort((b,a)) print('数组a排序后的下标：\n',ind) tmp=[(a[i],b[i])for i in ind] print('数组a和b排序后的结果：\n',tmp) #------------------------------------ 数组a排序后的下标： [5 0 6 4 3 1 2] 数组a和b排序后的结果： [(0, 8), (1, 9), (2, 7), (3, 6), (4, 0), (5, 5), (7, 2)]
5.数据去重与重复
5.1数据去重
在numpy中，可以使用unique函数找到数组中的唯一值并返回已排序的结果，实现数据去重，当其中的参数return_counts设置为True时，即可返回每个取值出现的次数。
names=np.array(['a','b','b','a','c','b','c','a']) print('原数组：',names) print('去重后的数组：',np.unique(names)) print('字母出现次数:',np.unique(names,return_counts=True)) #------------------------------------------------------- 原数组： ['a' 'b' 'b' 'a' 'c' 'b' 'c' 'a'] 去重后的数组： ['a' 'b' 'c'] 字母出现次数: (array(['a', 'b', 'c'], dtype='<U1'), array([3, 3, 2], dtype=int64))
5.2数据重复
在numpy 中主要使用tile和repeat函数实现数据重复。
tile函数实现数据重复
sz=np.arange(3) print('原数组：',sz) sz1=np.tile(sz,3) print('重复后的数组：',sz1) #-------------------------- 原数组： [0 1 2] 重复后的数组： [0 1 2 0 1 2 0 1 2]
repeat函数实现数据重复:axis=0表示按行进行元素重复，axis=1表示按列进行元素重复。
arr=np.diag([1,2,3]) print('原数组:\n',arr) arr1=np.repeat(arr,2,axis=0) print('按行重复:\n',arr1) arr2=np.repeat(arr,2,axis=1) print('按列重复:\n',arr2) #--------------------------- 原数组: [[1 0 0] [0 2 0] [0 0 3]] 按行重复: [[1 0 0] [1 0 0] [0 2 0] [0 2 0] [0 0 3] [0 0 3]] 按列重复: [[1 1 0 0 0 0] [0 0 2 2 0 0] [0 0 0 0 3 3]]
6.读写数组
6.1读写二进制文件
numpy中读/写二进制文件的方法有以下两种：
（1）numpy.load("文件名.npy"):从二进制的文件中读取数据。
（2）numpy.save("文件名[.npy]",arr):以二进制的格式保存数据。
a=np.arange(12).reshape(3,-1) print('a:',a) np.save('arr.npy',a) b=np.load('arr.npy') print('b:',b) #------------------------ a: [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] b: [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]
6.2读/写文本文件
numpy中读写文本文件的方法主要有以下三种：
(1)numpy.loadtxt("arr.txt",delimiter=","):把文件加载到一个二维数组中。
(2)numpy.savetxt("arr.txt",arr,fmt="%d",delimiter=","):将数组写到某种分隔符隔开的文本文件中。
(3)numpy.genfromtxt("arr.txt",delimiter=","):结构化数组和缺失数据。
a=np.arange(12).reshape(4,-1) np.savetxt("szout.txt",a,fmt="%d",delimiter=",") np.loadtxt("szout.txt",delimiter=",") #------------------------------------------ array([[ 0., 1., 2.], [ 3., 4., 5.], [ 6., 7., 8.], [ 9., 10., 11.]])
码字不易，大家的阅读就是我创作的动力^_^ ^_^
