最后一次更新日期： 2019/4/20
pandas是基于numpy的数据分析库，提供一些更易用的数据模型和大量高效的统计方法。
使用前先导入模块：
import pandas as pd
按需导入以下模块:
import numpy as np
import matplotlib.pyplot as plt
此篇为汇总，点击下方链接可前往各小节
简要使用教程1 - 数据模型与属性 (索引，数据序列，数据框，分类数据)
简要使用教程2 - 数据类型与转换 (数据类型，类型转换)
简要使用教程3 - 数组与统计运算 (运算符和标量值函数，统计方法，自定义函数，广播)
简要使用教程4 - 查询与关联 (索引查找，表连接)
简要使用教程5 - 增删改 (更新，增加，删除，重构索引，行列转置，缺失值填充)
简要使用教程6 - 排序与去重 (直接与间接排序，去重)
简要使用教程7 - 乱序与抽样 (随机排序，抽样)
简要使用教程8 - 读写 (读写csv，读写excel，读写sql)
简要使用教程9 - 快速绘图 (曲线图，条形图，直方图，箱线图，散点图，饼图)
也可以看看：
numpy使用指南
matplotlib简要使用教程
一. 数据模型与属性
1. 索引Index
numpy中只有位置索引，而pandas还增加了标签索引，依赖于一个专用的Index类型。
常规索引
In [64]: pd.Index([1,2,3])
Out[64]: Int64Index([1, 2, 3], dtype='int64')
In [65]: pd.Index([1.,2.,3.])
Out[65]: Float64Index([1.0, 2.0, 3.0], dtype='float64')
In [66]: pd.Index(['a','b','c'])
Out[66]: Index(['a', 'b', 'c'], dtype='object')
In [67]: pd.Index(range(10))
Out[67]: RangeIndex(start=0, stop=10, step=1)
In [68]: pd.Index(range(10)).values
Out[68]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int64)
In [80]: import datetime as dt
...: dt1=dt.datetime.now()
...: dt2=dt1+dt.timedelta(days=1)
In [81]: pd.Index([dt1,dt2])
Out[81]: DatetimeIndex(['2019-03-09 20:56:14.644159', '2019-03-10 20:56:14.644159'], dtype='datetime64[ns]', freq=None)
Index在创建时会根据传入数据(一维序列)自动生成具体的索引类型，也可通过dtype参数指定类型，但无法正常转换时会报错；copy参数指定创建索引时是否复制源数据，默认false。
具体的索引类型也可通过各自的方法创建。
Index.values可以查看作为数据基础的一维数组，Index.dtype可以查看数据类型。
多级索引
pandas提供了多级索引以便于分组数据，可用于构造高维数据集，groupby计算也会自动产生多级索引。
In [5]: midx=pd.MultiIndex(levels=[['a','b'],['c','d']],labels=[[1,1,0,0],[0,1,0,1]],name=['idx1','idx2'])
In [6]: midx
Out[6]:
MultiIndex(levels=[['a', 'b'], ['c', 'd']],
labels=[[1, 1, 0, 0], [0, 1, 0, 1]],
names=['idx1', 'idx2'])
In [9]: midx.set_labels([1,0,1,0],level=1)
Out[9]:
MultiIndex(levels=[['a', 'b'], ['c', 'd']],
labels=[[1, 1, 0, 0], [1, 0, 1, 0]],
names=['idx1', 'idx2'])
In [11]: midx.swaplevel(0,1)
Out[11]:
MultiIndex(levels=[['c', 'd'], ['a', 'b']],
labels=[[0, 1, 0, 1], [1, 1, 0, 0]],
names=['idx2', 'idx1'])
In [12]: pd.MultiIndex.from_arrays([['a','a','b','b'],['c','d','c','d']],names=['idx1','idx2'])
Out[12]:
MultiIndex(levels=[['a', 'b'], ['c', 'd']],
labels=[[0, 0, 1, 1], [0, 1, 0, 1]],
names=['idx1', 'idx2'])
MultiIndex的第一个参数levels是每个级别的唯一标签列表，是一个两层嵌套的序列，外层对应级别，内层对应唯一标签；
第二个参数labels是所有记录在每个级别上选取的标签序号，也是一个两层嵌套的序列，外层对应级别，内层对应记录，新版本中已被codes参数取代；
第四个参数names是每个级别的名称。
MultiIndex提供了一些辅助方法，set_levels、set_labels、set_names可以设置整体或是某一级别的索引属性，通过level参数指定级别，默认设置整体；
swaplevel可以交换级别，droplevel可以删除级别，sortlevel可以对指定级别排序；
from_array、from_tuples、from_product、from_frame方法可从其他结构的数据中创建索引。
2. 数据序列Series
In [99]: s=pd.Series([1,2,3,4],name='s1')
In [100]: s
Out[100]:
0 1
1 2
2 3
3 4
Name: s1, dtype: int64
In [101]: pd.Series([[1,2],[3,4]],index=['row1','row2'])
Out[101]:
row1 [1, 2]
row2 [3, 4]
dtype: object
In [102]: s.dtype
Out[102]: dtype('int64')
In [103]: s.name
Out[103]: 's1'
In [104]: s.values
Out[104]: array([1, 2, 3, 4], dtype=int64)
In [105]: s.index
Out[105]: RangeIndex(start=0, stop=4, step=1)
In [106]: s.shape
Out[106]: (4,)
核心数据模型其一，由序列名name、标签索引index、值数组(一维)values组成。用于存放一维数据，只有一个轴方向：0，shape属性可以查看数据集的形状。
创建时只能接收一维序列数据(list,tuple,ndarray)，超过一维的将后面的维度看作元素的维度，会根据传入的数据自动判断类型，也可通过dtype参数显示指定。
默认情况下会生成范围索引，可通过index参数指定一个一维序列作为索引，也可在创建后直接为index属性赋值。
3. 数据框DataFrame
In [107]: df=pd.DataFrame([[1,'a'],[2,'b']],columns=['col1','col2'])
In [108]: df
Out[108]:
col1 col2
0 1 a
1 2 b
In [113]: df.dtypes
Out[113]:
col1 int64
col2 object
dtype: object
In [114]: df.index
Out[114]: Int64Index([1, 2], dtype='int64', name='col1')
In [116]: df.columns
Out[116]: Index(['col1', 'col2'], dtype='object')
In [117]: df.values
Out[117]:
array([[1, 'a'],
[2, 'b']], dtype=object)
In [125]: df.col2
Out[125]:
col1
1 a
2 b
Name: col2, dtype: object
In [126]: pd.DataFrame({'col1':[1,3],'col2':['a','b']})
Out[126]:
col1 col2
0 1 a
1 3 b
In [127]: df.shape
Out[127]: (2, 2)
核心数据模型其二，也就是数据表，由列标签索引columns、行标签索引index、值数组(二维)values组成。用于存放二维数据，有两个轴方向：0和1，对应行坐标和列坐标，shape属性可以查看数据集的形状。列数据的访问可以通过与列名相同的属性名访问，仅在定义了字符串列名时可用，一个单列即是一个Series。
创建时只能接收二维序列数据(list,tuple,ndarray)，超过二维的将后面的维度看作元素的维度，会根据传入的数据自动判断类型，也可通过dtype参数显示指定，与numpy不太一样的是，DataFrame的列可以定义不同的数据类型，通过创建时的自动判断，或是筛选出列后转换类型，DataFrame.dtypes属性可查看所有列的数据类型。相比numpy，pandas的DataFrame创建还增加了对dict数据源的支持，key对应列名，value对应列数据。
默认情况下会生成范围索引，可通过index参数指定一个一维序列作为索引，也可在创建后直接为index属性赋值，DataFrame.set_index方法可以返回替换了索引的数据框副本而不影响原数据。
DataFrame相当于Series的堆叠，沿DataFrame的行或列方向进行宽度为1的切片，得到的就是一个Series。
原本pandas还提供了三维的数据模型Panel，但新版中已经废弃，可尝试使用多级索引MultiIndex来构造更高维度的数据集。
4. 分类数据Categorical
pandas提供了分类数据类型用于约束此类数据，该类型会限制分类标签的取值，并可为分类标签提供排序依据。
In[14]: pd.Categorical(['a','b','b','c'],categories=['a','b'],ordered=True)
Out[14]:
[a, b, b, NaN]
Categories (2, object): [a < b]
In[15]: pd.Categorical(['a','b','b','c'])
Out[15]:
[a, b, b, c]
Categories (3, object): [a, b, c]
第一个参数values为所有分类标签的序列；
第二个参数categories为唯一分类标签的序列，当指定该参数后，values中不属于categories的标签会被替换为NaN，不指定时会根据values自动生成；
第三个参数ordered声明唯一分类标签是否指示排序方式，为True时会按categories中的顺序对标签标定大小关系，默认False。
二. 数据类型与转换
1. 数据类型
pandas支持的数据类型就是numpy的数据类型，在创建数据模型时同样可通过dtype参数指定。
常用的数据类型有：np.bool_(bool),np.int64(int),np.float64(float),np.datetime64(datetime),object(str等),pd.Categorical(category)。
更详细的类型说明可查看numpy的使用指南。
和numpy不太一样的是，numpy中int类型默认为np.int32，而pandas中默认np.int64；numpy中存储字符串优先采用定长的np.str_，而pandas中统一使用object。
pandas数据模型使用单个ndarray作为基础数据，所以当pandas的每列采用不同数据类型时，作为数据来源的ndarray整体被设置为object数据类型。
2. 类型转换
In [48]: df=pd.DataFrame([[1,'2'],[3,'a']],columns=['col1','col2'])
In [49]: df.dtypes
Out[49]:
col1 int64
col2 object
dtype: object
In [50]: df.col1.astype('float')
Out[50]:
0 1.0
1 3.0
Name: col1, dtype: float64
In [52]: pd.to_numeric(df.col2,errors='ignore')
Out[52]:
0 2
1 a
Name: col2, dtype: object
In [53]: pd.to_numeric(df.col2,errors='coerce')
Out[53]:
0 2.0
1 NaN
Name: col2, dtype: float64
pandas和numpy一样主要使用astype进行类型转换，该方法返回转换后数据，需要在原数据上更改时可以用返回值去覆盖原数据。
当需要进行一些可能会失败的转换时，可以考虑使用专用的方法，例如pd.to_numeric用于将一个Series转换为数字类型，errors参数可以指定对错误的处理方式：'coerce'表示强制转换，不能转换的元素会替换为NaN；'ignore'表示存在无法转换的元素时会放弃转换。
当需要对DataFrame整体应用转换时，可使用apply方法。
三. 数组与统计运算
1. 运算符和标量值函数
pandas重载了python的大部分运算符，可以直接进行数组计算，numpy的标量值函数也可直接使用，这些运算都是将原本作用于单个元素的运算拓展到整个数组。
In [56]: df=pd.DataFrame([[1,'2'],[3,'a']],columns=['col1','col2'])
In [57]: df+df
Out[57]:
col1 col2
0 2 22
1 6 aa
In [201]: np.sqrt(df.col1)
Out[201]:
0 1.000000
1 1.732051
Name: col1, dtype: float64
使用的运算符和函数必须对参与运算的所有数据类型都是有意义的，否则会报错。
匹配方式
In [154]: s1=pd.Series([1,2,3,4],index=[0,1,2,3])
In [155]: s2=pd.Series([5,6,7,8],index=[1,2,3,4])
In [156]: s1+s2
Out[156]:
0 NaN
1 7.0
2 9.0
3 11.0
4 NaN
dtype: float64
此处需要注意pandas和numpy的区别，pandas的数组运算在元素匹配上是基于标签索引的，未能匹配到的位置会被替换为NaN，numpy则是基于位置索引。
2. 统计方法
聚合函数
pandas继承了numpy的聚合函数：sum、mean、max、min等。
可通过Series和DataFrame的方法调用，或是调用numpy下的静态方法。
In [58]: df.sum()
Out[58]:
col1 4
col2 2a
dtype: object
In [60]: np.max(df)
Out[60]:
col1 3
col2 a
dtype: object
In [114]: df.agg({'col1':'max','col2':'sum'})
Out[114]:
col1 3
col2 2a
dtype: object
In [115]: df.agg(['max','sum'])
Out[115]:
col1 col2
max 3 a
sum 4 2a
通过pandas数据模型的方法调用时，
第一个参数axis可以指定统计的轴，Series指定该参数没有意义，DataFrame默认沿轴0统计，即按列统计。pandas无法指定对所有轴展开统计，如有需要可以使用numpy的方法；
第二个参数skipna可以指示是否跳过NaN值；
第三个参数level用于在存在多级索引的情况下指定某一级索引进行统计；
第四个参数numeric_only用于指定是否只对数字应用计算。
当对DataFrame沿行方向统计时，由于不同列的数据类型可能不一样，需保证对应运算是有意义的，否则无法得到期望的结果。
agg方法是aggregate方法的简写，用于对不同列应用不同聚合函数或是多种聚合函数，可以传入list或是dict声明统计方式。
分组统计
pandas提供了类似于sql的groupby方法用于分组统计。
In [88]: df=pd.DataFrame([['a','c',1],['a','d',2],['b','d',3]],columns=['col1','col2','col3'])
In [89]: df
Out[89]:
col1 col2 col3
0 a c 1
1 a d 2
2 b d 3
In [93]: result=df.groupby(by=['col1','col2']).agg(['max','min'])
In [94]: result
Out[94]:
col3
max min
col1 col2
a c 1 1
d 2 2
b d 3 3
In [95]: result.sum(level=0)
Out[95]:
col3
max min
col1
a 3 3
b 3 3
In [140]: gb=df.groupby(by=['col1','col2'])
In [141]: gb.groups
Out[141]:
{('a', 'c'): Int64Index([0], dtype='int64'),
('a', 'd'): Int64Index([1], dtype='int64'),
('b', 'd'): Int64Index([2], dtype='int64')}
In [142]: gb.get_group(('a','c'))
Out[142]:
col1 col2 col3
0 a c 1
只调用groupby方法会得到一个DataFrameGroupBy对象，通过其groups方法可查看所有分组信息，get_group方法可获取指定分组。
该对象可调用各种聚合函数，或调用agg方法进行复合的聚合统计，返回包含多级索引的DataFrame统计结果表，对于结果表，可以继续应用统计函数并通过level参数指定索引级别进行二次统计。
3. 应用自定义函数
除pandas和numpy提供的函数外，还可以自定义函数并使用apply、applymap、map方法快速应用于整个数据集。
In [119]: df.apply(lambda x: x.col1+x.col2, axis=1)
Out[119]:
0 3
1 7
dtype: int64
In [120]: def add(row):
...: return row.col1+row.col2
In [121]: df.apply(add, axis=1)
Out[121]:
0 3
1 7
dtype: int64
In [122]: df.applymap(lambda x: x*2)
Out[122]:
col1 col2
0 2 4
1 6 8
In [123]: def double(item):
...: return item*2
In [124]: df.applymap(double)
Out[124]:
col1 col2
0 2 4
1 6 8
In [128]: s=pd.Series(['a','b','b'])
In [129]: s.map(lambda x: x*2)
Out[129]:
0 aa
1 bb
2 bb
dtype: object
In [130]: s.map({'a':'c','b':'d'})
Out[130]:
0 c
1 d
2 d
dtype: object
DataFrame有apply和applymap两个方法：
apply将函数应用于每行或者每列，axis参数指定应用函数的轴方向，值为0表示按列应用，即逐列作为函数的参数进行计算，值为1表示按行应用，默认为0；
applymap将函数应用于每个元素。
Series只有一个map方法，用于将函数应用于元素，除此以外，还提供值映射的功能，输入dict类型时会根据key-value映射将相应的值替换。
支持lambda匿名函数。
4. 广播
In [80]: l2=[1,2]
...: a2=np.array(l2)
...: s2=pd.Series(l2)
...: df21=pd.DataFrame([1,2])
...: df12=pd.DataFrame([[1,2]])
...: l22=[[1,2],[3,4]]
...: a22=np.array(l22)
...: df22=pd.DataFrame(l22)
...: df23=pd.DataFrame([[3,4,5],[6,7,8]])
In [99]: df22+l2
Out[99]:
0 1
0 2 4
1 4 6
In [100]: df22+a2
Out[100]:
0 1
0 2 4
1 4 6
In [101]: df22+s2
Out[101]:
0 1
0 2 4
1 4 6
In [102]: df22+df21
Out[102]:
0 1
0 2 NaN
1 5 NaN
In [103]: df22+df12
Out[103]:
0 1
0 2.0 4.0
1 NaN NaN
In [104]: df23+s2
Out[104]:
0 1 2
0 4.0 6.0 NaN
1 7.0 9.0 NaN
In [130]: df21+df12
Out[130]:
0 1
0 2.0 NaN
1 NaN NaN
pandas的广播机制继承自numpy但有不一样的地方：
标量值会与DataFrame或Series中每个元素进行同样的计算；
Series或一维list或一维ndarray会与DataFrame的每一行进行运算，Series在长度不足以匹配DataFrame的行时不足部分会替换为NaN，其他两种长度不足会报错；
DataFrame与DataFrame进行运算会按元素匹配，无论行列，长度不足的部分都会替换为NaN；
二维ndarray与DataFrame的运算遵循numpy的广播规则，长度不足且为1的轴会被广播至同等大小；
二维list与DataFrame的运算不被支持。
四. 查询和关联
1. 索引查找
(1). 索引器格式
单值选取：[value,...]
多值选取：[[value1,value2],...]
范围选取：[start:end:step,...]
start表示区间的开始，默认值0，end表示区间的结束(不包含)，默认值等于轴长度，step表示选取的步长，默认值1，采用默认值的参数可以省略，[:,...]表示对应轴方向上全部选取。
pandas中索引器的格式与numpy差不多，但用法有区别。pandas除了numpy的位置索引，还增加了标签索引，虽然可以对Series和DataFrame直接使用索引器，但用法被严格限制，建议改用iloc和loc方法进行索引。
(2). 直接索引
In [157]: df=pd.DataFrame(np.arange(1,10).reshape((3,3)),columns=['col1','col2','col3'],index=['row1','row2','row3'])
In [158]: df[0:3:2]
Out[158]:
col1 col2 col3
row1 1 2 3
row3 7 8 9
In [161]: df['row1':'row3':2]
Out[161]:
col1 col2 col3
row1 1 2 3
row3 7 8 9
In [162]: df['col2']
Out[162]:
row1 2
row2 5
row3 8
Name: col2, dtype: int32
In [163]: df[['col1','col3']]
Out[163]:
col1 col3
row1 1 3
row2 4 6
row3 7 9
In [168]: df['col2'][1:3]
Out[168]:
row2 5
row3 8
Name: col2, dtype: int32
直接索引提供了有限的几种使用方式：按行位置进行索引切片、按行标签进行索引切片、按列标签取列、按列标签列表取多列、布尔索引筛选行、索尔索引筛选元素等。
一次索引器只能使用一种方式，不能行列同时操作，如有需要，可进行连续索引。
(3). loc和iloc索引
In [169]: df.loc['row1','col1']
Out[169]: 1
In [170]: df.loc['row1':'row3':2,'col1':'col3':2]
Out[170]:
col1 col3
row1 1 3
row3 7 9
In [185]: df.iloc[0,0]
Out[185]: 1
In [186]: df.iloc[0:3:2,0:3:2]
Out[186]:
col1 col3
row1 1 3
row3 7 9
loc专用于标签索引，iloc专用于位置索引，索引器可接收单值、列表、范围、布尔索引，可同时索引行和列。
(4). 布尔索引
In [190]: df>5
Out[190]:
col1 col2 col3
row1 False False False
row2 False False True
row3 True True True
In [191]: df[df>5]
Out[191]:
col1 col2 col3
row1 NaN NaN NaN
row2 NaN NaN 6.0
row3 7.0 8.0 9.0
In [192]: df['col1']>2
Out[192]:
row1 False
row2 True
row3 True
Name: col1, dtype: bool
In [193]: df.loc[df['col1']>2]
Out[193]:
col1 col2 col3
row2 4 5 6
row3 7 8 9
In [196]: df.loc[df['col1']>2,df.iloc[1]>5]
Out[196]:
col3
row2 6
row3 9
In [208]: df.iloc[df['col1'].values>2]
Out[208]:
col1 col2 col3
row2 4 5 6
row3 7 8 9
布尔索引是一种比较特殊的索引，通过对pandas或numpy的数据模型进行逻辑运算得到，与源数据结构相同，数据类型为bool，用于标识每个元素是否符合逻辑运算的条件。在索引器中使用布尔索引可以筛选出符合条件的数据。
在直接索引时，二维布尔索引可以用于筛选DataFrame的元素，形状不变，不符合条件的元素会被替换为NaN，这一点和numpy不一样，numpy进行同样形式的筛选时会将符合条件的元素构造为新的一维数组返回；一维布尔索引只可以用于筛选行数据；
在使用loc索引时，不能使用二维布尔索引，只能针对每个轴使用一维布尔索引，并且必须是由Series运算得到的带有标签索引的布尔索引；
在使用iloc索引时，同样不能使用二维布尔索引，只能针对每个轴使用一维布尔索引，并且必须是由一维ndarray运算得到的不含标签索引的布尔索引(Series.values可得到对应的ndarray)。
(5). 指定值查找
In [141]: df=pd.DataFrame({'a':[np.nan,1,2],'b':[3,np.nan,4]})
In [142]: df
Out[142]:
a b
0 NaN 3.0
1 1.0 NaN
2 2.0 4.0
In [143]: df.isin([2,3])
Out[143]:
a b
0 False True
1 False False
2 True False
In [144]: df.isna()
Out[144]:
a b
0 True False
1 False True
2 False False
isin方法用于查找存在于指定列表中的值，isna方法用于查找NaN值，两方法都会返回布尔索引，通常结合索引器使用。
2. 表连接
pandas提供了类似于sql的join、merge、concat方法进行表连接。
(1). 索引连接
In [227]: df1=pd.DataFrame([[1,2],[3,4]],columns=['col1','col2'],index=[1,0])
In [228]: df2=pd.DataFrame([[5,6],[7,8]],columns=['col3','col4'],index=[0,1])
In [229]: df1.join(df2,how='inner')
Out[229]:
col1 col2 col3 col4
1 1 2 7 8
0 3 4 5 6
join方法根据索引进行表连接，how参数指定连接方式，有inner内连接、outer外连接、left左连接、right右连接 这几种，默认为left。
此处的join和sql中的join并不一样。
(2). 键连接
In [233]: df1=pd.DataFrame({'col1':[1,2,3],'col2':[4,5,6]})
In [234]: df2=pd.DataFrame({'col2':[4,5,7],'col3':[1,2,2]})
In [235]: df1.merge(df2)
Out[235]:
col1 col2 col3
0 1 4 1
1 2 5 2
In [237]: df1.merge(df2,how='left',left_on='col1',right_on='col3')
Out[237]:
col1 col2_x col2_y col3
0 1 4 4.0 1.0
1 2 5 5.0 2.0
2 2 5 7.0 2.0
3 3 6 NaN NaN
merge方法根据指定键(列)进行表连接，通过on参数(相同键)或left_on和right_on参数(不同键)指定，默认会将两表中都存在的键作为连接键；how参数指定连接方式，有inner内连接、outer外连接、left左连接、right右连接 这几种，默认为inner。
该方法才是sql中join的等效方法。
(3). 拼接
In [239]: df1=pd.DataFrame({'col1':[1,2,3],'col2':[4,5,6]})
In [240]: df2=pd.DataFrame({'col2':[4,5,7],'col3':[1,2,2]})
In [241]: pd.concat([df1,df2])
Out[241]:
col1 col2 col3
0 1.0 4 NaN
1 2.0 5 NaN
2 3.0 6 NaN
0 NaN 4 1.0
1 NaN 5 2.0
2 NaN 7 2.0
In [242]: pd.concat([df1,df2],join='inner')
Out[242]:
col2
0 4
1 5
2 6
0 4
1 5
2 7
In [243]: pd.concat([df1,df2],axis=1)
Out[243]:
col1 col2 col2 col3
0 1 4 4 1
1 2 5 5 2
2 3 6 7 2
用于拼接表，等效于sql中的union all。
axis参数指定用于拼接的轴，默认0；join参数指定其他轴的处理方式，inner表示只返回都存在的项，outer表示全部返回，默认outer。
拼接后的结果表中可能会有行索引或列索引上的重复，可以视需要重整索引。
五. 增删改
1. 更新
In [259]: df=pd.DataFrame({'a':[1,2],'b':[3,4]})
In [260]: df.iloc[0,0]=0
In [261]: df[df>2]+=1
In [262]: df
Out[262]:
a b
0 0 4
1 2 5
In [265]: df['a']=[2,1]
In [266]: df
Out[266]:
a b
0 2 4
1 1 5
In [268]: df[:]=[1,2]
In [269]: df
Out[269]:
a b
0 1 2
1 1 2
更新数据的方式与numpy一样，索引筛选数据后直接赋值就行了，可以对所有元素赋值同一个标量，也可赋值同样形状的数据集，或是对DataFrame每行赋值同样的数据序列。
2. 增加
In [246]: df=pd.DataFrame({'a':[1,2],'b':[3,4]})
In [247]: df['c']=[5,6]
In [248]: df
Out[248]:
a b c
0 1 3 5
1 2 4 6
In [252]: df.loc[2]=-1
In [253]: df
Out[253]:
a b c
0 1 3 5
1 2 4 6
2 -1 -1 -1
In [254]: df.insert(0,'new',[0,0,0])
In [255]: df
Out[255]:
new a b c
0 0 1 3 5
1 0 2 4 6
2 0 -1 -1 -1
借助索引器可直接为新行或是新列赋值。
insert方法可以在指定位置插入新列，loc参数指定位置索引，column参数指定列名，value指定新列的数据。
3. 删除
In [276]: df=pd.DataFrame({'a':[1,2,3],'b':[4,5,6]})
In [277]: df[df['a']>2]
Out[277]:
a b
2 3 6
In [281]: df.drop([0,2])
Out[281]:
a b
1 2 5
In [282]: df.drop('a',axis=1)
Out[282]:
b
0 4
1 5
2 6
删除数据最灵活的方法就是通过索引筛去不需要的数据。
也可通过drop删除指定索引标签的数据，labels指定要删除的标签，可以是标量或是列表，axis参数指定查找索引标签的轴，默认为0。该方法是根据索引标签而不是位置去删除的，所以如果指定标签存在重复，这些数据会一起被删除。
4. 重构索引
In [246]: df=pd.DataFrame({'a':[1,2],'b':[3,4]})
In [256]: df.reindex(columns=['a','b','c','d'],fill_value=0)
Out[256]:
a b c d
0 1 3 0 0
1 2 4 0 0
reindex方法用于重构索引，可以实现复杂的结构变更，包括行列的增加、删除、移位，index设置新的行索引，columns参数设置新的列索引，已存在的索引会和数据一起被移至新的位置，不存在的将被创建，fill_value参数可以指定新增行列的填充值。
5. 行列转置
In [133]: df=pd.DataFrame({'a':[1,2],'b':[3,4]})
In [134]: df
Out[134]:
a b
0 1 3
1 2 4
In [135]: df.T
Out[135]:
0 1
a 1 2
b 3 4
DataFrame.T用于实现行列转置，整个数据集将沿左上至右下的对角线翻转。
Series调用转置方法是无效的，如果需要转置，先调用to_frame方法转为DataFrame。
6. 缺失值填充
In [95]: df=pd.DataFrame({'a':[np.nan,1,3],'b':[2,np.nan,6]})
In [96]: df
Out[96]:
a b
0 NaN 2.0
1 1.0 NaN
2 3.0 6.0
In [97]: df.fillna(0)
Out[97]:
a b
0 0.0 2.0
1 1.0 0.0
2 3.0 6.0
In [98]: df.fillna(df.mean())
Out[98]:
a b
0 2.0 2.0
1 1.0 4.0
2 3.0 6.0
In [120]: df.dropna()
Out[120]:
a b
2 3.0 6.0
In [121]: df[df.isna()]=0
In [122]: df
Out[122]:
a b
0 0.0 2.0
1 1.0 0.0
2 3.0 6.0
fillna方法用于直接填充缺失值，可传入标量，对所有列填充同样的值，也可传入字典或系列，对不同列填充不同的值。
dropna方法用于直接删除带却缺失值的行或列：axis参数指定删除行(0)或列(1)；how参数指定删除的条件，'all'表示全部值为NaN时删除，'any'表示有一个为NaN时删除；thresh参数设置在出现几个NaN时执行删除。
isna方法配合索引器也能对缺失值进行更新，可通过赋值标量对所有列填充同样的值，或是赋值序列对不同列填充不同的值。
六. 排序与去重
1. 直接与间接排序
In[5]: df=pd.DataFrame([[2,'a'],[1,'c'],[3,'b']],columns=['col1','col2'],index=[3,2,1])
In[6]: df
Out[6]:
col1 col2
3 2 a
2 1 c
1 3 b
In[7]: df.sort_index()
Out[7]:
col1 col2
1 3 b
2 1 c
3 2 a
In[8]: df.sort_values('col1')
Out[8]:
col1 col2
2 1 c
3 2 a
1 3 b
In [21]: df.loc[df['col2'].sort_values().index]
Out[21]:
col1 col2
3 2 a
1 3 b
2 1 c
sort_index方法可以按索引排序，axis参数指定排序的轴，默认0，level参数指定用于排序的多级索引的级别，默认None，ascending参数指定是否升序，默认True。
sort_values方法可以按指定键排序，by参数指定用于排序的键，axis参数指定排序的轴，默认0，ascending参数指定是否升序，默认True。
间接排序可通过loc方法传入排序后的标签索引实现，排序前两个数据模型的索引必须一致；iloc方法类似，需要传入经过numpy的argsort方法排序后的位置索引。
2. 去重
In[8]: df=pd.DataFrame({'a':[1,2,2,2],'b':[3,3,4,4]})
In[10]: df
Out[10]:
a b
0 1 3
1 2 3
2 2 4
3 2 4
In[11]: df.duplicated()
Out[11]:
0 False
1 False
2 False
3 True
dtype: bool
In[12]: df.drop_duplicates()
Out[12]:
a b
0 1 3
1 2 3
2 2 4
In[14]: df.drop_duplicates('a',keep='last')
Out[14]:
a b
0 1 3
3 2 4
duplicated方法用于返回标识去重结果的一维布尔数组，保留的项为True。subset参数指定参与去重的行或列标签，默认使用所有列；keep参数指定保留方式，'first'表示保留第一项，'last'表示保留最后一项，None表示不保留。
drop_duplicates方法用于返回去重结果。subset和keep参数的作用和duplicated一样。
七. 乱序和抽样
1. 随机排序
In [24]: df=pd.DataFrame({'a':[1,2,3],'b':[4,5,6]})
In [25]: df.iloc[np.random.permutation(df.shape[0])]
Out[25]:
a b
1 2 5
0 1 4
2 3 6
In [27]: df.sample(frac=1.)
Out[27]:
a b
0 1 4
2 3 6
1 2 5
随机排序，用于打乱数据集。一种方法是通过numpy生成乱序索引，然后应用在pandas的iloc索引方法上；另一种方法是使用pandas的抽样方法sample，设置抽样比例frac参数为1.，采用默认的不放回抽样的方式，也可以达到同样的效果。
2. 抽样
In [34]: df.sample(n=2)
Out[34]:
a b
1 2 5
2 3 6
In [36]: df.sample(frac=0.8,replace=True)
Out[36]:
a b
1 2 5
1 2 5
sample方法用于抽样，第一个参数n设置抽样数量，第二个参数frac设置抽样比例，第三个参数replace设置是否放回，默认False，第四个参数weight可设置样本权重，第五个参数random_state设置随机数种子。
八. 读写
1. 读写csv
In [13]: df=pd.DataFrame({'a':[1,2],'b':[3,4]},index=['r1','r2'])
In [14]: df.to_csv()
Out[14]: ',a,b\nr1,1,3\nr2,2,4\n'
In [15]: df.to_csv(index=False)
Out[15]: 'a,b\n1,3\n2,4\n'
In [16]: df.to_csv("d:\\test.csv",index=False)
In [17]: df2=pd.read_csv("d:\\test.csv")
In [18]: df2
Out[18]:
a b
0 1 3
1 2 4
to_csv方法用于写入csv文件：
参数path_or_buf设置文件路径或对象，默认为None，表示直接返回完整的内容字符串；
参数sep设置分隔符，长度为1的字符串，默认为','；
参数na_rep设置缺失值填充，默认''；
参数float_format设置浮点数的格式字符串，如'%.2f'表示保留两位小数；
参数columns设置要写的列，默认None，表示全部；
参数header设置是否写入列名，默认True，如果给出字符串列表，则作为列别名；
参数index设置是否写入行索引标签，默认True；
参数index_label设置行索引列的列名，默认None，会直接使用索引的名称，不写入列名需要设置为False；
参数encoding设置编码格式，python3默认utf-8；
参数chunksize设置每次批量写入的块大小，默认一次写入全部数据。
read_csv方法用于读取csv文件：
参数filepath_or_buffer设置文件路径或类文件对象，必须赋值；
参数sep设置分隔符，长度为1的字符串，默认为','；
参数header设置作为列名的行号，可传入列表，会读取为多级索引，默认是第一行作为列名，当通过names显示传递列名时，该设置无效，另外，该参数会跳过注释行和空行；
参数names设置列名列表，默认为None，如果文件不含列名，header也应设置为None，该参数不能有重复项，会报错；
参数index_col设置作为行标签的列号，可传入列表，会读取为多级索引，默认不设置；
参数usecols设置要读取的列列表，可以是列位置(int)或是列名(str)的列表，也可以传入对列名进行逻辑判断的函数，结果为True的列将被返回；
参数prefix设置默认列名前缀，在没有设置列名时会将该前缀组合列号作为列名；
参数dtype设置数据类型，dict类型，键为列名，值为numpy数据类型，默认None；
参数skiprows设置开头要跳过的行数，需要传入int，也可以设置要跳过的行号，传入list of int或对行号进行逻辑判断的函数；
参数skipfooter设置尾部要跳过的行数，需要传入int；
参数nrows设置要读取的行数，用于分批读取大文件；
参数na_filter设置是否检测缺失值，默认True，在确定没有缺失值的情况下可以关闭以提升读取性能；
参数skip_blank_lines设置是否跳过空行，默认True；
参数encoding设置编码格式，python3默认utf-8；
参数error_bad_lines设置列数异常的坏行是否报错，默认True，False时会直接剔除坏行；
参数chunksize设置分块的大小，如果设置，会按该大小分块读取并以迭代器返回。
2. 读写excel
In [5]: df=pd.DataFrame({'a':[1,2],'b':[3,4]},index=['r1','r2'])
In [7]: df.to_excel('d:\\test.xlsx',sheet_name='test1',index=False)
In [8]: df2=pd.read_excel('d:\\test.xlsx',sheet_name=0)
In [9]: df2
Out[9]:
a b
0 1 3
1 2 4
to_excel方法用于写入xls或xlsx文件：
参数excel_writer设置文件路径或ExcelWriter，必须赋值；
参数sheet_name设置要读取的工作表名称，默认'Sheet1'；
参数na_rep设置缺失值填充，默认''；
参数float_format设置浮点数的格式字符串，如'%.2f'表示保留两位小数；
参数columns设置要写入的列，为列名的序列；
参数header设置是否写入列名，默认True，当输入字符串列表时会当作列的别名；
参数index设置是否写入行索引标签，默认True；
参数index_label设置行索引列的列名，当存在多级索引时应当输入字符串列表，默认None，会直接使用索引的名称；
参数startrow设置写入的起始行，默认0；
参数startcol设置写入的起始列，默认0；
参数merge_cells设置单元格是否合并，默认True。
read_excel方法用于读取xls或xlsx文件：
参数io设置文件路径或Excel文件对象，必须赋值；
参数sheet_name设置要读取的工作表，可以传入序号(int)或工作表名(str)或是包含前两种的列表，传入None表示全部，默认0；
参数header设置解析为列名的行号，传入行号的列表时会解析为多级索引，如果没有列名，需要设置为None；
参数names设置列名，与header配合使用，默认None；
参数index_col设置解析为行标签的列号，传入列号的列表时会解析为多级索引，默认None；
参数usecols设置需要返回的列，可传入列号的列表list of int、列名的列表list of str、用逗号分隔的列名序列(例如 'A,B,C')或用冒号标识的列名范围(例如 'A:E')str，也可传入对列名进行逻辑判断的函数，结果为True的列将被返回；
参数dtype设置数据类型，dict类型，键为列名，值为numpy数据类型，默认None；
参数skiprows设置开头要跳过的行数，需要传入int，也可以设置要跳过的行号，传入list of int或对行号进行逻辑判断的函数；
参数skipfooter设置尾部要跳过的行数，需要传入int。
3. 读写sql
In [21]: import sqlalchemy as sqla
...: username='sa'
...: password='123456'
...: server='127.0.0.1'
...: database='Test'
...: charset='utf8'
...: engine = sqla.create_engine('mssql+pymssql://{}:{}@{}/{}?charset={}'.format(username,password,server,database,charset))
In [23]: df=pd.DataFrame({'a':[1,2],'b':[3,4]},index=['r1','r2'])
In [24]: df.to_sql('test1',engine,if_exists='append',index=False)
In [25]: df.to_sql('test1',engine,if_exists='append',index=False)
In [27]: df2=pd.read_sql('select * from test1',engine)
In [28]: df2
Out[28]:
a b
0 1.0 3.0
1 2.0 4.0
2 1.0 3.0
3 2.0 4.0
to_sql方法用于写入数据库：
参数name设置要写入的表名，str类型；
参数conn设置数据库连接，sqlalchemy.engine.Engine类型，需要配合sqlalchemy库使用，通过create_engine方法创建，连接字符串格式形如'{数据库类型}+{驱动名}://{用户名}:{密码}@{服务器地址}:{端口号}/{数据库名}?charset={字符集}'；
参数if_exists设置表存在时的处理方式，'fail'表示抛出异常，'replace'表示替换现有表，'append'表示作为新数据插入现有表，默认'fail'；
参数index设置行索引标签是否作为一列写入，默认True;
参数index_label设置行索引标签列的列名，当存在多级索引时应当输入字符串列表，默认None，会直接使用索引的名称;
参数chunksize设置每次批量写入的块大小，默认一次写入全部数据；
参数dtype设置写入的数据类型，dict类型，键为列名，值为sqlalchemy数据类型；
read_sql方法用于读取数据库：
参数sql设置要执行的sql查询或表名；
参数conn设置数据库连接，sqlalchemy.engine.Engine类型；
参数index_col设置作为行标签索引的列名，传入列名的列表时会生成多级索引；
参数coerce_float设置是否尝试将一些非字符串非数字对象（如decimal.Decimal）的值转换为浮点数，默认True；
参数params设置传递给执行sql的参数列表，具体格式由使用的驱动决定；
参数parse_dates设置要解析为时间的列名列表，默认None；
参数columns设置要读取的列，仅在sql参数传入表名时有效，默认None读取全部列；
参数chunksize设置分块的大小，如果设置，会按该大小分块读取并以迭代器返回。
九. 快速绘图
准备好pandas数据对象就可以调用方法直接绘图，pandas提供的快速绘图只适用于单次绘图，不便于构建复杂的图表，如有需要，使用matplotlib的方法创建图像和子图。
1. 曲线图
In [30]: df=pd.DataFrame({'a':[1,1.5,2.5,4],'b':[3,2.1,3.2,1],'c':[1,2,3,4]})
In [53]: fig=plt.figure(figsize=(12,4))
...:
...: ax1=fig.add_subplot(1,2,1)
...: df.plot.line(ax=ax1)
...:
...: ax2=fig.add_subplot(1,2,2)
...: df.plot.line(x='c',y=['a','b'],ax=ax2)
...:
...: #plt.show()
Out[53]: <matplotlib.axes._subplots.AxesSubplot at 0x2aefe00ddd8>
参数x设置作为x轴数据的列名(只能一个)，参数y设置作为y轴数据的列名/列名列表，参数ax设置子图对象，默认None单独绘制。
plt.figure用于创建图像，figsize用于设置图像大小，tuple类型，格式为(weight,height);
Figure.add_subplot用于创建子图，第一个参数设置纵向分区个数，第二个参数设置横向分区个数，第三个参数设置是第几个子图，是按分区先横后纵排列的；
plt.plot用于显示绘制好的图像，在当前场景下可以省略，ipython调用完pandas的绘图方法后会直接显示。
绘制曲线图也可以使用plot(kind='line')，参数kind也可以省略，因为默认值就是'line'。
2. 条形图
In [30]: df=pd.DataFrame({'a':[1,1.5,2.5,4],'b':[3,2.1,3.2,1],'c':[1,2,3,4]})
In [147]: fig=plt.figure(figsize=(12,4))
...:
...: ax1=fig.add_subplot(1,2,1)
...: df.plot.bar(ax=ax1)
...:
...: ax2=fig.add_subplot(1,2,2)
...: df.plot.bar(stacked=True,ax=ax2)
Out[147]: <matplotlib.axes._subplots.AxesSubplot at 0x2aeff4f17b8>
参数stacked设置条形图是否堆叠。
水平条形图需要改用DataFrame.plot.barh方法。
3. 直方图
In [205]: df=pd.DataFrame({'a':[1,2,2,3],'b':[3,3,3,4],'c':[1,2,3,4]})
In [210]: fig=plt.figure(figsize=(12,4))
...:
...: ax1=fig.add_subplot(1,2,1)
...: df.plot.hist(alpha=0.5,ax=ax1)
...:
...: ax2=fig.add_subplot(1,2,2)
...: df.plot.hist(stacked=True,bins=4,ax=ax2)
Out[210]: <matplotlib.axes._subplots.AxesSubplot at 0x2aefff32080>
参数alpha设置透明度，参数stacked设置是否堆叠，参数bins设置分箱数。
配合diff可以绘制按列拆分为子图的直方图：
In [165]: df.diff().hist(bins=4)
Out[165]:
array([[<matplotlib.axes._subplots.AxesSubplot object at 0x000002AE805A4748>,
<matplotlib.axes._subplots.AxesSubplot object at 0x000002AE805E3D68>],
[<matplotlib.axes._subplots.AxesSubplot object at 0x000002AE80615390>,
<matplotlib.axes._subplots.AxesSubplot object at 0x000002AE8063DA20>]],
dtype=object)
4. 箱线图
In [166]: df = pd.DataFrame(np.random.rand(10, 4),columns=['A','B','C','D'])
In [167]: df.plot.box()
Out[167]: <matplotlib.axes._subplots.AxesSubplot at 0x2aeff644080>
5. 散点图
In[185]: df=pd.DataFrame(np.random.rand(50,3),columns=['a','b','c'])
In[186]: fig=plt.figure(figsize=(12,4))
...:
...: ax1=fig.add_subplot(1,2,1)
...: df.plot.scatter(x='a',y='b',s=df['c']*200,ax=ax1)
...:
...: ax2=fig.add_subplot(1,2,2)
...: df[df['c']>=0.5].plot.scatter(x='a',y='b',color='b',label='c1',ax=ax2)
...: df[df['c']<0.5].plot.scatter(x='a',y='b',color='g',label='c2',ax=ax2)
Out[186]: <matplotlib.axes._subplots.AxesSubplot at 0x2ae81a82e48>
参数
x设置作为x轴数据的列名(只能一个)，参数y设置作为y轴数据的列名(只能一个)，参数s设置点的大小，参数color设置点的颜色，参数label设置标签，需要为每个类别绘制不同颜色的点时，筛选出每个类别的数据分别绘制到同一个子图上，并指定颜色和标签。
6. 饼图
In [203]: df=pd.DataFrame(2*np.random.rand(3,2),index=['a','b','c'],columns=['p1','p2'])
In [204]: df.plot.pie(y='p1',figsize=(4,4))
Out[204]: <matplotlib.axes._subplots.AxesSubplot at 0x2ae81f66cf8>
In [206]: df.plot.pie(subplots=True,figsize=(8.5,4))
Out[206]:
array([<matplotlib.axes._subplots.AxesSubplot object at 0x000002AE8171BEB8>,
<matplotlib.axes._subplots.AxesSubplot object at 0x000002AEFFFD78D0>],
dtype=object)
有两种绘制方式，一是参数y指定一个列作为取值绘制饼图，二是设置参数subplots为True，会用每个列的数据绘制子图。
figsize是绘图的通用参数，用于设置图像大小。
