Pandas语法大全

Pandas语法大全

简介

pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素之一。 Pandas 是python的一个数据分析包，最初由AQR Capital Management于2008年4月开发，并于2009年底开源出来，目前由专注于Python数据包开发的PyData开发team继续开发和维护，属于PyData项目的一部分。Pandas最初被作为金融数据分析工具而开发出来，因此，pandas为时间序列分析提供了很好的支持。 Pandas的名称来自于面板数据（panel data）和python数据分析（data analysis）。panel data是经济学中关于多维数据集的一个术语，在Pandas中也提供了panel的数据类型。

数据结构

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

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

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

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

Pandas中常用的函数和方法

在学习Pandas时，我们需要记忆很多的函数和方法。所以在这里我们汇总一下Pandas官方文档中比较常用的函数和方法。

注意在下面的介绍中： df 代表的是任意的Pandas DataFrame对象 s 代表的是任意的Pandas Series对象

库的导入

1. import pandas as pd

2. import numpy as np

导入数据 

pd.read_csv(filename)：从CSV文件导入数据 

pd.read_table(filename)：从限定分隔符的文本文件导入数据 

pd.read_excel(filename)：从Excel文件导入数据 

pd.read_sql(query,connection_object)：从SQL表/库导入数据 

pd.read_json(json_string)：从JSON格式的字符串导入数据 

pd.read_html(url)：解析URL、字符串或者HTML文件，抽取其中的tables表格

pd.read_clipboard()：从你的粘贴板获取内容，并传给read_table() 

pd.DataFrame(dict)：从字典对象导入数据，Key是列名，Value是数据

导出数据

df.to_csv(filename)：导出数据到CSV文件 

df.to_excel(filename)：导出数据到Excel文件 

df.to_sql(table_name,connection_object)：导出数据到SQL表 

df.to_json(filename)：以Json格式导出数据到文本文件

创建测试对象

pd.DataFrame(np.random.rand(20,5))：创建20行5列的随机数组成的DataFrame对象 

pd.Series(my_list)：从可迭代对象my_list创建一个Series对象 

df.index=pd.date_range('1900/1/30',periods=df.shape[0])：增加一个日期索引

查看、检查数据

df.head(n)：查看DataFrame对象的前n行

df.tail(n)：查看DataFrame对象的最后n行 

df.shape()：查看行数和列数 

http://df.info()：查看索引、数据类型和内存信息 

df.describe()：查看数值型列的汇总统计 

s.value_counts(dropna=False)：查看Series对象的唯一值和计数

df.apply(pd.Series.value_counts)：查看DataFrame对象中每一列的唯一值和计数

数据选取

df[col]：根据列名，并以Series的形式返回列 

df[[col1,col2]]：以DataFrame形式返回多列 

s.iloc[0]：按位置选取数据 

s.loc['index_one']：按索引选取数据

df.iloc[0,:]：返回第一行 

df.iloc[0,0]：返回第一列的第一个元素

数据清理

df.columns=['a','b','c']：重命名列名 

pd.isnull()：检查DataFrame对象中的空值，并返回一个Boolean数组

pd.notnull()：检查DataFrame对象中的非空值，并返回一个Boolean数组

df.dropna()：删除所有包含空值的行 

df.dropna(axis=1)：删除所有包含空值的列 

df.dropna(axis=1,thresh=n)：删除所有小于n个非空值的行 

df.fillna(x)：用x替换DataFrame对象中所有的空值 

s.astype(float)：将Series中的数据类型更改为float类型 

s.replace(1,'one')：用‘one’代替所有等于1的值 

s.replace([1,3],['one','three'])：用'one'代替1，用'three'代替3 

df.rename(columns=lambdax:x+1)：批量更改列名 

df.rename(columns={'old_name':'new_ name'})：选择性更改列名 

df.set_index('column_one')：更改索引列 

df.rename(index=lambdax:x+1)：批量重命名索引

数据处理：Filter、Sort和GroupBy

df[df[col]>0.5]：选择col列的值大于0.5的行

df.sort_values(col1)：按照列col1排序数据，默认升序排列 

df.sort_values(col2,ascending=False)：按照列col1降序排列数据 

df.sort_values([col1,col2],ascending=[True,False])：先按列col1升序排列，后按col2降序排列数据 

df.groupby(col)：返回一个按列col进行分组的Groupby对象 

df.groupby([col1,col2])：返回一个按多列进行分组的Groupby对象 

df.groupby(col1)[col2]：返回按列col1进行分组后，列col2的均值 df.pivot_table(index=col1, 

values=[col2,col3],aggfunc=max)：创建一个按列col1进行分组，并计算col2和col3的最大值的数据透视表 

df.groupby(col1).agg(np.mean)：返回按列col1分组的所有列的均值

data.apply(np.mean)：对DataFrame中的每一列应用函数np.mean 

data.apply(np.max,axis=1)：对DataFrame中的每一行应用函数np.max

数据合并

df1.append(df2)：将df2中的行添加到df1的尾部 

df.concat([df1,df2],axis=1)：将df2中的列添加到df1的尾部

df1.join(df2,on=col1,how='inner')：对df1的列和df2的列执行SQL形式的join

数据统计

df.describe()：查看数据值列的汇总统计 

df.mean()：返回所有列的均值 

df.corr()：返回列与列之间的相关系数 

df.count()：返回每一列中的非空值的个数 

df.max()：返回每一列的最大值 

df.min()：返回每一列的最小值 

df.median()：返回每一列的中位数 

df.std()：返回每一列的标准差

pandas十分钟入门

导入

1. In [1]: import pandas as pd

3. In [2]: import numpy as np

5. In [3]: import matplotlib.pyplot as plt

创建对象创建一个Series通过传递值的列表，让大pandas创建一个默认的整数索引：

1. In [4]: s = pd.Series([1,3,5,np.nan,6,8])

2. In [5]: s

3. Out[5]:

4. 0    1.0

5. 1    3.0

6. 2    5.0

7. 3    NaN

8. 4    6.0

9. 5    8.0

10. dtype: float64

DataFrame通过传递带有日期时间索引和标签列的numpy数组来创建一个数组：

1. In [6]: dates = pd.date_range('20130101', periods=6)

3. In [7]: dates

4. Out[7]:

5. DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',

6.               '2013-01-05', '2013-01-06'],

7.              dtype='datetime64[ns]', freq='D')

9. In [8]: df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))

11. In [9]: df

12. Out[9]:

13.                   A         B         C         D

14. 2013-01-01  0.469112 -0.282863 -1.509059 -1.135632

15. 2013-01-02  1.212112 -0.173215  0.119209 -1.044236

16. 2013-01-03 -0.861849 -2.104569 -0.494929  1.071804

17. 2013-01-04  0.721555 -0.706771 -1.039575  0.271860

18. 2013-01-05 -0.424972  0.567020  0.276232 -1.087401

19. 2013-01-06 -0.673690  0.113648 -1.478427  0.524988

DataFrame通过传递可以转换为序列对象的字典来创建一个。

1. In [10]: df2 = pd.DataFrame({ 'A' : 1.,

2.   ....:                      'B' : pd.Timestamp('20130102'),

3.   ....:                      'C' : pd.Series(1,index=list(range(4)),dtype='float32'),

4.   ....:                      'D' : np.array([3] * 4,dtype='int32'),

5.   ....:                      'E' : pd.Categorical(["test","train","test","train"]),

6.   ....:                      'F' : 'foo' })

7.   ....:

9. In [11]: df2

10. Out[11]:

11.     A          B    C  D      E    F

12. 0  1.0 2013-01-02  1.0  3   test  foo

13. 1  1.0 2013-01-02  1.0  3  train  foo

14. 2  1.0 2013-01-02  1.0  3   test  foo

15. 3  1.0 2013-01-02  1.0  3  train  foo

有特定的dtypes

1. In [12]: df2.dtypes

2. Out[12]:

3. A           float64

4. B    datetime64[ns]

5. C           float32

6. D             int32

7. E          category

8. F            object

9. dtype: object

如果您使用的是IPython，则会自动启用列名称的标签填充（以及公共属性）。以下是将要完成的属性的子集：

1. In [13]: df2.<TAB>

2. df2.A                  df2.bool

3. df2.abs                df2.boxplot

4. df2.add                df2.C

5. df2.add_prefix         df2.clip

6. df2.add_suffix         df2.clip_lower

7. df2.align              df2.clip_upper

8. df2.all                df2.columns

9. df2.any                df2.combine

10. df2.append             df2.combine_first

11. df2.apply              df2.compound

12. df2.applymap           df2.consolidate

查看数据

查看框架的顶部和底部行

1. In [14]: df.head()

2. Out[14]:

3.                   A         B         C         D

4. 2013-01-01  0.469112 -0.282863 -1.509059 -1.135632

5. 2013-01-02  1.212112 -0.173215  0.119209 -1.044236

6. 2013-01-03 -0.861849 -2.104569 -0.494929  1.071804

7. 2013-01-04  0.721555 -0.706771 -1.039575  0.271860

8. 2013-01-05 -0.424972  0.567020  0.276232 -1.087401

10. In [15]: df.tail(3)

11. Out[15]:

12.                   A         B         C         D

13. 2013-01-04  0.721555 -0.706771 -1.039575  0.271860

14. 2013-01-05 -0.424972  0.567020  0.276232 -1.087401

15. 2013-01-06 -0.673690  0.113648 -1.478427  0.524988

显示索引，列和底层numpy数据

1. In [16]: df.index

2. Out[16]:

3. DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',

4.               '2013-01-05', '2013-01-06'],

5.              dtype='datetime64[ns]', freq='D')

7. In [17]: df.columns

8. Out[17]: Index(['A', 'B', 'C', 'D'], dtype='object')

10. In [18]: df.values

11. Out[18]:

12. array([[ 0.4691, -0.2829, -1.5091, -1.1356],

13.       [ 1.2121, -0.1732,  0.1192, -1.0442],

14.       [-0.8618, -2.1046, -0.4949,  1.0718],

15.       [ 0.7216, -0.7068, -1.0396,  0.2719],

16.       [-0.425 ,  0.567 ,  0.2762, -1.0874],

17.       [-0.6737,  0.1136, -1.4784,  0.525 ]])

描述显示您的数据的快速统计摘要

1. In [19]: df.describe()

2. Out[19]:

3.              A         B         C         D

4. count  6.000000  6.000000  6.000000  6.000000

5. mean   0.073711 -0.431125 -0.687758 -0.233103

6. std    0.843157  0.922818  0.779887  0.973118

7. min   -0.861849 -2.104569 -1.509059 -1.135632

8. 25%   -0.611510 -0.600794 -1.368714 -1.076610

9. 50%    0.022070 -0.228039 -0.767252 -0.386188

10. 75%    0.658444  0.041933 -0.034326  0.461706

11. max    1.212112  0.567020  0.276232  1.071804

转置您的数据

1. In [20]: df.T

2. Out[20]:

3.   2013-01-01  2013-01-02  2013-01-03  2013-01-04  2013-01-05  2013-01-06

4. A    0.469112    1.212112   -0.861849    0.721555   -0.424972   -0.673690

5. B   -0.282863   -0.173215   -2.104569   -0.706771    0.567020    0.113648

6. C   -1.509059    0.119209   -0.494929   -1.039575    0.276232   -1.478427

7. D   -1.135632   -1.044236    1.071804    0.271860   -1.087401    0.524988

按轴排序

1. In [21]: df.sort_index(axis=1, ascending=False)

2. Out[21]:

3.                   D         C         B         A

4. 2013-01-01 -1.135632 -1.509059 -0.282863  0.469112

5. 2013-01-02 -1.044236  0.119209 -0.173215  1.212112

6. 2013-01-03  1.071804 -0.494929 -2.104569 -0.861849

7. 2013-01-04  0.271860 -1.039575 -0.706771  0.721555

8. 2013-01-05 -1.087401  0.276232  0.567020 -0.424972

9. 2013-01-06  0.524988 -1.478427  0.113648 -0.673690

按值排序

1. In [22]: df.sort_values(by='B')

2. Out[22]:

3.                   A         B         C         D

4. 2013-01-03 -0.861849 -2.104569 -0.494929  1.071804

5. 2013-01-04  0.721555 -0.706771 -1.039575  0.271860

6. 2013-01-01  0.469112 -0.282863 -1.509059 -1.135632

7. 2013-01-02  1.212112 -0.173215  0.119209 -1.044236

8. 2013-01-06 -0.673690  0.113648 -1.478427  0.524988

9. 2013-01-05 -0.424972  0.567020  0.276232 -1.087401

获取

选择一个单列，它产生一个Series，等同于df.A

1. In [23]: df['A']

2. Out[23]:

3. 2013-01-01    0.469112

4. 2013-01-02    1.212112

5. 2013-01-03   -0.861849

6. 2013-01-04    0.721555

7. 2013-01-05   -0.424972

8. 2013-01-06   -0.673690

9. Freq: D, Name: A, dtype: float64

选择通过[]，切片的行。

1. In [24]: df[0:3]

2. Out[24]:

3.                   A         B         C         D

4. 2013-01-01  0.469112 -0.282863 -1.509059 -1.135632

5. 2013-01-02  1.212112 -0.173215  0.119209 -1.044236

6. 2013-01-03 -0.861849 -2.104569 -0.494929  1.071804

8. In [25]: df['20130102':'20130104']

9. Out[25]:

10.                   A         B         C         D

11. 2013-01-02  1.212112 -0.173215  0.119209 -1.044236

12. 2013-01-03 -0.861849 -2.104569 -0.494929  1.071804

13. 2013-01-04  0.721555 -0.706771 -1.039575  0.271860

标签的选择

使用标签获取横截面

1. In [26]: df.loc[dates[0]]

2. Out[26]:

3. A    0.469112

4. B   -0.282863

5. C   -1.509059

6. D   -1.135632

7. Name: 2013-01-01 00:00:00, dtype: float64

通过标签选择多轴

1. In [27]: df.loc[:,['A','B']]

2. Out[27]:

3.                   A         B

4. 2013-01-01  0.469112 -0.282863

5. 2013-01-02  1.212112 -0.173215

6. 2013-01-03 -0.861849 -2.104569

7. 2013-01-04  0.721555 -0.706771

8. 2013-01-05 -0.424972  0.567020

9. 2013-01-06 -0.673690  0.113648

显示标签切片，两个端点都包括在内

1. In [28]: df.loc['20130102':'20130104',['A','B']]

2. Out[28]:

3.                   A         B

4. 2013-01-02  1.212112 -0.173215

5. 2013-01-03 -0.861849 -2.104569

6. 2013-01-04  0.721555 -0.706771

减少返回物体的尺寸

1. In [29]: df.loc['20130102',['A','B']]

2. Out[29]:

3. A    1.212112

4. B   -0.173215

5. Name: 2013-01-02 00:00:00, dtype: float64

获得标量值

1. In [30]: df.loc[dates[0],'A']

2. Out[30]: 0.46911229990718628

为了快速访问标量（等同于之前的方法）

1. In [31]: df.at[dates[0],'A']

2. Out[31]: 0.46911229990718628

按位置选择

通过传递整数的位置进行选择

1. In [32]: df.iloc[3]

2. Out[32]:

3. A    0.721555

4. B   -0.706771

5. C   -1.039575

6. D    0.271860

7. Name: 2013-01-04 00:00:00, dtype: float64

通过整数片，类似于numpy / python

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

2. Out[33]:

3.                   A         B

4. 2013-01-04  0.721555 -0.706771

5. 2013-01-05 -0.424972  0.567020

通过整数位置位置列表，类似于numpy / python样式

1. In [34]: df.iloc[[1,2,4],[0,2]]

2. Out[34]:

3.                   A         C

4. 2013-01-02  1.212112  0.119209

5. 2013-01-03 -0.861849 -0.494929

6. 2013-01-05 -0.424972  0.276232

用于明确地切片行

1. In [35]: df.iloc[1:3,:]

2. Out[35]:

3.                   A         B         C         D

4. 2013-01-02  1.212112 -0.173215  0.119209 -1.044236

5. 2013-01-03 -0.861849 -2.104569 -0.494929  1.071804

用于明确地切分列

1. In [36]: df.iloc[:,1:3]

2. Out[36]:

3.                   B         C

4. 2013-01-01 -0.282863 -1.509059

5. 2013-01-02 -0.173215  0.119209

6. 2013-01-03 -2.104569 -0.494929

7. 2013-01-04 -0.706771 -1.039575

8. 2013-01-05  0.567020  0.276232

9. 2013-01-06  0.113648 -1.478427

为了明确获取一个值

1. In [37]: df.iloc[1,1]

2. Out[37]: -0.17321464905330858

为了快速访问标量（等同于之前的方法）

1. In [38]: df.iat[1,1]

2. Out[38]: -0.17321464905330858

布尔索引使用单列的值来选择数据。

1. In [39]: df[df.A > 0]

2. Out[39]:

3.                   A         B         C         D

4. 2013-01-01  0.469112 -0.282863 -1.509059 -1.135632

5. 2013-01-02  1.212112 -0.173215  0.119209 -1.044236

6. 2013-01-04  0.721555 -0.706771 -1.039575  0.271860

从满足布尔条件的DataFrame中选择值。

1. In [40]: df[df > 0]

2. Out[40]:

3.                   A         B         C         D

4. 2013-01-01  0.469112       NaN       NaN       NaN

5. 2013-01-02  1.212112       NaN  0.119209       NaN

6. 2013-01-03       NaN       NaN       NaN  1.071804

7. 2013-01-04  0.721555       NaN       NaN  0.271860

8. 2013-01-05       NaN  0.567020  0.276232       NaN

9. 2013-01-06       NaN  0.113648       NaN  0.524988

使用isin()过滤方法：

1. In [41]: df2 = df.copy()

3. In [42]: df2['E'] = ['one', 'one','two','three','four','three']

5. In [43]: df2

6. Out[43]:

7.                   A         B         C         D      E

8. 2013-01-01  0.469112 -0.282863 -1.509059 -1.135632    one

9. 2013-01-02  1.212112 -0.173215  0.119209 -1.044236    one

10. 2013-01-03 -0.861849 -2.104569 -0.494929  1.071804    two

11. 2013-01-04  0.721555 -0.706771 -1.039575  0.271860  three

12. 2013-01-05 -0.424972  0.567020  0.276232 -1.087401   four

13. 2013-01-06 -0.673690  0.113648 -1.478427  0.524988  three

15. In [44]: df2[df2['E'].isin(['two','four'])]

16. Out[44]:

17.                   A         B         C         D     E

18. 2013-01-03 -0.861849 -2.104569 -0.494929  1.071804   two

19. 2013-01-05 -0.424972  0.567020  0.276232 -1.087401  four

设置

设置新列自动按索引对齐数据

1. In [45]: s1 = pd.Series([1,2,3,4,5,6], index=pd.date_range('20130102', periods=6))

3. In [46]: s1

4. Out[46]:

5. 2013-01-02    1

6. 2013-01-03    2

7. 2013-01-04    3

8. 2013-01-05    4

9. 2013-01-06    5

10. 2013-01-07    6

11. Freq: D, dtype: int64

13. In [47]: df['F'] = s1

通过标签设置值

1. In [48]: df.at[dates[0],'A'] = 0

按位置设置值

1. In [49]: df.iat[0,1] = 0

通过分配一个numpy数组进行设置

1. In [50]: df.loc[:,'D'] = np.array([5] * len(df))

事先设置操作的结果

1. In [51]: df

2. Out[51]:

3.                   A         B         C  D    F

4. 2013-01-01  0.000000  0.000000 -1.509059  5  NaN

5. 2013-01-02  1.212112 -0.173215  0.119209  5  1.0

6. 2013-01-03 -0.861849 -2.104569 -0.494929  5  2.0

7. 2013-01-04  0.721555 -0.706771 -1.039575  5  3.0

8. 2013-01-05 -0.424972  0.567020  0.276232  5  4.0

9. 2013-01-06 -0.673690  0.113648 -1.478427  5  5.0

一个where与设置操作。

1. In [52]: df2 = df.copy()

3. In [53]: df2[df2 > 0] = -df2

5. In [54]: df2

6. Out[54]:

7.                   A         B         C  D    F

8. 2013-01-01  0.000000  0.000000 -1.509059 -5  NaN

9. 2013-01-02 -1.212112 -0.173215 -0.119209 -5 -1.0

10. 2013-01-03 -0.861849 -2.104569 -0.494929 -5 -2.0

11. 2013-01-04 -0.721555 -0.706771 -1.039575 -5 -3.0

12. 2013-01-05 -0.424972 -0.567020 -0.276232 -5 -4.0

13. 2013-01-06 -0.673690 -0.113648 -1.478427 -5 -5.0

缺少数据Reindexing允许您更改/添加/删除指定轴上的索引。这将返回数据的副本。

1. In [55]: df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + ['E'])

3. In [56]: df1.loc[dates[0]:dates[1],'E'] = 1

5. In [57]: df1

6. Out[57]:

7.                   A         B         C  D    F    E

8. 2013-01-01  0.000000  0.000000 -1.509059  5  NaN  1.0

9. 2013-01-02  1.212112 -0.173215  0.119209  5  1.0  1.0

10. 2013-01-03 -0.861849 -2.104569 -0.494929  5  2.0  NaN

11. 2013-01-04  0.721555 -0.706771 -1.039575  5  3.0  NaN

删除任何缺少数据的行。

1. In [58]: df1.dropna(how='any')

2. Out[58]:

3.                   A         B         C  D    F    E

4. 2013-01-02  1.212112 -0.173215  0.119209  5  1.0  1.0

填写缺少的数据

1. In [59]: df1.fillna(value=5)

2. Out[59]:

3.                   A         B         C  D    F    E

4. 2013-01-01  0.000000  0.000000 -1.509059  5  5.0  1.0

5. 2013-01-02  1.212112 -0.173215  0.119209  5  1.0  1.0

6. 2013-01-03 -0.861849 -2.104569 -0.494929  5  2.0  5.0

7. 2013-01-04  0.721555 -0.706771 -1.039575  5  3.0  5.0

获取值为的布尔值掩码 nan

1. In [60]: pd.isna(df1)

2. Out[60]:

3.                A      B      C      D      F      E

4. 2013-01-01  False  False  False  False   True  False

5. 2013-01-02  False  False  False  False  False  False

6. 2013-01-03  False  False  False  False  False   True

7. 2013-01-04  False  False  False  False  False   True

统计

执行描述性统计

1. In [61]: df.mean()

2. Out[61]:

3. A   -0.004474

4. B   -0.383981

5. C   -0.687758

6. D    5.000000

7. F    3.000000

8. dtype: float64

另一轴上的操作相同

1. In [62]: df.mean(1)

2. Out[62]:

3. 2013-01-01    0.872735

4. 2013-01-02    1.431621

5. 2013-01-03    0.707731

6. 2013-01-04    1.395042

7. 2013-01-05    1.883656

8. 2013-01-06    1.592306

9. Freq: D, dtype: float64

使用具有不同维度和需要对齐的对象进行操作。另外，pandas会沿指定的尺寸自动播放。

1. In [63]: s = pd.Series([1,3,5,np.nan,6,8], index=dates).shift(2)

3. In [64]: s

4. Out[64]:

5. 2013-01-01    NaN

6. 2013-01-02    NaN

7. 2013-01-03    1.0

8. 2013-01-04    3.0

9. 2013-01-05    5.0

10. 2013-01-06    NaN

11. Freq: D, dtype: float64

13. In [65]: df.sub(s, axis='index')

14. Out[65]:

15.                   A         B         C    D    F

16. 2013-01-01       NaN       NaN       NaN  NaN  NaN

17. 2013-01-02       NaN       NaN       NaN  NaN  NaN

18. 2013-01-03 -1.861849 -3.104569 -1.494929  4.0  1.0

19. 2013-01-04 -2.278445 -3.706771 -4.039575  2.0  0.0

20. 2013-01-05 -5.424972 -4.432980 -4.723768  0.0 -1.0

21. 2013-01-06       NaN       NaN       NaN  NaN  NaN

应用将功能应用于数据

1. In [66]: df.apply(np.cumsum)

2. Out[66]:

3.                   A         B         C   D     F

4. 2013-01-01  0.000000  0.000000 -1.509059   5   NaN

5. 2013-01-02  1.212112 -0.173215 -1.389850  10   1.0

6. 2013-01-03  0.350263 -2.277784 -1.884779  15   3.0

7. 2013-01-04  1.071818 -2.984555 -2.924354  20   6.0

8. 2013-01-05  0.646846 -2.417535 -2.648122  25  10.0

9. 2013-01-06 -0.026844 -2.303886 -4.126549  30  15.0

11. In [67]: df.apply(lambda x: x.max() - x.min())

12. Out[67]:

13. A    2.073961

14. B    2.671590

15. C    1.785291

16. D    0.000000

17. F    4.000000

18. dtype: float64

直方图

1. In [68]: s = pd.Series(np.random.randint(0, 7, size=10))

3. In [69]: s

4. Out[69]:

5. 0    4

6. 1    2

7. 2    1

8. 3    2

9. 4    6

10. 5    4

11. 6    4

12. 7    6

13. 8    4

14. 9    4

15. dtype: int64

17. In [70]: s.value_counts()

18. Out[70]:

19. 4    5

20. 6    2

21. 2    2

22. 1    1

23. dtype: int64

字符串方法

系列在str 属性中配备了一组字符串处理方法，可以轻松地在数组的每个元素上进行操作，如下面的代码片段所示。

1. In [71]: s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])

3. In [72]: s.str.lower()

4. Out[72]:

5. 0       a

6. 1       b

7. 2       c

8. 3    aaba

9. 4    baca

10. 5     NaN

11. 6    caba

12. 7     dog

13. 8     cat

14. dtype: object

合并在连接/合并类型操作的情况下，pandas提供了各种功能，可以轻松地将Series，DataFrame和Panel对象与索引和关系代数功能的各种设置逻辑组合在一起。

1. In [73]: df = pd.DataFrame(np.random.randn(10, 4))

3. In [74]: df

4. Out[74]:

5.          0         1         2         3

6. 0 -0.548702  1.467327 -1.015962 -0.483075

7. 1  1.637550 -1.217659 -0.291519 -1.745505

8. 2 -0.263952  0.991460 -0.919069  0.266046

9. 3 -0.709661  1.669052  1.037882 -1.705775

10. 4 -0.919854 -0.042379  1.247642 -0.009920

11. 5  0.290213  0.495767  0.362949  1.548106

12. 6 -1.131345 -0.089329  0.337863 -0.945867

13. 7 -0.932132  1.956030  0.017587 -0.016692

14. 8 -0.575247  0.254161 -1.143704  0.215897

15. 9  1.193555 -0.077118 -0.408530 -0.862495

17. # break it into pieces

18. In [75]: pieces = [df[:3], df[3:7], df[7:]]

20. In [76]: pd.concat(pieces)

21. Out[76]:

22.          0         1         2         3

23. 0 -0.548702  1.467327 -1.015962 -0.483075

24. 1  1.637550 -1.217659 -0.291519 -1.745505

25. 2 -0.263952  0.991460 -0.919069  0.266046

26. 3 -0.709661  1.669052  1.037882 -1.705775

27. 4 -0.919854 -0.042379  1.247642 -0.009920

28. 5  0.290213  0.495767  0.362949  1.548106

29. 6 -1.131345 -0.089329  0.337863 -0.945867

30. 7 -0.932132  1.956030  0.017587 -0.016692

31. 8 -0.575247  0.254161 -1.143704  0.215897

32. 9  1.193555 -0.077118 -0.408530 -0.862495

加入

1. In [77]: left = pd.DataFrame({'key': ['foo', 'foo'], 'lval': [1, 2]})

3. In [78]: right = pd.DataFrame({'key': ['foo', 'foo'], 'rval': [4, 5]})

5. In [79]: left

6. Out[79]:

7.   key  lval

8. 0  foo     1

9. 1  foo     2

11. In [80]: right

12. Out[80]:

13.   key  rval

14. 0  foo     4

15. 1  foo     5

17. In [81]: pd.merge(left, right, on='key')

18. Out[81]:

19.   key  lval  rval

20. 0  foo     1     4

21. 1  foo     1     5

22. 2  foo     2     4

23. 3  foo     2     5

可以给出的另一个例子是：

1. In [82]: left = pd.DataFrame({'key': ['foo', 'bar'], 'lval': [1, 2]})

3. In [83]: right = pd.DataFrame({'key': ['foo', 'bar'], 'rval': [4, 5]})

5. In [84]: left

6. Out[84]:

7.   key  lval

8. 0  foo     1

9. 1  bar     2

11. In [85]: right

12. Out[85]:

13.   key  rval

14. 0  foo     4

15. 1  bar     5

17. In [86]: pd.merge(left, right, on='key')

18. Out[86]:

19.   key  lval  rval

20. 0  foo     1     4

21. 1  bar     2     5

追加

1. In [87]: df = pd.DataFrame(np.random.randn(8, 4), columns=['A','B','C','D'])

3. In [88]: df

4. Out[88]:

5.          A         B         C         D

6. 0  1.346061  1.511763  1.627081 -0.990582

7. 1 -0.441652  1.211526  0.268520  0.024580

8. 2 -1.577585  0.396823 -0.105381 -0.532532

9. 3  1.453749  1.208843 -0.080952 -0.264610

10. 4 -0.727965 -0.589346  0.339969 -0.693205

11. 5 -0.339355  0.593616  0.884345  1.591431

12. 6  0.141809  0.220390  0.435589  0.192451

13. 7 -0.096701  0.803351  1.715071 -0.708758

15. In [89]: s = df.iloc[3]

17. In [90]: df.append(s, ignore_index=True)

18. Out[90]:

19.          A         B         C         D

20. 0  1.346061  1.511763  1.627081 -0.990582

21. 1 -0.441652  1.211526  0.268520  0.024580

22. 2 -1.577585  0.396823 -0.105381 -0.532532

23. 3  1.453749  1.208843 -0.080952 -0.264610

24. 4 -0.727965 -0.589346  0.339969 -0.693205

25. 5 -0.339355  0.593616  0.884345  1.591431

26. 6  0.141809  0.220390  0.435589  0.192451

27. 7 -0.096701  0.803351  1.715071 -0.708758

28. 8  1.453749  1.208843 -0.080952 -0.264610

分组通过“group by”我们所指的是涉及一个或多个以下步骤的过程

拆分数据到基于某些标准组 独立地为每个组应用一个功能 将结果组合到一个数据结构中

1. In [91]: df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',

2.   ....:                           'foo', 'bar', 'foo', 'foo'],

3.   ....:                    'B' : ['one', 'one', 'two', 'three',

4.   ....:                           'two', 'two', 'one', 'three'],

5.   ....:                    'C' : np.random.randn(8),

6.   ....:                    'D' : np.random.randn(8)})

7.   ....:

9. In [92]: df

10. Out[92]:

11.     A      B         C         D

12. 0  foo    one -1.202872 -0.055224

13. 1  bar    one -1.814470  2.395985

14. 2  foo    two  1.018601  1.552825

15. 3  bar  three -0.595447  0.166599

16. 4  foo    two  1.395433  0.047609

17. 5  bar    two -0.392670 -0.136473

18. 6  foo    one  0.007207 -0.561757

19. 7  foo  three  1.928123 -1.623033

分组然后将函数sum应用于结果组。

1. In [93]: df.groupby('A').sum()

2. Out[93]:

3.            C        D

4. A                    

5. bar -2.802588  2.42611

6. foo  3.146492 -0.63958

按多列分组会形成一个分层索引，然后我们应用该功能。

1. In [94]: df.groupby(['A','B']).sum()

2. Out[94]:

3.                  C         D

4. A   B                        

5. bar one   -1.814470  2.395985

6.    three -0.595447  0.166599

7.    two   -0.392670 -0.136473

8. foo one   -1.195665 -0.616981

9.    three  1.928123 -1.623033

10.    two    2.414034  1.600434

堆栈

1. In [95]: tuples = list(zip(*[['bar', 'bar', 'baz', 'baz',

2.   ....:                      'foo', 'foo', 'qux', 'qux'],

3.   ....:                     ['one', 'two', 'one', 'two',

4.   ....:                      'one', 'two', 'one', 'two']]))

5.   ....:

7. In [96]: index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])

9. In [97]: df = pd.DataFrame(np.random.randn(8, 2), index=index, columns=['A', 'B'])

11. In [98]: df2 = df[:4]

13. In [99]: df2

14. Out[99]:

15.                     A         B

16. first second                    

17. bar   one     0.029399 -0.542108

18.      two     0.282696 -0.087302

19. baz   one    -1.575170  1.771208

20.      two     0.816482  1.100230

该stack()方法“压缩”DataFrame列中的级别。

1. In [100]: stacked = df2.stack()

3. In [101]: stacked

4. Out[101]:

5. first  second  

6. bar    one     A    0.029399

7.               B   -0.542108

8.       two     A    0.282696

9.               B   -0.087302

10. baz    one     A   -1.575170

11.               B    1.771208

12.       two     A    0.816482

13.               B    1.100230

14. dtype: float64

对于“堆叠式”DataFrame或Series（具有MultiIndexas index），stack()is 的逆操作，unstack()默认情况下，它将卸载最后一级：

1. In [102]: stacked.unstack()

2. Out[102]:

3.                     A         B

4. first second                    

5. bar   one     0.029399 -0.542108

6.      two     0.282696 -0.087302

7. baz   one    -1.575170  1.771208

8.      two     0.816482  1.100230

10. In [103]: stacked.unstack(1)

11. Out[103]:

12. second        one       two

13. first                      

14. bar   A  0.029399  0.282696

15.      B -0.542108 -0.087302

16. baz   A -1.575170  0.816482

17.      B  1.771208  1.100230

19. In [104]: stacked.unstack(0)

20. Out[104]:

21. first          bar       baz

22. second                      

23. one    A  0.029399 -1.575170

24.       B -0.542108  1.771208

25. two    A  0.282696  0.816482

26.       B -0.087302  1.100230

数据透视表

1. In [105]: df = pd.DataFrame({'A' : ['one', 'one', 'two', 'three'] * 3,

2.   .....:                    'B' : ['A', 'B', 'C'] * 4,

3.   .....:                    'C' : ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] * 2,

4.   .....:                    'D' : np.random.randn(12),

5.   .....:                    'E' : np.random.randn(12)})

6.   .....:

8. In [106]: df

9. Out[106]:

10.        A  B    C         D         E

11. 0     one  A  foo  1.418757 -0.179666

12. 1     one  B  foo -1.879024  1.291836

13. 2     two  C  foo  0.536826 -0.009614

14. 3   three  A  bar  1.006160  0.392149

15. 4     one  B  bar -0.029716  0.264599

16. 5     one  C  bar -1.146178 -0.057409

17. 6     two  A  foo  0.100900 -1.425638

18. 7   three  B  foo -1.035018  1.024098

19. 8     one  C  foo  0.314665 -0.106062

20. 9     one  A  bar -0.773723  1.824375

21. 10    two  B  bar -1.170653  0.595974

22. 11  three  C  bar  0.648740  1.167115

我们可以很容易地从这些数据生成数据透视表：

1. In [107]: pd.pivot_table(df, values='D', index=['A', 'B'], columns=['C'])

2. Out[107]:

3. C             bar       foo

4. A     B                    

5. one   A -0.773723  1.418757

6.      B -0.029716 -1.879024

7.      C -1.146178  0.314665

8. three A  1.006160       NaN

9.      B       NaN -1.035018

10.      C  0.648740       NaN

11. two   A       NaN  0.100900

12.      B -1.170653       NaN

13.      C       NaN  0.536826

时间系列pandas具有简单，强大且高效的功能，可在频率转换过程中执行重采样操作（例如，将数据转换为5分钟的数据）

1. In [108]: rng = pd.date_range('1/1/2012', periods=100, freq='S')

3. In [109]: ts = pd.Series(np.random.randint(0, 500, len(rng)), index=rng)

5. In [110]: ts.resample('5Min').sum()

6. Out[110]:

7. 2012-01-01    25083

8. Freq: 5T, dtype: int64

时区表示

1. In [111]: rng = pd.date_range('3/6/2012 00:00', periods=5, freq='D')

3. In [112]: ts = pd.Series(np.random.randn(len(rng)), rng)

5. In [113]: ts

6. Out[113]:

7. 2012-03-06    0.464000

8. 2012-03-07    0.227371

9. 2012-03-08   -0.496922

10. 2012-03-09    0.306389

11. 2012-03-10   -2.290613

12. Freq: D, dtype: float64

14. In [114]: ts_utc = ts.tz_localize('UTC')

16. In [115]: ts_utc

17. Out[115]:

18. 2012-03-06 00:00:00+00:00    0.464000

19. 2012-03-07 00:00:00+00:00    0.227371

20. 2012-03-08 00:00:00+00:00   -0.496922

21. 2012-03-09 00:00:00+00:00    0.306389

22. 2012-03-10 00:00:00+00:00   -2.290613

23. Freq: D, dtype: float64

转换到另一个时区

1. In [116]: ts_utc.tz_convert('US/Eastern')

2. Out[116]:

3. 2012-03-05 19:00:00-05:00    0.464000

4. 2012-03-06 19:00:00-05:00    0.227371

5. 2012-03-07 19:00:00-05:00   -0.496922

6. 2012-03-08 19:00:00-05:00    0.306389

7. 2012-03-09 19:00:00-05:00   -2.290613

8. Freq: D, dtype: float64

在时间跨度表示之间进行转换

1. In [117]: rng = pd.date_range('1/1/2012', periods=5, freq='M')

3. In [118]: ts = pd.Series(np.random.randn(len(rng)), index=rng)

5. In [119]: ts

6. Out[119]:

7. 2012-01-31   -1.134623

8. 2012-02-29   -1.561819

9. 2012-03-31   -0.260838

10. 2012-04-30    0.281957

11. 2012-05-31    1.523962

12. Freq: M, dtype: float64

14. In [120]: ps = ts.to_period()

16. In [121]: ps

17. Out[121]:

18. 2012-01   -1.134623

19. 2012-02   -1.561819

20. 2012-03   -0.260838

21. 2012-04    0.281957

22. 2012-05    1.523962

23. Freq: M, dtype: float64

25. In [122]: ps.to_timestamp()

26. Out[122]:

27. 2012-01-01   -1.134623

28. 2012-02-01   -1.561819

29. 2012-03-01   -0.260838

30. 2012-04-01    0.281957

31. 2012-05-01    1.523962

32. Freq: MS, dtype: float64

在句号和时间戳之间转换可以使用一些便利的算术函数。在下面的例子中，我们将季度结束时间为11月的季度转换为季度结束后的月末的上午9点：

1. In [123]: prng = pd.period_range('1990Q1', '2000Q4', freq='Q-NOV')

3. In [124]: ts = pd.Series(np.random.randn(len(prng)), prng)

5. In [125]: ts.index = (prng.asfreq('M', 'e') + 1).asfreq('H', 's') + 9

7. In [126]: ts.head()

8. Out[126]:

9. 1990-03-01 09:00   -0.902937

10. 1990-06-01 09:00    0.068159

11. 1990-09-01 09:00   -0.057873

12. 1990-12-01 09:00   -0.368204

13. 1991-03-01 09:00   -1.144073

14. Freq: H, dtype: float64

分类pandas可以将分类数据包含在a中DataFrame。

1. In [127]: df = pd.DataFrame({"id":[1,2,3,4,5,6], "raw_grade":['a', 'b', 'b', 'a', 'a', 'e']})

将原始等级转换为分类数据类型。

1. In [128]: df["grade"] = df["raw_grade"].astype("category")

3. In [129]: df["grade"]

4. Out[129]:

5. 0    a

6. 1    b

7. 2    b

8. 3    a

9. 4    a

10. 5    e

11. Name: grade, dtype: category

12. Categories (3, object): [a, b, e]

将类别重命名为更有意义的名称（分配给Series.cat.categories就地！）

1. In [130]: df["grade"].cat.categories = ["very good", "good", "very bad"]

对类别重新排序并同时添加缺失的类别（每个缺省返回一个新的方法）。Series .catSeries

1. In [131]: df["grade"] = df["grade"].cat.set_categories(["very bad", "bad", "medium", "good", "very good"])

3. In [132]: df["grade"]

4. Out[132]:

5. 0    very good

6. 1         good

7. 2         good

8. 3    very good

9. 4    very good

10. 5     very bad

11. Name: grade, dtype: category

12. Categories (5, object): [very bad, bad, medium, good, very good]

排序是按类别排列的，而不是词法顺序。

1. In [133]: df.sort_values(by="grade")

2. Out[133]:

3.   id raw_grade      grade

4. 5   6         e   very bad

5. 1   2         b       good

6. 2   3         b       good

7. 0   1         a  very good

8. 3   4         a  very good

9. 4   5         a  very good

按分类列分组也显示空白类别。

1. In [134]: df.groupby("grade").size()

2. Out[134]:

3. grade

4. very bad     1

5. bad          0

6. medium       0

7. good         2

8. very good    3

9. dtype: int64

绘图绘制文档。

1. In [135]: ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))

3. In [136]: ts = ts.cumsum()

5. In [137]: ts.plot()

6. Out[137]: <matplotlib.axes._subplots.AxesSubplot at 0x109464b70>

在DataFrame上，plot()可以方便地绘制所有带有标签的列：

1. In [138]: df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index,

2.   .....:                   columns=['A', 'B', 'C', 'D'])

3.   .....:

5. In [139]: df = df.cumsum()

7. In [140]: plt.figure(); df.plot(); plt.legend(loc='best')

8. Out[140]: <matplotlib.legend.Legend at 0x109a28860>

CSV写入一个csv文件

1. In [141]: df.to_csv('foo.csv')

从csv文件读取

1. In [142]: pd.read_csv('foo.csv')

2. Out[142]:

3.     Unnamed: 0          A          B         C          D

4. 0    2000-01-01   0.266457  -0.399641 -0.219582   1.186860

5. 1    2000-01-02  -1.170732  -0.345873  1.653061  -0.282953

6. 2    2000-01-03  -1.734933   0.530468  2.060811  -0.515536

7. 3    2000-01-04  -1.555121   1.452620  0.239859  -1.156896

8. 4    2000-01-05   0.578117   0.511371  0.103552  -2.428202

9. 5    2000-01-06   0.478344   0.449933 -0.741620  -1.962409

10. 6    2000-01-07   1.235339  -0.091757 -1.543861  -1.084753

11. ..          ...        ...        ...       ...        ...

12. 993  2002-09-20 -10.628548  -9.153563 -7.883146  28.313940

13. 994  2002-09-21 -10.390377  -8.727491 -6.399645  30.914107

14. 995  2002-09-22  -8.985362  -8.485624 -4.669462  31.367740

15. 996  2002-09-23  -9.558560  -8.781216 -4.499815  30.518439

16. 997  2002-09-24  -9.902058  -9.340490 -4.386639  30.105593

17. 998  2002-09-25 -10.216020  -9.480682 -3.933802  29.758560

18. 999  2002-09-26 -11.856774 -10.671012 -3.216025  29.369368

20. [1000 rows x 5 columns]

HDF5写入HDF5商店

1. In [143]: df.to_hdf('foo.h5','df')

从HDF5商店阅读

1. In [144]: pd.read_hdf('foo.h5','df')

2. Out[144]:

3.                    A          B         C          D

4. 2000-01-01   0.266457  -0.399641 -0.219582   1.186860

5. 2000-01-02  -1.170732  -0.345873  1.653061  -0.282953

6. 2000-01-03  -1.734933   0.530468  2.060811  -0.515536

7. 2000-01-04  -1.555121   1.452620  0.239859  -1.156896

8. 2000-01-05   0.578117   0.511371  0.103552  -2.428202

9. 2000-01-06   0.478344   0.449933 -0.741620  -1.962409

10. 2000-01-07   1.235339  -0.091757 -1.543861  -1.084753

11. ...               ...        ...       ...        ...

12. 2002-09-20 -10.628548  -9.153563 -7.883146  28.313940

13. 2002-09-21 -10.390377  -8.727491 -6.399645  30.914107

14. 2002-09-22  -8.985362  -8.485624 -4.669462  31.367740

15. 2002-09-23  -9.558560  -8.781216 -4.499815  30.518439

16. 2002-09-24  -9.902058  -9.340490 -4.386639  30.105593

17. 2002-09-25 -10.216020  -9.480682 -3.933802  29.758560

18. 2002-09-26 -11.856774 -10.671012 -3.216025  29.369368

20. [1000 rows x 4 columns]

excel写入excel文件

1. In [145]: df.to_excel('foo.xlsx', sheet_name='Sheet1')

从excel文件中读取

1. In [146]: pd.read_excel('foo.xlsx', 'Sheet1', index_col=None, na_values=['NA'])

2. Out[146]:

3.                    A          B         C          D

4. 2000-01-01   0.266457  -0.399641 -0.219582   1.186860

5. 2000-01-02  -1.170732  -0.345873  1.653061  -0.282953

6. 2000-01-03  -1.734933   0.530468  2.060811  -0.515536

7. 2000-01-04  -1.555121   1.452620  0.239859  -1.156896

8. 2000-01-05   0.578117   0.511371  0.103552  -2.428202

9. 2000-01-06   0.478344   0.449933 -0.741620  -1.962409

10. 2000-01-07   1.235339  -0.091757 -1.543861  -1.084753

11. ...               ...        ...       ...        ...

12. 2002-09-20 -10.628548  -9.153563 -7.883146  28.313940

13. 2002-09-21 -10.390377  -8.727491 -6.399645  30.914107

14. 2002-09-22  -8.985362  -8.485624 -4.669462  31.367740

15. 2002-09-23  -9.558560  -8.781216 -4.499815  30.518439

16. 2002-09-24  -9.902058  -9.340490 -4.386639  30.105593

17. 2002-09-25 -10.216020  -9.480682 -3.933802  29.758560

18. 2002-09-26 -11.856774 -10.671012 -3.216025  29.369368

20. [1000 rows x 4 columns]

有需要AI资料的同学请加微信，辛苦帮忙转发

阅读更多