第四章 Numpy基础：数组和矢量计算
第一部分：numpy的ndarray:一种多维数组对象
实话说，用numpy的主要目的在于应用矢量化运算。Numpy并没有多么高级的数据分析功能，理解Numpy和面向数组的计算能有助于理解后面的pandas.按照课本的说法，作者关心的功能主要集中于：
用于数据整理和清理、子集构造和过滤、转换等快速的矢量化运算 常用的数组解法，如排序、唯一化、集合运算等 高效的描述统计和数据聚合/摘要运算 用于异构数据集的合并/连接运算的数据对齐和关系型数据运算 将条件逻辑表述为数组表达式（而不是带有if-elif-else分支的循环） 数据的分组运算（聚合、转换、函数应用等）。
作者说了，可能还是pandas更好一些，我感觉显然pandas更高级，其中的函数真是太方便了，数据框才是最好的数据结构。只是，Numpy中的函数之类的是基础，需要熟悉。
NumPy的ndarray：一种多维数组对象
ndarray对象是NumPy最重要的对象，特点是矢量化。ndarray每个元素的数据类型必须相同，每个数组有两个属性：shape和dtype.
#-*- encoding:utf-8 -*-import numpy as npimport pandas as pdimport matplotlib.pyplot as pltdata = [[1,2,5.6],[21,4,2]]data = np.array(data)print data.shapeprint data.dtypeprint data.ndim
>>>
(2, 3)
float64
2
array函数接受一切序列型的对象（包括其他数组），然后产生新的含有传入数据的NumPy数组，array会自动推断出一个合适的数据类型。还有一个方法是ndim：这个翻译过来叫维度，标明数据的维度。上面的例子是两维的。zeros和ones可以创建指定长度或形状全为0或1的数组。empty可以创建一个没有任何具体值的数组，arange函数是python内置函数range的数组版本。
#-*- encoding:utf-8 -*-import numpy as npimport pandas as pdimport matplotlib.pyplot as pltdata = [[1,2,5.6],[21,4,2],[2,5,3]]data1 = [[2,3,4],[5,6,7,3]]data = np.array(data)data1 = np.array(data1)arr1 = np.zeros(10)arr2 = np.ones((2,3))arr3 = np.empty((2,3,4))print arr1print arr2print arr3print arr3.ndim
>>>
[ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[[ 1. 1. 1.]
[ 1. 1. 1.]]
[[[ 3.83889007e-321 0.00000000e+000 0.00000000e+000 0.00000000e+000]
[ 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000]
[ 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000]]
[[ 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000]
[ 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000]
[ 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000]]]
3
上面是常用的生成数组的函数。
ndarray的数据类型
dtype（数据类型）是一个特殊的对象。它含有ndarray将一块内存解释为指定数据类型所需的信息。他是NumPy如此灵活和强大的原因之一。多数情况下，它们直接映射到相应的机器表示，这使得“读写磁盘上的二进制数据流”以及“集成低级语言代码（C\Fortran）”等工作变得更加简单。dtype命名方式为，类型名+表示元素位长的数字。标准双精度浮点型数据需要占用8字节（64位）。记作float64.常见的数据类型为：
我终于找到了f4,f8的含义了……布尔型数据的代码倒是很有个性。函数astype可以强制转换数据类型。
#-*- encoding:utf-8 -*-import numpy as npimport pandas as pdimport matplotlib.pyplot as pltarr = np.array([1,2,3,4,5])print arr.dtypefloat_arr = arr.astype(np.float64)print float_arr.dtypearr1 = np.array([2.3,4.2,32.3,4.5])#浮点型会被整型截断print arr1.astype(np.int32)#一个全是数字的字符串也可以转换为数值类型arr2 = np.array(['2323.2','23'])print arr2.astype(float)#数组的dtype还有一个用法int_array = np.arange(10)calibers = np.array([.22,.270,.357,.44,.50],dtype = np.float64)print int_array.astype(calibers.dtype)print np.empty(10,'u4')
调用astype总会创建一个新的数组（原始数组的一个拷贝），即使和原来的数据类型相同。警告：浮点数只能表示近似数，比较小数的时候要注意。
数组与标量之间的运算
矢量化（vectorization）是数组最重要的特点了。可以避免（显示）循环。注意加减乘除的向量化运算。不同大小的数组之间的运算叫广播（broadcasting）。
索引和切片，不再赘述，注意的是 广播的存在使得数组即使只赋一个值也会被广播到所有数组元素上，其实和R语言中自动补齐功能相同。下面的性质有点蛋疼：跟列表最重要的区别在于，数组切片是原始数组的视图，对视图的任何修改都会反映到源数据上。即使是下面的情况：
#-*- encoding:utf-8 -*-import numpy as npimport pandas as pdimport matplotlib.pyplot as pltarr = np.array([1,2,3,4,5,6,7,8,9])arr1 = arr[1:2]arr1[0] = 10print arr#如果想得到拷贝，需要显示地复制一份arr2 = arr[3:4].copy()arr2[0] = 10print arrarr2d = np.array([[1,2,3],[4,5,6],[7,8,9]])#下面两种索引方式等价print arr2d[0][2]print arr2d[0,2]print arr2d[:,1] #注意这里的方式和下面的方式print arr2d[:,:1]arr3d = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[[10,11,12]]]])print arr3d[(1,0)]
>>>
[ 1 10 3 4 5 6 7 8 9]
[ 1 10 3 4 5 6 7 8 9]
3
3
[2 5 8] #注意这里的方式和下面的方式
[[1]
[4]
[7]]
[7, 8, 9]
布尔型索引
这里的布尔型索引就是TRUE or FALSE索引。==、！=、-（表示否定）、&（并且）、|（或者）。注意布尔型索引选取数组中的数据，将创建数据的副本。python关键字and、or无效。
花式索引（Fancy indexing）
花式索引指的是利用整数数组进行索引。
#-*- encoding:utf-8 -*-import numpy as npimport pandas as pdimport matplotlib.pyplot as pltarr = np.arange(32).reshape(8,4)print arr#注意这里的向量式方式print arr[[1,5,7,2],[0,3,1,2]]print arr[[1,5,7,2]][:,[0,3,1,2]]#也可以使用np.ix_函数，将两个一维整数数组组成选取方形区域的索引器print arr[np.ix_([1,5,7,2],[0,3,1,2])]>>>[[ 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]][ 4 23 29 10][[ 4 7 5 6][20 23 21 22][28 31 29 30][ 8 11 9 10]][[ 4 7 5 6][20 23 21 22][28 31 29 30][ 8 11 9 10]]
花式索引总是将数据复制到新数组中，跟切片不同,一定要注意下面的区别：
#-*- encoding:utf-8 -*-import numpy as npimport pandas as pdimport matplotlib.pyplot as pltarr = np.arange(32).reshape(8,4)arr1 = np.arange(32).reshape(8,4)#注意下面得到的结果是一样的arr3 = arr[[1,2,3]][:,[0,1,2,3]]arr3_1 = arr1[1:4][:]#注意下面是区别了arr3[0,1] = 100 #花式索引得到的是复制品，重新赋值以后arr不变化arr3_1[0,1] = 100 #切片方式得到的是一个视图，重新赋值后arr1会变化print arr3print arr3_1print arrprint arr1>>>[[ 4 100 6 7][ 8 9 10 11][ 12 13 14 15]][[ 4 100 6 7][ 8 9 10 11][ 12 13 14 15]][[ 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]][[ 0 1 2 3][ 4 100 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]]
数组转置和轴转换
转置transpose，是一种对源数据的视图，不会进行复制。调用T就可以。np中的矩阵乘积函数为np.dot。
比较复杂的是高维数组：
#-*- encoding:utf-8 -*-import numpy as npimport pandas as pdimport matplotlib.pyplot as pltarr = np.arange(24).reshape((2,3,4))#下面解释一下transpose：#（1,0,2） 是将reshape中的参数 (2,3,4) 进行变化 ，变为（3,2,4）#但是由于是转置，所以是将所有元素的下标都进行了上述变化，比如 12这个元素，原来索引为 (1,0,0) ,现在为 (0,1,0)arr1 = arr.transpose((1,0,2))arr2 = arr.T #直接用T是变为了(4,3,2)的形式#arr3 = np.arange(120).reshape((2,3,4,5))#arr4 = arr3.T #直接用T就是将形式变为 (5,4,3,2)#ndarray还有swapaxes方法，接受一对轴编号arr5 = arr.swapaxes(1,2)#print arr#print arr1#print arr2#print arr3#print arr4print arr5>>>[[[ 0 4 8][ 1 5 9][ 2 6 10][ 3 7 11]][[12 16 20][13 17 21][14 18 22][15 19 23]]]
第二部分是关于一些元素级函数：即作用于数组每个元素上的函数，用过R语言之后就觉得其实没什么了。
下面是一些常见的矢量化函数（姑且这么叫吧）。
下面是几个例子：
#-*- encoding:utf-8 -*-import numpy as npimport numpy.random as nprimport pandas as pd#接收两个数组的函数,对应值取最大值x = npr.randn(8)y = npr.randn(8)#注意不是max函数z = np.maximum(x,y)print x,y,z#虽然并不常见，但是一些ufunc函数的确可以返回多个数组。modf函数就是一例，用来分隔小数的整数部分和小数部分，是python中divmod的矢量化版本arr = npr.randn(8)print np.modf(arr)#ceil函数取天花板，不小于这个数的最小整数print np.ceil(arr)#concatenate函数是将两个numpy数组连接，注意要组成元组方式再连接#arr = np.concatenate((arr,np.array([0,0])))#logical_not函数, 非 函数#print np.logical_not(arr)print np.greater(x,y)print np.multiply(x,y)
第三部分：利用数组进行数据处理
作者说矢量化数组运算比纯pyhton方式快1-2个数量级（or more）,又一次强调了broadcasting作用很强大。
#-*- encoding:utf-8 -*-import numpy as npimport pandas as pdimport matplotlib.pyplot as plt#假设想在一个二维网格上计算一个 sqrt(x^2 + y^2)#生成-5到5的网格，间隔0.01points = np.arange(-5,5,0.01)#meshgrid返回两个二维矩阵，描述出所有（-5,5）* （-5,5）的点对xs,ys = np.meshgrid(points,points)z = np.sqrt(xs ** 2 + ys ** 2)#print xs#print ys#不做个图都对不起观众#imshow函数，展示z是一个矩阵，cmap就是colormap，用的时候值得研究plt.imshow(z,cmap=plt.cm.gray)plt.colorbar()plt.title("Image plot of $\sqrt{x^2 + y^2}$ for a grid of values")plt.show()
上面的画图语句在用的时候还需要好好研究一下。
下面的一个例子是np.where函数，简洁版本的if-else。
'''#np.where函数通常用于利用已有的数组生产新的数组arr = npr.randn(4,4)#正值赋成2，负值为-2print np.where(arr > 0,2,-2)#注意这里的用法print np.where(arr > 0,2,arr)#可以用where表示更为复杂的逻辑表达#两个布尔型数组cond1和cond2，4种不同的组合赋值不同#注意：按照课本上的说法，下面的语句是从左向右运算的，不是从做内层括号计算起的；这貌似与python的语法不符np.where(cond1 & cond2,0,np.where(cond1,1,np.where(cond2,2,3)))#不过感觉没有更好的写法了。#书上“投机取巧”的式子，前提是True = 1，False = 0result = 1 * (cond1 - cond2) + 2 * (cond2 & -cond1) + 3 * -（cond1 | cond2）'''
#-*- encoding:utf-8 -*-import numpy as npimport pandas as pdimport matplotlib.pyplot as pltimport numpy.random as npr#值得注意的是，mean、sum这样的函数，会有一个参数axis表示对哪个维度求值arr = np.array([[0,1,2],[3,4,5],[6,7,8]])#cumsum不是聚合函数，维度不会减少print arr.cumsum(0)
下面是常用的数学函数：
用于布尔型数组的方法
sum经常用于True的加和；any和all分别判断是否存在和是否全部为True。
排序及唯一化
#-*- encoding:utf-8 -*-import numpy as npimport pandas as pdimport matplotlib.pyplot as pltimport numpy.random as npr#sort函数是就地排序arr = npr.randn(10)print arrarr.sort()print arr#多维数组可以按照维度排序，把轴编号传递给sort即可arr = npr.randn(5,3)print arr#sort传入1，就是把第1轴排好序,即按列arr.sort(1)print arr#np.sort返回的是排序副本，不是就地排序#输出5%分位数arr_npr = npr.randn(1000)arr_npr.sort()print arr_npr[int(0.05 * len(arr_npr))]#pandas中有更多排序、分位数之类的函数，直接可以取分位数的，第二章的例子中就有#numpy中有unique函数，唯一化函数，R语言中也有names = np.array(['Bob','Joe','Will','Bob','Will'])print sorted(set(names))print np.unique(names)values = np.array([6,0,0,3,2,5,6])#in1d函数用来查看一个数组中的元素是否在另一个数组中,名字挺好玩，注意返回的长度与第一个数组相同print np.in1d(values,[6,2,3])
下面是常用集合运算
用于数组的文件输入输出
NumPy能够读写磁盘上的文本数据或二进制数据。后面的章节将会给出一些pandas中用于将表格型数据读取到内存的工具。
np.save 和 np.load是读写磁盘数据的两个主要函数。默认情况下，数组是以未压缩的原始二进制文件格式保存在扩展名为.npy的文件中。
#-*- encoding:utf-8 -*-import numpy as npimport pandas as pdimport matplotlib.pyplot as pltimport numpy.random as npr'''arr = np.arange(10)np.save('some_array',arr)np.savez('array_archive.npz',a = arr,b = arr)arr1 = np.load('some_array.npy')arch = np.load('array_archive.npz')print arr1print arch['a']'''#下面是存取文本文件，pandas中的read_csv和read_table是最好的了#有时需要用np.loadtxt或者np.genfromtxt将数据加载到普通的NumPy数组中#这些函数有许多选项使用：指定各种分隔符，针对特定列的转换器函数，需要跳过的行数等#np.savetxt执行的是相反的操作：将数组写到以某种分隔符隔开的文本文件中#genfromtxt跟loadtxt差不多，只不过它面向的是结构化数组和缺失数据处理
线性代数
关于线性代数的一些函数，NumPy的linalg中有很多关于矩阵的函数，与MATLAB、R使用的是相同的行业标准级Fortran库。
随机数生成
NumPy.random模块对Python内置的random进行了补充，增加了一些用于高效生成多种概率分布的样本值的函数。
#-*- encoding:utf-8 -*-import numpy as npimport numpy.random as nprfrom random import normalvariate#生成标准正态4*4样本数组samples = npr.normal(size = (4,4))print samples#从下面的例子中看出，如果产生大量样本值，numpy.random快了不止一个数量级N = 1000000#xrange()虽然也是内置函数，但是它被定义成了Python里一种类型(type),这种类型就叫做xrange.#下面的循环中，for _ in xrange(N) 非常good啊，查了一下和range的关系，两者都用于循环，但是在大型循环时，xrange好得多%timeit samples = [normalvariate(0,1) for _ in xrange(N)]%timeit npr.normal(size = N)
范例：随机漫步
#-*- encoding:utf-8 -*-import numpy as npimport random #这里的random是python内置的模块import matplotlib.pyplot as pltposition = 0walk = [position]steps = 1000for i in xrange(steps):step = 1 if random.randint(0,1) else -1position += stepwalk.append(position)plt.plot(walk)plt.show()#下面看看简单的写法nsteps = 1000draws = np.random.randint(0,2,size = nsteps)steps = np.where(draws > 0,1,-1)walk = steps.cumsum()plt.plot(walk)plt.show()#argmax函数返回数组第一个最大值的索引，但是在这argmax不高效，因为它会扫描整个数组print (np.abs(walk) >= 10).argmax()nwalks = 5000nsteps = 1000draws = np.random.randint(0,2,size = (nwalks,nsteps))steps = np.where(draws > 0,1,-1)walks = steps.cumsum(1)print walks.max()print walks.min()#这里的any后面的参数1表示每行(轴为1)是否存在truehist30 = (np.abs(walks) >= 30).any(1)print hist30print hist30.sum() #这就是有多少行超过了30#这里argmax的参数1就是crossing_time = (np.abs(walks[hist30]) >= 30).argmax(1)print crossing_time.mean()X = range(1000)plt.plot(X,walks.T)plt.show()
NumPy写完了，接下来写pandas.NumPy写的还好，比较顺利。
如果觉得《《利用python进行数据分析》读书笔记--第四章 numpy基础：数组和矢量计算》对你有帮助，请点赞、收藏，并留下你的观点哦！
