目录
（1）数组属性（ndim,shape,size,dtype,itemsize)
（3）创建数组的函数(arange,linspace,logspace,zeros,ones,eye,diag,full)
（5）数组的转置(np.transpose(a))/arr1.T
（6）数组的点积运算np.dot(b,a) /np.multiply(arr1,arr2)
（1）将列表转为、数组、矩阵：np.array(list)、np.mat(list)
（2）将矩阵、数组转为列表：矩阵变量.tolist()、数组变量.tolist(）
4.1用np.load()、np.save()、np.savez()读写npy或npz文件
4.2用np.loadtxt()、np.savetxt()读写读写txt或csv文本文件
5.3numpy.char.add() numpy.char.add()
1.NumPy 数组对象 ndarray
（1）NumPy是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
（2）Numpy 提供了两种基本的对象，ndarray(多维数组) 和ufunc(对数组进行处理的函数)。
（3）使用时，需要引用： import numpy as np
1.1创建数组
（1）数组属性（ndim,shape,size,dtype,itemsize)
ndarray（数组）是存储单一数据类型多维数组
| 序号 | 属性 | 说明 |
|---|---|---|
| 1 | ndim | 返回 int，表示数组的维数 |
| 2 | shape | 返回 tuple，表示数组的尺寸，对于 n 行 m 列的矩阵，形状为(n，m) ，例如： 一维数组返回（n, ），二维数组返回（n，m） |
| 3 | size | 返回 int，数组的元素总数，等于数组形状的乘积，对于n行m列的矩阵，为n*m |
| 4 | dtype | 返回 data-type，描述数组中元素的类型 |
| 5 | itemsize | 返回 int，表示数组的每个元素的大小（以字节为单位） |
（2）数组创建(object,dtype,ndmin)
创建一维或多维数组
语法：numpy.array(object, dtype=None, copy=True)| 序号 | 参数 | 说明 |
|---|---|---|
| 1 | object | 接收array。表示想要创建的数组。无默认 |
| 2 | dtype | 接收data-type。表示数组所需的数据类型。如果未给定，则选择保存对象所需的最小类型。默认为None |
| 3 | ndmin | 接收int。指定生成数组应该具有的最小维数。默认为None |
注意一维数组返回的形式
import numpy as np
lst1=(1,2,3,4) #使用元组创建
arr1=np.array(lst1)
print(arr1)
print("数组2:尺寸{0}，维数{1}，元素总数{2}，元素类型{3}，每个元素所占字节的大小{4}".format(arr1.shape,arr1.ndim,arr1.size,arr1.dtype,arr1.itemsize))
print("\n")
lst2=[[1,2,3,4],[5,6,7,8],[9,10,11,12]] #使用列表创建
arr2=np.array(lst2)
print(arr2)
print("数组2:尺寸{0}，维数{1}，元素总数{2}，元素类型{3}，每个元素所占字节的大小{4}".format(arr2.shape,arr2.ndim,arr2.size,arr2.dtype,arr2.itemsize))
print("\n")
lst3=[[[1],[3],[4]],[[5],[7],[8]]]
arr3=np.array(lst3)
print(arr3)
print("数组3:尺寸{0}，维数{1}，元素总数{2}，元素类型{3}，每个元素所占字节的大小{4}".format(arr3.shape,arr3.ndim,arr3.size,arr3.dtype,arr3.itemsize))运行结果：
[1 2 3 4]
数组2:尺寸(4,)，维数1，元素总数4，元素类型int32，每个元素所占字节的大小4
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
数组2:尺寸(3, 4)，维数2，元素总数12，元素类型int32，每个元素所占字节的大小4
[[[1]
[3]
[4]]
[[5]
[7]
[8]]]
数组3:尺寸(2, 3, 1)，维数3，元素总数6，元素类型int32，每个元素所占字节的大小4（3）创建数组的函数(arange,linspace,logspace,zeros,ones,eye,diag,full)
| 序号 | 函数名 | 说明 | 例子 |
|---|---|---|---|
| 1 | arange(a,b,x) | 创建含开始值a、不含终值b，步长x的一维数组 | np.arange(0,1,0.2) == [0.，0.2，0.4，0.6，0.8] |
| 2 | linspace(a,b,n) | 创建含开始值a、含终值b和等分个数n的一维数组 | np.linspace(0,10,5) == [ 0. , 2.5, 5. , 7.5, 10. ] |
| 3 | logspace (a,b,n) | 生成10的a次方到10的b次方的n个元素的等比数列 | np. logspace (0,2,5) ==[1. 3.162 10. 31.62 100. ] |
| 4 | zeros(m) zeros((m,n)) | zeros(m)创建元素全为0的一维数组zeros((m,n))创建元素全为0的二维数组 | np. zeros (3) np. zeros ((2,3)) |
| 5 | ones(m) ones((m,n)) | ones(m)：创建元素全为1的一维数组 ones((m,n))创建元素全为1的二维数组 | np. ones (3) np. ones ((2,3)) |
| 6 | eye(n) | 创建n阶单位二维数组（对角线上元素为1） | np. eye (2) |
| 7 | diag() | 创建对角二维数组 | np. diag([2,5,-1]) |
| 8 | full([x, y], z) | 生成x行y列元素全为z的二维数组 | np. full([2,3],5) |
（4）构造复杂数组
a.reshape
np.arange(8).reshape(2,4)运行结果：
array([[0, 1, 2, 3],
[4, 5, 6, 7]])b.重复数组：tile
arr2=np.arange(8).reshape(2,4)
np.tile(arr2,(3,2))运行结果：
array([[0, 1, 2, 3, 0, 1, 2, 3],
[4, 5, 6, 7, 4, 5, 6, 7],
[0, 1, 2, 3, 0, 1, 2, 3],
[4, 5, 6, 7, 4, 5, 6, 7],
[0, 1, 2, 3, 0, 1, 2, 3],
[4, 5, 6, 7, 4, 5, 6, 7]])c.repeat
np.repeat(arr2,2)运行结果：
array([0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7])（5）Numpy中的特殊值：nan和inf
（nan和inf都是float类型）
a. nan(Not A Number):
当我们读取本地的文件为float的时候，如果有缺失，就会出现nan
当做了一个不合适的计算的时候(比如无穷大(inf)减去无穷大)。
b.inf(Infinite)：
inf(-inf,inf)：infinity，inf表示正无穷，-inf表示负无穷
python中直接会报错，numpy中是一个inf或者-inf，不会报错
a=np.arange(1,2)
a/0运行结果：
array([inf])1.2生成随机数（numpy. random子模块）
（1）随机数相关函数
| 序号 | 函数名 | 说明 | 例子 |
|---|---|---|---|
| 1 | random(n) | 返回n个随机数的一维数组，这些数为[0,1）之间的浮点数，服从均匀分布 | np.random. random(3) |
| 2 | rand(x,y) | 生成x行y列二维数组，其元素为区间[0，1）上的均匀分布的随机浮点数 | np.random. rand(2,3) |
| 3 | rand(m,x,y) | 生成三维数组，共有m个x行y列二维数组，其元素为区间 [0，1）上的均匀分布的随机浮点数 | np.random. rand(3,2,2) |
| 4 | randn(x,y) | 生成x行y列二维数组，其元素为标准正态分布的随机浮点数 | np.random. randn(3,3) |
| 5 | randint(low, high, (shape)) | 创建一个最小值不低于low、最大值不高于high整数随机数组 | np.random.randint(2,10,size = [2,5]) |
| 序号 | 函数名 | 说明 |
|---|---|---|
| 6 | seed() | 确定随机数生成器的种子 ,在每次生成之前需要再次调用seed() |
| 7 | choice(a) | 参数a为列表，或数组，从a中随机取一个元素 |
| 8 | y=permutation(x) | 将序列x随机打乱，返回给y,此时x的值不变。如果x是多维数组，则沿其第一个坐标轴的索引随机排列数组 |
| 9 | shuffle(x) | 直接对序列x进行随机打乱排序 |
| 10 | normal(u,v,n) | 生成n个，均值为u，方差为v的高斯分布随机浮点数 |
（2）应用
a.
from numpy import random as rd
rd.random(5)
rd.random((3,4))运行结果：
array([0.58619174, 0.06247343, 0.84017831, 0.63815375, 0.46042566])
array([[0.24023425, 0.1860916 , 0.37419645, 0.34041927],
[0.34157804, 0.43737014, 0.36257427, 0.52398765],
[0.02673513, 0.2060452 , 0.2481129 , 0.8455839 ]])b.
rd.rand(5)
rd.rand(2,3)
rd.rand(3,2,2)运行结果：
array([0.02122595, 0.66222968, 0.48443043, 0.54530034, 0.08890302])
array([[0.1680066 , 0.33335514, 0.98475729],
[0.8081956 , 0.83266227, 0.58464254]])
array([[[0.35478992, 0.70424096],
[0.12713102, 0.47035449]],
[[0.99656191, 0.18810933],
[0.49414356, 0.61905677]],
[[0.81740989, 0.81782039],
[0.96569224, 0.41761645]]])c.
rd.randn(5)
rd.randn(3,3)运行结果：
array([-1.35116869, 2.32640432, 0.80147545, 0.58502637, 1.53861434])
array([[-0.38645073, -0.45861905, -0.67179273],
[ 0.21555035, -1.26997059, -1.43987108],
[ 2.33711767, -0.89370368, 0.4191503 ]])d.
rd.randint(3,19,7)
rd.randint(2,10,(3,4))运行结果：
array([11, 12, 9, 3, 12, 7, 3])
array([[9, 7, 4, 7],
[5, 4, 7, 8],
[9, 8, 2, 8]])e.
from numpy import random as rd
rd.seed(0)
rd.randint(1,9,4)运行结果：
array([5, 8, 6, 1])
rd.seed(0)
rd.randint(1,9,4)运行结果：
array([5, 8, 6, 1])f.
from numpy import random as rd
import numpy as np
arr1=np.arange(10)
rd.choice(arr1,(3,4))
rd.choice(10,(3,4))运行结果：
array([[8, 7, 1, 4],
[1, 3, 4, 8],
[1, 6, 2, 0]])
array([[4, 5, 3, 6],
[8, 9, 7, 8],
[5, 9, 7, 6]])g.
rd.permutation(arr1),arr1运行结果：
(array([4, 2, 1, 0, 8, 9, 7, 5, 3, 6]), array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))h.
rd.shuffle(arr1),arr1运行结果：
(None, array([1, 4, 8, 5, 2, 3, 6, 9, 0, 7]))i.
rd.normal(2,4,5)
rd.normal(2,4,(3,4))运行结果:
array([-2.91606916, 7.78159623, 6.07224489, 0.95701275, 2.14623467])
array([[-2.97555319, -1.2100308 , 6.25574842, -0.37150436],
[ 3.45491254, 2.64299424, -0.30932206, -2.9847665 ],
[-4.95823474, 7.446301 , -2.30881523, 0.64218829]])1.3通过索引访问随机数
（1）一维数组的索引
（与Python中的list的索引方法一致）
arr[n]: 返回索引号为 n 的元素
arr[n：m]: 返回索引号为 从n的元素，到索引号为m的元素（不含m）
arr =np.arange(10) # arr = [0 1 2 3 4 5 6 7 8 9]
print( arr[5] ) #首个索引号从0开始，输出：5
print( arr[3：5] ) # 索引号从第3个，到第4个，输出：[3 4]
print( arr[：5] ) #索引号从第0个，到第4个，输出：[0 1 2 3 4]
print(arr[-1] ) # -1表示数组最后一个元素：9
print( arr[6-1:2] ) #索引号从第6个，到最后一个，2为步长，表示每隔一个元素：[6 8]
print( arr[5:1:-2] ) # 步长为负数时，开始索引号必须大于结束索引号，输出：[5 3]（2）多维数组的索引
（多维数组的每一个维度都有一个索引，各个维度的索引之间用逗号隔开（行、列的索引号，从0开始）
应用：
a.
import numpy as np
arr1=np.arange(12).reshape(3,4)
arr1运行结果：
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])b.
arr1[0,2:5]运行结果：
array([2, 3])c.
arr1[0:1,2:5],arr1[0,2:5]运行结果：
(array([[2, 3]]), array([2, 3]))d.
arr1[0:1,3]运行结果：
array([3])e.
arr1[0:1,-1:-3:-1]运行结果：
array([[3, 2]])f.
arr1[2:] 运行结果：
array([[ 8, 9, 10, 11]])g.
arr1[:,2] 运行结果：
array([ 2, 6, 10])（3）数组的迭代：
（数组是一种可迭代对象）
print(arr1)运行结果：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]for item in arr1:
print(item)运行结果：
[0 1 2 3]
[4 5 6 7]
[ 8 9 10 11]for item in enumerate(arr1):
print(item,item[0],item[1])运行结果：
(0, array([0, 1, 2, 3])) 0 [0 1 2 3]
(1, array([4, 5, 6, 7])) 1 [4 5 6 7]
(2, array([ 8, 9, 10, 11])) 2 [ 8 9 10 11]（4）补充
要查看模块的作用说明、简介，可以直接在交互区直接输入：
import numpy as np
print(np.random.__doc__) 查看某个函数的用法，help(函数名) ，如：
help(np.random.permutation)2.NumPy通用函数及数组之间的运算
2.1四则运算
加（+）、减（-）、乘（*）、除（/）、幂（**）
（1）数组间的四则运算
（包括一维与一维、二维与二维之间的四则运算）表示对每个数组中的对应元素分别进行四则运算，所以形状必须相同）
arr1=np.arange(1,4)
arr2=np.arange(4,7)
arr3=np.array("abc")
arr1,arr2,arr3运行结果：
(array([1, 2, 3]), array([4, 5, 6]), array('abc', dtype='<U3'))arr1+arr3运行结果：
不能运算arr1+arr2,arr1-arr2,arr1*arr2,arr1/arr2,arr1**arr2运行结果：
(array([5, 7, 9]),
array([-3, -3, -3]),
array([ 4, 10, 18]),
array([0.25, 0.4 , 0.5 ]),
array([ 1, 32, 729], dtype=int32))（2）一个数与数组的四则运算
表示这个数与数组的所有元素进行运算
a = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]]) # np.shape(a)：(3,4 )
b = 2 * a
c = b.reshape(4,3)
b,c运行结果：
(array([[ 2, 4, 6, 8],
[ 8, 10, 12, 14],
[14, 16, 18, 20]]),
array([[ 2, 4, 6],
[ 8, 8, 10],
[12, 14, 14],
[16, 18, 20]]))（3）比较运算：>、<、=、>=、<=、!
比较运算返回的结果是一个布尔数组，每个元素为每个数组对应元素的比较结果
x = np.array([1,3,5])
y = np.array([2,3,4])
print(x<y) # 输出：[ True False False]
print(x>=y) # 输出：[False True True]
print(x==y) # 输出：[False True False]
print(x!=y) # 输出：[ True False True]（4）逻辑运算
np.any函数表示逻辑or，np.all函数表示逻辑and，运算结果返回布尔值
x = np.array([1,3,5])
y = np.array([2,3,4])
print(np.all(x==y)) # 输出：False
print(np.all(x!=y)) # 输出：False
print(np.any(x!=y)) # 输出：True（5）数组的转置(np.transpose(a))/arr1.T
（一维数组的转置还是它自己；二维数组的转置，行列互换）
a = np.array([1,2,3,4]) # np.shape(a) = (4,) 表示一维数组
b = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]]) # (3,4) 表示二维数组
c = np.transpose(a) # 一维数组 a 的转置：np.shape(c) = (4,)
d = np.transpose(b) # 二维数组 b 的转置：np.shape(d) = (4,3)arr1.T（6）数组的点积运算np.dot(b,a) /np.multiply(arr1,arr2)
(其运算机制相当于两个矩阵的乘法运算。第1个数组的列数必需等于第2个数组的行数)
a.
a = np.array([1,2,3,4])
b = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])
e = np.dot(b,a)
e运行结果：
array([30, 60, 90])b.
arr11=arr1.reshape(3,1) #arr1([1, 2, 3])
arr22=arr2.reshape(1,3) #arr2([4, 5, 6])
np.dot(arr11,arr22)运行结果：
array([[ 4, 5, 6],
[ 8, 10, 12],
[12, 15, 18]])c.
np.multiply(arr1,arr2)运行结果：
array([ 4, 10, 18])2.2ufunc函数的广播机制 （慎用）
（ 广播（broadcasting）是指不同形状的数组之间执行算术运算的方式）
为了更好地理解广播机制，需要遵循4个原则：
（1）让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐；
（2）输出数组的shape是输入数组shape的各个轴上的最大值；
（3）如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错；
（4）当输入数组的某个轴的长度为1时,沿着此轴运算时都用此轴上的第一组值。
arr1 = np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]]) # arr1.shape : (4,3)
arr2 = np.array([1,2,3]) # arr2.shape : (3,)
print(arr1+arr2)
arr1 = np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]]) # arr1.shape : (4,3)
arr2 = np.array([1,2,3,4]).reshape((4,1)) # arr2.shape : (4,1)
2.3利用NumPy 进行统计分析
（非常实用的常见统计函数）
arr.sum() # 计算数组的所有元素的和 ,输出 ： 190
arr.sum(axis=0) # 按行求和（固定列） ,输出 ：[30 34 38 42 46]
arr.sum(axis=1) # 按列求和（固定行） ,输出 ：[10 35 60 85]
arr.mean() # 计算数组的均值 ,输出 ： 9.5
arr.std() # 计算数组的标准差 ,输出 ：5.766
arr.var() # 计算数组的方差 ,输出 ：33.25
arr.min() # 计算数组的最小值 ,输出 ：0
arr.max() # 计算数组的最大值 ,输出 ：19
arr.argmin() #返回数组最小元素的索引 ,输出 ：0
arr.argmax() #返回数组最大元素的索引 ,输出 ：19
arr.argmin(axis=0) #按行返回数组最小元素的索引 ,输出 ：[0 0 0 0 0]
arr.argmax(axis=1) #按列返回数组最大元素的索引 ,输出 ：[4 4 4 4]
arr.cumsum() #计算所有元素的累计和,输出 ：
arr.cumprod() #计算所有元素的累计积 ,输出 ：
np.prod(arr) # 求所有元素的积
np.ptp(arr,axis=0) # 按行求最大元素与最小元素的差（1）轴
二维数组，可以通过参数axis指定操作的维度，axis = 0 表示对行操作，axis = 1表示对列操作。如果没有给出参数axis，表示对数组所有元素操作，一维数组不需要指定参数axis。
二维数组的轴：
三维数组的轴：
（2）应用
a.
arr = np.arange(20).reshape(4,5)运行结果：
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19]])b.
from numpy import random as rd
arr1=np.arange(20)
rd.shuffle(arr1)
arr2=arr1.reshape(4,5)
arr2运行结果：
array([[ 7, 19, 0, 2, 12],
[ 5, 1, 13, 18, 8],
[17, 4, 11, 16, 10],
[15, 14, 6, 3, 9]])arr2.argmin(axis=1)运行结果：
array([1, 3, 0, 0], dtype=int64)arr2.argmax(axis=0)运行结果：
array([2, 0, 1, 1, 0], dtype=int64)c.
arr=np.arange(20).reshape(4,5)
print(arr)
arr.cumsum(axis=1)运行结果：
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
array([[ 0, 1, 3, 6, 10],
[ 5, 11, 18, 26, 35],
[10, 21, 33, 46, 60],
[15, 31, 48, 66, 85]], dtype=int32)d.
arr.cumprod()运行结果：
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],dtype=int32)e.
np.prod(arr)运行结果：
0f.数组迭代
import numpy as np
a=np.arange(8).reshape(4,2)
for elem in a.flat:
print(elem)运行结果:
0
1
2
3
4
5
6
7（3）Numpy可以对数组中的元素，进行直接排序
sort函数是最常用的排序方法。 arr.sort() , 默认 axis=1
sort函数也可以指定一个axis参数，使得sort函数可以沿着指定轴对数据集进行排序。axis=1为沿横轴 (x轴)排序；axis=0为沿纵轴 (y轴) 排序
应用：
a.
import numpy as np
arr=np.array([[8,-2,3,1],[2,0,5,7],[7,4,9,6]])
print(arr)运行结果：
[[ 8 -2 3 1]
[ 2 0 5 7]
[ 7 4 9 6]]b.
arr.sort() #等于arr.sort(axis=1)
arr运行结果：
array([[-2, 1, 3, 8],
[ 0, 2, 5, 7],
[ 4, 6, 7, 9]])c.
arr.sort(axis=0)
arr运行结果：
array([[ 2, -2, 3, 1],
[ 7, 0, 5, 6],
[ 8, 4, 9, 7]])（4）Numpy可以对数组中的元素，进行间接排序
argsort函数返回值为重新排序值的下标， 用法为：arr.argsort()。
import numpy as np
arr=np.array([[8,-2,3,1],[2,0,5,7],[7,4,9,6]])
print(arr)
arr.argsort()运行结果：
[[ 8 -2 3 1]
[ 2 0 5 7]
[ 7 4 9 6]]
array([[1, 3, 2, 0],
[1, 0, 2, 3],
[1, 3, 0, 2]], dtype=int64)2.4在数组中插入一行（或一列）
语法：np.insert ( a_array , row_m/col_m , values = b_array , axis=1 )a_array = np.array([[1,2,3],[4,5,6],[7,8,9]])
n , m = np.shape(a_array)
b_array = np.ones(3)
c4 = np.insert(a_array,0,values=b_array,axis=0) # 在第0行前插入一行
c5 = np.insert(a_array,1,values=b_array,axis=0) #在第1行前插入一行
c6 = np.insert(a_array,n,values=b_array,axis=0) # 在最后一行后插入一行
a_array = np.array([[1,2,3],[4,5,6],[7,8,9]])
n , m = np.shape(a_array)
b_array = np.ones(3)
c4 = np.insert(a_array,0,values=b_array,axis=1) # 在第0列前插入一列
c5 = np.insert(a_array,1,values=b_array,axis=1) #在第1列前插入一列
c6 = np.insert(a_array,n,values=b_array,axis=1) # 在最后一列后插入一列
3.NumPy矩阵运算
3.1创建NumPy矩阵
（1）mat
matr1=np.mat("1,2,3;4,5,6;7,8,9")
matr1=np.mat([[1,2,3],[4,5,6],[7,8,9]])
matr1运行结果：
matrix([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])（2）matrix
matr2=np.matrix("1,2,3;4,5,6;7,8,9")
matr2=np.matrix([[1,2,3],[4,5,6],[7,8,9]])
matr2运行结果：
matrix([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])（3）bmat
a.
np.bmat("matr1;matr2")运行结果：
matrix([[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])b.
np.bmat("matr1 matr2")运行结果：
matrix([[1, 2, 3, 1, 2, 3],
[4, 5, 6, 4, 5, 6],
[7, 8, 9, 7, 8, 9]])c.
np.bmat("matr1 matr2;matr1 matr2")运行结果：
matrix([[1, 2, 3, 1, 2, 3],
[4, 5, 6, 4, 5, 6],
[7, 8, 9, 7, 8, 9],
[1, 2, 3, 1, 2, 3],
[4, 5, 6, 4, 5, 6],
[7, 8, 9, 7, 8, 9]])（4）其他方法
a. stack
#数组的合并
arr4=np.arange(1,13).reshape([3,4])
print(arr4)
print("\n")
arr5=arr4.reshape(3,4)
print(arr5)
print("\n")
print(np.vstack((arr4,arr5))) #垂直方向拼接
print(np.hstack((arr4,arr5))) #水平方向的拼接
print(np.stack((arr4,arr5),axis=0)) #垂直方向拼接
print(np.stack((arr4,arr5),axis=1)) #水平方向的拼接运行结果：
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]][[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]
[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
[[ 1 2 3 4 1 2 3 4]
[ 5 6 7 8 5 6 7 8]
[ 9 10 11 12 9 10 11 12]][[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]]
[[[ 1 2 3 4]
[ 1 2 3 4]]
[[ 5 6 7 8]
[ 5 6 7 8]]
[[ 9 10 11 12]
[ 9 10 11 12]]]b.concatenate
print(np.concatenate((arr4,arr5),axis=0)) #垂直方向拼接
print(np.concatenate((arr4,arr5),axis=1)) #水平方向拼接
print(np.concatenate((arr4,arr5))) #水平方向拼接运行结果：
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]
[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
[[ 1 2 3 4 1 2 3 4]
[ 5 6 7 8 5 6 7 8]
[ 9 10 11 12 9 10 11 12]]
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]
[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]c.数组展平 ravel()/flatten()
（order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序）
arr=np.arange(1,13)
arr2=arr.reshape(3,4)
print(arr2)
print(arr2.ravel())
print(arr2.flatten())
print(arr2.flatten('F'))
print(arr5.flatten('C'))运行结果：
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
[ 1 2 3 4 5 6 7 8 9 10 11 12]
[ 1 2 3 4 5 6 7 8 9 10 11 12]
[ 1 5 9 2 6 10 3 7 11 4 8 12]
[ 1 2 3 4 5 6 7 8 9 10 11 12]d.split
split：将一个数组分割为多个子数组
import numpy as np
a = np.arange(9)
print ('第一个数组：')
print (a)
print ('\n')
print ('将数组分为三个大小相等的子数组：')
b = np.split(a,3)
print (b)
print ('\n')
print ('将数组在一维数组中表明的位置分割：')
b = np.split(a,[4,7])
print (b)运行结果：
第一个数组：
[0 1 2 3 4 5 6 7 8]
将数组分为三个大小相等的子数组：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
将数组在一维数组中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]import numpy as np
a = np.arange(25).reshape(5,5)
print ('第一个数组：')
print (a)
print ('\n')
print ('将数组分为三个大小相等的子数组：')
b = np.split(a,5)
print (b)
print ('\n')
print ('将数组在一维数组中表明的位置分割：')
b = np.split(a,[2,3,5])
print (b)运行结果：
第一个数组：
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]
[20 21 22 23 24]]
将数组分为三个大小相等的子数组：
[array([[0, 1, 2, 3, 4]]), array([[5, 6, 7, 8, 9]]), array([[10, 11, 12, 13, 14]]), array([[15, 16, 17, 18, 19]]), array([[20, 21, 22, 23, 24]])]
将数组在一维数组中表明的位置分割：
[array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]]), array([[10, 11, 12, 13, 14]]), array([[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24]]), array([], shape=(0, 5), dtype=int32)]hsplit：将一个数组水平分割为多个子数组（按列）
# hsplit
import numpy as np
harr = np.floor(10 * np.random.random((2, 6)))
print ('原array：')
print(harr)
print ('拆分后：')
print(np.hsplit(harr, 3))运行结果：
原array：
[[9. 8. 0. 0. 3. 6.]
[4. 3. 5. 1. 3. 5.]]
拆分后：
[array([[9., 8.],
[4., 3.]]), array([[0., 0.],
[5., 1.]]), array([[3., 6.],
[3., 5.]])]vsplit ：将一个数组垂直分割为多个子数组（按行）
#vsplit
import numpy as np
a = np.arange(16).reshape(4,4)
print ('第一个数组：')
print (a)
print ('\n')
print ('竖直分割：')
b = np.vsplit(a,2)
print (b)运行结果：
第一个数组：
[[ 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.2NumPy矩阵运算
import numpy as np
matr1 = np.matrix("1 2 3;0 5 6;0 0 9")
matr2 = matr1 * 3 # 矩阵数乘
matr3 = matr1 + matr2 # 矩阵加法
matr4 = matr1 - matr2 # 矩阵减法
matr5 = matr1 * matr2 # 矩阵相乘（乘法）
matrB = np.multiply(matr1,matr2) # 矩阵对应元素相乘
matr6 = matr1.T # 矩阵的转置
matr8 = matr1.H # 矩阵的共轭转置
matr9 = matr1.I # 矩阵的逆
arr = np.arange(6).reshape(2,3) # 将一维向量重置为2×3矩阵
print(arr+2) # 矩阵中的每个元素都加 2
print(arr/0) # 数组中的每个元素都除以03.3NumPy下的线性代数运算
（1）函数
（1）求方阵的逆矩阵： np.linalg.inv(A)
（2）求广义逆矩阵： np.linalg.pinv(A)
（3）求矩阵的行列式： np.linalg.det(A)
（4）求矩阵的特征值： np.linalg.eigvals（A）
（5）求特征值和特征向量： np.linalg.eig(A)
（6）svd分解（矩阵的奇异值分解） np.linalg.svd(A)
举例：
import numpy as np
x = np.array([[1,2,3],[0,1,-1],[1,0,0]]) # x 为二维数组：形状为 (3,3)
print(np.linalg.det(x)) # x 对应矩阵的行列式，输出：-5
y = np.linalg.inv(x) # x 对应矩阵的逆，此时的 y 为二维数组：形状为 (3,3)
a = np.dot(x,y) # 数组 x 与 y 做点积运算，等价于两个矩阵相乘
b = np.mat(x)*np.mat(y) # 将数组 x 与 y 转为矩阵，再做矩阵乘法，等价于 np.dot(x,y)
c = x * y # 数组x与y相乘，即两个数组对应元素相乘，注意：不同于np.dot(x,y)
print(a==b) # 完全相同，全为True
d = np.linalg.eigvals(x) # x 对应矩阵的特征值，返回的 d 为列表
print(d) # [-1.51154714+0.j 1.75577357+0.47447678j 1.75577357-0.47447678j ]
e = np.linalg.eig(x) # x 对应矩阵的特征值及特征向量，返回的 e 为元组
print(e[0],e[1]) # e[0]为 x 的特征值，e[1]为 x 的特征向量
（2）求数组x的范数语法
x_norm= np.linalg.norm(x,ord=None, axis=None,keepdims=False)
| 序号 | 参数 | 说明 | 计算方法 |
|---|---|---|---|
| 1 | 默认 | 2——范数 | |
| 2 | ord=2 | 2——范数 | 同上 |
| 3 | ord=1 | 1——范数 | |
| 4 | ord=np.inf | 无穷大范数 |
举例：
x = np.array([3, 4])
np.linalg.norm(x) # 向量x的范数（默认为2），输出 5
np.linalg.norm(x, ord=2) # 向量x的2范数，输出 5
np.linalg.norm(x, ord=1) # 向量x的2范数，输出 7
np.linalg.norm(x, ord=np.inf) # 向量x的无穷大范数，输出 43.4Python中列表、矩阵、数组之间的转换
（1）将列表转为、数组、矩阵：np.array(list)、np.mat(list)
import numpy as np
list1 =[[1,2,3],[4,5,6]] # 列表
list1 # [[1, 2, 3], [4, 5, 6]]
arr2 = np.array(list1) # 列表 -----> 数组
arr2 # array([[1, 2, 3],[4, 5, 6]])
mat3 = np.mat(list1) # 列表 ----> 矩阵
mat3 # matrix([[1, 2, 3],[4, 5, 6]])
mat4 = mat3[:,0:2] # 对矩阵的操作,选取其前两列的数据
mat4 # matrix([[1, 2],[4, 5]])（2）将矩阵、数组转为列表：矩阵变量.tolist()、数组变量.tolist(）
list2 = mat3.tolist() # 矩阵 ---> 列表
list2 # [[1, 2, 3], [4, 5, 6]]
list2 == list1 # 输出：True
list3 = list(arr2) # 数组 ---> 列表
list3 # [array([1, 2, 3]), array([4, 5, 6])]
list4 = arr2.tolist() # 数组 ---> 列表,内部数组也转换成列表
list4 # [[1, 2, 3], [4, 5, 6]]（3）矩阵和数组转换
arr3 = np.array(mat3) # 矩阵 ---> 数组
arr3 # array([[1, 2, 3], [4, 5, 6]])
mat5 = np.mat(arr2) # 数组 ---> 矩阵
mat5 # matrix([[1, 2, 3], [4, 5, 6]])（4）注意
a.在一维情况下，矩阵 --->数组--->矩阵结果不同
b.在一维情况下的列表 ---> 矩阵---> 列表结果不同
a1 =[1,2,3,4,5,6] # 列表 ： [1, 2, 3, 4, 5, 6]
a3 = np.mat(a1) # 列表 --> 矩阵 ： matrix([[1, 2, 3, 4, 5, 6]])
a4 = a3.tolist() # 矩阵 -> 列表（一个元素的列表）：[[1, 2, 3, 4, 5, 6]]
a4[0] # [1, 2, 3, 4, 5, 6]
a5 = np.mat(np.array(a1)) # 数组 ---> 矩阵 ：matrix([[1, 2, 3, 4, 5, 6]])
a6 = np.array(a5) # 矩阵 ---> 数组
a6 # array([[1, 2, 3, 4, 5, 6]])4.NumPy读写文件
4.1用np.load()、np.save()、np.savez()读写npy或npz文件
（1）np.load()
函数np.load()以读写模式打开npy或npz二进制文件，格式如下，参数如表所示
np.load(file,mmap_mode=None,allow_pickle=True, encoding=ASCII)| 序号 | 参数名 | 参数说明 |
|---|---|---|
| 1 | file | 要打开的文件名，含文件路径 |
| 2 | mmap_mode | 文件打开模式，可以取None、‘r+’、‘r’、‘w+’、‘c’，默认None；如果不选择None，则进行memory-map文件，memory-map文件还存储在磁盘上，然而却可以被访问，memory mapping对于读取大文件的小部分数据特别有用 |
| 3 | allow_pickle | 是否允许读取pickled对象，默认True；pickled是序列化数据对象 |
| 4 | fix_imports | 默认True，使用Python 3读取Python2存储的pickled文件时有用 |
| 5 | encoding | 字符编码格式，默认ASCII；使用Python 3读取Python2存储的pickled文件时有用 |
（2）np.save()
函数np.save()将一个数组以.npy格式保存二进制文件，格式如下：
np.save(file, array, allow_pickle=True, fix_imports=True)| 序号 | 参数名 | 参数说明 |
|---|---|---|
| 1 | file | 要打开的文件名，含文件路径 |
| 2 | array | 要存储的数组 |
| 3 | allow_pickle | 是否允许读取pickled对象，默认True；pickled是序列化数据对象 |
| 4 | fix_imports | 默认True，使用Python 3读取Python2存储的pickled文件时有用 |
举例：
import numpy as np
arr=np.arange(12).reshape(4,3)
arr
运行结果：
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
np.save("arr",arr)
arr_2=np.load("arr.npy")
arr_2
运行结果：
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])（3）np.savez()
函数np.savez()将多个数组保存到一个非压缩的.npz格式的二进制文件中，格式：
np.savez(file, *args, **kwds)| 序号 | 参数名 | 参数说明 |
|---|---|---|
| 1 | file | 要打开的文件名，含文件路径 |
| 2 | args | 存储到文件中的数组的名称，如果不指定,则为"arr_0",“arr_1”… |
| 3 | kwds | 存储的数组，对应与keyword的名称 |
举例:
import numpy as np
x=np.arange(20).reshape(2,2,5)
y=np.arange(24).reshape(2,2,6)
print("x:\n",x)
print("y:\n",y)
运行结果：
x:
[[[ 0 1 2 3 4]
[ 5 6 7 8 9]]
[[10 11 12 13 14]
[15 16 17 18 19]]]
y:
[[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
[[12 13 14 15 16 17]
[18 19 20 21 22 23]]]
np.savez("data",x,key_y=y)
c=np.load("data.npz")
print("keys",list(c.keys()))
print("c['arr_0']:\n",c['arr_0'])
print("c[key_y]:\n",c["key_y"])
运行结果：
keys ['key_y', 'arr_0']
c['arr_0']:
[[[ 0 1 2 3 4]
[ 5 6 7 8 9]]
[[10 11 12 13 14]
[15 16 17 18 19]]]
c[key_y]:
[[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
[[12 13 14 15 16 17]
[18 19 20 21 22 23]]]（4）注意点：
a. npy文件可以保存任意维度的numpy数组，不限于一维和二维；
b. npy保存了numpy数组的结构，保存的时候是什么shape和dtype，取出来时就是什么样的shape和dtype；
c. np.save()只能保存一个numpy数组，np.savez()可以保存多个数组，读写通过键名keyword进行标识。每次保存会覆盖掉之前文件中存在的内容（如果有的话）。
函数np.savez_compressed(file, *args, **kwds)将多个数组存储成压缩的.npz格式文件保存，参数如np.savez()。
4.2用np.loadtxt()、np.savetxt()读写读写txt或csv文本文件
（1）np.loadtxt()
csv文件：通过逗号分隔的文本文件，可用记事本，或excel直接读取。
函数np.loadtxt()以读写模式打开txt或csv文本文件，格式如下：
np.loadtxt(file, dtype=np.float, comments=’#’, delimiter=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding=‘bytes’)| 序号 | 参数名 | 参数说明 |
|---|---|---|
| 1 | file | 要打开的文件名，含文件路径 |
| 2 | dtype | np支持的数据类型，默认float；如果是个structured数据类型，返回的组将会是一维的，每行解释为数组的一个元素，因此，列数应该和数据类型的成员一样 |
| 3 | comments | 注释标识符，默认：# |
| 4 | delimiter | 数据分隔符，默认：‘ ’ ；txt文件为空格，csv文件为逗号 |
| 5 | skiprows | 跳过的行数，默认为0 |
| 6 | usecols | 读取哪些列，为列表或元组，如：usecols=(x,y,z)获取第x,y,z列数据 |
| 7 | unpack | 默认False，如果为True，分会返回单个列 |
（2）np.savetxt()
函数np.savetxt()将一个数组以txt或csv格式保存为文本文件，格式如下：
np.savetxt(file, X, fmt=’%.18e’, delimiter=’ ‘, newline=’\n’, header=’’,footer=’’, comments=’# ', encoding=None)| 序号 | 参数名 | 参数说明 |
|---|---|---|
| 1 | file | 要打开的文件名，含文件路径 |
| 2 | X | 要存储的一维、或二维数组（只能保存一个数组） |
| 3 | comments | 注释标识符，默认：# |
| 4 | delimiter | 数据分隔符，默认：‘ ’ ；txt文件为空格，csv文件为逗号 |
| 5 | newline | 新行的标识，默认为换行符：\n |
| 6 | header | 写在文本的前面，默认：‘ ’ |
| 7 | footer | 写在文本的后面，默认：‘ ’ |
（3）应用：
a.
import numpy as np
arr1=np.arange(9).reshape(3,3)
np.savetxt("./arr1.txt",arr1,fmt="%i",comments="", delimiter=",", header="A B C")
y=np.loadtxt("./arr1.txt",dtype=int, delimiter=",",skiprows=1)
y
运行结果：
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])b.
import numpy as np
arr1=np.arange(9).reshape(3,3)
np.savetxt("./arr1.csv",arr1,fmt="%i",comments="", header="A B C")
y=np.loadtxt("./arr1.csv",dtype=np.float32, skiprows=1)
y
运行结果：
array([[0., 1., 2.],
[3., 4., 5.],
[6., 7., 8.]], dtype=float32)（4）注意点：
说明：csv和txt只能用来存一维或二维numpy数组；当numpy数组很大时，最好使用hdf5文件，hdf5文件相对更小；因为若numpy数组很大，对整个numpy数组进行运算容易发生MemoryError，那么此时可以选择对numpy数组切片，将运算后的数组保存到 hdf5文件中，hdf5文件支持切片索引。
5.补充
5.1numpy.char.strip()
函数用于移除开头或结尾处的特定字符
import numpy as np
print(np.char.strip('asbook ifaba','a'))
print(np.char.strip(['asbook ifaba','asbook','java'],'a'))运行结果：
sbook ifab
['sbook ifab' 'sbook' 'jav']5.2numpy.char.splitlines()
函数以换行符作为分隔符来分割字符串，并返回数组
import numpy as np
print(np.char.splitlines('i\nlike robot?'))
print(np.char.splitlines('i\rlike robot?'))运行结果：
['i', 'like robot?']
['i', 'like robot?']5.3numpy.char.add() numpy.char.add()
函数依次对两个数组的元素进行字符串连接
import numpy as np
print ('连接两个字符串：')
print (np.char.add(['hello'],[' lucy']))
print ('\n')
print ('连接示例：')
print (np.char.add(['hello', 'hi'],[' abc', ' xyz']))运行结果：
连接两个字符串：
['hello lucy']
连接示例：
['hello abc' 'hi xyz']5.4标准的三角函数：sin()、cos()、tan()
5.5numpy.around(a,decimals)
舍入函数 numpy.around() 函数返回指定数字的四舍五入值
5.6numpy.floor()
numpy.floor() 返回数字的下舍整数
5.7numpy.ceil()
numpy.ceil() 返回数字的上入整数
5.8numpy.lexsort(())
对于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。
5.9numpy.nonzero()
函数返回输入数组中非零元素的索引
5.10numpy.extract()
函数根据某个条件从数组中抽取元素，返回满条件的元素
7039
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
