让数据清洗和数据分析变得简答的数据结构和操作工具
pandas是专门为处理表格和混杂数据设计的。而NumPy更适合处理统一的数值数组数据。
Series
In [38]: from pandas import Series,DataFrame
In [39]: obj=pd.Series([4,7,-5,3])
Series由索引和值构成
In [40]: obj
Out[40]:
0 4
1 7
2 -5
3 3
dtype: int64
自定义索引
In [43]: obj2=pd.Series([4,7,-5,3],index=['d','b','a','c'])
用索引操作元素：
In [48]: obj2[['a','b']]
使用NumPy函数或类似NumPy的运算（如根据布尔型数组进行过滤、标量乘法、应用数学函数等）都会保留索引值的链接：
目前看来，和numpy相比，Series就是多了索引
可以将Series看作是一个有序的字典
In [52]: 'a' in obj2
Out[52]: True
In [49]: sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}#用字典构建Series
In [50]: obj3=pd.Series(sdata)
用字典构造Series的时候，可以改变键的顺序
In [58]: keys
Out[58]: ['Ohio', 'Oregon', 'Texas', 'Utah']
In [59]: obj4=pd.Series(sdata,index=keys)
In [60]: obj4
Out[60]:
Ohio 35000
Oregon 16000
Texas 71000
Utah 5000
dtype: int64
如果添加的index中的元素不在原字典中，则会显示为
In [61]: obj5=pd.Series(sdata,['a','b','c','d'])
In [62]: obj5
Out[62]:
a NaN
b NaN
c NaN
d NaN
dtype: float64
表示缺失数据。
pandas的isnull和notnull函数可用于检测缺失数据：
In [66]: pd.isnull(obj5)
Out[66]:
a True
b True
c True
d True
dtype: bool
Series对象自带属性name，可以直接赋值
In [70]: obj4.name='population'
In [71]: obj4
Out[71]:
Ohio 35000
Oregon 16000
Texas 71000
Utah 5000
Name: population, dtype: int64
Series对象的index值也可以直接修改
In [72]: obj
Out[72]:
0 4
1 7
2 -5
3 3
dtype: int64
In [73]: obj.index=['anchor','ama','avec','god']
In [74]: obj
Out[74]:
anchor 4
ama 7
avec -5
god 3
dtype: int64
DataFrame
DataFrame是一个表格型数据结构，含有一组有序的列（每列可以是不同的元素）；
DataFrame既有行索引，也有列索引。可以视作由多个Series对象构成的(每个列是一个Series，这些Series对象共用相同的索引）
关于DataFrame的结构
DataFrame实际就是由多个共用索引的Series对象构成。
对于一个DataFrame对象来说，它的key就是列索引，而对于DataFrame对象中的每一个Series对象（每一列）来说，key就是行索引
In [77]: data
Out[77]:
{'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
'year': [2000, 2001, 2002, 2001, 2002, 2003],
'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
In [80]: frame
jupyter notebook界面
显示前5行数据
In [6]: frame.head()
Out[6]:
state year pop
0 Ohio 2000 1.5
1 Ohio 2001 1.7
2 Ohio 2002 3.6
3 Nevada 2001 2.4
4 Nevada 2002 2.9
如果指定了列序列，则DataFrame的列就会按照指定顺序进行排列：
In [8]: pd.DataFrame(data,columns=['year','state','pop'])
Out[8]:
year state pop
0 2000 Ohio 1.5
1 2001 Ohio 1.7
2 2002 Ohio 3.6
3 2001 Nevada 2.4
4 2002 Nevada 2.9
5 2003 Nevada 3.2
指定列序列和索引（此时索引不在是唯一键（唯一键成了列序列），所以可以在构建时修改）。如果传入的列在数据中找不到，则会在结果中产生缺省值
In [9]: pd.DataFrame(data,columns=['year','state','pop','debt'],index=['one','two','three','four','five','six'])
Out[9]:
year state pop debt
one 2000 Ohio 1.5 NaN
two 2001 Ohio 1.7 NaN
three 2002 Ohio 3.6 NaN
four 2001 Nevada 2.4 NaN
five 2002 Nevada 2.9 NaN
six 2003 Nevada 3.2 NaN
前面说了可以将DataFrame对象看成多个Series，那么自然在python这门神奇的语言，咳咳：
In [11]: frame
Out[11]:
year state pop debt
one 2000 Ohio 1.5 NaN
two 2001 Ohio 1.7 NaN
three 2002 Ohio 3.6 NaN
four 2001 Nevada 2.4 NaN
five 2002 Nevada 2.9 NaN
six 2003 Nevada 3.2 NaN
In [12]: frame['year']
Out[12]:
one 2000
two 2001
three 2002
four 2001
five 2002
six 2003
Name: year, dtype: int64
In [13]: frame.state
Out[13]:
one Ohio
two Ohio
three Ohio
four Nevada
five Nevada
six Nevada
In [14]: type(frame['year'])
Out[14]: pandas.core.series.Series
为DataFrame对象创建一个新列
In [26]: frame['eastern']=frame['state']=='Ohio'
In [27]: frame
Out[27]:
year state pop debt eastern
one 2000 Ohio 1.5 NaN True
two 2001 Ohio 1.7 NaN True
three 2002 Ohio 3.6 NaN True
four 2001 Nevada 2.4 NaN False
five 2002 Nevada 2.9 NaN False
six 2003 Nevada 3.2 NaN False
使用del删除该列
In [28]: del frame['eastern']
In [29]: frame
Out[29]:
year state pop debt
one 2000 Ohio 1.5 NaN
two 2001 Ohio 1.7 NaN
three 2002 Ohio 3.6 NaN
four 2001 Nevada 2.4 NaN
five 2002 Nevada 2.9 NaN
six 2003 Nevada 3.2 NaN
在python中，通过索引获得的值（包括切片）都是获得原对象的试图，因此对DataFrame中的Series对象进行操作，会直接影响到原DataFrame对象。要想获得相应对象的副本，调用该对象的copy方法即可。
**除了嵌套列表之外，还可以通过嵌套字典来构造DataFrame，此时外层字典的键作为列索引，内层字典的键作为行索引（嵌套Series同理）
**
In [65]: pop = {'Nevada': {2001: 2.4, 2002: 2.9},
....: 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
类似numpy数组，DateFrame也可以转置
In [34]: frame2.T
Out[34]:
2000 2001 2002
Nevada NaN 2.4 2.9
Ohio 1.5 1.7 3.6
image.png
构建DataFrame对象
构建DataFrame对象的方法汇总：使用嵌套列表，字典，Series对象的字典构建；使用二维ndarray数组构建（此时行索引和列索引皆为自然数）;
构造DateFrame对象时，当传入了多个字典组成的列表时，DataFrame方法会将所有的键的集合作为列索引
索引对象
pandas的索引对象负责管理轴标签和其他元数据（比如轴名称等）。
构建Series 和 DataFrame时，所用到的任何数组或其他序列的标签都会被转换成一个Index(索引对象)：
In [37]: frame.index
Out[37]: Index(['one', 'two', 'three', 'four', 'five', 'six'], dtype='object')
创建多级索引对象：pd.MultiIndex.from_arrays()
Index对象是不可变的
In [42]: index[1]='d'#试图修改index的值
TypeError: Index does not support mutable operations
image.png
5.2 基本功能
reindex函数:根据新索引返回一个新的Series对象
In [79]: obj
Out[79]:
0 blue
2 purple
4 yellow
dtype: object
In [80]: obj.reindex(range(6))
Out[80]:
0 blue
1 NaN
2 purple
3 NaN
4 yellow
5 NaN`
dtype: object
为了避免缺省值，在使用reindex函数的时候，添加参数method=‘ffill’来实现值向前填充
In [81]: obj.reindex(range(6),method='ffill')
Out[81]:
0 blue
1 blue
2 purple
3 purple
4 yellow
5 yellow
dtype: object
image.png
删除Series对象中的元素
In [111]: se
Out[111]:
Texas 1
Utah 2
California 3
dtype: int64
In [112]: se.drop('Texas')
Out[112]:
Utah 2
California 3
dtype: int64
删除DataFrame对象中的元素
In [122]: frame.drop(['a','b'])
Out[122]:
Texas Utah California
c 6 7 8
默认为删除axis=0轴（行）的值,可以添加参数axis=1或axis=columns
In [124]: frame.drop('Texas',axis=1)
Out[124]:
Utah California
a 1 2
b 4 5
c 7 8
drop函数添加参数inplace=True可以就地修改原来的对象，而不会返回新的对象
In [128]: frame
Out[128]:
Texas Utah California
a 0 1 2
b 3 4 5
c 6 7 8
In [129]: frame.drop('a',inplace=True)
In [130]: frame
Out[130]:
Texas Utah California
b 3 4 5
c 6 7 8
索引，选取和过滤
对Series的索引操作和numpy相似
只是Series的索引可以是字符串
In [151]: se
Out[151]:
Texas 1
Utah 2
California 3
dtype: int64
In [152]: se['Texas':'California']
Out[152]:
Texas 1
Utah 2
California 3
dtype: int64
用一个值或一个序列对DataFrame对象进行索引就是获取一个或多个列:
In [149]: data[['Texas','California']]
Out[149]:
Texas California
one 0 2
two 3 5
three 6 8
同样支持布尔型数组索引
In [154]: data[data['Texas']>3]
Out[154]:
Texas Utah California
three 6 7 8
也支持布尔型DataFrame对象索引
In [164]: data[data>5]
Out[164]:
Texas Utah California
one NaN NaN NaN
two NaN NaN NaN
three 6.0 7.0 8.0
以上都是针对DataFrame对象的列的索引，接下来用loc和iloc对行进行索引
多级索引的选取
当要进行选取的行或列有多级索引时，索引方法要改变。此时，使用df.reindex()进行索引，如
In [26]: arrays=[['key1','key1','key2','key2'],['a','a','b','b']]
In [27]: mul_index=pd.MultiIndex.from_arrays(arrays,names=['level1','level2'])
In [28]: mul_index
Out[28]:
MultiIndex(levels=[['key1', 'key2'], ['a', 'b']],
labels=[[0, 0, 1, 1], [0, 0, 1, 1]],
names=['level1', 'level2'])
In [29]: df=pd.DataFrame(np.random.randint(10,size=(4,4)),columns=mul_index)
In [30]: df
Out[30]:
level1 key1 key2
level2 a a b b
0 1 0 7 5
1 2 1 9 1
2 7 4 5 9
3 3 7 9 9
此时可通过一层一层的来获取某一列元素：
In [31]: df['key1']['a']
Out[31]:
level2 a a
0 1 0
1 2 1
2 7 4
3 3 7
但通常我会选择一种更加明了的方式:reindex
###用loc和iloc进行选取
一般情况下建议用loc和iloc方法取选定的行列。因为直接对df对象进行切片会产生歧义，从而报错
loc用键去取行
In [176]: data.loc['one']
Out[176]:
Texas 0
Utah 1
California 2
Name: one, dtype: int32
iloc用数字索引取行
In [175]: data.iloc[0]
Out[175]:
Texas 0
Utah 1
California 2
Name: one, dtype: int32
In [181]: data.iloc[0,1]
Out[181]: 1
###整数索引
下面这段代码会报错
ser = pd.Series(np.arange(3.))
ser
ser[-1]
原因是因为可能会发生歧义,当索引为非数字时则不会报错
In [202]: ser2=pd.Series(np.arange(3.),index=['a','b','c'])
In [203]: ser2[-1]
Out[203]: 2.0
**为了避免歧义，尽量使用loc和iloc显示地表明。**
###算数运算和数据对齐
当不同索引的对象进行算术运算时，自动取索引的并集
In [154]: s1 + s2
Out[154]:
a 5.2
c 1.1
d NaN
e 0.0
f NaN
g NaN
dtype: float64
**不重叠的索引出引入NA值**
**对于DataFrame，对齐操作会同时发生在行和列上：**
###在算术方法中填充值
**我们已经知道了在进行算数运算时，DataFrame对象和Series对象会自动数据对齐并在不重叠的地方自动填充na值。可以在调用以下方法时添加参数fill_value=（要设置的自动填充值）**
上图中，r开头的方法表示将参数装置，如下面两种计算一致：
In [213]: ser2.add(ser1)
Out[213]:
a NaN
b 8.0
c 10.0
d NaN
dtype: float64
In [214]: ser1.radd(ser2)
Out[214]:
a NaN
b 8.0
c 10.0
d NaN
dtype: float64
**与此类似，在可能产生na值的地方都可以设置fill_value属性** 如对DataFrame对象重新索引时：
In [221]: frame.reindex(['a','b','c'],fill_value=1)
Out[221]:
Texas Utah California
a 1 1 1
b 3 4 5
c 6 7 8
**DataFrame和Seires之间的运算符合广播**
In [232]: frame
Out[232]:
Texas Utah California
b 3 4 5
c 6 7 8
In [233]: se=frame.iloc[0]
In [234]: se
Out[234]:
Texas 3
Utah 4
California 5
Name: b, dtype: int32
这里取出frame的第0行，就是为了在行中传播，因此要匹配列
In [235]: frame.sub(se,axis='columns')
Out[235]:
Texas Utah California
b 0 0 0
c 3 3 3
**小结:**要在行中传播，则匹配列；在列中传播，则匹配行（此时需要在运算方法中设置axis=‘index’，默认为axis=‘columns’）
###函数应用和映射
**NumPy的ufuncs（元素级数组方法）也可用于操作pandas对象：**
In [246]: frame2
Out[246]:
Texas Utah California
0 1.973670 -0.337147 -0.267831
1 -1.340909 0.662307 0.180784
2 0.341601 0.071515 -0.099701
In [248]: np.abs(frame2)
Out[248]:
Texas Utah California
0 1.973670 0.337147 0.267831
1 1.340909 0.662307 0.180784
2 0.341601 0.071515 0.099701
**传递函数到DataFrame对象的每一行（列）:使用对象的apply方法**
In [238]: frame
Out[238]:
Texas Utah California
b 3 4 5
c 6 7 8
In [239]: f=lambda x:x.max()-x.min()
将函数应用到每一列（匹配行）
In [241]: frame.apply(f,axis='index')
Out[241]:
Texas 3
Utah 3
California 3
dtype: int64
**传递函数到DataFrame对象的每一个元素：使用对象的applymap方法**
In [249]: f=lambda x:x*2
In [250]: frame2
Out[250]:
Texas Utah California
0 1.973670 -0.337147 -0.267831
1 -1.340909 0.662307 0.180784
2 0.341601 0.071515 -0.099701
In [252]: frame2.applymap(f)
Out[252]:
Texas Utah California
0 3.947339 -0.674294 -0.535662
1 -2.681818 1.324614 0.361568
2 0.683203 0.143031 -0.199401
ps：当然，由于DataFrame对象的传播性，所以使用apply方法也可以应用到元素级
###排序和排名
**（1）对索引进行排名**
**对象.sort_index() (在对DataFrame对象进行操作时，需要加入参数axis来指定轴)**
**（2）对值进行排名**
**对象.sort_value()(在对DataFrame对象进行操作时，需要加入参数by来指定某一列，或多个列的列表形式)**
####排名。
Series对象的rank方法。默认情况下，rank是通过“为各组分配一个平均排名”的方式破坏平级关系的：
In [269]: obj
Out[269]:
0 7
1 -5
2 7
3 4
4 2
5 0
6 4
dtype: int64
**默认情况下，值越小，优先级越高。**
obj.rank()的值为优先级
In [270]: obj.rank()
Out[270]:
0 6.5
1 1.0
2 6.5
3 4.5
4 3.0
5 2.0
6 4.5
dtype: float64
将原数据出现的顺序加入排名考虑因素
In [271]: obj.rank(method='first')
降序排名
In [273]: obj.rank(method='first',ascending=False)
5.3 汇总和计算描述统计
对象.describe方法可以得到关于该对象的各个统计值
image.png
相关系数与协方差
唯一值、值计数以及成员资格
unique，它可以得到Series中的唯一值数组：
value_counts用于计算一个Series中各值出现的频率：
isin用于判断矢量化集合的成员资格，可用于过滤Series中或DataFrame列中数据的子集
image.png
pandas方法补充
pd.date_range('16/3/2019',periods=5)
返回自16/3/2019 后5天的索引对象
tips=pd.read_csv('examples/tips.csv')
tips.head(10)
image.png
pd.crosstab()
party_counts = pd.crosstab(tips['day'], tips['size'])
party_count
image.png
crosstab()的第一个参数是索引列，第二个参数即是要分析的列，该方法返回一个视图。
pd.pct_change/se.pct_change()
迭代每个元素，并返回每个元素与之前的元素的改变百分比。
通常用于观察某组数据的变化趋势
In [184]: se=pd.Series([1,1,2])
In [185]: se.pct_change()
Out[185]:
0 NaN
1 0.0
2 1.0
dtype: float64
pandas.DataFrame.corrwith
DataFrame.corrwith(other, axis=0, drop=False, method='pearson')
Compute pairwise correlation between rows or columns of DataFrame with rows or columns of Series or DataFrame. DataFrames are first aligned along both axes before computing the correlations.
计算Series或DataFrame对象的某些行或列（默认为列）与传入的Series或DataFrame对象的某一行或某一列的相关系数
Series.asof(date)
返回指定日期前最近的一个不为Nan的值
pandas.Series.take
根据传入的索引选取指定的行或列
pandas.Series.astype
Series.astype(dtype, copy=True, errors='raise', **kwargs)
Cast a pandas object to a specified dtype dtype.
pandas.qcut
根据值的数量进行切分。返回一个
Categorical对象
参数labels：给各个区间取名字
pandas.cut
根据值的大小进行切分
pandas.get_dummies
Convert categorical variable into dummy/indicator variables
将分类变量转变为哑变量。
哑变量，又成为虚拟变量，通常由0，1表示。 一维矩阵变为二维矩阵
pandas.date_range
Return a fixed frequency DatetimeIndex
返回一个固定频率的时间索引。
参数start：开始的时间点
参数end：结束的时间点
参数freq：可取值为频率字符串：D,M,Y
参数periods：时间段。
In [118]: pd.date_range(start='1/1/2018',periods=8)
Out[118]:
DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
'2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
dtype='datetime64[ns]', freq='D')
pandas.Series.reset_index
Generate a new DataFrame or Series with the index reset.
This is useful when the index needs to be treated as a column, or when the index is meaningless and needs to be reset to the default before another operation.
用索引列生成一个Series或DataFrame对象。
pandas.DataFrame.join
DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
Join columns of another DataFrame.
在一个DataFrame对象中加入另一个DataFrame的列
Join columns with other DataFrame either on index or on a key column. Efficiently join multiple DataFrame objects by index at once by passing a list.
当两个DataFrame对象有公共键时，需要提供后缀。
当两个DataFrame对象没有公共键时，根据索引进行合并。
In [44]: df1
Out[44]:
k1 k2
0 1 4
1 2 272
2 3 1
In [45]: df2
Out[45]:
k3 k4
0 5 6
1 6 4
2 7 2
In [46]: df1.join(df2)
Out[46]:
k1 k2 k3 k4
0 1 4 5 6
1 2 272 6 4
2 3 1 7 2
可以加入多个DataFrame对象(以列表的形式)
In [48]: df1
Out[48]:
k1 k2
0 1 4
1 2 272
2 3 1
In [49]: df2
Out[49]:
k3 k4
0 5 6
1 6 4
2 7 2
In [50]: df3
Out[50]:
k5 k6
0 1 4
1 2 5
2 3 6
In [51]: df1.join([df2,df3])
Out[51]:
k1 k2 k3 k4 k5 k6
0 1 4 5 6 1 4
1 2 272 6 4 2 5
2 3 1 7 2 3 6
pandas.DataFrame.merge
DataFrame.merge(right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)
Merge DataFrame or named Series objects with a database-style join.
相比于pandas.DataFrame.join,merge能提供一种数据库风格的连接
The join is done on columns or indexes. If joining columns on columns, the DataFrame indexes will be ignored. Otherwise if joining indexes on indexes or indexes on a column or columns, the index will be passed on.
根据列或者索引将两个DataFrame连接在一起。如果没有重复元素的列，并且没有指定连接的键列，则不能连接。
In [80]: df2
Out[80]:
key data2
0 a 0
1 b 1
2 d 2
In [81]: df
Out[81]:
key A
0 K0 A0
1 K1 A1
2 K2 A2
3 K3 A3
4 K4 A4
5 K5 A5
In [82]: pd.merge(df,df2,left_on='key',right_on='key')
Out[82]:
Empty DataFrame
Columns: [key, A, data2]
Index: []
In [83]: pd.merge(df,df2,left_on='key',right_on='key',how='outer')
Out[83]:
key A data2
0 K0 A0 NaN
1 K1 A1 NaN
2 K2 A2 NaN
3 K3 A3 NaN
4 K4 A4 NaN
5 K5 A5 NaN
6 a NaN 0.0
7 b NaN 1.0
8 d NaN 2.0
通常对于连接DataFrame对象的两个列，分为一对多和多对多的情况。
一对多时，一会赋值于多进行匹配
多对多时，产生交集（内连接，默认方式）和笛卡儿积（外连接）
pandas.DataFrame.pivot_table
DataFrame.``pivot_table`(*values=None*, *index=None*, *columns=None*, *aggfunc='mean'*, *fill_value=None*, *margins=False*, *dropna=True*, *margins_name='All'*)[[source]](http://github.com/pandas-dev/pandas/blob/v0.24.2/pandas/core/frame.py#L5750-L5759)
Create a spreadsheet-style pivot table as a DataFrame. The levels in the pivot table will be stored in MultiIndex objects (hierarchical indexes) on the index and columns of the result DataFrame.
参数：
index:Keys to group by on the pivot table index。传入的序列长度必须于原数据一致。作为分组透视表索引的关键字
columns：同index。
values：进行分析的数值。
通常，pivot_table的必要参数为index，values
In [98]: df
Out[98]:
A B C D E
0 foo one small 1 2
1 foo one large 2 4
2 foo one large 2 5
3 foo two small 3 5
4 foo two small 3 6
5 bar one large 4 6
6 bar one small 5 8
7 bar two small 6 9
8 bar two large 7 9
指定透视表的索引列，对应的values列。columns通常为可选的，用作进一步分析。
In [97]: table=pd.pivot_table(df,values='D',index=['A','B'],columns=['C'],aggfunc=n
p.sum)
In [99]: table
Out[99]:
C large small
A B
bar one 4.0 5.0
two 7.0 6.0
foo one 4.0 1.0
two NaN 6.0
pandas.DataFrame.sort_values
DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')
sort by the values along either axis
可以接收一给列名，或者一组列名。沿这指定的轴进行计算。（默认为0轴）
pandas.concat
pandas.concat`(*objs*, *axis=0*, *join='outer'*, *join_axes=None*, *ignore_index=False*, *keys=None*, *levels=None*, *names=None*, *verify_integrity=False*, *sort=None*, *copy=True*)[[source]](http://github.com/pandas-dev/pandas/blob/v0.24.2/pandas/core/reshape/concat.py#L24-L229)
merge，join实现的是列之间的连接，若要实现行连接，则要使用concat。通常一组数据的一行为一条独立的数据，所以concat一般适用于连接格式相同的多组数据。
参数keys:给最外层索引取名字。
pandas.Series.isin
Series.isin(*values*)[[source]](http://github.com/pandas-dev/pandas/blob/v0.24.2/pandas/core/series.py#L3947-L4004)
Check whether values are contained in Series.
判断Series是否再values中
pandas.DataFrame.duplicated
DataFrame.duplicated(subset=None, keep='first')
Return boolean Series denoting duplicate rows, optionally only considering certain columns.
返回一个布尔值的Series对象，从上往下，依次比较，重复的行数为True，不重复的为False
pandas.DataFrame.rename
DataFrame.rename(mapper=None, index=None, columns=None, axis=None, copy=True, inplace=False, level=None)
给指定轴上的索引重新取名字。
一般传入一个字典，作为各个索引名的映射。
pandas.DataFrame.quantile
`DataFrame.``quantile`(*q=0.5*, *axis=0*, *numeric_only=True*, *interpolation='linear'*)[[source]](http://github.com/pandas-dev/pandas/blob/v0.24.2/pandas/core/frame.py#L7697-L7788) [](http://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.quantile.html#pandas.DataFrame.quantile "Permalink to this definition")
Return values at the given quantile over requested axis.
传入指定的分位值在指定的轴上计算分位数
如传入0.5，即是计算二分位数
计算公式：quan=1+(n-1)*q
In [28]: df
Out[28]:
a b
0 1 1
1 2 10
2 3 100
3 4 100
In [29]: df.quantile(0.5)
Out[29]:
a 2.5
b 55.0
Name: 0.5, dtype: float64
上图中，a列：1+(4-1)*0.5=2.5
todo.
pandas.Series.idxmax
`Series.``idxmax`(*axis=0*, *skipna=True*, **args*, ***kwargs*)[[source]](http://github.com/pandas-dev/pandas/blob/v0.24.2/pandas/core/series.py#L1886-L1954)[¶](http://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.idxmax.html#pandas.Series.idxmax "Permalink to this definition")
Return the row label of the maximum value.
返回Series对象的最大值的行标签
If multiple values equal the maximum, .the first row label with that value is returned
如果有多个最大值，则返回匹配的第一个数据。
pandas.Series.map
Series.map(arg, na_action=None)
Map values of Series according to input correspondence.
Used for substituting each value in a Series with another value, that may be derived from a function, a dict or a Series
根据给定的序列映射Series对象中的每个值。可以传入函数，字典或者Sereis
pandas.DataFrame.plot
DataFrame.plot(x=None, y=None, kind='line', ax=None, subplots=False, sharex=None, sharey=False, layout=None, figsize=None, use_index=True, title=None, grid=None, legend=True, style=None, logx=False, logy=False, loglog=False, xticks=None, yticks=None, xlim=None, ylim=None, rot=None, fontsize=None, colormap=None, table=False, yerr=None, xerr=None, secondary_y=False, sort_columns=False, **kwds)
Make plots of DataFrame using matplotlib / pylab.
New in version 0.17.0: Each plot kind has a corresponding method on the DataFrame.plot accessor: df.plot(kind='line') is equivalent to df.plot.line().
调用matplotlib来画DataFrame对象
参数：
kind : str
'line’ : line plot (default)
‘bar’ : vertical bar plot
‘barh’ : horizontal bar plot#改变轴向
‘hist’ : histogram
‘box’ : boxplot
‘kde’ : Kernel Density Estimation plot
‘density’ : same as ‘kde’
‘area’ : area plot
‘pie’ : pie plot
‘scatter’ : scatter plot
‘hexbin’ : hexbin plot
subplots:是否要以子图的形式显示，默认为False
sharex ：当subplots为True时，所有子图共享x轴
sharex ：当subplots为True时，所有子图共享y轴
网友评论