numpy基本操作

前言：本文根据《利用Python进行数据分析》的第三章学习了numpy的基本操作，并加入自己的一些理解和总结，旨在方便以后的查阅，希望能对Python的初学者有所帮助，强烈建议把所有代码手动实现一遍！如有错误欢迎指正。
导入numpy模块

import numpy as np

创建ndarray

1. ndarray是N维数组对象
2. 每个ndarray都有一个shape（表示各维度大小的元组）和一个dtype（一个用于说明数组数据类型的对象）
3. 每个ndarray中所有的元素都是同一类型的

array函数创建

data1 = [1, 23, 4.3, 54]    #创建一个列表
arr1=np.array(data1)        #没有说明数据类型，array会自动选取最合适的
print(arr1)    

data2 = [[1, 2, 3, 4,],[5, 6, 7, 8]]  #嵌套型列表
arr2 = np.array(data2)                #产生二维的数组
print(arr2)

arr3 = np.arange(-5,5,1)     #与range不同的是arange将直接返回一个ndarray
print(arr3)

[ 1.  23.   4.3 54. ]
[[1 2 3 4]
 [5 6 7 8]]
[-5 -4 -3 -2 -1  0  1  2  3  4]

其他函数创建

函数	说明
asarray	将输入转换为ndarray，如果输入本身就是ndarray就不转换
arange	类似于内置的range，但是返回一个ndarray而不是列表
ones、ones_like	根据指定的形状和dtype创建一个全部为1的数值，ones_like以另外一个数组为参数创建一个与它同大小，同类型的全为1的数组
zeros、zeros_like	与ones一样，产生的是全为0的数组
empyt、empty_like	只分配空间但不填充任何值（注意不是全为0的数组，而是一些未初始化的垃圾值）
eye、identity	参数为N，创建一个N*N的单位矩阵（对角线为1，其余为0）

#注意如果要用ones，zeros，empty产生多维数组要传入元组参数如（2,3）
print(np.ones(6))
print("-----------------------")
print(np.ones((2,3)))
print("-----------------------")
print(np.zeros((2,3)))
print("-----------------------")
print(np.zeros_like(arr2))        #参数为一个其他ndarray
print("-----------------------")
print(np.empty(((2,3,2))))

[1. 1. 1. 1. 1. 1.]
-----------------------
[[1. 1. 1.]
 [1. 1. 1.]]
-----------------------
[[0. 0. 0.]
 [0. 0. 0.]]
-----------------------
[[0 0 0 0]
 [0 0 0 0]]
-----------------------
[[[4.94e-322 0.00e+000]
  [0.00e+000 0.00e+000]
  [0.00e+000 0.00e+000]]

 [[0.00e+000 0.00e+000]
  [0.00e+000 0.00e+000]
  [0.00e+000 0.00e+000]]]

ndarray的数据类型

dtype是ndarray的一个特殊对象，存储ndarray的数据类型的信息

常见的数据类型

类型	说明
int8、uint8（16\32\64）	有符号和无符号的整形
float16、float16（32\64\128）	有符号和无符号的浮点型（浮点型只能近似的表示一些分数值，注意浮点错误）
complex64（128\256）	复数
bool	True和False的布尔类型
object	python的对象类型
string_	固定长度的字符串（每个字符一个字节），例如出啊年长度为10的字符串则使用S10
unicode_	固定长度的unicode类型，类似于string_

创建数组的时候显示指定dtype的类型

arr1 = np.array([1,2,3],dtype=np.float64)    #创建数组时显示得指定数据类型
print(arr1.dtype)
arr2 = np.array([1,2,3],dtype=np.int32)     #指定dtype时候不要掉了np.
print(arr2.dtype)
arr3 = np.array(["a","b","c"],dtype=np.object)
print(arr3)

float64
int32
['a' 'b' 'c']

用astype转换成其他的dtype

• 调用astype无论如何都会创建一个新的数组（原始数组的一份拷贝），即使新的dtype和原来的一样

arr = np.array([1,2.5,3,4],dtype=np.int32)  #当浮点数遇到int类型会被截断
print(arr)
print(arr.dtype)

float_arr = arr.astype(np.float64) 
print(float_arr)
print(float_arr.dtype)

int_arr = float_arr.astype(arr.dtype)  #使用别的数组的dtype对象作为参数
print(int_arr.dtype)

[1 2 3 4]
int32
[1. 2. 3. 4.]
float64
int32

用函数dtype( )自定义数组类型

基本用法：np.dtype(object,align,copy)

参数	含义
object	被转换成数据类型的对象
align	如果为True，则向字段添加间隔
copy	是否生成新副本，如果为flase，结果是内建数据类型对象的引用。

结构化数据类型

test = np.dtype([("name","S8"),("age","int32"),("score","float32")])
print(test)

[('name', 'S8'), ('age', '

将创建的数据类型用于创建ndarray对象

student1 = np.array([("studentA",19,89.5),("studentB",20,99)])
print(student1)
print(student1.shape)
print("-------------------------")
student2 = np.array([("studentA",19,89.5),("studentB",20,99)],dtype=test)
print(student2)
print(student2.shape)  ##注意两个数组的shape的区别，使用test类型的数组只有两个元素

[['studentA' '19' '89.5']
 ['studentB' '20' '99']]
(2, 3)
-------------------------
[(b'studentA', 19, 89.5) (b'studentB', 20, 99. )]
(2,)

数组的索引和切片

• python的索引是从0开始的
• 数组切片只是原始数组的视图而不是拷贝，对于切片的操作将会反映到原始数据上，如果要拷贝使用.copy()方法

一维数组

arr = np.arange(10)       #注意arange产生的是从0开始的数，故不会包括传入的参数的那个数
print(arr)
print(arr[5])          #用中括号[]进行索引，5索引数组的第6个
print(arr[3:5])        #使用冒号产生的序列是左闭右开的，3:5产生[3,4],索引数组的4,5位置

##如果将一个标量赋值到某一个切片，则会“广播”到整个选区
arr_slice = arr[3:8]
arr_slice[0:3] = 666   #对索引切片赋值
print(arr_slice)       
print(arr)             #对arr的切片arr_slice操作将会反映到原始数据上

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

多维数组

在一个二维数组中各索引位置上的元素不再是标量而是一维数组

arr2d=np.array([[1,2,3],[4,5,6],[6,7,8]])
print(arr2d)
print(arr2d[0])
print(arr2d[0][2])
print(arr2d[0,2])

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

在多维数组中，如果省略了后面的索引，则返回的对象是一个维度低一点的ndarray

arr3d = np.array([[[1,2,3],[1,2,3]],[[4,5,6],[4,5,6]]])  #创建一个2*2（行）*3（列）
print(arr3d)
print('-----------------')
print(arr3d[0])     #第一个二维数组
print(arr3d[0,0])   #第一个二维数组的第一行
print('-----------------') 
arr3d[0] = 666  #将一个标量赋值给切片，改变原始数据
print(arr3d)

[[[1 2 3]
  [1 2 3]]

 [[4 5 6]
  [4 5 6]]]
-----------------
[[1 2 3]
 [1 2 3]]
[1 2 3]
-----------------
[[[666 666 666]
  [666 666 666]]

 [[  4   5   6]
  [  4   5   6]]]

使用冒号进行切片

arr2d = np.array([[1,2,3,4],[5,6,7,8]])
print(arr2d)
print('-------------------')
##冒号两边都有数值
print(arr2d[0:1,1:3])    #冒号两边都有数值产生的序列不包括右边的数，0:1产生0
print('-------------------')
##冒号一边有数字一边没有
print(arr2d[:1,1:])      #从头开始或者一直到尾
print('-------------------')
##冒号两边都没有数字
print(arr2d[:,[0,2]])        #单独冒号表示选取整个轴，冒号可以和数字索引一起用

[[1 2 3 4]
 [5 6 7 8]]
-------------------
[[2 3]]
-------------------
[[2 3 4]]
-------------------
[[1 3]
 [5 7]]

布尔类型索引

1. 布尔类型数组的长度必须和被索引的轴长度一致
2. 通过布尔型索引选取的数据创建的是原始数据的副本,改变这个副本的值对原始数据没有影响

names = np.array(['Bob','Joe','Will','Bob','Will','Joe','Joe']) #创建一个一维名字数组
data = np.random.randn(7,4)     #randn函数产生一个7行4列的正态分布随机数
print(data)                     #data每一行对应names中的每个人的数据
print('----------------------------------------')
##通过布尔索引的方法选取Joe的数据
print(names == 'Joe')           #通过比较运算符可以产生一个布尔型数组
print(data[names == 'Joe'])
print('----------------------------------------')
##选取Joe以外的数据，可以使用!= 或者用~对条件进行否定
print(names != 'Joe')
print(data[~(names == 'Joe')])
print('----------------------------------------')
##还可以用&（且）、|（或）联和多个条件
#and和or在布尔数组中无效
data_new = data[(data<-0.5) | (data>0.5)]  #将会从data中挑选满足条件的数据生成一个向量
print(data_new)

[[-0.70895383 -0.25364137 -0.74235663 -1.52245216]
 [-0.7140899  -0.33776257  0.31585126  0.13717969]
 [-0.9607891  -0.67649792 -0.57906685 -0.92532351]
 [ 0.50384185 -0.58432576 -0.78138774 -1.5992024 ]
 [ 1.68515498 -1.73574284 -0.23303881 -0.67730431]
 [ 0.20205852  0.57841884 -0.3866833   0.82587714]
 [ 0.94169053  0.11703199  0.61742887  0.64033957]]
----------------------------------------
[False  True False False False  True  True]
[[-0.7140899  -0.33776257  0.31585126  0.13717969]
 [ 0.20205852  0.57841884 -0.3866833   0.82587714]
 [ 0.94169053  0.11703199  0.61742887  0.64033957]]
----------------------------------------
[ True False  True  True  True False False]
[[-0.70895383 -0.25364137 -0.74235663 -1.52245216]
 [-0.9607891  -0.67649792 -0.57906685 -0.92532351]
 [ 0.50384185 -0.58432576 -0.78138774 -1.5992024 ]
 [ 1.68515498 -1.73574284 -0.23303881 -0.67730431]]
----------------------------------------
[-0.70895383 -0.74235663 -1.52245216 -0.7140899  -0.9607891  -0.67649792
 -0.57906685 -0.92532351  0.50384185 -0.58432576 -0.78138774 -1.5992024
  1.68515498 -1.73574284 -0.67730431  0.57841884  0.82587714  0.94169053
  0.61742887  0.64033957]

花式索引

• Fancy indexing，指的是利用整数数组进行索引
• 花式索引切片不一样，它总是将数据复制到新的数组中，而不是创建视图

arr = np.empty((8,4))     #注意传入的参数是一个元组
for i in range(8):
    arr[i] = i
print(arr)
print('-------------------')

##以特定的顺序选取子集，只需要传入指定顺序的整数列表或ndarray
print(arr[[4,3,0,6]])
print('-------------------')

##如果以负数为索引则从后往前数
print(arr[[-3,-1,-4]])

[[0. 0. 0. 0.]
 [1. 1. 1. 1.]
 [2. 2. 2. 2.]
 [3. 3. 3. 3.]
 [4. 4. 4. 4.]
 [5. 5. 5. 5.]
 [6. 6. 6. 6.]
 [7. 7. 7. 7.]]
-------------------
[[4. 4. 4. 4.]
 [3. 3. 3. 3.]
 [0. 0. 0. 0.]
 [6. 6. 6. 6.]]
-------------------
[[5. 5. 5. 5.]
 [7. 7. 7. 7.]
 [4. 4. 4. 4.]]

如果传入多个索引组将会返回一个对应位置的列表

如果要切出指定各轴顺序的一个矩阵

• 先索引一个轴再用冒号和数组复合索引另外一个轴
• 使用np.ix_函数转换成方形区域索引器

##目标：对arr重构顺序，各维顺序反一下
arr = np.arange(16).reshape((4,4))     #reshape方法的参数是一个列表
print(arr)
print('----------------------')
print(arr[[3,2,1,0],[3,2,1,0]])        #将只会返回对角线上的元素
print('----------------------')
print(arr[[3,2,1,0]][:,[3,2,1,0]])     #切出矩阵的方法1
print('----------------------')
print(arr[np.ix_([3,2,1,0],[3,2,1,0])])#切出矩阵的方法2

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

数组的转置和轴对换

转置返回的是源数据的视图，不会进行任何复制操作。可以使用transpose方法或者T属性

arr = np.arange(15).reshape((3,5))
print(arr)
print('--------------------')
print(arr.transpose())
print(arr.T)     #所有的轴

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
--------------------
[[ 0  5 10]
 [ 1  6 11]
 [ 2  7 12]
 [ 3  8 13]
 [ 4  9 14]]
[[ 0  5 10]
 [ 1  6 11]
 [ 2  7 12]
 [ 3  8 13]
 [ 4  9 14]]

多维数组的转置

• 使用transpose方法，要传入由轴变化组成的元组作为参数。
• 使用.T属性，调换所有轴
• 使用swapaxes函数，传入俩个轴作为参数，比如swapaxes(1,2)表示行列对换

arr = np.arange(16).reshape((2,2,4))
print(arr)
print('-------------------')
print(arr.transpose((0,2,1)))
print('-------------------')
print(arr.transpose((1,0,2)))
print('-------------------')
print(arr.T)
print(arr.transpose(2,1,0)) #两者等价
print('-------------------')
print(arr.swapaxes(1,2))    #行列对调

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

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

 [[ 8 12]
  [ 9 13]
  [10 14]
  [11 15]]]
-------------------
[[[ 0  1  2  3]
  [ 8  9 10 11]]

 [[ 4  5  6  7]
  [12 13 14 15]]]
-------------------
[[[ 0  8]
  [ 4 12]]

 [[ 1  9]
  [ 5 13]]

 [[ 2 10]
  [ 6 14]]

 [[ 3 11]
  [ 7 15]]]
[[[ 0  8]
  [ 4 12]]

 [[ 1  9]
  [ 5 13]]

 [[ 2 10]
  [ 6 14]]

 [[ 3 11]
  [ 7 15]]]
-------------------
[[[ 0  4]
  [ 1  5]
  [ 2  6]
  [ 3  7]]

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

解释一下：
(1,0,2)中的0,1,2分别表示原始数据的0轴，1轴（行），2轴（列）

• transpose(0,2,1)比较好理解，即原来数组的0轴位置不变，1轴（行），2轴（列）的位置进行交换
• transpose(1,0,2)比较难理解，即原来数组的列不做变换，0轴和1轴交换。如下表列出的：

值	原始位置	转置后的位置
0	[0,0,0]	[0,0,0]
1	[0,0,1]	[0,0,1]
2	[0,0,2]	[0,0,2]
3	[0,0,3]	[0,0,3]
4	[0,1,0]	[1,0,0]
5	[0,1,1]	[1,0,1]
6	[0,1,2]	[1,0,2]
7	[0,1,3]	[1,0,3]
8	[1,0,0]	[0,1,0]
9	[1,0,1]	[0,1,1]
10	[1,0,2]	[0,1,2]
11	[1,0,3]	[0,1,3]
12	[1,1,0]	[1,1,0]
13	[1,1,1]	[1,1,1]
14	[1,1,2]	[1,1,2]
15	[1,1,3]	[1,1,3]

可以发现矩阵中元素的位置第一个和第二个相互调换了

数组的运算

通用函数：快速的元素级别数组函数ufunc

一元ufunc（只传入一个数组作为参数）

函数	说明
abs、fabs	计算绝对值，如果不是复数用fabs速度更快
sqrt	计算平方根，相当于arr**0.5
square	计算各元素的平方
exp	计算各元素的平方
log、log10、log2、log1p	自然对数，底数为10的对数，底数为2的对数、log(1+x)
sign	计算各元素的正负号：1（正数），0（负数），-1（负数）
ceil	大于该值得最小整数
floor	小于该值得最大整数
rint	计算各元素的四舍五入到最接近的整数，保留dtype
modf	将数组的整数部分和小数部分以两个独立的数组形式返回
isnan	返回一个表示“哪些元素为NaN”的布尔型数组
isfinite、isinf	返回表示哪些元素有穷（非inf且非NaN）或哪些元素是无穷的布尔型数组
cos、cosh、sin、sinh、tan、tanh	普通型和双曲型三角函数

二元ufunc（传入两个个数组作为参数）

函数	说明
add	将数组的对应的元素相加
subtract	将第一个数组中的元素中减去第二个数组的元素
multiply	两个数组对应元素相乘
divide、floor_divide	除法，向下圆整除法（丢弃余数）
power	对一个数组中的元素计算第二个数组中对应位置元素的指数次幂
maximum、fmax	元素级别的最大值。fmax将忽略NaN
minmum、fmin	元素级别的最小值。fmin将忽略NaN
mod	元素级别的求模计算（除法的余数）
copysign	将第二个数组中的值得符号赋值给第一个数组中的值
greater、greater_equal、less、less_equal、equal、not_equal	元素级别的比较运算符
logical_and、logical_or、logical_xor	逻辑且或非

矢量化数组运算

import numpy as np
import matplotlib.pyplot as plt
points = np.arange(-5,5,0.01)
xs,ys = np.meshgrid(points,points)
z = np.sqrt(xs**2+ys**2)          #直接把两个数组当成两个浮点数编写表达式
plt.imshow(z,cmap=plt.cm.gray)
plt.colorbar()

numpy.where( )函数的用法

基本用法：

np.where(condition,arr1,arr2)

• condition可以是一个布尔型数组，也可以是一个判断表达式如：arr>0
• arr1和arr2可以是数组也可以是标量
• 在condition中如果某个位置上是true，则返回的数组该位置上的值是arr1对应位置的值，如果为False则返回arr2对应位置上的值。

##全部为数组
cond = [True,False,True,False]
arr1 = [1,2,3,4]
arr2 = [5,6,7,8]
result = np.where(cond,arr1,arr2)
print(result)

##arr为标量，condition为表达式
arr = np.random.randn(4,4)
print(arr)
result2 = np.where(arr>0)    #不加arr就会返回满足condition的元素的位置
print(arr[result2])          #相当于arr[arr>0]
result3 = np.where(arr>0,2,-2) #大于0替换为2，小于0替换为-2
print(result3)

[1 6 3 8]
[[-1.81205932  1.42043149 -1.98253756 -1.32045557]
 [ 0.80179704 -0.13721308  0.45621985  0.44734455]
 [-3.4079512   1.48717493  2.27197121 -1.49444463]
 [ 1.00074553 -0.45347556 -0.2535534  -0.27079081]]
[1.42043149 0.80179704 0.45621985 0.44734455 1.48717493 2.27197121
 1.00074553]
[[-2  2 -2 -2]
 [ 2 -2  2  2]
 [-2  2  2 -2]
 [ 2 -2 -2 -2]]

数学和统计学方法

• 可以对整个数组或者某个轴向（传入axis参数）进行统计计算
• 既可以当做数组的实例方法调用，也可以当做函数使用
• 这些函数都是对数组进行操作，不能对列表等其他数据操作

arr = np.random.randn(5,4) #生成正态分布数据
##对整个数组求均值
print(arr.mean())     #实例方法调用
print(np.mean(arr))   #numpy的函数调用
print("-----------------------")
##计算某个轴方向的均值，加上axis参数
print(arr.mean(axis=0))  #按列计算均数
print(arr.mean(axis=1))  #按行计算均数
##0长度的数组求和为0，均值为NaN
z = np.array([])
print(z.sum())
print(z.mean())

0.12314046483595358
0.12314046483595358
-----------------------
[ 0.2177185  -0.47398446  0.68319769  0.06563012]
[-1.05646019 -0.15665779  0.28705528  0.54456823  0.99719679]
0.0
nan


C:\Users\yz\Anaconda3\lib\site-packages\ipykernel_launcher.py:12: RuntimeWarning: Mean of empty slice.
  if sys.path[0] == '':
C:\Users\yz\Anaconda3\lib\site-packages\numpy\core\_methods.py:80: RuntimeWarning: invalid value encountered in double_scalars
  ret = ret.dtype.type(ret / rcount)

注意：如果数组中有缺失值的情况则计算结果都会变成NaN，可以换nansum函数

a = np.array([1,2,np.NaN])
print(a)
print(np.sum(a))
print(np.nansum(a))
print(a.mean())
print(np.nanmean(a))   #自动把缺失剔除，样本量减少成2

[ 1.  2. nan]
nan
3.0
nan
1.5

常用数组统计方法：

方法	说明
sum	求和，零长度的数组的sum为0
mean	算数平均数，0长度数组mean为NaN
std、var	标准差和方差，自由度可调（默认为n）
argmin、argmax	分别最小和最大的元素的索引
cumsum、cumprod	累加和累和

布尔型数组的方法

• 前面那些函数也能处理布尔型数组，只是会被强制转换为1（True）和（False）
• any表示数组中是否存在一个或多个True，all表示检查数组所有值是否都为True
• all和any也能用于非布尔型数组，所有非0元素都是True

arr = np.random.randn(100)
print((arr>0).sum())        #标准正态分布一般有约一半大于0
bools = np.array([False,False,True,False])
print(bools.any())
print(bools.all())

51
True
False

排序

• 通过sort方法就地排序，改变原始数据，可以传入轴编号在轴向上排序
• 调用numpy的sort方法，返回的是排好序的副本

arr = np.random.randn(5)
print(arr)
arr.sort()     #调用sort方法，对原始数据进行排序
print(arr)
arr2 = np.sort(arr)
print(arr2)    #调用numpy的方法，产生副本

##对特定轴排序
arr2d = np.random.randn(4,5)
arr2d.sort(0)   #纵向排序（按列）
print(arr2d)

##取上四分位数
large_arr = np.random.randn(1000)
large_arr.sort()
quartile = large_arr[int(0.95 * len(large_arr))]
print(quartile)

[-2.88091758  0.62410985  1.22699226  0.40509877 -0.19889688]
[-2.88091758 -0.19889688  0.40509877  0.62410985  1.22699226]
[-2.88091758 -0.19889688  0.40509877  0.62410985  1.22699226]
[[-0.78683194 -1.01394101 -0.17340087 -1.18691901 -0.70883819]
 [-0.53602351 -0.890812   -0.15535201 -0.99046646  0.15046626]
 [ 0.96336737 -0.18296109 -0.03872459 -0.28239641  0.74740009]
 [ 1.2535721  -0.04418151  1.22633803  0.6967652   0.91461072]]
1.6839265073710565

集合运算操作

方法	说明
unique(x)	计算x和y中的公共元素，并返回有序结果
intersect1d(x, y)	计算x和y的公共元素，并返回有序结果
union1d(x, y)	计算x和y的并集，并返回有序的结果
in1d(x, y)	得到一个表示“x的元素是否存在于y”的布尔型数组
setdiff1d(x, y)	集合的差，即元素在x中且不再y中
setxor1d(x, y)	集合的对称差，即存在于一个数组中但是不同时存在于两个数组中的元素

np.unique方法

fruit = np.array(['banana','apple','banana','orange','apple'])
print(np.unique(fruit))  #找出了唯一值而且排序了

ints = np.array([3,2,1,4,5,6,3,4,2,1,3])
print(np.unique(ints))
a = np.unique(ints)

##unique等价于
print(sorted(set(ints)))  #set会唯一化数组的值

['apple' 'banana' 'orange']
[1 2 3 4 5 6]
[1, 2, 3, 4, 5, 6]

np.in1d方法

arr = np.array([[1,2,3],[4,5,6]])
b = np.in1d(arr,[1,2])
print(b)    #输出的是一维的布尔型数组

[ True  True False False False False]

数组的文件输入和输出

方法	使用
np.save(‘name.npy’,array)	name.npy表示存储路径，.npy可以省略，array表示要存的数组。以未压缩的二进制格式存储
np.load(‘name.npy’)	此处的.npy不能够省略
np.savez(‘name.npz’,name1=array1,name2=array2	保存多个数组，注意后缀的不同，将数组以关键字的形式存入，给不同的数组不同的name，加载的时候得到类似字典的对象，该对象会对各个数组进行延迟加载
np.loadtxt(‘filename’,delimiter=’,’)	从txt文件中加载数组，delimiter表示文本分隔符类型
np.savetxt(‘filename’,array,delimiter=’,’)	以特定的分隔符把array存储到txt文档中

arr1 = np.arange(10)
arr2 = np.arange(15)
np.save('array',arr1)
np.savez('arrays',A=arr1,B=arr2)
np.savetxt('a.txt',arr1,delimiter=',')

print(np.load('array.npy'))
arrays = np.load('arrays.npz')
print(arrays['A'])
print(np.loadtxt('a.txt',delimiter=','))

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

线性代数运算

• 矩阵乘法：可以用x.dot(y)或者np.dot(x,y)
• numpy.linalg的线性代数方法

函数	说明
diag	返回方阵对角线元素的一维数组，或将一维数组转换成方阵
dot	矩阵乘法
trace	计算对角线元素的和
det	计算矩阵的行列式
eig	计算方阵的特征值和特征向量
inv	计算方阵的逆
pinv	计算矩阵的Moore-Penrose伪逆
qr	计算矩阵的QR分解
svd	计算奇异值分解
solve	解线性方程组Ax=b，A要为一个方阵
lstsq	计算Ax=b的最小二乘解

x = np.random.randn(5, 5)
mat = x.T.dot(x)
mat_inv = np.linalg.inv(mat)
print(mat_inv.dot(mat)) #矩阵乘以逆矩阵得到单位矩阵

[[ 1.00000000e+00 -4.13145425e-16  2.83577297e-16 -4.01989475e-17
  -1.96494157e-16]
 [-5.66963589e-17  1.00000000e+00 -1.75198193e-16  7.66816011e-17
   1.34956784e-16]
 [-5.39608902e-17  5.34348393e-18  1.00000000e+00  1.84203780e-17
  -6.43525192e-16]
 [-2.78534988e-17 -6.15412021e-18  7.22769643e-17  1.00000000e+00
  -2.63494168e-17]
 [ 1.84756860e-16  3.39066693e-16 -2.60301339e-16  3.59226477e-17
   1.00000000e+00]]

随机数生成

• 使用numpy.random模块

函数	作用
random.seed(a=None, version=2)	设置随机数生成器种子a
permutation	返回一个序列的随机排列或返回一个随机排列的范围
random.random()	生成一个0-1之间的随机浮点数
random.uniform(a,b,size=(x,y))	生成[a,b]之间的浮点数,随机数数量由size控制
random.randint(a,b,size=(x,y))	生成[a,b]之间的整数
random.randrange(a,b,step)	在集合[a,b)，中以step为基数随机抽取一个数。如random.randrange(0, 20, 2),相当于从[0,2,4,6,…,18]中随机取一个
random.choice(sequence)	从序列中随机抽取其中一个元素，这个序列可以是字符串、列表、元组等。
random.shuffle(sequence)	将列表的元素打乱，洗牌
random.sample(sequence,k)	从序列sequence中随机抽取k个样本出来，原始序列不改变
random.randn(a,b)	产生正态分布的随机数数组（均数0，标准差为1），a、b为各维度的个数
random.binomial(n, p, size=None)	参数为n、p，返回的是n次成功多少次
random.normal(loc=0.0, scale=1.0, size=None)	产生正态（高斯）分布的随机数，loc：均值，scale：标准差
random.beta()	产生Beta分布的随机数
random.chisquare	产生卡方分布的随机数
random.gamma()	产生Gamma分布随机数
random.uniform()	产生[0,1)之间的均匀分布随机数