Pandas中的主要数据结构有两个：Series和DataFrame和Index
关键是比numpy 多了个index
Series是一种类似于一维数组（Python中的list）的对象，由一组数据和一组索引（下标）两部分组成。Series可以保存任何数据类型。
DataFrame是一个二维的表格型数据结构，可以把它想象成是一个Excel表格来理解，既有行索引，也有列索引。其中每列可以是不同的值类型。
Index也是比较常见的数据结构，虽然没有前两者那么重要，但也是必不可少的。

1. 创建

• 创建Series
  Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
  data 可以为 列表，1维 np.array ，默认index 是0,1,2,3 ，或者字典（字典的key 当index用）
• 创建dataFrame
  DataFrame由具有共同索引的Series按列排列构成（2D）
  df = pd.DataFrame(data=data, index=index, columns=columns)
  data为 二维数组，或者 字典
  data3 = { 'A' : { 'a':1, 'b':4}, 'B': {'a':2,'b':5}, 'C':{'a':3, 'c':6} }
  pd.read_csv(filepath_or_buffer, sep=',', header='infer', names=None, index_col=None, encoding=None ) #从文件创建
  pd.read_excel(io, sheetname=0, header=0, index_col=None, names=None)

2. 索引

data = [1,2,3]
index = ['a','b','c']
s = Series(data=data, index=index)

s['b'] # scalar, 返回一个值
s[0:2] # 范围，左闭右开，返回Series切片
s['a':'c'] # 注意，利用标签切片的时候左右都是闭区间
s[[0,2]] #列表，返回Series切片
s[['a','c']] 选择a c两行
mask = [False, True, False] #mask，类似于列表，只是长度必须和Series相同，返回Series切片
s[mask]
s.loc['b'] # 单索引，返回一个值
s.loc['a':'c'] # 范围，注意：左闭右闭，返回Series切片
s.loc[['a','c']] # 列表，返回Series切片
s.iloc[1] # scalar, 返回一个值
s.iloc[0:2] # 范围，左闭右开，返回Series切片
s.iloc[[0, 2]] #列表，返回Series切片

3. 修改

Series.replace(to_replace=None, value=None, inplace=False)
to_replace：要修改的值，可以为列表
value：改为的值，可以为列表，与to_repalce要匹配；
inplace：是否在原地修改；
Series.rename(index=None, level = None, inplace = False）
Series.append(to_append, ignore_index=False, verify_integrity=False)
to_append: 另一个series或多个Series构成的列表
ignore_index：False-保留原有索引，True-清除所有索引，生成默认数值索引；
verify_integrity：True的情况下，如果to_append索引与当前索引有重复，则报错
s1.drop(['a','c'])

4. dataFrame 索引

索引 （一个个列出来的） 是列操作，切片（冒号的是切片）是行操作，一维布尔索引是行操作

df['A'] # 列操作，单列索引，返回Series。相当于 df.A。
df[['A','C']] # 列操作，列索引列表，返回DataFrame
df[0] #报错
df[0:1] # 行操作，位置范围，返回DataFrame
mask = [False, True]
df[mask] # 行操作，mask，必须和行长度一致，返回DataFrame
df.loc['b','B'] # 返回单一值，因为两维都是单索引
df.loc['a':'b', 'A'] #返回Series，如果只有一维是单索引
df.loc[['a','b'], 'B'] #两个维度 分别当作series 对待
df.iloc[[0,1], [0,2]] # 返回DataFrame
df.loc['c']=[7,8,9] 增加 c 行
df['D']=[7,8,9] 增加D列

5. dataFrame合并

pd.concat([df, df1], axis=0 ) 增加多行
pd.concat([df, df1], axis=1 ) 增加多列
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort = False)
指定列的相同数据的排列组合，left_on ,index 这些就是用来指定用哪列数据来merge ，用列或者索引数值。左右参数配对使用。
例子：

pd.merge(df1,df2,how='left',right_on='data2',left_index=True)

pd.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)
例子：

pd.concat([df1,df2],axis=1,keys=['x','y'])

merge是更注重内部数据融合，concat更偏重index和column连接。

6. dataFrame行列转换

DataFrame.set_index(keys, drop=True, append=False, inplace=False)#keys是列名 ，将key这一列转换为index drop：True or False，是否保留原列；append：True or False，是否保留当前索引；inplace：True or False，是否原地修改
例子：

df.set_index(['A','C'], drop = False, append = False) 
A C  变为level0和level1 index的name
df.set_index(keys = [['A','C']], append = False) 
如果是单层[]，会查找column， append为False，实现了改索引功能 ， 给index修改为指定的字符列表。

DataFrame.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill='')
level：int 或者行索引的名字，可以为列表，默认包含所有行索引。drop：True or False，是否将行索引插入到列中，默认是插入；inplace：是否本地修改；col_level：如果列索引也是多重的，那么新插入的列设置哪一重索引；col_fill：如果有多重索引，除了col_level已经设置的. 多重level index ，从左到右level0，1.。

df1.reset_index(level=0,drop=False)
  level_0  B  C
A
1       a  2  3
4       b  5  6

df1.index.set_names(['ab'], inplace = True) #给index的名字变为 ab

7. 处理Series和index里面的字符 重点str

和python 字符串功能类似，只不过是放到pandas框架下更方便处理

s=pd.Series(['a_b_c', 'c_d_e', np.nan, 'f_g_h'])

s.str[0] # 可以直接通过位置索引 str按列形式，将每个字符拆开
0 a
1 c
2 NaN
3 f
s.str.split('') #返回 series
0 [a, b, c]
1 [c, d, e]
2 NaN
3 [f, g, h]
dtype: object
s.str.split('', expand=True) # 指定参数进行扩展 返回dataFrame
0 1 2
0 a b c
1 c d e
2 NaN NaN NaN
3 f g h
s.str.split('_', expand=True, n=1) # 限制扩展的数量

0 1
0 a b_c
1 c d_e
2 NaN NaN
3 f g_h

s.str.split('', expand=True).get(1) # 等效于 s.str.split('',expand = True)[1]

s.str.rsplit('_', expand=True, n=1)# rsplit和split方法类似，只是从反方向来访问
s.str.cat() #series本身连接返回成str类型
s.str.cat(sep=',')
s.str.cat(sep=',', na_rep='-')
s.str.cat(('A', 'B', 'C', 'D', 'E')) 两个series左右连接 返回单series

8. 常用函数

.info() 查看整体信息
.ndim, .shape, .size
.head(), .tail()
.describe() 计算数值的平均数 中位数等

9. 计算

series 和 dataFrame 做运算
df1 = pd.DataFrame([[1,2],[3,4]], index =['a','b'],columns = ['A','B'])
df2 = pd.DataFrame([[3,4],[5,6]], index =['b','c'],columns = ['B','C'])
+号默认将Series的index与DataFrame的columns对齐，然后以DataFrame的index为index，纵向复制构造一个DataFrame。
DataFrame.add(other, axis='columns', fill_value=None)
other：另一个DataFrame或Series；
axis：如果other是Series，指定Series的索引去和DataFrame的行匹配，还是和列匹配（匹配column或者index完全一致）（+号是默认和列匹配），axis是index就横向复制，axis是columns就纵向复制。
fill_value：这个参数是指两个DataFrame只有一个值缺失的情况，缺失的值怎么处理。两者都缺失，那么就是NaN。
sub() 减法 乘法mul() 除法div() 模运算mod() 幂运算pow() 类似
dot() 点积
df1.T
.abs() 求绝对值
.cumxxx(axis='index') * 累计运算，从开始到当前数据结束获取一个值。 axis：'index'或'columns' xxx 可取：max, min, sum, prod
.clip(lower=None, upper=None) 裁剪也即将数据裁剪到一定范围内 ，将数据选取到此lower到upper范围内。