《利用Python进行数据分析·第2版》第四章 Numpy基础：数组和矢量计算
numpy高效处理大数组的数据原因：
-
numpy是在一个连续的内存块中存储数据，独立于其他python内置对象。其C语言编写的算法库可以操作内存而不必进行其他工作。比起内置序列，使用的内存更少（即时间更快，空间更少）
-
numpy可以在整个数组上执行复杂的计算，而不需要借助python的for循环
4.0 前提知识
数据：结构化的数据代指所有的通用数据，如表格型，多维数组，关键列，时间序列等
相关包：numpy pandas matplotlib scipy scikit-learn statsmodels
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
import statsmodels as sm
数据规整（Munge/Munging/Wrangling）：
指的是将非结构化和（或）散乱数据处理为结构化或整洁形式的整个过程。这几个词已经悄悄成为当今数据黑客们的行话了。Munge这个词跟Lunge押韵。
伪码（Pseudocode）：
算法或过程的“代码式”描述，而这些代码本身并不是实际有效的源代码。
语法糖（Syntactic sugar）:
这是一种编程语法，它并不会带来新的特性，但却能使代码更易读、更易写。
4.1 Numpy的ndarrray：一种多维数组对象
ndarray：N维数组对象，快速而灵活的大数据集容器
- 通用的同构数据多维容器(所有元素相同类型)
- 每个对象都有一个shape(表示各维度大小的元组)+dtype(表示数组数据类型的对象)+ ndim(维度)
对整块数据执行运算的语法=标量元素执行运算的语法
np.random.randn(n,m)：生成2行3列的正态分布随机数组
data = np.random.randn(2, 3)
array([[-0.2047, 0.4789, -0.5194],
[-0.5557, 1.9658, 1.3934]])
data * 10
array([[ -2.0471, 4.7894, -5.1944],
[ -5.5573, 19.6578, 13.9341]])
In [17]: data.shape
Out[17]: (2, 3)
In [18]: data.dtype
Out[18]: dtype('float64')
1）创建ndarray
np.array(一切对象)—>自动推断数据类型
np.zeros((n,m)) / np.ones((n,m)) / np.empty((n,m))：生成全0，全1，全未初始化垃圾值数组，传入元组/整数
np.arange()：range函数的numpy版本 如果没有特别指定，数据类型基本都是float64（浮点数）
2）ndarray的数据类型
dtype是一个特殊的对象：含有ndarray将一块内存解释为特定数据类型所需的信息
—>命名方式：类型名+元素位长(float8字节64位长)
numpy会将 Python类型映射到等价的dtype上（如误写float映射为np.float64）
npo：在此简写为np类型的对象
npo.astype()：np强制类型转换
3）Numpy数组的运算
矢量化（vectorization）：大小相等的数组之间任何运算均应用到元素级
数组与标量的算术运算会将标量值广播到各个元素
大小相同的数组之间比较会生成布尔数组（逻辑运算）
4）基本的索引和切片
一维数组：
标量赋值切片时，标量值自动广播
数组切片是原始数组的视图，不同于python内置列表，切片上的修改会映射到源数组上
（内置列表的切片是新建一个列表不会改变源列表）——>一种是视图，另一种是副本：副本用npo.copy()
二维数组：
npo[0,2] —> 表示第一行第三列的数
npo[[0,1],2] —> 表示第一二行第三列的数
5）切片索引
一维数组同python列表
二维数组npo[n]，n表示行；npo[:n]，则表示取数组前n行；npo[:2,1:]，表示取前两行，除第一列外的元素数组
6）布尔型索引
一维布尔型数组可用于数组索引：一维布尔型数组长度==索引数组的行长度(轴长度) —>用于筛选
二维则需要大小相同才可做索引运算
比较运算(组合逻辑)得到布尔型索引—>比较运算可以用!= / 也可以用~()对条件进行否定
（用来反转条件好用）
布尔型数组中用 & 和 | ，而不用and or —>数据运算得到的布尔型索引数组是新数组
print(data)
print(data[names == 'tom',1:])
[[ 0.16915065 0.15038684 0.34028728]
[ 0.32732646 0.69241855 0.65203056]
[ 0.84402175 0.77184234 0.48730057]
[ 0.94376757 0.33876278 0.77287885]
[ 0.58535219 0.50321862 0.28196336]]
[[ 0.15038684 0.34028728]
[ 0.50321862 0.28196336]]
（注意： 原书中翻译“通过布尔型索引选取数组中的数据，将总是创建数据的副本，即使返回一模一样的数组也是如此。”<该处翻译可能有误>，因为如下）
In [113]: data[data < 0] = 0
In [114]: data
Out[114]:
array([[ 0.0929, 0.2817, 0.769 , 1.2464],
[ 1.0072, 0. , 0.275 , 0.2289],
[ 1.3529, 0.8864, 0. , 0. ],
[ 1.669 , 0. , 0. , 0.477 ],
[ 3.2489, 0. , 0. , 0.1241],
[ 0.3026, 0.5238, 0.0009, 1.3438],
[ 0. , 0. , 0. , 0. ]])
可以通过布尔索引对数组进行赋值，证明布尔索引得到的数据是视图而非副本
7）花式索引
numpy术语，利用整数数组进行索引
In [119]: arr
Out[119]:
array([[ 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.]])
In [120]: arr[[4, 3, 0, 6]]
Out[120]:
array([[ 4., 4., 4., 4.],
[ 3., 3., 3., 3.],
[ 0., 0., 0., 0.],
[ 6., 6., 6., 6.]])
花式索引在选择索引行、列上使用频繁（1.一个[]就是一个维度，逗号分割维度 2.按照[]内顺序进行筛选
负数索引从末尾开始选取行
npo[[行],[:，列]]，扩展同理（后面格式必须得这样，否则会出现预期不一样的结果
array([[ 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]])
In [124]: arr[[1, 5, 7, 2], [0, 3, 1, 2]] #这种格式相当于是[1,0],[5,3]....
Out[124]: array([ 4, 23, 29, 10])
In [125]: arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]] #这种格式才是预期的结果，把第一行的第0,3,1,2列都拿出来,再是第五行的....
Out[125]:
array([[ 4, 7, 5, 6],
[20, 23, 21, 22],
[28, 31, 29, 30],
[ 8, 11, 9, 10]])
花式索引！=切片，花式索引是副本而非视图
8）数组转置和轴对换
npo.T属性：数组的转置数组（方法一：针对一二维数组：返回视图非副本
npo.transpose(arry_method)（方法二：针对高维数组：返回视图非副本 arry_method：由轴编号组成的元组 / 轴就是维度
transpose方法结合npo.shape进行 —>
In [60]: arr1
Out[60]: array([[[ 0, 1, 2], [ 3, 4, 5]], [[ 6, 7, 8], [ 9, 10, 11]]])
In [61]: arr1.shape #看形状
Out[61]: (2, 2, 3) #说明这是一个2*2*3的数组（矩阵），返回的是一个元组，可以对元组进行索引，也就是0,1,2，维度进行编号
In [134]: arr.transpose((1, 0, 2)) #这里的(1,0,2)元组就相当是维度元组(0,1,2) 说明把第三维和第二维进行了交换（一般而言保持第一维度不会变化
Out[134]:
array([[[ 0, 1, 2, 3], #比如数值6，原本是(1,0,0)的位置，变换后是(0,1,0)
[ 8, 9, 10, 11]],
[[ 4, 5, 6, 7],
[12, 13, 14, 15]]])
np.dot()：计算矩阵内积 —>np.dot(npo.T,npo)
npo.swapaxes(arry_method)（方法三：实现两个维度的交换：返回视图非副本 arry_method：接受一对轴编号 / 就是两个维度
4.2 通用函数：快速的元素级数组函数 ufunc
简单函数（接受一个或多个标量值，并产生一个或多个标量值）的矢量化包装器。
一元ufunc（接受一个矢量）：np.sqrt np.exp... 一元：unary
二元ufunc： np.add() np.maximum... 二元：binary
返回多个数组：np.modf（内置函数divmod的矢量化版本：divmod(a,b) / 返回一个包含shan商和余数的元组(a//b，a%b)
//更确切说是math库中modf的矢量化版本：将数组各元素的小数部分和整数部分以两个独立数组形式返回
ufunc可接受一个out可选参数：表示在传入数组上原地进行操作（即结果值返回至数组中
部分一元、二元ufunc
4.3利用数组进行数据处理
np.meshgrid()：生成网格点坐标矩阵 //强烈的规律性快速生成矩阵
图中每个交叉点都是网格点；网格点的坐标的矩阵就是坐标矩阵
xs, ys = np.meshgrid(points, points)
传入参数为两个一维数组，分别是所有的x、y值
返回产生的两个二维数组，分别是按网格状化后排列的x、y值
1）将条件逻辑表述为数组运算
np.where()：三元表达式 x if condition else y 的矢量化版本
条件：布尔矩阵 if：第二个参数 else：第三个参数 返回：产生的新数组
In [165]: xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
In [166]: yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
In [167]: cond = np.array([True, False, True, True, False]) #cond为True时，选取xarr的值，否则从yarr中选取。
In [168]: result = [(x if c else y) #列表生成式写法
.....: for x, y, c in zip(xarr, yarr, cond)]
In [169]: result
Out[169]: [1.1000000000000001, 2.2000000000000002, 1.3, 1.3999999999999999, 2.5] #1.大数据处理慢 2.无法用于多维数组(多个for时间度问题
In [170]: result = np.where(cond, xarr, yarr) #np.where解决
In [171]: result
Out[171]: array([ 1.1, 2.2, 1.3, 1.4, 2.5])
np.where作用：根据另一个数组而产生一个新数组；
第二三个参数不一定是矢量，也可以是标量
In [173]: arr
Out[173]:
array([[-0.5031, -0.6223, -0.9212, -0.7262],
[ 0.2229, 0.0513, -1.1577, 0.8167],
[ 0.4336, 1.0107, 1.8249, -0.9975],
[ 0.8506, -0.1316, 0.9124, 0.1882]])
In [174]: arr > 0
Out[174]:
array([[False, False, False, False],
[ True, True, False, True],
[ True, True, True, False],
[ True, False, True, True]], dtype=bool)
In [175]: np.where(arr > 0, 2, -2)
Out[175]:
array([[-2, -2, -2, -2],
[ 2, 2, -2, 2],
[ 2, 2, 2, -2],
[ 2, -2, 2, 2]])
2）数学和统计方法
聚合计算：(aggregation，通常叫约简(reduction)) 聚类统计
np.sum np.mean np.std... 求和平均标准差 可以对整个数组 / 也可以接受一个axis计算对某轴的统计值
axis=1(行) axis=0(列)
非聚合计算：np.cumsum np.cumprod... 累加累乘 产生一个结果数组（多维数组中一样，可以指定轴)
3）用于布尔型数组的方法
布尔型数组也可用于统计方法—>转为1 / 0
（sum求True个数
（any是否存在True （all是否都是True 同样适用于数值数组
4）排序
npo.sort()：原地排序 （多维数组加axis
np.sort返回副本，npo.sort原地修改本身
计算数组分位数：1.排序 2.选取特定位置值
In [203]: large_arr = np.random.randn(1000)
In [204]: large_arr.sort()
In [205]: large_arr[int(0.05 * len(large_arr))] # 5% quantile
Out[205]: -1.5311513550102103
其他排序：附录+pandas
5）唯一化以及其他的集合逻辑
集合函数
np.unique()：找出数组中唯一值并返回排序结果 = set+sorted
np.in1d()：试探一个数组的值在另一个数组中的成员是否包含，返回布尔型数组
4.4 用于数组的文件输入输出（较为简单的fIO)
np.save：数组以未压缩的原始二进制格式 扩展名：.npy
np.savez：多个数组保存到一个未压缩文件中，数组以关键字参数形式传入 扩展名：.npz
np.load：加载.npy正常 加载.npz时得到类似字典的对象：对各个数组进行延迟加载(类似迭代器，惰性计算
np.savez_compressed：数据压缩
4.5线性代数
x.dot(y) = np.dot(x,y) ：矩阵乘法 所有数组dot方法和np命名空间函数的区别是：dot方法是视图，函数是副本
@符(类似python3.5)也可以作为中缀运算符进行矩阵乘法：
In [230]: x @ np.ones(3)
Out[230]: array([ 6., 15.])
numpy.linalg中有一组标准的矩阵分解运算以及如求逆和行列式等：
In [231]: from numpy.linalg import inv, qr
In [232]: X = np.random.randn(5, 5)
In [233]: mat = X.T.dot(X)
In [234]: inv(mat)
Out[234]:
array([[ 933.1189, 871.8258, -1417.6902, -1460.4005, 1782.1391],
[ 871.8258, 815.3929, -1325.9965, -1365.9242, 1666.9347],
[-1417.6902, -1325.9965, 2158.4424, 2222.0191, -2711.6822],
[-1460.4005, -1365.9242, 2222.0191, 2289.0575, -2793.422 ],
[ 1782.1391, 1666.9347, -2711.6822, -2793.422 , 3409.5128]])
In [235]: mat.dot(inv(mat)) #求逆
Out[235]:
array([[ 1., 0., -0., -0., -0.],
[-0., 1., 0., 0., 0.],
[ 0., 0., 1., 0., 0.],
[-0., 0., 0., 1., -0.],
[-0., 0., 0., 0., 1.]])
In [236]: q, r = qr(mat) #qr矩阵分解
In [237]: r
Out[237]:
array([[-1.6914, 4.38 , 0.1757, 0.4075, -0.7838],
[ 0. , -2.6436, 0.1939, -3.072 , -1.0702],
[ 0. , 0. , -0.8138, 1.5414, 0.6155],
[ 0. , 0. , 0. , -2.6445, -2.1669],
[ 0. , 0. , 0. , 0. , 0.0002]])
```
##4.6 伪随机数生成
np.random.normal：标准正态分布
np.random.seed：设置随机数生成种子（全局状态种子
np.random.RandomState：创建一个与其他隔离的随机数生成器（局部状态种子）
##4.7 示例：随机漫步
纯python：
In [247]: import random
.....: position = 0
.....: walk = [position]
.....: steps = 1000
.....: for i in range(steps):
.....: step = 1 if random.randint(0, 1) else -1
.....: position += step
.....: walk.append(position)
.....:
转为numpy：
In [251]: nsteps = 1000
In [252]: draws = np.random.randint(0, 2, size=nsteps) #size决定是一维的
In [253]: steps = np.where(draws > 0, 1, -1)
In [254]: walk = steps.cumsum()
In [249]: plt.plot(walk[:100]) #x步数也就是时间，y是离初始点的距离
对l累加后的漫步数据一些统计计算处理：
In [255]: walk.min()
Out[255]: -3
In [256]: walk.max()
Out[256]: 31
假设离初始点距离10步外就是穿越过了漫步地点，想要知道首次穿越时间：
In [257]: (np.abs(walk) >= 10).argmax() #argmax返回数组最大值的第一个索引位置
Out[257]: 37 #所以第37步时第一次走出漫步地点
一次性模拟多个随机漫步：
In [258]: nwalks = 5000
In [259]: nsteps = 1000
In [260]: draws = np.random.randint(0, 2, size=(nwalks, nsteps)) # 0 or 1 #size决定是二维的 行：第几次walk 列：nwalk的第几步
In [261]: steps = np.where(draws > 0, 1, -1)
In [262]: walks = steps.cumsum(1) #按行作累加 / 非聚合
In [263]: walks
Out[263]:
array([[ 1, 0, 1, ..., 8, 7, 8],
[ 1, 0, -1, ..., 34, 33, 32],
[ 1, 0, -1, ..., 4, 5, 4],
...,
[ 1, 2, 1, ..., 24, 25, 26],
[ 1, 2, 3, ..., 14, 13, 14],
[ -1, -2, -3, ..., -24, -23, -22]])
计算所有随机漫步的统计数据：
In [264]: walks.max()
Out[264]: 138
In [265]: walks.min()
Out[265]: -133
之后计算每个随机漫步的首次穿越时间：阈值=30（注：不是每次漫步都能够穿越，所以需要清理检查
In [266]: hits30 = (np.abs(walks) >= 30).any(1) #按行筛选每行是不是有abs>30的值
In [267]: hits30
Out[267]: array([False, True, False, ..., False, True, False], dtype=bool)
In [268]: hits30.sum() # Number that hit 30 or -30 #为True的就是满足要求的，一共有3410个
Out[268]: 3410
获取穿越时间：
In [269]: crossing_times = (np.abs(walks[hits30]) >= 30).argmax(1) #花式索引筛选满足要求行+argmax找到首次穿越的时间
In [270]: crossing_times.mean()
Out[270]: 498.88973607038122