目录
- Numpy基础
- 1.多维数组对象：ndarray
- 1.1 生成多维数组对象
- 1.2 ndarry的数据类型
- 1.3 Numpy数组计算
- 1.4 数组索引与切片
- 1.5 布尔索引
- 1.6 神奇检索
- 1.7 数组转置与换轴
- 2. 通用函数：向量化计算
- 3. 使用数组进行面向数组编程
- 3.1 将条件逻辑作为数组操作
- 3.2 数学和统计方法
- 3.3 排序
- 3.4 其他集合逻辑
- 4. 线性代数
- 5. 示例：随机漫步
- pandas入门
- 1.pandas数据结构
- 1.1 series
- 1.2 DataFrame
- 1.3 索引对象
- 2. 基本功能
- 2.1 重建索引
- 2.2 删除条目
- 2.3 索引、选择、过滤
- 2.4 算术和整数对齐
- 2.5 函数应用和映射
- 2.6 排序和排名
- 3. 描述性统计
- 3.1 相关性和协方差
- 3.2 其他方法
- 数据载入、存储、文件格式
- 1.文本格式数据读写
- 1.1 分块读入文本文件
- 1.2 将数据写入文本
- 1.3 使用分隔格式
- 2.其他格式
- 2.1 读取Excel文件
- 数据清洗与准备
- 1. 缺失值
- 1.1 过滤缺失值
- 1.2 缺失值填补
- 2. 数据转换
- 2.1 删除重复值
- 2.2 使用函数或映射进行数据转换
- 2.3 替代值
- 2.4 重命名轴索引
- 2.5 离散化和分组
Numpy基础
1.多维数组对象：ndarray
1.1 生成多维数组对象
-
array函数
该函数的参数为任意的序列型对象，比如Python内建的列表对象
import numpy as np
ls1 = range(1,10,1)
array1 = np.array(ls1)
ls2 = [[1,2,3,4],[5,6,7,8]]
array2 = np.array(ls2)在生成多维数组后，可以使用array.shape查看维数，array.dtype查看数据类型。
也可以使用内建函数range的数组版：
array = np.arange(0,10,2)此外还有其他生成特殊数组的方法：
array3 = np.zeros(10)
array4 = np.ones(3,6) #创建3行6列的1数组
array5 = np.empty(2,3,2)更多的数组生成函数可以参考书P91的表4-1
1.2 ndarry的数据类型
数据类型(dtype)也是一种对象，可以在创建数组的时候进行声明：
array6 = np.array([1,2,3], dtype = np.float64)
array7 = np.array([1,2,3], dtype = np.int32)此外还可以利用astype方法转换数组数据类型：
array6.astype(np.int32)
array6.dtype也可以用astype方法将全部是数字的字符串转换为数字。
甚至直接用另一个数组的dtype属性作为astype方法的参数
1.3 Numpy数组计算
利用Numpy创建的数组具有一个重要的特性：可以进行向量化操作，而无须进行循环
array2 * array2 #会把array2中的每个元素分别相乘
1 / array2 #会用1除以array2中的每个元素1.4 数组索引与切片
对于一维数组，Numpy的索引和切片方法与Python的List类型相似。但是与Python的内建列表不同，数组的切片是原数组的视图，即任何对于视图的的修改都会反映到原数组上，看个例子就知道是什么意思了：
In [4]: arr[5:8]
Out[4]: array([5, 6, 7])
In [5]: arr_slice = arr[5:8]
In [6]: arr_slice[1] = 10
In [7]: arr
Out[7]: array([ 0, 1, 2, 3, 4, 5, 10, 7, 8, 9])可以看到对于切片的改变也会改变原数组。
这反映了在Numpy中很少去做赋值数组这种操作，因为Numpy本身设计的目的是处理大数组的，所以如果总是在复制数据会占用很多内存。
如果非得复制数据切片的话，需用方法copy()：
arr_slice = arr[5:8].copy()在多维数据中，情况会稍显复杂：
我们先创建一个3*3*1的数组看看：
In [9]: arr2d = np.array([[1,2,3],[4,5,6],[7,8,9]])
In [10]: arr2d
Out[10]:
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In [11]: arr2d[2]
Out[11]: array([7, 8, 9])
In [12]: arr2d[2][2]
Out[12]: 9
In [13]: arr2d[2,2]
Out[13]: 9即如果只用一个索引，会返回一整行。要返回某个具体元素的话，得用递归。
再来创建一个2*2*3的数组看看：
In [14]: arr3d = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
In [15]: arr3d
Out[15]:
array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
In [16]: arr3d[0]
Out[16]:
array([[1, 2, 3],
[4, 5, 6]])
In [17]: arr3d[1]
Out[17]:
array([[ 7, 8, 9],
[10, 11, 12]])
In [18]: arr3d[0][0]
Out[18]: array([1, 2, 3])所谓2*2*3数组，意思是每个元素都是3维数组，矩阵为2*2的。
注意以上所有子集选择返回的都是视图。
多维数组切片也与一维数组不太一样，与索引类似，进行切片时，首先对行切片，然后才是对列切片：
In [19]: arr2d[:2]
Out[19]:
array([[1, 2, 3],
[4, 5, 6]])
In [20]: arr2d[:2,1:]
Out[20]:
array([[2, 3],
[5, 6]])此外还可以把索引和切片结合：
In [22]: arr2d[0, :1]
Out[22]: array([1])这样就是选择了第一行（通过索引），然后选择了第一行的前一列（通过切片）
切片[:]表示选择所有的数组，通过结合这个操作就可以单纯返回列的切片：
In [23]: arr2d[:, :1]
Out[23]:
array([[1],
[4],
[7]])我把下面这张图称为：随心所欲想怎么切怎么切
1.5 布尔索引
布尔索引值就是用一些条件判断式来对多维数组进行索引。
比如我们有一个姓名数组，另一个多维数组存储的是相应的不同人的数据（利用numpy.random中的randn函数随机生成正态分布数据）：
In [25]: names = np.array(['bob','joe','will','bob','will','joe','joe'])
In [26]: data = np.random.randn(7,4)
In [27]: names
Out[27]: array(['bob', 'joe', 'will', 'bob', 'will', 'joe', 'joe'], dtype='<U4')
In [28]: data
Out[28]:
array([[ 0.33570344, -0.35161261, -1.46194168, -0.09575411],
[ 1.12495352, 1.01942178, -0.57483366, -0.76607756],
[ 0.40598446, -0.26207084, 1.21948522, -0.65978086],
[ 0.1566132 , -0.19558611, 3.31560437, 0.65168252],
[ 0.70533795, -0.02594408, -0.7427101 , 0.99027039],
[ 0.18283008, -0.71197155, 0.8294305 , 0.98896259],
[ 1.69864451, 0.08284518, 0.64629488, -0.6459553 ]])现在我们只想查看Bob的数据，该怎么索引呢？：
In [30]: data[names == 'bob']
Out[30]:
array([[ 0.33570344, -0.35161261, -1.46194168, -0.09575411],
[ 0.1566132 , -0.19558611, 3.31560437, 0.65168252]])我们还可以只看Bob的前两项数据：
In [31]: data[names == 'bob', :2]
Out[31]:
array([[ 0.33570344, -0.35161261],
[ 0.1566132 , -0.19558611]])可以看除了Bob以外的所有人的数据，可以使用!=或者~符号
data[names != 'bob']
data[~(names == 'bob')]可以选择bob和joe的数据：
In [35]: data[(names == 'bob') |( names == 'joe')]注意在numpy检索中，python关键字and和or失效，只能使用&,| 除了检索之外，还可以直接把检索出来的结果赋值。
此外，利用布尔值索引选择数据时，总是会生成数据的拷贝，返回的数组不会发生变化。
1.6 神奇检索
之前我们试过了在多维数组方括号[]中加入数字（索引），加入:进行切片，或者加入表达式进行布尔值检索，我们还可以继续加入数组，产生神奇的检索效果：返回符合特定顺序的子集：
array[[3,2,1]] ##按顺序返回第4行、第3行、第2行数据按照之前的习惯，如果再加入一个数组会怎样？
array[[3,2,1],[1,2,3]]这时会依次返回元素(3,1),(2,2,),(1,3)
但是如果是想按3，2，1的顺序返回行，再在返回数据中按1，2，3的顺序返回列怎么办？这时候应该使用一次递归：
array[[3,2,1]][:,[1,2,3]]注意神奇索引与布尔值索引类似，都会返回数据的拷贝。
1.7 数组转置与换轴
数组转置，直接用其特殊的T属性就可以了：
array.T数组转置后会返回底层数据的视图，不需要进行数据复制。
或者可以使用transpose方法：
arrary.transpose()而对于高维数据，transpose方法可以接受包含轴编号的元组，用于置换轴：
In [36]: arr = np.arange(16).reshape((2,2,4))
In [37]: arr
Out[37]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
In [38]: arr.transpose((1,0,2))
Out[38]:
array([[[ 0, 1, 2, 3],
[ 8, 9, 10, 11]],
[[ 4, 5, 6, 7],
[12, 13, 14, 15]]])上述操作中，把原来的1轴和0轴进行了交换
2. 通用函数：向量化计算
常用的通用函数如下：
np.sqrt(arr) #对每个元素求平方根
np.exp(arr) #对每个元素求指数幂
np.add(arr1,arr2) #将两个数组求和，返回一个数组作为结果
np.maximum(arr1,arr2) #求两个数组同一位置上的最大值，返回一个数组作为结果
value1, value2 = np.modf(arr) #返回浮点值数组的小数部分和整数部分更多的一元和二元通用函数可以见书P108的表4-3和表4-4
3. 使用数组进行面向数组编程
假设我们想要对网格数据进行计算，例如计算：
points = np.arange(-5, 5, 0.01)
xs, ys = np.meshgrid(points, points)这里用到了np.meshgrid(xarray, yarray)函数，这个函数接收两个一维数组作为参数，并且返回两个数组，返回的第一个数组是以xarray为行，一共ydimension行；第二个数组以yarray的转置为列，一共xdimension列。
z = np.sqrt(xs ** 2 + ys ** 2)3.1 将条件逻辑作为数组操作
numpy.where函数是python内建的x if condition else y的向量化版本：
np.where(cond, xarr, yarr)这条语句会使得当cond中的元素为真时，返回xarr中的对应元素值，当cond中的元素为假时，返回yarr中的对应元素值。
除此之外np.where的第二个和第三个参数还可以是标量，比如我们要把一个随机生成的数据矩阵中的正值替换为2，负值替换为-2；或者只把正值替换为2，负值不动：
arr = np.random.randn(4,4)
np.where(arr > 0, 2, -2)
np.where(arr > 0, 2, arr)3.2 数学和统计方法
可以用np.mean(arr)计算数组所有数值的平均数，也可以调用方法arr.mean()计算，还可以在方法中加上可选参数axis，来计算数组在某个方向上的统计值：arr.mean(0)，arr.mean(1) 当然除了平均数可以这么用之外，求和sum，求标准差std都可以这么用
还有函数cumsum，是从第一个元素开始累积求和。
我们还可以把数学统计方法和布尔值表达式结合，比如我们要计算某个数组中所有正数的和：
(arr > 0).sum()3.3 排序
和python一样，在numpy中也是使用sort方法进行排序：
arr = np.random.randn(6)
arr.sort()而在多维数组中，还可以向sort()方法传递参数，判断是按照哪个轴进行排序
arr = np.random.randn(2,3)
arr.sort(1)3.4 其他集合逻辑
numpy中还有一些专门针对一维ndarray的操作，例如np.unique，会返回数组中的唯一值：
In [2]: names = np.array([3,3,2,2,1,4,5,])
In [3]: np.unique(names)
Out[3]: array([1, 2, 3, 4, 5])还有其他很多集合操作，详见书P115的表4-6
4. 线性代数
来看看numpy中的线性代数运算：
x = np.random.randn(2,3)
y = np.random.randn(3,3)
z = np.dot(x,y)np.dot(x,y)表示对x,y做点乘，也可以写成x.dot(y) 注意如果是x * y，做的是向量化运算（即每个元素相乘）
如果要做其他的线性代数运算，需要利用np.linalg函数集：
np.linalg.det(x) ## 计算矩阵的行列式
np.linalg.diag(x) ## 将方阵的对角元素作为一维数组返回
np.linalg.trace(x) ## 计算矩阵的迹
np.linalg.inv(x) ## 计算矩阵的逆矩阵5. 示例：随机漫步
import random
import matplotlib.pyplot as plt
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)
plt.plot(walk[:100])
plt.show()
这个是纯python风格的代码，如果想要进行大量计算，还是用numpy比较好：
import numpy as np
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()这里的np.where函数就比较有灵性，省掉了if判断语句，而且对于累计求和直接用cumsum函数代替
利用numpy我们可以同时模拟多次随机漫步：
import numpy as np
nsteps = 1000
nwalks = 5000
draws = np.random.randint(0, 2, size = (nwalks, nsteps))
steps = np.where(draws > 0, 1, -1)
walk = steps.cumsum(1)pandas入门
1.pandas数据结构
1.1 series
series类型与数组有些相似，每个数据都对应着一个索引值。
In [1]: import pandas as pd
In [2]: obj = pd.Series([4, 7, -5, 3])
In [3]: obj
Out[3]:
0 4
1 7
2 -5
3 3
dtype: int64对于Series对象，可以用value和index属性获得对象的值和索引。
除此之外，我们还可以自己定义索引值，并通过索引值直接访问对象。
In [4]: obj = pd.Series([4, 7, -5, 3], index = ['a', 'b', 'c', 'd'])
In [5]: obj.index
Out[5]: Index(['a', 'b', 'c', 'd'], dtype='object')
In [7]: obj['a']
Out[7]: 4可以使用Numpy风格的操作，比如利用布尔值数组进行过滤，或者进行向量化计算：
In [8]: obj[obj > 0]
Out[8]:
a 4
b 7
d 3
dtype: int64
In [9]: obj * 2
Out[9]:
a 8
b 14
c -10
d 6
dtype: int64
In [10]: import numpy as np
In [11]: np.exp(obj)
Out[11]:
a 54.598150
b 1096.633158
c 0.006738
d 20.085537
dtype: float64我们可以把Series看作是一种字典。因此如果已经在Python内置数据结构中生成了一个字典，可以利用该字典生成Series。
我们还可以设定好index数组的内容，并传入该字典中，使得字典的输出内容以我们输入的index为序。
In [12]: sdata = {'Ohio': 35000, 'Texas': 710000}
In [13]: obj2 = pd.Series(sdata)
In [14]: obj2
Out[14]:
Ohio 35000
Texas 710000
dtype: int64
In [15]: states = ['California', 'Ohio', 'Texas']
In [16]: obj3 = pd.Series(sdata, index = states)
In [17]: obj3
Out[17]:
California NaN
Ohio 35000.0
Texas 710000.0
dtype: float64此外我们还可以检验Series中是否存在缺失值，检验方法有两种：
- 利用
pandas中的isnull和notnull函数； - 利用
Series的isnull和notnull方法。
对Series之间的运算跟数据库的join操作有些类似，类似于full join。
Series自身和索引还有一个重要的属性：name，可以将这个属性理解为Series自己的名称：
In [18]: obj3.name = 'population'
In [21]: obj3.index.name = 'state'
In [22]: obj3
Out[22]:
state
California NaN
Ohio 35000.0
Texas 710000.0
Name: population, dtype: float641.2 DataFrame
dataframe数据类型有点像R里的数据框，它是已排序的列集合，可以被视作是一个共享共同索引的Series的字典。
创建dataframe的方法有很多，最常用的是利用包含等长列表或numpy数组的字典来形成dataframe，然后可以通过指定参数columns来按照指定顺序排列，并且用index把列的顺序传给dataframe，如果index中有某一列不包含在字典中，结果中会出现缺失值。
data = {
'state': ['a', 'b', 'c', 'd'],
'year': [1,2,3,4],
'pop': [1.5,1.7,1.8,2.0]
}
frame = pd.DataFrame(data, columns = ['year', 'state', 'pop'],/
index = ['one', 'two', 'three', 'four'])输出的dataframe是这样的：
另外一种创建dataframe的方法是利用包含字典的嵌套字典：
pop = {
'Nevada': {2001 : 2.4, 2002 : 2.9},
'Ohio': {2000 : 1.5, 2001 : 1.7, 2002 : 3.6}
}
frame2 = pd.DataFrame(pop)用这个方法创建dataframe时，列是字典的键，索引是内部字典的键。输出结果为：
在dataframe中，我们可以直接检索出某一列，检索方法有两种：
- 像字典一样检索
frame['year'] - 利用属性检索
frame.year
可以直接对列的值进行修改，但是注意修改时长度必须要匹配，否则会报错。
frame['pop'] = 16.5
frame['pop'] = np.arange(4.)此外还可以将一组Series的值赋给dataframe,且可以指定index值，未指定的index会填充缺失值。如果被赋值的列不存在时会创建新列。注意只有用检索方法才能创建新列，属性方法不能创建新列。
val = pd.Series([-1.2,-1.5,-1.7], index = ['two', 'four', 'five'])
frame.pop = val和series类似，dataframe也有name属性，比如我们可以分别给索引和列指定name：
frame2.index.name = 'year'
frame2.columns.name = 'state'而dataframe的values属性会将包含在dataframe中的数据以二维ndarray的形式返回。
从dataframe中选取的列是数据框的视图，不是数据框的拷贝，对选取列的修改会直接影响dataframe，如果需要复制则需要使用copy方法。
可以使用类似Numpy的方法对dataframe进行矩阵操作，如转置，此时会把列和索引进行调换。
frame2.T1.3 索引对象
在pandas中，索引也是作为一个对象存在的，可以将其看作是不可修改的数组，甚至可以对它进行切片。
obj = pd.Series(range(3), index = ['a', 'b', 'c'])
index = obj.index
index[1:]在pandas中创建索引对象的方法是用Index函数：
labels = pd.Index(np.arange(3))
obj2 = pd.Series(range(3), index = labels)有个需要注意的小点是，在pandas中，索引名可以重复。
2. 基本功能
2.1 重建索引
reindex方法可以将已经编制好的Series按照新的索引进行排列，当索引值之前不存在时，将会引入缺失值。
import pandas as pd
obj = pd.Series([4, 7, -2, 3], index = ['d', 'b', 'a', 'c'])
obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])reindex方法中还有一个method方法，它允许我们再重建索引时按照合适的方法对数据进行插补，如：使用ffill方法，将值前项填充
obj = pd.Series([4,5,6,1], index = [1, 4, 5, 7])
obj2 = obj.reindex(range(8), method = 'ffill')除了Series，reindex还可以对DataFrame使用：
比如我们先创建一个DataFrame
frame = pd.DataFrame(np.arange(9).reshape((3,3)),
index = ['a', 'c', 'd'],
columns = ['O', 'T', 'C'])然后可以分别改变DataFrame的行索引和列索引，如果只有一个参数时，默认重建行索引。
frame2 = frame.reindex(['a', 'b', 'c', 'd'])
frame.reindex(colunmns = ['T', 'U', 'C'])一种更为便捷的索引方式是使用loc方法：
frame.loc[['a','b','c','d'], ['T','U','C']]2.2 删除条目
使用drop方法可以删除某个轴向的一整条数据，它会返回一个新对象，如果加上inplace参数，则会清除被删除的数据。
例如在Series中
obj = pd.Series([4,5,6,1], index = [1, 4, 5, 7])
obj2 = obj.reindex(range(8), method = 'ffill')
obj2.drop(1, inplace = True)在DataFrame中同理，只不过优先删除行向上的数据，列向上的数据需要通过指定参数axis = 'columns'来完成。
2.3 索引、选择、过滤
在Series中进行索引与在Numpy数组中进行索引操作相似，只是Series可以同时使用数字（行号）和索引值进行索引，此外也可以用表达式进行索引。还有一个需要注意的问题是Series进行索引时是包含最后一项值的。
在DataFrame中，情况有所不同，
In [23]: data = pd.DataFrame(np.arange(16).reshape((4,4)),
...: index = ['O','C','U','N'],
...: columns = ['one','two','three','four'])
In [24]: data
Out[24]:
one two three four
O 0 1 2 3
C 4 5 6 7
U 8 9 10 11
N 12 13 14 15In [25]: data['two']
Out[25]:
O 1
C 5
U 9
N 13
Name: two, dtype: int64
In [26]: data[['four','one']]
Out[26]:
four one
O 3 0
C 7 4
U 11 8
N 15 12In [30]: data[:2]
Out[30]:
one two three four
O 0 1 2 3
C 4 5 6 7In [33]: data[data['three'] > 5]
Out[33]:
one two three four
C 4 5 6 7
U 8 9 10 11
N 12 13 14 15In [35]: data > 5
Out[35]:
one two three four
O False False False False
C False False True True
U True True True True
N True True True True
In [36]: data[data > 5] = 0
In [37]: data
Out[37]:
one two three four
O 0 1 2 3
C 4 5 0 0
U 0 0 0 0
N 0 0 0 0这里有点Numpy中数组操作的感觉。
再介绍两种索引方法：loc, iloc，其中loc可以使用轴标签进行索引，iloc可以使用整数标签进行索引。
data.loc['C', ['two', 'three']]
data.iloc[[1,2], [3,0,1]]甚至可以用这两种索引符号进行切片索引
data.loc[:'U', 'two']
data.iloc[:, :3][data.three > 5]2.4 算术和整数对齐
在pandas中，可以对不同索引的对象进行算术运算，如果存在索引值对不相同的情形，将会把两个对象取并集，即类似于数据库中out join
对于dataframe来说，如果行或列上存在不匹配，都会执行数据对齐操作（即分别取并集）。
取并集的结果就是会出现缺失值标记NaN，影响后续计算，比如我们希望缺失值可以被视作0看待，进行后面的计算，此时就行不通了。
那么接下来考虑一下如何对默认设置的缺失值进行填充。方法就是在某个dataframe上使用以下方法，并指定参数fill_value
方法 | 描述 |
add | + |
sub | - |
div | / |
floordiv | // |
mul | * |
pow | ** |
例如我们可以用
df1.add(df2, fill_value = 0)就是把df2中的缺失值标记为0
那如果是对dataframe和series之间进行运算会有什么结果？看一个例子：
frame = pd.DataFrame(np.arange(12.).reshape((4,3)),
columns = list("bde"),
index = ['U', 'O', 'T', 'I'])
series = frame.iloc[0]
print(frame - series)运算结果如下，dataframe的列会与series的索引进行匹配：
可以看到frame中的每一行都减去了series，这就是所谓广播机制。
注意两点：
- dataframe与series必须要匹配上，对于没有匹配上的会设置成
NaN - 默认情况是对行进行广播，如果想要对列进行广播，必须要使用算术方法，并且要指定参数
series2 = frame.iloc[:,1]
frame.sub(series2, axis = 'index')2.5 函数应用和映射
- 一般numpy中的函数对pandas对象也有效
- 可以将函数应用到某一行或一列的一维数组上，使用datafrmae中的
apply方法，默认是对列进行处理。如果需要对行进行处理，可以指定参数axis = 'columns'
def f(x):
return x.max() - x.min()
frame.apply(f)除了这么用之外，还可以返回一个series
def f2(x):
return pd.Series([x.min(), x.max()], index = ['min', 'max'])
frame.apply(f2)- 如果需要按元素使用函数，那么可以对dataframe用
applymap方法，而对于series，我们可以用map方法。
2.6 排序和排名
- 使用
sort_index方法可以对series或dataframe按照索引值进行排序，在dataframe中默认对index进行排序，如果需要对columns进行排序，需要额外指定参数frame.sort_index(axis = 1) - 一般默认按照升序排序，如果需要按照降序排序，需要额外指定参数
frame.sort_index(ascending = False) - 如果需要对series的值进行排序，使用
sort_values方法，默认会把缺失值放在尾部。 - 在对dataframe的值进行排序时，需要指定要排序的列，并且排序有先后顺序，
frame.sort_values(by = ['a', 'b'])
- 排名可以返回给定series中每个数据的相对大小，使用内置的
rank()方法实现，同时如果有相同值，会默认进行平均化 - 如果不希望进行平均化处理，加入参数
rank(method = 'first')，相同数字出现在前面的序号较低 - 默认从低到高进行排名，越大的值排名越高，也可以通过制定参数
ascending = False进行调整 - 也可以对dataframe进行排名，但需要指定是行还是列：
frame.rank(axis = 'columns')
3. 描述性统计
- pandas中可以对dataframe按照行或者列进行聚合计算，并且计算中缺失值是被默认忽略的，例如
frame.sum()，可以返回每一列的总和，frame.sum(axis = 'columns')可以返回每一行的和 - 可以直接求列的最大值或最小值，
frame.idxmax()或frame.idxmin() - 可以求累加和
frame.cumsum()，但是这里不会替代原本的缺失值 - 使用函数
frame.descirbe()可以自动返回每一列的很多有关统计量的值。 - 更多的操作方法见书籍P159的表5-8
3.1 相关性和协方差
- 计算两列之间的相关系数：
frame['O'].corr(frame['I]) - 计算两列之间的协方差：
frame['O'].cov(frame['I']) - 计算协方差矩阵：
frame.cov() - 计算相关系数矩阵：
frame.corr() - 采用
corrwith方法，可以计算一个dataframe中的每一列与传入的某个series的相关系数frame.corrwith(frame['I'])
3.2 其他方法
- 返回一组数据的不重复集合：
series.unique()，返回结果是数组。 - 对series的值进行计数：
series.value_counts()，也可以使用value_counts()函数，将值作为参数 - 计算某个数字是否属于series，并且返回对应的项：
mask = series.isin(['b','c'], series[mask]
数据载入、存储、文件格式
1.文本格式数据读写
利用pandas中的解析函数可以读入大部分格式的数据。例如利用read_csv读入CSV格式数据，其中以逗号作为默认分隔符，利用read_table读入以制表符为默认分隔符的文件，read_excel从excel的xls或xlsx中读取表格数据。
讨论几种情况：
- 用
read_table读入以逗号为分隔符的文件，需要修改参数sep，pd.read_table("filename", sep = ',')。如果分隔符是不同数量的空格，则需要使用正则表达式作为分隔符，pd.read_table("filename", sep = "\s+") - 如果原始文件不包含标题行，需要指定参数
header，`pd.read_csv(“filename”, header = None) - 如果原始文件不包含标题行，还可以通过参数
names自己指定，pd.read_csv("filename", names = [ ...] - 若文件中有一列为索引列，又缺少标题行，则需要先指定标题，然后确定索引列
names = ['a','b',message], pd.read_csv("filename", names = names, index_col = 'message') - 此外还可以指定两列为索引列，形成分层索引
1.1 分块读入文本文件
一种常见的情况是需要处理的文件是大文件，此时只需要读入文件中的一个小片段，或者按照片段遍历整个文件。
通常为了屏幕上能把一个观测的数据完整展现出来，设置pd.options.display.max_rows = 10。
想要读取部分文件，指定参数nrows =。
在分块读入数据时，通过指定参数chunksize，确定每一块的行数，此时会返回TextParser对象，能够根据chunksize遍历文件。
chunker = pd.read_csv("filename", chunksize = 1000)
tot = pd.Series([])
for piece in chunker:
tot = tot.add(piece['key'].value_counts(), fill_value = 0)
tot = tot.sort_values(ascending = False)1.2 将数据写入文本
现在看看如何导出数据。
对于dataframe数据，用to_csv方法即可导出：data.to_csv("filename") 这种输出方式的分隔符默认为逗号，可以控制用其他的分隔符进行代替，此外如果有缺失值，在文本中是默认用空格表示的，可以替换成其他标注方式。
import sys
data.to_csv(sys.stdout, sep = "|", na_rep = "NULL")
## sys.stdout的意思是直接观察控制台中打印的文本效果也可以指定不输出行、列标签信息，或者只输出某些列
data.to_csv(sys.stdout, index = False, header = False)
data.to_csv(sys.stdout, index = False, columns = ['a', 'b', 'c'])1.3 使用分隔格式
一般来说观测都是按行记录的，如果碰到按列记录的情况该怎么处理？例如
a | b |
1 | 2 |
1 | 3 |
如果一个文件中只有单字符分隔符，可以使用Python内建的csv版块
with open("examples/ex7.csv") as f:
lines = list(csv.reader(f))然后提取出标题行和数据行
header, values = lines[0], lines[1:]然后就可以生成一个包含观测的字典了：
data_dict = {h : v for h, v in zip(header, zip(*values))}其中zip(*values)表示对values的解压
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 与 zip 相反，可理解为解压，为zip的逆过程，可用于矩阵的转置
[(1, 2, 3), (4, 5, 6)]2.其他格式
2.1 读取Excel文件
frame = pd.read_excel("filenmae", "sheet1")如果需要将数据写入excel，则需要先生成一个ExcelWriter，然后利用对象的to_excel方法写入数据。
writer = pd.ExcelWriter("filename")
frame.to_excel(writer, "sheet1")或者直接写成
frame.to_excel("filename")数据清洗与准备
1. 缺失值
1.1 过滤缺失值
在pandas中，为了返回一个series中所有的非空数据及其索引，可以使用dropna方法。
data = pd.Series([1, NA, 3.5, NA, 7])
data.dropna()但是在dataframe中就相对比较麻烦，因为对于dataframe，默认删除含有缺失值的所有行。如果只想删掉全部数据都是NA的行，需要添加参数how，如果需要删除全部数据都是NA的列，需要添加参数axis
data.dropna(how = "all")
data.dropna(how = 'all', axis = 1)我们还可以再个性化一点，例如设置如果缺失值大于等于2，就删除该条观测，通过指定thresh参数：
data.dropna(thresh = 2)1.2 缺失值填补
通过调用fillna()方法补全缺失值，可以指定一个常数来填补缺失值，再个性化一点，可以对不同的列指定不同的填补常数（参数为字典），当然最常用的方法是利用均值进行填补
df.fillna(0)
df.fillna({1 : 0.5, 2 : 0})
data = pd.Series([1., NA, 3.5, NA, 7])
data.fillna(data.mean())通过fillna方法，返回一个新的对象，如果想要对原始数据进行修改，可以添加inplace = True参数。
2. 数据转换
2.1 删除重复值
在dataframe中，可以用duplicated方法返回一个布尔型series，可以说明dataframe中每一行之间是否存在重复。而用drop_duplicates可以删掉重复的观测。
当然也可以不检测所有的列是否存在重复，可以单独指定某个列，这样只会保留该列中的不重复观测frame.drop_duplicates(['k1']) 判断和删除重复值时，默认保留第一个观测的值，如果要保留最后的值，可以传入参数keep = 'last'。
2.2 使用函数或映射进行数据转换
series的map方法接收一个函数或一个包含映射关系的字典型对象，从而可以进行键值对匹配。
例如dataframe中储存量一些肉和它们的重量，现在要增加一列：每种肉的类型，因此需要新建一列data['animal']
data['animal'] = data['food'].map(meat_to_animal)2.3 替代值
data.replace({-999 : np.nan, -1000 : 0})这样就可以把series中的-999替换成缺失值，-1000替换成0.
2.4 重命名轴索引
假设我们想把dataframe的index都变成大写字母，有以下两种方法：
- 使用map方法
- 使用rename方法
data = pd.DataFrame(np.arange(12).reshape(3,4),
index = ['Ohio', 'Colorado', 'Newyork'],
columns = ['one', 'two', 'three', 'four']
transform = lambda x : x[:4].upper()
# 使用map方法
data.index = data.index.map(transform)
# 使用rename方法
data.rename(index = str.upper)此外还可以通过rename方法单独对某个index或columns进行重命名，只需在参数里传入一个字典就可以了：
data.rename(index = {'Ohio' : 'INDIANA'},
columns = {'three' : 'peekaboo'})如果想要对原数据集进行修改，参数中传入inplace = True。
2.5 离散化和分组
假如有一组关于年龄的数据ages，需要把这组数据按照年龄段进行划分，则需要用到cut函数，第一个参数是原始数据，第二个参数是需要分组的节点。
bins = [18, 25, 35, 60, 100]
cats = pd.cut(ages, bins)这个函数返回的对象，是原始数组ages中每个数据对应的组，可以通过cats.codes查看每个数据的组别，通过cats.categories查看一共有几个组，pd.value_counts(cats)查看每一组中元素的个数。
