文章目录
Numpy数值计算基础
用于数据科学计算的基础模块。完成科学计算任务的同时，还能够用作高效的多维数据容器，用于存储和处理大型矩阵。Numpy的数据容器可以保存任意类型的数据，因此它可以快速整合各种数据。Numpy本身没有很多高级的数据分析工具。
学习目标
- 掌握Numpy创建多维数组与生成随机数的方法
- 掌握数组的索引与变换
- 掌握Numpy中数组矩阵的运算及通用函数的基本使用方法
- 掌握Numpy读写文件的方法和常用的统计分析函数
2.1数组对象ndarray
2.1.1创建数组对象
2-1创建数组并查看数组属性
import numpy as np #导入numpy库
arr1=np.array([1,2,3,4]) #创建一个一维数组
print('创建的数据为：',arr1) #打印
创建的数据为： [1 2 3 4]
arr2=np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]]) ##创建一个三维数组`
print('创建的三维数组为：\n',arr2) #打印
创建的三维数组为：
[[ 1 2 3 4]
[ 4 5 6 7]
[ 7 8 9 10]]
print('数组维度为：',arr2.shape) #查看数组结构
数组维度为： (3, 4)
print('数组类型为：',arr2.dtype) #查看数组类型
数组类型为： int32
print('数组元素个数为：',arr2.size) #查看数组元素个数`
数组元素个数为： 12
print('数组每个元素大小为：',arr2.itemsize) #查看数组每个元素的大小
数组每个元素大小为： 4
2-2重新 设置数组的shape属性
arr2.shape=4,3 #重新设置数组维度`
print('重新设置的数组2的维度为：',arr2.shape)`
重新设置的数组2的维度为： (4, 3)`
print('重新设置维度的数组2为：\n',arr2)`
重新设置维度的数组2为：`
[[ 1 2 3]
[ 4 4 5]
[ 6 7 7]
[ 8 9 10]]
以上都是先生成一个python序列，再使用array函数将其转换为数组的形式，这样做效率较低。因此numpy专门提供了很多专门用来创建数组的函数
2-3使用arange函数创建数组
开始值，终值，步长来一维数组，不含终值
print('使用arange函数创建的数组为：\n',np.arange(0,1,0.1)) #使用arange函数创建0开始，1.0为终值，步长为0.1的数组
使用arange函数创建的数组为：
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
2-4使用linspace函数创建数组
linspace函数通过指定开始值、终值和元素个数来创建一维数组，默认包含终值（与arange区别）
print('使用linspace函数生成的数组为：\n',np.linspace(0,1,10))
使用linspace函数生成的数组为：
[0. 0.11111111 0.22222222 0.33333333 0.44444444 0.55555556 0.66666667 0.77777778 0.88888889 1. ]
2-5使用logspace函数创建等比数列
logspace与linspace函数类似，创建的是等比数列。
创建从100（1）~10(10)的20个等比的数列
print('使用logspace函数创建的等比数列为:\n',np.logspace(0,10,20))
使用logspace函数创建的等比数列为:
[1.00000000e+00 3.35981829e+00 1.12883789e+01 3.79269019e+01
1.27427499e+02 4.28133240e+02 1.43844989e+03 4.83293024e+03
1.62377674e+04 5.45559478e+04 1.83298071e+05 6.15848211e+05
2.06913808e+06 6.95192796e+06 2.33572147e+07 7.84759970e+07 2.63665090e+08 8.85866790e+08 2.97635144e+09 1.00000000e+10]
2-6使用zeros函数创建数组
提供了其他的特殊的函数来创建数组,zeros,eye,diag,ones等
zeros函数创建所有元素为0的数组
print('zeros函数创建的数组：\n',np.zeros((2,3)))
zeros函数创建的数组：
[[0. 0. 0.] `
2-7使用eye函数创建数组
eye函数创建对角线为1的数组
print('eye函数创建的数组：\n',np.eye((3)))
eye函数创建的数组：
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
2-8使用diag函数创建数组
diag函数创建类似对角的数组，除对角线外其他元素为0，对角线元素为0或其他数字
``print(‘diag函数创建的数组：\n’,np.diag([1,2,3])) diag函数创建的数组： [[1 0 0] [0 2 0]
[0 0 3]]`
2-9使用ones函数创建数组
ones函数创建所有元素为1的数组
print('ones函数创建的数组：\n',np.ones((3)))
ones函数创建的数组：
[1. 1. 1.]
2-10数组数据类型转换
print('转换结果为：\n',np.float64(32)) #int转换为float
转换结果为：
32.0
print('转换结果为：\n',np.int8(42.0)) #float转换为int
转换结果为：
42
print('转换结果为：\n',np.bool(42)) #int转换为布尔类型
转换结果为：
True
print('转换结果为：\n',np.bool(0)) #int到bool类型
转换结果为：
False
print('转换结果为：\n',np.float(True)) #bool到浮点型
转换结果为：
1.0
print('转换结果为：\n',np.float(False)) #布尔到浮点型
转换结果为：
0.0
2-11创建数据类型
df=np.dtype([("name",np.str_,40),("numitems",np.int64),("price",np.float64)])
print('数据类型为：\n',df)
数据类型为：
[('name', '<U40'), ('numitems', '<i8'), ('price', '<f8')]
2-12查看数据类型
print('数据类型为：\n',df["name"])
数据类型为：
<U40
print('数据类型为：\n',np.dtype(df["name"]))
数据类型为：
<U40
使用array函数创建数组时，数组的默认数据类型为浮点型。自定义数组则可以指定数据类型
自定义数组数据
itemz=np.array([("tomatoes",42,4.14),("cabbages",13,1.72)],dtype=df)
print('自定义数据为：\n',itemz)
自定义数据为：
[('tomatoes', 42, 4.14) ('cabbages', 13, 1.72)]
2.1.2生成随机数
random是最常用的生成随机数的函数
print('生成的随机数组为：',np.random.random(100)) #每次生成的随机数都不一样
生成的随机数组为： [0.5414394 0.5012236 0.35249272 0.09769069 0.6475065 0.98641875
0.64135529 0.08061222 0.04190536 0.03458307 0.08118907 0.68696491
0.51004343 0.6858908 0.54504495 0.98814038 0.26325152 0.74208912
0.54847215 0.12902914 0.44575298 0.06392824 0.08550842 0.06104936
0.7926837 0.0144069 0.07766267 0.58615123 0.61704458 0.27513275
0.25431812 0.92537037 0.15578226 0.68445613 0.02767364 0.38113537
0.79595552 0.8260522 0.59981855 0.32827585 0.1126209 0.24992717
0.91755226 0.06445743 0.10480144 0.84633844 0.7064718 0.16507553
0.34488413 0.95952993 0.64346169 0.76231375 0.6661867 0.02587888
0.26290033 0.28978876 0.68573666 0.3530325 0.26461015 0.64860455
0.09969484 0.71772394 0.0178291 0.22189977 0.08611602 0.91256162
0.37283443 0.54140164 0.69328537 0.63926342 0.98635428 0.86592274
0.4146884 0.25501787 0.69481642 0.97776931 0.81314084 0.93928548
0.06571086 0.93979774 0.57665148 0.26755796 0.78038513 0.18855067
0.55590344 0.48810975 0.89531296 0.48303248 0.99821839 0.55081464
0.28083176 0.29653623 0.13610769 0.71791088 0.37012591 0.72331635
0.84702313 0.66458812 0.21930531 0.90331974]
rand函数用于生成服从均匀分布的随机数
print('生成的随机数组为：',np.random.rand(10,5))
生成的随机数组为： [[0.01932417 0.01791003 0.74598223 0.76213752 0.75621956]
[0.10245317 0.64091723 0.44050907 0.72125074 0.797107 ]
[0.79630621 0.78402876 0.89969261 0.13664477 0.73312912]
[0.02421392 0.59043566 0.597735 0.47476056 0.13479233]
[0.40949046 0.94931334 0.24626724 0.15688518 0.4430787 ]
[0.16666454 0.0717138 0.42882409 0.92195781 0.19430092]
[0.39851859 0.71871671 0.87534222 0.84967326 0.15873748]
[0.37974825 0.34834934 0.67042749 0.56788288 0.71355081]
randh函数用于生成服从正态分布的随机数
print('生成的随机数组为：',np.random.randn(10,5))
生成的随机数组为： [[ 1.27352466 -0.0659775 0.01888002 1.31867737 -1.6837147 ]
[-0.00567767 1.54918115 0.28218841 2.0030673 -0.80086495]
[-0.19758532 -0.39607603 -0.99615034 -0.53079879 0.8369686 ]
[-0.62874687 0.61947075 -0.53059219 0.86770825 2.16602977]
[-1.34455605 -0.6352837 0.5382481 0.88364061 1.29529511]
[ 0.22003359 2.23242998 0.58226151 2.13286719 0.97495864]
[ 0.89660402 -1.09040434 -0.12308345 -0.4312826 -1.01142497]
[-2.72122353 -1.05665528 1.28831854 -0.96534334 -1.18869332]
[-0.17032955 -0.53721905 -0.28488351 1.36280418 0.28442919]
[-1.18284567 -0.18156955 -1.10135001 -0.95745263 -1.33624823]]
randiant函数可以生成给定上下限范围的随机数，格式如下：
numpy.random.randiant(low.high=None,size=None,dtype=‘1’)
print('生成的随机数组为：',np.random.randint(2,10,size=[2,5])) #返回值为最小值不低于2，不大于5的2行5列的数组
生成的随机数组为： [[5 5 5 6 6]
[2 2 5 7 4]]
2.1.3通过索引访问数组
Numpy以提高效率的数组著称，都归功于索引的易用性。主要学习的是一维数组和多维数组的索引方式。
- 一维数组的索引
与Python中list的索引方法一致
2-18使用索引访问一维数组
arr=np.arange(10) #创建一个数组
print('数组为：\n',arr) #打印数组
数组为：
[0 1 2 3 4 5 6 7 8 9]
print('索引结果为：\n',arr[5]) #打印数组索引为5的元素
索引结果为：
5
print('索引结果为：\n',arr[3:5]) #打印数组索引从3到5的元素
索引结果为：
[3 4]
print('索引结果为：\n',arr[:5]) #打印索引为5及其之前的所有元素
索引结果为：
[0 1 2 3 4]
print('索引结果为：\n',arr[-1]) #打印倒数第一个元素
索引结果为：
9
arr[2:4]=100,101 #重新定义数组
print('索引结果为：\n',arr) #打印新建的数组
索引结果为：
[ 0 1 100 101 4 5 6 7 8 9]
print('索引结果为：\n',arr[1:-1:2]) #打印从索引1到倒数第一个元素，以2为步长的元素集合
索引结果为：
[ 1 101 5 7]
print('索引结果为：\n',arr[5:1:-2]) #打印索引5到1步长为-2的所有元素
索引结果为：
[ 5 101]
2-19使用索引访问多维数组
arr=np.array([[1,2,3,4,5],[4,5,6,7,8],[7,8,9,10,11]]) #创建2行5列数组
print('创建的二维数组为：\n',arr) #打印数组
创建的二维数组为：
[[ 1 2 3 4 5]
[ 4 5 6 7 8]
[ 7 8 9 10 11]]
print('索引结果为：\n',arr[0,3:5]) #打印索引为0的行的索引3到5列
索引结果为：
[4 5]
print('索引结果为：\n',arr[1:,2:]) #打印索引为1行及其之后行的索引为2列之后的元素
索引结果为：
[[ 6 7 8]
[ 9 10 11]]
print('索引结果为：\n',arr[:,2]) #打印所有行的索引为2的列
索引结果为：
[3 6 9]
2-20使用整数函数和布尔值索引访问多维数组
创建的二维数组为：
[[ 1 2 3 4 5]
[ 4 5 6 7 8]
[ 7 8 9 10 11]]
print('索引结果为：\n',arr[[0,1,2],[1,2,3]])
#使用两个数组分别对应行和列的下标
索引结果为：
[ 2 6 10]
print('索引结果为：\n',arr[1:,(0,2,3)])
#打印索引1及之后行的0,2,3索引列
索引结果为：
[[ 4 6 7]
[ 7 9 10]]
mask=np.array([1,0,1],dtype=np.bool)
#mask是一个布尔数组，
print('',mask)
[ True False True]
print('索引结果为：',arr[mask,2]) #索引第1,3行中第2列元素
索引结果为： [3 9]
2.1.4 变换数组的形态
2-21改变数组形状
对数组进行操作时，经常会改变数组的维度。在Numpy中，常用reshape函数改变数组的“形状”，即改变数组的维度。
它的参数为一个正整数元组，分别指定数组在每个维度上的大小。
reshape函数在改变原始数据形状的同时不改变原始数据的值。如果指定维度与原数组的元素数目不吻合，会抛出异常。
arr=np.arange(12)
print(arr)
[ 0 1 2 3 4 5 6 7 8 9 10 11]
print('新的一维数组为：',arr.reshape(3,4)) #改变数组的维度
新的一维数组为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
print('新的数组维度为：',arr.reshape(3,4).ndim)
新的数组维度为： 2
2-22使用ravel函数展平数组
arr=np.arange(12).reshape(3,4)
print('创建的二维数组为：',arr)
创建的二维数组为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
print('创建的二维数组展平后为：',arr.ravel())
创建的二维数组展平后为： [ 0 1 2 3 4 5 6 7 8 9 10 11]
2-23flatten函数展平数组
print('创建的二维数组展平后为：',arr.flatten()) #横向展平数组
创建的二维数组展平后为： [ 0 1 2 3 4 5 6 7 8 9 10 11]
print('创建的二维数组展平为：',arr.flatten('F')) #纵向展平数组
创建的二维数组展平后为： [ 0 4 8 1 5 9 2 6 10 3 7 11]
2-24使用hstack函数横向组合数组
组合数组的需求
arr1=np.arange(12).reshape(3,4)
print("数组1为：",arr1)
数组1为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
arr2=arr1*3
print('数组2为：',arr2)
数组2为： [[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]
print('横向组合为:',np.hstack((arr1,arr2)))
横向组合为: [[ 0 1 2 3 0 3 6 9]
[ 4 5 6 7 12 15 18 21]
[ 8 9 10 11 24 27 30 33]]
2-25使用vstack函数纵向组合数组
print('纵向组合为:',np.vstack((arr1,arr2)))
纵向组合为: [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]
2-26使用concatenate函数组合函数
print('横向组合为:',np.concatenate((arr1,arr2),axis=1))
横向组合为: [[ 0 1 2 3 0 3 6 9]
[ 4 5 6 7 12 15 18 21]
[ 8 9 10 11 24 27 30 33]]
print('纵向组合为:',np.concatenate((arr1,arr2),axis=0))
纵向组合为: [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]
2-27使用hsplit函数实现数组横向分割
arr=np.arange(16).reshape(4,4)
print(arr)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
print('横向分割为：\n',np.hsplit(arr1,2))
横向分割为：
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
2-28使用vsplit函数实现数组纵向分割
print('纵向分割为：\n',np.vsplit(arr,2))
纵向分割为：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
2-29使用split函数分割数组
print('横向分割为：\n',np.split(arr,2,axis=1))
横向分割为：
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
print('纵向分割为：\n',np.split(arr,2,axis=0))
纵向分割为：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
Numpy矩阵与通用函数
创建Numpy矩阵
2-30使用mat函数与matrix函数创建矩阵
import numpy as np
matr1=np.mat("1 2 3;4 5 6;7 8 9")
print('创建的矩阵为：\n',matr1)
创建的矩阵为：
[[1 2 3]
[4 5 6]
[7 8 9]]
matr2=np.matrix([[1,2,3],[4,5,6],[7,8,9]])
print('创建的矩阵为:\n',matr2)
创建的矩阵为:
[[1 2 3]
[4 5 6]
[7 8 9]]
2-31使用bmat函数创建矩阵
arr1=np.eye(3)
print(arr1)
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
arr2=arr1*3
print(arr2)
[[3. 0. 0.]
[0. 3. 0.]
[0. 0. 3.]]
print('创建的矩阵为:\n',np.bmat("arr1 arr2; arr1 arr2"))
#将小的矩阵创建为大的矩阵，即将小矩阵组合成为大矩阵。在numpy中，使用bmat分块矩阵函数实现
创建的矩阵为:
[[1. 0. 0. 3. 0. 0.]
[0. 1. 0. 0. 3. 0.]
[0. 0. 1. 0. 0. 3.]
[1. 0. 0. 3. 0. 0.]
[0. 1. 0. 0. 3. 0.]
[0. 0. 1. 0. 0. 3.]]
2-32矩阵运算
在numpy中，矩阵计算是针对整个矩阵中的每个元素进行的。与使用for循环相比，其在运算速度上会更快。
matr1=np.mat("1 2 3;4 5 6;7 8 9") #创建矩阵
print(matr1)
[[1 2 3]
[4 5 6]
[7 8 9]]
matr2=matr1*3 #矩阵与数字相乘
print(matr2)
[[ 3 6 9]
[12 15 18]
[21 24 27]]
print("矩阵相加结果为：\n",matr1+matr2) #矩阵相加
矩阵相加结果为：
[[ 4 8 12]
[16 20 24]
[28 32 36]]
print("矩阵相减结果为：\n",matr1-matr2) #矩阵相减
矩阵相减结果为：
[[ -2 -4 -6]
[ -8 -10 -12]
[-14 -16 -18]]
print("矩阵相乘结果为：\n",matr1*matr2) #矩阵相乘
矩阵相乘结果为：
[[ 90 108 126]
[198 243 288]
[306 378 450]]
2-33矩阵的属性
print("矩阵转置结果为：\n",matr1.T) #矩阵的转置
矩阵转置结果为：
[[1 4 7]
[2 5 8]
[3 6 9]]
print("矩阵共轭转置结果为：\n",matr1.H) #矩阵的共轭矩阵
矩阵共轭转置结果为：
[[1 4 7]
[2 5 8]
[3 6 9]]
print("矩阵的逆矩阵结果为：\n",matr1.I) #矩阵的逆矩阵
矩阵的逆矩阵结果为：
[[ 3.15251974e+15 -6.30503948e+15 3.15251974e+15]
[-6.30503948e+15 1.26100790e+16 -6.30503948e+15]
[ 3.15251974e+15 -6.30503948e+15 3.15251974e+15]]
print("矩阵的二维数组结果为：\n",matr1.A) #矩阵的二维展示
矩阵的二维数组结果为：
[[1 2 3]
[4 5 6]
[7 8 9]]
掌握ufunc函数
ufunc函数全称为通用函数，是一种能够对数组中所有元素进行操作的函数。ufunc函数是针对数组进行操作的，并且都以numpy数组作为输出，因此不需要对数组的每一个元素都进行操作。对一个数组进行重复运算时，使用ufunc函数比使用math库中的函数效率要高很多。
- 常用的ufunc函数运算
ufunc函数运算有四则运算、比较运算和逻辑运算等。
ufunc函数支持所有的四则运算，并且保留习惯的运算符，和数值运算的使用方式一样，但需要注意的是，操作的对象是数组。
数组间的四则运算表示每个数组中的元素分别进行四则运算，所以进行四则运算的两个数组的形状必须相同。
2-34数组的四则运算
x=np.array([1,2,3])
y=np.array([4,5,6])
print('相加：\n',x+y)
相加：
[5 7 9]
print('相减：\n',x-y)
相减：
[-3 -3 -3]
print('相乘：\n',x*y)
相乘：
[ 4 10 18]
print('相除：\n',x/y)
相除：
[0.25 0.4 0.5 ]
print('幂运算：\n',x**y)
幂运算：
[ 1 32 729]
2-35数组的比较运算
numpy中可以使用完整的比较运算。
返回值是一个布尔值，其每个元素为数组对应元素的比较结果。
x=np.array([1,2,3])
y=np.array([4,5,6])
print('数组比较结果:\n',x<y)
数组比较结果:
[ True True True]
print('数组比较结果:\n',x>y)
数组比较结果:
[False False False]
print('数组比较结果:\n',x==y)
数组比较结果:
[False False False]
print('数组比较结果:\n',x>=y)
数组比较结果:
[False False False]
print('数组比较结果:\n',x<=y)
数组比较结果:
[ True True True]
print('数组比较结果:\n',x!=y)
数组比较结果:
[ True True True]
2-36数组的逻辑运算
在numpy的逻辑运算中，numpy.all表示and即且，numpy.any表示or即或
print('数组逻辑计算结果为:\n',np.all(x==y))
数组逻辑计算结果为:
False
print('数组逻辑计算结果为:\n',np.any(x==y))
数组逻辑计算结果为:
False
- ufunc函数的广播机制
广播是指不同形状的数组之间执行算数运算方式。这与ufunc是不同的。
广播机制的原则：
- 让所有输入数组向其中shape最长的数组看齐，shape中不足的部分通过在前面加1补齐
- 输出的数组的shape是输入数组的shape的各个轴上的最大值
- 如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1，则这个数组能够用来计算，否则出错
- 当输入数组的某个轴的长度为1，沿着此轴运算时使用此轴上的第一组组
2-37一维数组的广播机制
arr1=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print(arr1)
[[0 0 0]
[1 1 1]
[2 2 2]
[3 3 3]]
print("数组1的shape为：\n",arr1.shape)
数组1的shape为：
(4, 3)
arr2=np.array([1,2,3])
print('数组2为：\n',arr2)
数组2为：
[1 2 3]
print('数组2的shape为：\n',arr2.shape)
数组2的shape为：
(3,)
print('数组相加的结果为：\n',arr1+arr2)
数组相加的结果为：
[[1 2 3]
[2 3 4]
[3 4 5]
[4 5 6]]
2-38二维数组的广播机制
arr1=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print('数组1为：\n',arr1)
数组1为：
[[0 0 0]
[1 1 1]
[2 2 2]
[3 3 3]]
print('数组1的维度为：\n',arr1.shape)
数组1的维度为：
(4, 3)
arr2=np.array([1,2,3,4]).reshape((4,1))
print('数组2为：\n',arr2)
数组2为：
[[1]
[2]
[3]
[4]]
print('数组2的维度为：\n',arr2.shape)
数组2的维度为：
(4, 1)
print('数组相加的结果为：\n',arr1+arr2)
数组相加的结果为：
[[1 1 1]
[3 3 3]
[5 5 5]
[7 7 7]]
利用Numpy进行统计
数组运算更为简洁而快速，通常比等价的Python方式快几倍，特别是处理数组统计计算与分析的情况时。
读/写文件
numpy的文件读写主要有二进制文件读写和文件列表形式的数据读写两种形式。
读写文件时利用Numpy进行数据处理的基础。其次，它还提供了若干函数，可以把结果保存到二进制或文本文件中。还提供了许多从文件读取数据并将其转换为数组的方法。
save函数以二进制格式保存数据，load函数从二进制文件中读取数据。
save函数的语法格式：
np.save(file,arr,allow_pickle=True,fix_imports=True)
2-39二进制数据存储
import numpy as np
arr=np.arange(100).reshape(10,10)
np.save("../save_arr",arr)
print('保存的数组为:\n',arr)
保存的数组为:
[[ 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 25 26 27 28 29]
[30 31 32 33 34 35 36 37 38 39]
[40 41 42 43 44 45 46 47 48 49]
[50 51 52 53 54 55 56 57 58 59]
[60 61 62 63 64 65 66 67 68 69]
[70 71 72 73 74 75 76 77 78 79]
[80 81 82 83 84 85 86 87 88 89]
2-40多个数组存储
arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.arange(0,1.0,0.1)
np.savez('../savez_arr',arr1,arr2)
print('保存的数组1为：\n',arr1)
保存的数组1为：
[[1 2 3]
[4 5 6]]
print('保存的数组2为：\n',arr2)
保存的数组2为：
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
2-41二进制文件读取
loaded_data=np.load("../save_arr.npy")
print('读取的数组为：\n',loaded_data)
读取的数组为：
[[ 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 25 26 27 28 29]
[30 31 32 33 34 35 36 37 38 39]
[40 41 42 43 44 45 46 47 48 49]
[50 51 52 53 54 55 56 57 58 59]
[60 61 62 63 64 65 66 67 68 69]
[70 71 72 73 74 75 76 77 78 79]
[80 81 82 83 84 85 86 87 88 89]
[90 91 92 93 94 95 96 97 98 99]]
print('读取的数组1为：\n',loaded_data1['arr_0'])
读取的数组1为：
[[1 2 3]
[4 5 6]]
print('读取的数组2为：\n',loaded_data1['arr_1'])
读取的数组2为：
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
需要注意的是，在存储数据时可以省略扩展名，但在读取是不能省略扩展名。
2-42文件存储与读取
在实际的数据分析任务中，更多的使用文本格式的数据。如txt或csv格式，因此经常使用savetxt函数，loadtxt函数，genformtxt函数执行对文本格式数据的读取任务。
savetxtx函数可将数组写到以某种分隔符隔开的文本文件中，语法格式如下：
np.savetxt(fname,X,fmt=‘%.18e’,delimiter=’ ‘,newline=’\n’，header=‘’,footer=’ ‘,comments=’# ')
文件名，数组数组，数据分隔符
loadtxt函数执行的是相反的操作，即把文件加载到一个二维数组中。
np.savetxt('../arr.txt', arr , fmt="%d", delimiter=',')
loaded_data=np.loadtxt('../arr.txt',delimiter=",")
print('读取的数组为：',loaded_data)
读取的数组为： [[ 0. 0. 1. 1. 2. 2.]
[ 3. 3. 4. 4. 5. 5.]
[ 6. 6. 7. 7. 8. 8.]
[ 9. 9. 10. 10. 11. 11.]]
2-43使用genfromtxt函数读取数组
genfromtxt函数和loadtxt函数相似，不过它面向的是结构化数组和缺失数据。
通常的参数有3个，文件名参数fname，分割的字符参数delimiter，是否含有列标题参数names
loaded_data=np.genfromtxt("../arr.txt",delimiter=",")
print('读取的数组为：\n',loaded_data)
读取的数组为：
[[ 0. 0. 1. 1. 2. 2.]
[ 3. 3. 4. 4. 5. 5.]
[ 6. 6. 7. 7. 8. 8.]
[ 9. 9. 10. 10. 11. 11.]]
使用函数进行简单的统计分析
- 排序
numpy排序的主要方式可以概括为直接排序和简介排序两种。
直接排序是指对数值直接进行排序；间接排序是指根据一个或多个键对数据集进行排序。直接排序中经常使用sort函数，间接排序经常使用argsort函数和lexsort函数
sort函数是最常用的排序方法，无返回值。如果目标函数是一个视图，则原始数据会被修改。使用sort函数排序时可以指定一个axis参数，使得sort函数可以沿着指定轴对数据集进行排序。
2-44使用sort函数进行排序
np.random.seed(42)
arr=np.random.randint(1,10,size=10)
print('创建的数组为：\n',arr)
创建的数组为：
[7 4 8 5 7 3 7 8 5 4]
arr.sort()
print('排序后数组为：\n',arr)
排序后数组为：
[3 4 4 5 5 7 7 7 8 8]
arr=np.random.randint(1,10,size=(3,3))
#生成3行3列的数组
print('创建的数组为：\n',arr)
创建的数组为：
[[8 8 3]
[6 5 2]
[8 6 2]]
arr.sort(axis=1) #按照横轴进行排序
print('排序后数组为：\n',arr)
排序后数组为：
[[3 8 8]
[2 5 6]
[2 6 8]]
arr.sort(axis=0) #按照纵轴进行排序
print('排序后数组为：\n',arr)
排序后数组为：
[[2 5 6]
[2 6 8]
[3 8 8]]
2-45使用argsort函数进行排序
使用argsort函数和lexsort函数，可以在给定一个或多个键时，得到一个由整数构成的索引数组，索引值表示数据在新的序列中的位置。
arr=np.array([2,3,6,8,0,7])
print('创建的数组为：\n',arr)
创建的数组为：
[2 3 6 8 0 7]
print('排序后的数组为：\n',arr.argsort())
#返回值为重新排序值的下标
排序后的数组为：
[4 0 1 2 5 3]
2-46使用lexsort函数进行排序
lexsort函数可以一次性对满足多个键的数组执行间接排序
a=np.array([3,2,6,4,5])
b=np.array([50,30,40,20,10])
c=np.array([400,300,600,100,200])
d=np.lexsort((a,b,c))
print('【排序后数组为:\n',list(zip(a[d],b[d],c[d])))
【排序后数组为:
[(4, 20, 100), (5, 10, 200), (2, 30, 300), (3, 50, 400), (6, 40, 600)]
- 去重与重复数据
统计分析工作中，难免会出现脏数据的情况。
重复数据就是脏数据的情况之一。若一个一个删除会很低效。
在numpy中，可以通过unique函数找出数组中唯一值并返回已排序的结果
2-47数组内数据去重
names=np.array(['小明','小黄','小花','小明','小花','小兰','小白'])
print('创建的数组为：\n',names)
创建的数组为：
['小明' '小黄' '小花' '小明' '小花' '小兰' '小白']
print('去重后的数组为：\n',np.unique(names))
去重后的数组为：
['小兰' '小明' '小白' '小花' '小黄']
print('去重后的数组为：\n',sorted(set(names)))
去重后的数组为：
['小兰', '小明', '小白', '小花', '小黄']
ints=np.array([1,2,3,4,4,5,6,6,7,8,8,9,10])
print('创建的数组为：\n',ints)
创建的数组为：
[ 1 2 3 4 4 5 6 6 7 8 8 9 10]
print('去重后的数组为:\n',np.unique(ints))
去重后的数组为:
[ 1 2 3 4 5 6 7 8 9 10]
另外，重复一个数据若干次也是统计分析中需要的工作。
2-48使用tile函数实现数据重复
在numpy中主要使用file函数和repeat函数实现数据重复
tile函数的格式如下：
numpy.tile(A.reps)
A指定重复的数组，参数reps指定重复次数
arr=np.arange(5)
print(arr)
[0 1 2 3 4]
print('重复后的数组为：\n',np.tile(arr,3))
重复后的数组为：
[0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]
2-49使用repeat函数实现数据重复
repeat函数格式如下：
numpy.repeat(a,repeats,axis=None)
a指参与重复的元素，repeats指重复次数,axis指沿着哪个轴进行重复
np.random.seed(42)
arr=np.random.randint(0,10,size=(3,3))
print(arr)
[[6 3 7]
[4 6 9]
[2 6 7]]
print('重复后的数组为：\n',arr.repeat(2,axis=0))
#沿着x轴进行重复
重复后的数组为：
[[6 3 7]
[6 3 7]
[4 6 9]
[4 6 9]
[2 6 7]
[2 6 7]]
print('重复后的数组为：\n',arr.repeat(2,axis=1))
#沿着y轴进行重复
重复后的数组为：
[[6 6 3 3 7 7]
[4 4 6 6 9 9]
[2 2 6 6 7 7]]
两个函数的主要区别在于，tile函数是对数组进行重复操作，repeat函数是对数组中的每个元素进行重复操作。
3. 常用的统计函数
常见的统计函数有sum,mean,std,var,min,max等
几乎所有的统计函数在针对二维数组计算时都需要注意轴的概念。
当axis参数为0时，表示沿着纵轴进行计算，为1时，表示沿着横轴进行计算。但默认时，函数并不按照任意轴向计算，而是计算一个总值。
2-50常用的统计函数的使用
arr=np.arange(20).reshape(4,5)
print(arr)
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
print('数组的和为：\n',np.sum(arr))
数组的和为：
190
print('数组纵轴的和为：\n',arr.sum(axis=0))
数组纵轴的和为：
[30 34 38 42 46]
print('数组横轴的和为：\n',arr.sum(axis=1))
数组横轴的和为：
[10 35 60 85]
print('数组均值为：\n',np.mean(arr))
数组均值为：
9.5
print('数组纵轴的均值为：\n',arr.mean(axis=0))
数组纵轴的均值为：
[ 7.5 8.5 9.5 10.5 11.5]
print('数组横轴的均值为：\n',arr.mean(axis=1))
数组横轴的均值为：
[ 2. 7. 12. 17.]
print('数组的标准差为：\n',np.std(arr))
数组的标准差为：
5.766281297335398
print('数组的方差为：\n',np.var(arr))
数组的方差为：
33.25
print('数组的最小值为：\n',np.min(arr))
数组的最小值为：
0
print('数组的最大值为：\n',np.max(arr))
数组的最大值为：
19
print('数组的最小值的索引为：\n',np.argmin(arr))
数组的最小值的索引为：
0
print('数组的最大值的索引为：\n',np.argmax(arr))
数组的最大值的索引为：
19
以上所使用的函数的计算均为聚合计算，直接显示计算的最终结果。
2-51cumsum函数和cumprod函数的使用
但在numpy中，cumsum和cumprod函数采用不聚合计算，产生一个由中间结果组成的数组
arr=np.arange(2,10)
print(arr)
[2 3 4 5 6 7 8 9]
print('数组元素的累计和为：\n',np.cumsum(arr))
数组元素的累计和为：
[ 2 5 9 14 20 27 35 44]
print('数组元素的累计积为：\n',np.cumprod(arr))
数组元素的累计积为：
[ 2 6 24 120 720 5040 40320 362880]
实训
实训1 创建数组并进行运算
1.训练要点
(1)掌握NumPy的数组创建及随机数生成。
(2)掌握NumPy中用于统计分析的基本运算函数。
2.需求说明
NumPy数组在数值运算方面的效率优于Python提供的list，所以灵活掌握NumPy中数组的创建以及基础的运算是有必要的。
3.实现思路及步骤
(1)创建一个数值范围为0~1，间隔为0.01的数组。
print('1.1的结果为：\n',np.arange(0,1,0.01))
1.1的结果为：
[0. 0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.1 0.11 0.12 0.13
0.14 0.15 0.16 0.17 0.18 0.19 0.2 0.21 0.22 0.23 0.24 0.25 0.26 0.27
0.28 0.29 0.3 0.31 0.32 0.33 0.34 0.35 0.36 0.37 0.38 0.39 0.4 0.41
0.42 0.43 0.44 0.45 0.46 0.47 0.48 0.49 0.5 0.51 0.52 0.53 0.54 0.55
0.56 0.57 0.58 0.59 0.6 0.61 0.62 0.63 0.64 0.65 0.66 0.67 0.68 0.69
0.7 0.71 0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79 0.8 0.81 0.82 0.83
0.84 0.85 0.86 0.87 0.88 0.89 0.9 0.91 0.92 0.93 0.94 0.95 0.96 0.97
0.98 0.99]
(2)创建100个服从正态分布的随机数。
print('1.2的结果为：\n',np.random.randn(100))
1.2的结果为：
[-0.88523035 -0.41218848 -0.4826188 0.16416482 0.23309524 0.11799461
1.46237812 1.53871497 -2.43910582 0.60344123 -0.25104397 -0.16386712
-1.47632969 1.48698096 -0.02445518 0.35555132 0.41701111 0.83246186
-0.29339915 -0.02983857 0.09512578 0.66465434 -0.1402185 -0.0331934
-0.74907652 -0.77838201 0.94884286 1.58085059 -0.36817094 0.37556463
-1.19315823 -0.4090519 -0.44674147 1.52424163 0.3229998 -1.39341694
-2.17833425 -1.04389641 0.17269371 0.32419877 0.74585954 -1.83658324
0.56446424 0.02550067 0.47319325 0.6591906 2.34074633 1.07098519
0.09641648 0.41910211 -0.95302779 -1.0478706 -1.87567677 -1.36678214
0.63630511 -0.90672067 0.47604259 1.30366127 0.21158701 0.59704465
-0.89633518 -0.11198782 1.46894129 -1.12389833 0.9500054 1.72651647
0.45788508 -1.68428738 0.32684522 -0.08111895 0.46779475 0.73612235
-0.77970188 -0.84389636 -0.15053386 -0.96555767 0.15048908 -0.11342125
2.63352822 -1.02509089 -0.78204783 0.42394307 0.8727051 2.28722598
1.6229205 0.82373308 0.29305925 0.89663038 -0.61032202 -0.3161659
-1.48242425 -0.22884752 0.96264129 -0.20969244 -0.77404293 -0.35977815
0.72408325 -0.25576464 0.8499212 -1.31132423]
(3)对创建的两个数组进行四则运算。
print('两个数组的和为:,\n',arr1+arr2)
两个数组的和为:,
[-0.87030495 -0.49664322 -1.28995069 2.97366342 -1.0562658 0.96488432
-0.60606062 -0.44378749 0.3813228 -1.36851692 -0.56273831 -0.03647281
-0.72601702 -0.69248937 1.22672702 1.15498688 -0.28176602 0.08583491
1.41701607 -1.23647888 0.53802266 2.1845712 2.18503476 -1.70991122
-0.52262696 0.41865939 -1.06187695 -0.3982467 0.142709 1.69132156
0.25459734 0.52693673 0.83242373 0.87348869 0.36809946 -0.84708706
1.1496728 0.80148946 -0.7167523 -0.29230156 1.28751161 1.01548313
-0.30029799 0.16006623 0.29653777 1.06700378 1.7089407 0.53564916
1.64920765 1.36331697 0.70565013 -0.93348335 -0.50771086 1.27124064
-1.17052958 0.66897849 1.56048561 0.72242086 -0.02139725 -0.25661436
1.41615272 1.08170729 0.3345107 1.69529247 1.49399779 2.43859386
1.22689407 0.50549957 0.53700907 -1.2445702 0.85065904 0.69428506
-0.61007407 0.70471237 2.08316821 0.01545235 -0.19989463 1.87492822
1.4142403 3.85109521 -0.51857016 1.53038724 1.13589091 0.88928128
1.75051222 0.82027464 -1.07637621 0.02264247 2.24443345 2.0620289
0.52688081 1.41359706 3.70393805 0.8988132 0.92841668 1.14059871
1.56697571 0.62109882 1.58612936 -0.95422959]
print('两个数组的差为:,\n',arr1-arr2)
两个数组的差为:,
[ 0.87030495 0.51664322 1.32995069 -2.91366342 1.1362658 -0.86488432
0.72606062 0.58378749 -0.2213228 1.54851692 0.76273831 0.25647281
0.96601702 0.95248937 -0.94672702 -0.85498688 0.60176602 0.25416509
-1.05701607 1.61647888 -0.13802266 -1.7645712 -1.74503476 2.16991122
1.00262696 0.08134061 1.58187695 0.9382467 0.417291 -1.11132156
0.34540266 0.09306327 -0.19242373 -0.21348869 0.31190054 1.54708706
-0.4296728 -0.06148946 1.4767523 1.07230156 -0.48751161 -0.19548313
1.14029799 0.69993377 0.58346223 -0.16700378 -0.7889407 0.40435084
-0.68920765 -0.38331697 0.29434987 1.95348335 1.54771086 -0.21124064
2.25052958 0.43102151 -0.44048561 0.41757914 1.18139725 1.43661436
-0.21615272 0.13829271 0.9054893 -0.43529247 -0.21399779 -1.13859386
0.09310593 0.83450043 0.82299093 2.6245702 0.54934096 0.72571494
2.05007407 0.75528763 -0.60316821 1.48454765 1.71989463 -0.33492822
0.1457597 -2.27109521 2.11857016 0.08961276 0.50410909 0.77071872
-0.07051222 0.87972536 2.79637621 1.71735753 -0.48443345 -0.2820289
1.27311919 0.40640294 -1.86393805 0.9611868 0.95158332 0.75940129
0.35302429 1.31890118 0.37387064 2.93422959]
print('两个数组的积为:,\n',arr1*arr2)
两个数组的积为:,
[-0. -0.00506643 -0.02619901 0.0883099 -0.04385063 0.04574422
-0.03996364 -0.03596512 0.02410582 -0.13126652 -0.06627383 -0.01611201
-0.10152204 -0.10692362 0.15214178 0.15074803 -0.07068256 -0.01430806
0.22266289 -0.27103099 0.06760453 0.41465995 0.43230765 -0.44617958
-0.18303047 0.04216485 -0.34368801 -0.18042661 -0.03844148 0.40638325
-0.0136208 0.06725039 0.16397559 0.17935127 0.00955382 -0.41898047
0.28428221 0.1596511 -0.41676587 -0.26609761 0.35500465 0.24824808
-0.30252516 -0.11607152 -0.06312338 0.2776517 0.57451272 0.0308551
0.56121967 0.42792531 0.10282507 -0.73617651 -0.53440965 0.39285754
-0.92368597 0.06543817 0.56027194 0.08687989 -0.3488104 -0.49950247
0.48969163 0.28774145 -0.17700337 0.67113426 0.54655858 1.16258601
0.37415009 -0.11021529 -0.09723384 -1.33485343 0.10546133 -0.01115761
-0.95765333 -0.01845997 0.99394448 -0.55091074 -0.72951992 0.85079473
0.49470743 2.41826522 -1.05485613 0.58351367 0.25903054 0.04920347
0.76483026 -0.02526655 -1.66528354 -0.73720105 1.20070143 1.04310572
-0.33580727 0.45827333 2.561223 -0.02900372 -0.01088832 0.18106877
0.58269668 -0.33843415 0.59400678 -1.9247873 ]
print('两个数组的商为:,\n',arr1/arr2)
两个数组的商为:,
[-0.00000000e+00 -1.97377555e-02 -1.52677503e-02 1.01913826e-02
-3.64875016e-02 5.46517180e-02 -9.00818907e-02 -1.36243099e-01
2.65496005e-01 -6.17065176e-02 -1.50889119e-01 -7.50992641e-01
-1.41841119e-01 -1.58056754e-01 1.28827200e-01 1.49255680e-01
-3.62182675e-01 -2.01983993e+00 1.45511448e-01 -1.33195102e-01
5.91676311e-01 1.06352205e-01 1.11957307e-01 -1.18562127e-01
-3.14701697e-01 1.48227741e+00 -1.96690017e-01 -4.04042400e-01
-2.03946357e+00 2.06947504e-01 -6.60754306e+00 1.42898810e+00
6.24483176e-01 6.07188347e-01 1.20998752e+01 -2.92376395e-01
4.55885017e-01 8.57494867e-01 -3.46477505e-01 -5.71594762e-01
4.50698327e-01 6.77145207e-01 -5.83092004e-01 -1.59298335e+00
-3.06700935e+00 7.29331031e-01 3.68312123e-01 7.15926927e+00
4.10534434e-01 5.61079216e-01 2.43131376e+00 -3.53312007e-01
-5.05978888e-01 7.15017465e-01 -3.15691706e-01 4.62268425e+00
5.59728192e-01 3.73964555e+00 -9.64420779e-01 -6.96893450e-01
7.35156525e-01 1.29317484e+00 -2.17171011e+00 5.91386890e-01
7.49416462e-01 3.63413973e-01 1.16423867e+00 -4.07293758e+00
-4.75554623e+00 -3.56668371e-01 4.64625278e+00 -4.51799375e+01
-5.41323238e-01 -2.88678744e+01 5.50936207e-01 -1.02103655e+00
-7.91753568e-01 6.96877849e-01 1.22981779e+00 2.58077565e-01
-6.06717810e-01 1.12439526e+00 2.59583287e+00 1.40010463e+01
9.22557636e-01 -2.85951143e+01 -4.44128571e-01 -1.02672127e+00
6.44956338e-01 7.59366938e-01 -2.41209786e+00 1.80700021e+00
3.30467124e-01 -2.98203103e+01 -8.11511741e+01 4.98429409e+00
1.58161189e+00 -2.78015681e+00 1.61681657e+00 -5.09199121e-01]
(4)对创建的随机数组进行简单的统计分析。
print('1.4的统计分析结果的数组和为：\n',np.sum(arr2))
1.4的统计分析结果的数组和为：
6.7340096554519
print('1.4的统计分析结果的均值为：\n',np.mean(arr2))
1.4的统计分析结果的均值为：
0.067340096554519
print('1.4的统计分析结果的标准差为：\n',np.std(arr2))
1.4的统计分析结果的标准差为：
1.0449116390258357
print('1.4的统计分析结果的方差为：\n',np.var(arr2))
1.4的统计分析结果的方差为：
1.0918403333716586
print('1.4的统计分析结果的最小值为：\n',np.min(arr2))
1.4的统计分析结果的最小值为：
-1.9442295937495997
print('1.4的统计分析结果的最小值为：\n',np.max(arr2))
1.4的统计分析结果的最小值为：
3.06109521437826
实训2 创建一个国际象棋的棋盘
1.训练要点
(1)掌握矩阵创建方法。(2)掌握数组索引的方法。
2.需求说明
创建国际象棋棋盘，填充8x8矩阵。国际象棋棋盘是个正方形，由横纵向各8格、颜色一深一浅交错排列的64个小方格组成，深色格为黑格，浅色格为白格，棋子就在这些格子中移动，如图 2-3所示。
3.实现思路及步骤
(1)创建一个8x8矩阵。
(2)把1、3、5、7行和2、4、6列的元素设置为1。
cheese=np.zeros((8,8),dtype=int)
print(cheese)
[[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 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 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]]
cheese[1::2,::2]=1
print(cheese)
[[0 0 0 0 0 0 0 0]
[1 0 1 0 1 0 1 0]
[0 0 0 0 0 0 0 0]
[1 0 1 0 1 0 1 0]
[0 0 0 0 0 0 0 0]
[1 0 1 0 1 0 1 0]
[0 0 0 0 0 0 0 0]
[1 0 1 0 1 0 1 0]]
cheese[::2,1::2]=1
print(cheese)
[[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]]