《利用python进行数据分析》读书笔记--第四章 numpy基础：数组和矢量计算

http://www.cnblogs.com/batteryhp/p/5000104.html

第四章 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 np
import pandas as pd
import matplotlib.pyplot as plt

data = [[1,2,5.6],[21,4,2]]
data = np.array(data)
print data.shape
print data.dtype
print data.ndim

>>>

(2, 3)
float64
2

array函数接受一切序列型的对象（包括其他数组），然后产生新的含有传入数据的NumPy数组，array会自动推断出一个合适的数据类型。还有一个方法是ndim：这个翻译过来叫维度，标明数据的维度。上面的例子是两维的。zeros和ones可以创建指定长度或形状全为0或1的数组。empty可以创建一个没有任何具体值的数组，arange函数是python内置函数range的数组版本。

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

data = [[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 arr1
print arr2
print arr3
print 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 np
import pandas as pd
import matplotlib.pyplot as plt

arr = np.array([1,2,3,4,5])
print arr.dtype
float_arr = arr.astype(np.float64)
print float_arr.dtype

arr1 = 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 np
import pandas as pd
import matplotlib.pyplot as plt

arr = np.array([1,2,3,4,5,6,7,8,9])
arr1 = arr[1:2]
arr1[0] = 10
print arr
#如果想得到拷贝，需要显示地复制一份
arr2 = arr[3:4].copy()
arr2[0] = 10
print arr

arr2d = 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 np
import pandas as pd
import matplotlib.pyplot as plt

arr = 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 np
import pandas as pd
import matplotlib.pyplot as plt

arr = 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 arr3
print arr3_1
print arr
print 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 np
import pandas as pd
import matplotlib.pyplot as plt

arr = 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 arr4
print 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 np
import numpy.random as npr
import 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 np
import pandas as pd
import matplotlib.pyplot as plt

#假设想在一个二维网格上计算一个 sqrt(x^2 + y^2)
#生成-5到5的网格，间隔0.01
points = 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，负值为-2
print 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 = 0
result = 1 * (cond1 - cond2) + 2 * (cond2 & -cond1) + 3 * -（cond1 | cond2）
'''

#-*- encoding:utf-8 -*-

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import 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 np
import pandas as pd
import matplotlib.pyplot as plt
import numpy.random as npr

#sort函数是就地排序
arr = npr.randn(10)
print arr
arr.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 np
import pandas as pd
import matplotlib.pyplot as plt
import 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 arr1
print 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 np
import numpy.random as npr
from 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 np
import random #这里的random是python内置的模块
import matplotlib.pyplot as plt

position = 0
walk = [position]
steps = 1000
for i in xrange(steps):
    step = 1 if random.randint(0,1) else -1
    position += step
    walk.append(position)
plt.plot(walk)
plt.show()

#下面看看简单的写法
nsteps = 1000
draws = 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 = 5000
nsteps = 1000
draws = 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)是否存在true
hist30 = (np.abs(walks) >= 30).any(1)
print hist30
print 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写的还好，比较顺利。