强大的Python库之Pandas

1 简介和使用场景

Python Data Analysis Library 或 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素之一。

2 Pandas的诞生时间和作用

Pandas   是python的一个数据分析包，最初由AQR Capital Management于2008年4月开发，并于2009年底开源出来，目前由专注于Python数据包开发的PyData开发team继续开发和维护，属于PyData项目的一部分。Pandas最初被作为金融数据分析工具而开发出来，因此，pandas为时间序列分析提供了很好的支持。 Pandas的名称来自于面板数据（panel data）和python数据分析（data analysis）。panel data是经济学中关于多维数据集的一个术语，在Pandas中也提供了panel的数据类型。

3 Pandas数据类型

Series [ˈsɪəri:z] ：一维数组，与Numpy中的一维array类似。二者与Python基本的数据结构List也很相近，其区别是：List中的元素可以是不同的数据类型，而Array和Series中则只允许存储相同的数据类型，这样可以更有效的使用内存，提高运算效率。

Time- Series：以时间为索引的Series。

DataFrame：二维的表格型数据结构。很多功能与R中的data.frame类似。可以将DataFrame理解为Series的容器。以下的内容主要以DataFrame为主。

Panel ：三维的数组，可以理解为DataFrame的容器。

 

官网：http://pandas.pydata.org/

4 Pandas和matplotlib、sqlalchemy的安装

安装pandas输入：sudo pip3 install pandas

安装matplotlib输入：sudo pip3 install matplotlib

安装sqlalchemy输入：sudo pip3 install sqlalchemy

 

5 干货开始

pandas 是基于 Numpy 构建的含有更高级数据结构和工具的数据分析包

类似于 Numpy 的核心是 ndarray，pandas 也是围绕着 Series 和 DataFrame 两个核心数据结构展开的 。Series 和 DataFrame 分别对应于一维的序列和二维的表结构。pandas 约定俗成的导入方法如下：

1. from pandas import Series,DataFrame

2. import pandas as pd

Series

---

Series 可以看做一个定长的有序字典。基本任意的一维数据都可以用来构造 Series 对象：

1. >>> s = Series([1,2,3.0,'abc'])

2. >>> s

3. 0 1

4. 1 2

5. 2 3

6. 3 abc

7. dtype: object

虽然 dtype:object 可以包含多种基本数据类型，但总感觉会影响性能的样子，最好还是保持单纯的 dtype。

Series 对象包含两个主要的属性：index 和 values，分别为上例中左右两列。因为传给构造器的是一个列表，所以 index 的值是从 0 起递增的整数，如果传入的是一个类字典的键值对结构，就会生成 index-value 对应的 Series；或者在初始化的时候以关键字参数显式指定一个 index 对象：

1. >>> s = Series(data=[1,3,5,7],index = ['a','b','x','y'])

2. >>> s

3. a 1

4. b 3

5. x 5

6. y 7

7. dtype: int64

8. >>> s.index

9. Index(['a', 'b', 'x', 'y'], dtype='object')

10. >>> s.values

11. array([1, 3, 5, 7], dtype=int64)

Series 对象的元素会严格依照给出的 index 构建，这意味着：如果 data 参数是有键值对的，那么只有 index 中含有的键会被使用；以及如果 data 中缺少响应的键，即使给出 NaN 值，这个键也会被添加。

注意 Series 的 index 和 values 的元素之间虽然存在对应关系，但这与字典的映射不同。index 和 values 实际仍为互相独立的 ndarray 数组，因此 Series 对象的性能完全 ok。

Series 这种使用键值对的数据结构最大的好处在于，Series 间进行算术运算时，index 会自动对齐。

另外，Series 对象和它的 index 都含有一个 name 属性：

1. >>> s.name = 'a_series'

2. >>> s.index.name = 'the_index'

3. >>> s

4. the_index

5. a 1

6. b 3

7. x 5

8. y 7

9. Name: a_series, dtype: int64

DataFrame

---

DataFrame 是一个表格型的数据结构，它含有一组有序的列（类似于 index），每列可以是不同的值类型（不像 ndarray 只能有一个 dtype）。基本上可以把 DataFrame 看成是共享同一个 index 的 Series 的集合。

DataFrame 的构造方法与 Series 类似，只不过可以同时接受多条一维数据源，每一条都会成为单独的一列：

1. >>> data = {'state':['Ohino','Ohino','Ohino','Nevada','Nevada'],

2. 'year':[2000,2001,2002,2001,2002],

3. 'pop':[1.5,1.7,3.6,2.4,2.9]}

4. >>> df = DataFrame(data)

5. >>> df

6. pop state year

7. 0 1.5 Ohino 2000

8. 1 1.7 Ohino 2001

9. 2 3.6 Ohino 2002

10. 3 2.4 Nevada 2001

11. 4 2.9 Nevada 2002

12.  

13. [5 rows x 3 columns]

虽然参数 data 看起来是个字典，但字典的键并非充当 DataFrame 的 index 的角色，而是 Series 的 “name” 属性。这里生成的 index 仍是 “01234”。

较完整的 DataFrame 构造器参数为：DataFrame(data=None,index=None,coloumns=None)，columns 即 “name”：

1. >>> df = DataFrame(data,index=['one','two','three','four','five'],

2. columns=['year','state','pop','debt'])

3. >>> df

4. year state pop debt

5. one 2000 Ohino 1.5 NaN

6. two 2001 Ohino 1.7 NaN

7. three 2002 Ohino 3.6 NaN

8. four 2001 Nevada 2.4 NaN

9. five 2002 Nevada 2.9 NaN

10.  

11. [5 rows x 4 columns]

同样缺失值由 NaN 补上。看一下 index、columns 和 索引的类型：

1. >>> df.index

2. Index(['one', 'two', 'three', 'four', 'five'], dtype='object')

3. >>> df.columns

4. Index(['year', 'state', 'pop', 'debt'], dtype='object')

5. >>> type(df['debt'])

6. <class 'pandas.core.series.Series'>

DataFrame 面向行和面向列的操作基本是平衡的，任意抽出一列都是 Series。

对象属性

---

重新索引

Series 对象的重新索引通过其 .reindex(index=None,**kwargs) 方法实现。**kwargs 中常用的参数有俩：method=None,fill_value=np.NaN：

1. ser = Series([4.5,7.2,-5.3,3.6],index=['d','b','a','c'])

2. >>> a = ['a','b','c','d','e']

3. >>> ser.reindex(a)

4. a -5.3

5. b 7.2

6. c 3.6

7. d 4.5

8. e NaN

9. dtype: float64

10. >>> ser.reindex(a,fill_value=0)

11. a -5.3

12. b 7.2

13. c 3.6

14. d 4.5

15. e 0.0

16. dtype: float64

17. >>> ser.reindex(a,method='ffill')

18. a -5.3

19. b 7.2

20. c 3.6

21. d 4.5

22. e 4.5

23. dtype: float64

24. >>> ser.reindex(a,fill_value=0,method='ffill')

25. a -5.3

26. b 7.2

27. c 3.6

28. d 4.5

29. e 4.5

30. dtype: float64

1. In [1]: from pandas import Series

2. ...: ser3 = Series(['USA','Mexico','Canada'],index = [0,5,10])

3. ...: ranger = range(15)

4. ...: ser3.reindex(ranger,method = 'ffill')

5. ...:

6. Out[1]:

7. 0 USA

8. 1 USA

9. 2 USA

10. 3 USA

11. 4 USA

12. 5 Mexico

13. 6 Mexico

14. 7 Mexico

15. 8 Mexico

16. 9 Mexico

17. 10 Canada

18. 11 Canada

19. 12 Canada

20. 13 Canada

21. 14 Canada

22. dtype: object

.reindex() 方法会返回一个新对象，其 index 严格遵循给出的参数，method:{'backfill', 'bfill', 'pad', 'ffill', None} 参数用于指定插值（填充）方式，当没有给出时，自动用fill_value 填充，默认为 NaN（ffill = pad，bfill = back fill，分别指插值时向前还是向后取值）

DataFrame 对象的重新索引方法为：.reindex(index=None,columns=None,**kwargs)。仅比 Series 多了一个可选的 columns 参数，用于给列索引。用法与上例类似，只不过插值方法method 参数只能应用于行，即轴 0。

1. >>> state = ['Texas','Utha','California']

2. >>> df.reindex(columns=state,method='ffill')

3. Texas Utha California

4. a 1 NaN 2

5. c 4 NaN 5

6. d 7 NaN 8

7.  

8. [3 rows x 3 columns]

9. >>> df.reindex(index=['a','b','c','d'],columns=state,method='ffill')

10. Texas Utha California

11. a 1 NaN 2

12. b 1 NaN 2

13. c 4 NaN 5

14. d 7 NaN 8

15.  

16. [4 rows x 3 columns]

不过 fill_value 依然对有效。聪明的小伙伴可能已经想到了，可不可以通过df.T.reindex(index,method='**').T 这样的方式来实现在列上的插值呢，答案是可行的。另外要注意，使用 reindex(index,method='**') 的时候，index 必须是单调的，否则就会引发一个ValueError: Must be monotonic for forward fill，比如上例中的最后一次调用，如果使用index=['a','b','d','c'] 的话就不行。

删除指定轴上的项

即删除 Series 的元素或 DataFrame 的某一行（列）的意思，通过对象的 .drop(labels, axis=0) 方法：

1. >>> ser

2. d 4.5

3. b 7.2

4. a -5.3

5. c 3.6

6. dtype: float64

7. >>> df

8. Ohio Texas California

9. a 0 1 2

10. c 3 4 5

11. d 6 7 8

12.  

13. [3 rows x 3 columns]

14. >>> ser.drop('c')

15. d 4.5

16. b 7.2

17. a -5.3

18. dtype: float64

19. >>> df.drop('a')

20. Ohio Texas California

21. c 3 4 5

22. d 6 7 8

23.  

24. [2 rows x 3 columns]

25. >>> df.drop(['Ohio','Texas'],axis=1)

26. California

27. a 2

28. c 5

29. d 8

30.  

31. [3 rows x 1 columns]

.drop() 返回的是一个新对象，元对象不会被改变。

索引和切片

就像 Numpy，pandas 也支持通过 obj[::] 的方式进行索引和切片，以及通过布尔型数组进行过滤。

不过须要注意，因为 pandas 对象的 index 不限于整数，所以当使用非整数作为切片索引时，它是末端包含的。

1. >>> foo

2. a 4.5

3. b 7.2

4. c -5.3

5. d 3.6

6. dtype: float64

7. >>> bar

8. 0 4.5

9. 1 7.2

10. 2 -5.3

11. 3 3.6

12. dtype: float64

13. >>> foo[:2]

14. a 4.5

15. b 7.2

16. dtype: float64

17. >>> bar[:2]

18. 0 4.5

19. 1 7.2

20. dtype: float64

21. >>> foo[:'c']

22. a 4.5

23. b 7.2

24. c -5.3

25. dtype: float64

这里 foo 和 bar 只有 index 不同——bar 的 index 是整数序列。可见当使用整数索引切片时，结果与 Python 列表或 Numpy 的默认状况相同；换成 'c' 这样的字符串索引时，结果就包含了这个边界元素。

另外一个特别之处在于 DataFrame 对象的索引方式，因为他有两个轴向（双重索引）。

可以这么理解：DataFrame 对象的标准切片语法为：.ix[::,::]。ix 对象可以接受两套切片，分别为行（axis=0）和列（axis=1）的方向：

1. >>> df

2. Ohio Texas California

3. a 0 1 2

4. c 3 4 5

5. d 6 7 8

6.  

7. [3 rows x 3 columns]

8. >>> df.ix[:2,:2]

9. Ohio Texas

10. a 0 1

11. c 3 4

12.  

13. [2 rows x 2 columns]

14. >>> df.ix['a','Ohio']

15. 0

而不使用 ix ，直接切的情况就特殊了：

• 索引时，选取的是列
• 切片时，选取的是行

这看起来有点不合逻辑，但作者解释说 “这种语法设定来源于实践”，我们信他。

1. >>> df['Ohio']

2. a 0

3. c 3

4. d 6

5. Name: Ohio, dtype: int32

6. >>> df[:'c']

7. Ohio Texas California

8. a 0 1 2

9. c 3 4 5

10.  

11. [2 rows x 3 columns]

12. >>> df[:2]

13. Ohio Texas California

14. a 0 1 2

15. c 3 4 5

16.  

17. [2 rows x 3 columns]

使用布尔型数组的情况，注意行与列的不同切法（列切法的 : 不能省）：

1. >>> df['Texas']>=4

2. a False

3. c True

4. d True

5. Name: Texas, dtype: bool

6. >>> df[df['Texas']>=4]

7. Ohio Texas California

8. c 3 4 5

9. d 6 7 8

10.  

11. [2 rows x 3 columns]

12. >>> df.ix[:,df.ix['c']>=4]

13. Texas California

14. a 1 2

15. c 4 5

16. d 7 8

17.  

18. [3 rows x 2 columns]

[python] view plain copy

1. import numpy as np  
2. import pandas as pd  
3. df = pd.DataFrame(np.arange(0,60,2).reshape(10,3),columns=list('abc'))  

df 是这样子滴

那么这三种选取数据的方式该怎么选择呢？

一、当每列已有column name时，用 df [ 'a' ] 就能选取出一整列数据。如果你知道column names 和index，且两者都很好输入，可以选择 .loc

[python] view plain copy

1. df.loc[0, 'a']  
2. df.loc[0:3, ['a', 'b']]  
3. df.loc[[1, 5], ['b', 'c']]  

由于这边我们没有命名index，所以是DataFrame自动赋予的，为数字0-9

二、如果我们嫌column name太长了，输入不方便，有或者index是一列时间序列，更不好输入，那就可以选择 .iloc了。这边的 i 我觉得代表index，比较好记点。

[python] view plain copy

1. df.iloc[1,1]  
2. df.iloc[0:3, [0,1]]  
3. df.iloc[[0, 3, 5], 0:2]  

iloc 使得我们可以对column使用slice（切片）的方法对数据进行选取。

算术运算和数据对齐

pandas 最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，结果的索引取索引对的并集。自动的数据对齐在不重叠的索引处引入空值，默认为 NaN。

1. >>> foo = Series({'a':1,'b':2})

2. >>> foo

3. a 1

4. b 2

5. dtype: int64

6. >>> bar = Series({'b':3,'d':4})

7. >>> bar

8. b 3

9. d 4

10. dtype: int64

11. >>> foo + bar

12. a NaN

13. b 5

14. d NaN

15. dtype: float64

DataFrame 的对齐操作会同时发生在行和列上。

当不希望在运算结果中出现 NA 值时，可以使用前面 reindex 中提到过 fill_value 参数，不过为了传递这个参数，就需要使用对象的方法，而不是操作符：df1.add(df2,fill_value=0)。其他算术方法还有：sub(), div(), mul()。

Series 和 DataFrame 之间的算术运算涉及广播，暂时先不讲。

函数应用和映射

Numpy 的 ufuncs（元素级数组方法）也可用于操作 pandas 对象。

当希望将函数应用到 DataFrame 对象的某一行或列时，可以使用 .apply(func, axis=0, args=(), **kwds) 方法。

1. f = lambda x:x.max()-x.min()

2. >>> df

3. Ohio Texas California

4. a 0 1 2

5. c 3 4 5

6. d 6 7 8

7.  

8. [3 rows x 3 columns]

9. >>> df.apply(f)

10. Ohio 6

11. Texas 6

12. California 6

13. dtype: int64

14. >>> df.apply(f,axis=1)

15. a 2

16. c 2

17. d 2

18. dtype: int64

排序和排名

Series 的 sort_index(ascending=True) 方法可以对 index 进行排序操作，ascending 参数用于控制升序或降序，默认为升序。

若要按值对 Series 进行排序，当使用 .order() 方法，任何缺失值默认都会被放到 Series 的末尾。

在 DataFrame 上，.sort_index(axis=0, by=None, ascending=True) 方法多了一个轴向的选择参数与一个 by 参数，by 参数的作用是针对某一（些）列进行排序（不能对行使用 by 参数）：

1. >>> df.sort_index(by='Ohio')

2. Ohio Texas California

3. a 0 1 2

4. c 3 4 5

5. d 6 7 8

6.  

7. [3 rows x 3 columns]

8. >>> df.sort_index(by=['California','Texas'])

9. Ohio Texas California

10. a 0 1 2

11. c 3 4 5

12. d 6 7 8

13.  

14. [3 rows x 3 columns]

15. >>> df.sort_index(axis=1)

16. California Ohio Texas

17. a 2 0 1

18. c 5 3 4

19. d 8 6 7

20.  

21. [3 rows x 3 columns]

排名（Series.rank(method='average', ascending=True)）的作用与排序的不同之处在于，他会把对象的 values 替换成名次（从 1 到 n）。这时唯一的问题在于如何处理平级项，方法里的method 参数就是起这个作用的，他有四个值可选：average, min, max, first。

1. >>> ser=Series([3,2,0,3],index=list('abcd'))

2. >>> ser

3. a 3

4. b 2

5. c 0

6. d 3

7. dtype: int64

8. >>> ser.rank()

9. a 3.5

10. b 2.0

11. c 1.0

12. d 3.5

13. dtype: float64

14. >>> ser.rank(method='min')

15. a 3

16. b 2

17. c 1

18. d 3

19. dtype: float64

20. >>> ser.rank(method='max')

21. a 4

22. b 2

23. c 1

24. d 4

25. dtype: float64

26. >>> ser.rank(method='first')

27. a 3

28. b 2

29. c 1

30. d 4

31. dtype: float64

注意在 ser[0]=ser[3] 这对平级项上，不同 method 参数表现出的不同名次。

DataFrame 的 .rank(axis=0, method='average', ascending=True) 方法多了个 axis 参数，可选择按行或列分别进行排名，暂时好像没有针对全部元素的排名方法。

统计方法

pandas 对象有一些统计方法。它们大部分都属于约简和汇总统计，用于从 Series 中提取单个值，或从 DataFrame 的行或列中提取一个 Series。

比如 DataFrame.mean(axis=0,skipna=True) 方法，当数据集中存在 NA 值时，这些值会被简单跳过，除非整个切片（行或列）全是 NA，如果不想这样，则可以通过 skipna=False 来禁用此功能：

1. >>> df

2. one two

3. a 1.40 NaN

4. b 7.10 -4.5

5. c NaN NaN

6. d 0.75 -1.3

7.  

8. [4 rows x 2 columns]

9. >>> df.mean()

10. one 3.083333

11. two -2.900000

12. dtype: float64

13. >>> df.mean(axis=1)

14. a 1.400

15. b 1.300

16. c NaN

17. d -0.275

18. dtype: float64

19. >>> df.mean(axis=1,skipna=False)

20. a NaN

21. b 1.300

22. c NaN

23. d -0.275

24. dtype: float64

其他常用的统计方法有：

########################	******************************************
count	非 NA 值的数量
describe	针对 Series 或 DF 的列计算汇总统计
min , max	最小值和最大值
argmin , argmax	最小值和最大值的索引位置（整数）
idxmin , idxmax	最小值和最大值的索引值
quantile	样本分位数（0 到 1）
sum	求和
mean	均值
median	中位数
mad	根据均值计算平均绝对离差
var	方差
std	标准差
skew	样本值的偏度（三阶矩）
kurt	样本值的峰度（四阶矩）
cumsum	样本值的累计和
cummin , cummax	样本值的累计最大值和累计最小值
cumprod	样本值的累计积
diff	计算一阶差分（对时间序列很有用）
pct_change	计算百分数变化

处理缺失数据

---

pandas 中 NA 的主要表现为 np.nan，另外 Python 内建的 None 也会被当做 NA 处理。

处理 NA 的方法有四种：dropna , fillna , isnull , notnull 。

is(not)null

这一对方法对对象做元素级应用，然后返回一个布尔型数组，一般可用于布尔型索引。

dropna

对于一个 Series，dropna 返回一个仅含非空数据和索引值的 Series。

问题在于对 DataFrame 的处理方式，因为一旦 drop 的话，至少要丢掉一行（列）。这里的解决方式与前面类似，还是通过一个额外的参数：dropna(axis=0, how='any', thresh=None) ，how 参数可选的值为 any 或者 all。all 仅在切片元素全为 NA 时才抛弃该行(列)。另外一个有趣的参数是 thresh，该参数的类型为整数，它的作用是，比如 thresh=3，会在一行中至少有 3 个非 NA 值时将其保留。

fillna

fillna(value=None, method=None, axis=0) 中的 value 参数除了基本类型外，还可以使用字典，这样可以实现对不同的列填充不同的值。method 的用法与前面 .reindex() 方法相同，这里不再赘述。

inplace 参数

---

前面有个点一直没讲，结果整篇示例写下来发现还挺重要的。就是 Series 和 DataFrame 对象的方法中，凡是会对数组作出修改并返回一个新数组的，往往都有一个 replace=False 的可选参数。如果手动设定为 True，那么原数组就可以被替换。

2.4 dataframe类型转换-----------------------------------------------------------------------
df.astype(int)

2.5 dataframe和Series的数据结构构建--------------------------------------------------------------

只规定一维的话，默认将每个维度看作一column，可以在index对另一个维度的索引进行规定(当然如果对column排序有要求，也可以按照column进行重排序reindex操作)
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
'year': [2000, 2001, 2002, 2001, 2002],
'pop': [1.5, 1.7, 3.6, NaN, 2.9]}
frame = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
index=['one', 'two', 'three', 'four', 'five'])
请注意这种创建方法，字典的key值一定是frame的列索引column index

如果是二维字典的话，那么将最外层的规定为columnID，内层的为rowID
data = {'state': {1:'Ohio', 2:'Ohio', 3:'Ohio', 4:'Nevada', 5:'Nevada'},
'year': {1:2000, 2:2001, 3:2002, 4:2001, 5:2002},
'pop': {1:1.5, 2:1.7, 3:3.6, 4:2.4, 5:2.9}}
frame = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
index=['one', 'two', 'three', 'four', 'five'])
外层字典的键是列索引，内层键是row索引

如果一维都不规定，那么则将data看作np.array对象,而在index和columns函数中对rowID和columns分别进行规定
 

dataframe和Series的归根的结构特征
pd.Series({'a':2,'b':1,'c':3,'d':54,'e':3})
pd.Series([2,1,3,54,3],index=['a','b','c','d','e'])
dataframe(Series(),index=[],columns=[])

除却值外
dataframe有两个维度
Series只有一个维度

2.6 dataframe索引index------------------------------------------
几种index索引种类
Index
Int64Index
MultiIndex
DatatimeIndex
PeriodIndex

df.columns和df.index 都是一种索引

reindex重索引
df.reindex(['e','d','c','b','a']) #按照这个索引进行重新排序
df.reindex(['e','d','c','b','a'],method='ffill') #没有这个索引的，自动根据前个索引的值进行填充
df.reindex(['e','d','c','b','a'],fill_value=0) #没有这个索引的，自动赋值为0
 

2.7  dataframe函数操作---------------------------------------------
元组能够操作的函数，在dataframe里一样能够操作
f=lambda x:x.max()-x.min()
df.apply(f)
f=lambda x:'%.2f' %x
df.apply(f)

排序操作-------------------------------------

dataframe可以按照index和columns两种索引对dataframe进行排序
sort_index()按照索引排序
df.sort_index() #按照rowID进行排序，默认升序
df.sore_index(axis=1,ascending=False) #按照columnID进行排序，设定为降序


order()按照值排序
dataframe的按值排序，其实是按照某列，或者联合多列中的大小值给所有的row排序
也就是说以某个列的值，代表各个row之间的值进行排序
df.order(by=['a'])
df.order(by=['a','b'])

rank排序
df.rank() 默认在各个column里面进行排序
df.rank(axis=1)默认在各个row里面进行排序

汇总操作-------------------------------------
df
    one  two
a   1.4  NaN
b   7.1  -4.5
c   NaN  NaN
d   0.74 -1.3
df.sum()按照列进行加和，计算各个column的和
df.sum(axis=1) #跟matlab和Octave一样
df.mean() #和sum一样原理
df.idxmax() 会返回各个列索引内最大的值  
output:  one  b
         two  d
df.idxmin() 会返回各个列索引内最小的值
output:  a  
         two  d

 

相关系数操作-------------------------------------
两个series协方差
s1.corr(s2)相关系数
s1.cov(s2)协方差

dataframe的协方差和相关系数，计算的就是两个或多个column之间的相关参数
df.corr()协方差
df.cov()相关系数
df.corr(df['a'])计算所有列和某个列的相关系数


唯一性操作-------------------------------------
s1.unique()
pd.value_count(s1,sort=False) #进行map-reduce运算
df.apply(pd.value_counts,fillna(0)) #也是对各个列进行操作，然后没有出现的key的次数赋值为0



2.8  dataframe和series的对齐操作align-----------------------------------------------

dataframe之间加和对齐
是二维的操作，在row和col上都有对齐操作，没有重叠的项都为NaN

series之间的加和对齐
是一维的操作，对于菲重叠的index项，也赋值为NaN

dataframe和series的加和操作
s=pd.DataFrame(np.arange(9).reshape(3,3),index=['New York','beijing', 'Tian Jin'],columns=['b','d','e'] )
series2=pd.Series(range(3),index=['b','e','f'])
因为dataframe是二维的，而Series是一维的对象，那么二维和一维操作如何运算呢？
我们默认将Series看作一个row行对象，然后dataframe有多少个行，那么我们就复制多少个值为Series的row对象，然后跟dataframe进行相减运算。
没有重叠的列column的时候，就按NaN处置。

3 清理数据-------------------------------------------------------------------
df[df.isnull()]
df[df.notnull()]
df.dropna()将所有含有nan项的row删除
df.dropna(axis=1,thresh=3) 将在列的方向上三个为NaN的项删除
df.dropna(how='ALL')将全部项都是nan的row删除
填充值
df.fillna(0)
df.fillna({1:0,2:0.5}) 对第一列nan值赋0，第二列赋值0.5
df.fillna(method='ffill') 在列方向上以前一个值作为值赋给NaN


4 一些定式发现-------------------------------------------------------------------------------------------
默认是以column为单位进行操作
比如pd.dataframe(data)   pd.dataframe(dict)
比如df.rank()
比如pd.sort_index()
比如df.sum()
都需要设定axis=1或者指定index才能够进行亚row级别的操作
也就是说我们认知的时候，先认知的是column字段，然后是各个row

两级访问元素
s['a',2]
s[:,2]
df=s.unstack()
s=df.stack()

来源：https://sanwen8.cn/p/2241oUa.html

shift函数是对数据进行移动的操作，假如现在有一个DataFrame数据df，如下所示：

index	value1
A	0
B	1
C	2
D	3

那么如果执行以下代码：

df.shift()

就会变成如下：

index	value1
A	NaN
B	0
C	1
D	2

看一下函数原型：

DataFrame.shift(periods=1, freq=None, axis=0)

参数

• periods：类型为int，表示移动的幅度，可以是正数，也可以是负数，默认值是1,1就表示移动一次，注意这里移动的都是数据，而索引是不移动的，移动之后没有对应值的，就赋值为NaN。
  执行以下代码：

df.shift(2)

就会得到：

index	value1
A	NaN
B	NaN
C	0
D	1

执行：

df.shift(-1)

会得到：

index	value1
A	1
B	2
C	3
D	NaN

• freq： DateOffset, timedelta, or time rule string，可选参数，默认值为None，只适用于时间序列，如果这个参数存在，那么会按照参数值移动时间索引，而数据值没有发生变化。例如现在有df1如下：

index	value1
2016-06-01	0
2016-06-02	1
2016-06-03	2
2016-06-04	3

执行：

df1.shift(periods=1,freq=datetime.timedelta(1))

会得到：

index | value1
—-|—-
2016-06-02 | 0
2016-06-03 | 1
2016-06-04 | 2
2016-06-05 | 3

• axis：{0, 1, ‘index’, ‘columns’}，表示移动的方向，如果是0或者’index’表示上下移动，如果是1或者’columns’，则会左右移动。

http://www.cnblogs.com/big-face/p/5418416.html

1 import pandas as pd, numpy as np
2 dates = pd.date_range('20130101', periods=6)
3 df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))

1 mutate + ifelse

1 df['E'] = np.where(df['D'] >= 0, '>=0', '<0')
2 df['F'] = np.random.randint(0, 2, 6)
3 df.assign(G = df.A * df.D) # 或者
4 df['F'] = df['F'].apply(str) #针对单列的
5 df.applymap(str) #这个相当于是mutate_each

2 table

1 pd.value_counts(df["E"])
2 pd.pivot_table(df,index=['E','F'])

3 index 也就是取df的rownames，但与R不一样的在于，df可能有多维rownames

1 df.index
2 df.set_index(['A'], drop = 0, append = 1) # 把已有的列设置为index，可保留之前的index，也可以把新的index在原数据中删除
3 df['dates'] = df.index # 新生成一列dates
4 df.reset_index(level=0, inplace=True) # 同上
5 df.reset_index(level=['index']) # 同上

4 删除列和行

1 df = df.drop('index', axis = 1) # 可以删除多列
2 df.drop(df.index[[1,3]])

5 column names

1 df.columns
2 df.columns = ['a', 'b', 'c', 'e', 'd', 'f'] # 重命名
3 df.rename(columns = {'A':'aa','B':'bb', 'C':'cc', 'D':'dd', 'E':'ee', 'F':'ff'}, inplace=True)
4 df.rename(columns=lambda x: x[1:].upper(), inplace=True) # 也可以用函数 inplace参数的意思就是代替原来的变量，深拷贝

6 哑变量 dummy variables

1 pd.Series(['a|b', np.nan, 'a|c']).str.get_dummies()

7 纯粹的df的矩阵，即不包含column和index

1 df.values
2 df.get_values()

8 summary

1 df.describe() # 只会针对数值型变量做计算

9 rbind

1 df2=pd.DataFrame([[5,6],[7,8]],columns=list('AB'))
2 df.append(df2, ignore_index=True)

10 group by 分组汇总计算，和pivot_table类似

1 df.groupby(['E','F']).mean()
2 df.groupby(['E','F']).agg(['sum', 'mean'])
3 pd.pivot_table(df,index=['E','F'], aggfunc=[np.sum, np.mean])
4 df.pivot_table(index=['E','F'], aggfunc=[np.sum, np.mean]) # 同上
5 df.groupby(['E','F']).agg({'A':['mean','sum'], 'B':'min'}) # groupby 也可以这样写

11 排序

1 df.sort(['A','B'],ascending=[1,0]) # 按列排序，na_position控制NAN的位置
2 df.sort_index(ascending=0) # 按index排序

12 筛选

1 df[(df.A >= -1) & (df.B <= 0)] # 值筛选
2 df[df.E.str.contains(">")] # 包含某个字符，contains筛选的其实是正则表达式
3 df[df.F.isin(['1'])] # 在列表内

13 变量选择

1 df['A'] # 单个的列
2 df[0:3] # 行
3 df['20130102':'20130104'] # 按index筛选
4 df.loc[:,] # 类似于R里面的dataframe选行和列的方法
5 df.iloc[:,] # iloc只能用数字了