pandas入门

概述

1. 处理表格型数据，每一列数据类型可以不一样
2. 导入：import pandas as pd
   from pandas import Series,DataFrame
3. 常用显示选项：
   pd.options.display.max_rows = n ：设置pd对象的显示行数，前后2/n行
   *pd.options.display.max_columns = n *：设置pd对象的显示列数，前后2/n列
   pd.set_option(‘max_colwidth’,n) :显示pd对象的列长度
   pd.set_option(‘precision’, 2) ：显示小数点后的位数

数据结构

Series

可以自定义索引的一维数组。默认索引是0，1，2…,N-1

属性：

.value :值
.index ：索引
.name: 名字
可以自定义索引的一维数组。默认索引是0，1，2…,N-1

生成 Series：

se = pd.Series(seq,index=[ ])
seq是字典时，索引自动为字典的索引，并且自动排好顺序，不想让索引自动排序的话，就将想要顺序的字典的key的列表传递给index参数。
如果键多值少，则值以NaN(not a number)出现,如果键少值多，则值被移除。
总而言之，以索引为准。

se = pd.Series([4,7,-5,3]) # 从列表生成Series，默认索引
print(se.values)
print(se.index)

se2 = pd.Series([4,7,-5,3],index=['d','b','a','c'])  # 自定义索引
print(se2.index)

通过索引存取数据，多个索引用索引列表表示，筛选或进行计算时索引将保留：

print(se2['a'])  # 通过索引取数
se2['d'] = 6     # 赋值
print(se2[['c','a','d']])  # 多个索引用列表表示，顺序可变
print(se2[se2 > 0])   # 筛选大于0的数，索引仍保留
np.exp(se2)      # 计算指数，索引仍保留

se2.name = 'se_name'   # 对se2命名
se2.index.name = 'in'  # 对se2的索引命名
se2

改变索引,按位置赋值，改变索引后原索引的名字也没有了:

se2.index = ['x','y','z','wb']  # 索引重新赋值，索引可以接收列表
se2

检查缺失值：

实例方法：返回与原数据结构一样大小的数据
.isnull() :每个值是否为空
.notnull() ：每个值是否不为空

数据对齐特性：一切以索引为准，索引只多不少。

DataFrame

类似于矩阵的数据表，每一列可以是不同的数据类型，既有行索引也有列索引(列名)，可以使用分层索引在DataFrame中展现超过二维的数据。

构建DataFrame：

frame = pd.DataFrame(data，columns=[ ],index=[ ])
可选参数：columns是列索引，index是行索引。
若data省略，则创建的是空的df.

data = {'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]}  # 字典，值是列表，key是列索引
frame = pd.DataFrame(data)  # 自动行索引
frame.head()    # 展示前5行

基本操作：索引，选择，增删

1.索引
自定义索引(标签索引)，但同时暗中仍有对应的整数索引
按整数索引切片不包含右端点，按标签索引切片包含右端点
一般不会指定行索引，所以都是通过默认的整数索引
索引对象，不可改变,无法被修改。不可变的ndarray,有序可切片，存储轴标签。可以包含重复标签。

# 对象的属性和实例方法名均为小写单词，首字母小写，而模块下的方法名以大写开头
index = pd.Index(np.arange(6))[3:] # 生成索引对象
df = pd.DataFrame([[1,2],[3,4],[5,6]],columns=['a','b'],index=index) # 指定列名和行索引，列名即列索引，也是索引对象
print(df)
print(df.columns)  # 属性：列索引.columns
print('a' in df.columns)
print(3 in df.index)  # 行索引 .index

索引的.is_unique属性：标签索引是否唯一，不含重复值
obj.index.is_unique
如果重复，则选择标签索引时会返回一个符合的序列。

2.选择

• 选择列
  frame[‘列名’] $\iff$ frame.列名
  返回的一列是Series，是引用，与原DataFrame索引相同，且name被合理设置。可以修改列的引用，原DataFrame即被修改。
• 筛选符合条件的值：在下标框中写筛选条件，筛选条件返回的是同样大小的TF结构
  - 通过下标框[ ]筛选

se = pd.Series(np.arange(3),index=['a','b','c']) # 指定自定义索引
print(se['a']) # 按自定义索引选择，等价于print(se[0])   # 按默认的整数索引选择。
print(se[['b','a']])  # 索引列表，同时选择多个，按指定顺序返回新对象,等价于print(se[[1,0]])。最外层列表是用于选择的下标框

print(se[0:2])  # 按整数索引切片不包含右端点，0，1
print(se['a':'c'])  # 但是按标签索引切片包含右端点，a,b,c,等价于se[0:]

print(se <= 1)  # T T F
se[se <= 1]   # 筛选符合条件的值：在下标框中写筛选条件，筛选条件返回的是同样大小的TF结构
se[se <= 1] = 5  # 为符合条件的值重新赋值，直接在原对象上修改
print(se)

对df，通过下标框直接选择时，传递单个索引或索引列表只选列，传递切片或筛选条件只选行

df = pd.DataFrame(np.arange(9).reshape(3,3),index=['a','b','c'],columns=['one','two','three'])
df['one']  # 只能通过列名选择列，列没有整数索引

# 只能通过行索引的切片或筛选条件选择行，行有整数索引，切片的话只能选出连续的行
df['a':'a']  # 选择第一行
df['a':'b']  # 选择前两行，等价于df[0:2],同样，自定义索引包含右端点，整数索引不包含
df[df['one'] < 6] # 选出df['one']<6的行，默认所有列
# 原理：df['one'] < 6 返回与'one'列同样大小的TF结构，传递到df[]选出T的行,所有列
print(df < 5) # 返回与df同样结构的3*3的TF数据框
df[df < 5]   # 将此结构中符合条件的值筛选出来，但是原结构不变，其他值变为NaN，否则不好管理结构
df[df < 5] = 0 # 符合条件的值重新赋值，保留原结构，其他值不变,直接操作原结构

- 通过loc,iloc选择数据，没有逗号时默认选行

• 基于标签的索引：df.loc[行标签/列表/切片,列标签/列表/切片]
  记住三点：loc通过标签选择，行与列用逗号隔开，不管是索引，索引列表还是切片的组合只要程序能看懂就行
• 基于位置的索引：df.iloc[行位置,列位置]，通过整数位置选择行列，允许切片。
  不能半边是标签半边是位置

df.loc['a',['two','one']]  # 通过选择列的顺序重排列
df.loc[:,'one':'two']  # 含有切片操作

df.iloc[:,0:2]
df.iloc[:,:2][df.two > 3]  # 在所有行前两列中筛选出满足'two'列大于3的样本
# 在要筛选的数据框后面+[筛选条件]

注1：如果未指定标签索引，通常是行，会有默认的整数索引作为标签索引，看得见的索引就是标签索引，程序可能会有歧义，因此选择好loc或是iloc。
注2：loc里切片是标签索引，包含右端点，iloc不包含。
注3：当索引是字符串时才需要用引号括起来。

3 增加新列
直接增加，好像原来就有一样。将列表或数组赋给一列时，需要保证长度匹配。
将Series赋给一列时，Series的索引将自动匹配DataFrame的索引，以df索引为准。

frame['debt'] = 16.5    # 增加一列，名为debt,值全为16.5
frame['debt2'] = np.arange(6.)  # 增加一列，名为debt2，值为0.0-5.0
frame

4 删除列del
del df[‘列名’]

frame['eastern'] = (frame.state == 'Ohio')  # 增加一列布尔值，判断state是否是Ohio
del frame['debt2']   # 删除一列
frame

注意：选出的列是视图，不是拷贝，对其的修改会反映到DataFrame上。如果需要复制，需显式使用Series的copy方法。
转置：df.T
注1： 什么对象能构建成DataFrame？答：一切你觉得能变成二维表结构的，程序也会这么觉得。具体而言：能变成二维表结构的列表、字典、2D ndarray.
注2： df也有name属性和values属性

基本功能

重建索引df.reindex()

本人还未用之，暂且记录。详见P136。
obj2 = reindex(newIndexList,method,fill_value,…)
可选参数：
method：插值方式：‘ffill’:前向填充，按照前一个的值填充后面不知道的。‘bfill’：后向填充
fill_value：引入NaN时使用的替代值

se = pd.Series(['bule','purple','red'],index=[0,2,4])
se2 = se.reindex(range(6),method='ffill')
se2

在df中，仅传入一个列表则重建其行索引。说是重建，则一定要传一个最全的索引。

删除行或列

obj.drop()
通过索引删除数据，返回新对象，原对象不改变.

• 如果加上属性inplace=True,则在原位置即原对象上直接操作，返回None,原对象被修改
• 属性axis=1或’columns’删除列（通过列索引）

se = pd.Series(np.arange(3),index=['a','b','c'])
se2 = se.drop('b')  # 通过索引删除数据
se.drop(['b','c'],inplace=True)   # 索引列表

df = pd.DataFrame(np.arange(9).reshape(3,3),index=['a','b','c'],columns=['one','two','three'])
df.drop(['a','b'],inplace=True)  # 默认删除行（通过行索引）
df.drop(['one','two'],inplace=True,axis='columns')  # 属性axis=1或'columns'删除列（通过列索引）

算术方法

对两个对象进行算术运算，是按相同的索引才运算，两个索引对不上则分别产生NaN，返回两个对象索引的并集(标签索引优先级高于默认索引）

• 算术方法：add(),sub(),div(),floordiv(),mul(),pow()
  对应算术运算符：+ - / // * **
• 使用填充值：df1.add(df2,fill_value=)

df1 = pd.DataFrame(np.arange(12).reshape(3,4),columns=list('abcd'))
df2 = pd.DataFrame(np.arange(12).reshape(4,3),columns=list('cde'))
print(df1)
print(df2)
print(df1 + df2)
df1.add(df2,fill_value=0) # 先在df1中按照df2的结构扩充填0，在df2结构之外的对不上的部分仍是NaN，最后相加

• df与Series间的运算：广播机制：默认将series的索引与df的列索引匹配，将操作广播到各行，即df的各行均执行对se的该操作
  若想更换广播方向，则使用算术方法,如：df1.add(df2,axis='index’或0)，与行索引匹配，广播到各列。

逐元素应用函数

对series，se.map(function)
对df,

1. df.applymap(function):对df的每个元素应用函数function
2. numpy的逐元素函数，例如np.abs(df)

df = pd.DataFrame(np.random.randn(4,3))
f = lambda x : '%.2f' % x    # 返回格式化字符串，保留两位小数
df.applymap(f)  # 所有元素保留两位小数

• 按行或列应用函数：df.apply(function,axis=0) 默认沿行方向对每列应用function，function若返回标量，则结果是series，function若返回series，则结果是df

f = lambda x : x.max() - x.min()  # 求极差
f2 = lambda x : pd.Series([x.min(),x.max()],index=['min','max']) # 将最值列表变为series返回
df.apply(f)  # 对每列求极差，返回Series
df.apply(f2)  # 对每列计算最大值，最小值，返回DataFrame

排序

1.按索引大小排: se/df.sort_index(axis=0,ascending=True) 默认对行索引排，升序
2.按值排 ：se/df.sort_values(by=,ascending=,axis=0) # 默认对行排序

df = pd.DataFrame(np.random.randn(4,3))
df.sort_values(by=0,ascending=False)  # 按照0列降序，排序
df.sort_values(by=[1,0],ascending=[False,True])  # 先排1列降序，1列有相同的按0列升序排

描述性统计

参数：默认计算各列axis=0,默认忽略NA skipna=True
df.describe() ：只计算数值型数据
对于非数值型数据，对唯一值进行频数统计 se.value_counts()

df = pd.DataFrame(np.random.randn(4,3))
df[3] = list('abbb')   # 增加一列字符型
df.describe()  # 只计算数值型数据
df[3].value_counts()  # 对于非数值型数据，对唯一值进行频数统计,等价于pd.value_counts(df[3],sort=True)

非数值型数据

实例方法	描述
se.unique()	按观察顺序返回唯一值数组，.sort()排序
se.value_counts()等价于下面	返回唯一值的频数统计，返回series
pd.value_conuts(obj.values,sort=False)	频数统计的顶层方法，obj是任意序列或数组
obj.isin(列表)	obj中的每个元素是否在列表中，返回同样大的TF序列

各列之间的相关性和协方差

• df.corr() 相关性
• df.cov() 协方差
• df与另一个序列或df的相关性：df.corrwith(se,axis=) P161

缺失值填充
se/df.fillna(value) : 将所有NaN或None填充为指定值

df = pd.DataFrame(np.random.randn(4,3))
df.iat[0,0] = np.nan  # or None
df.fillna(0)  # 将所有NaN或None填充为指定值

df.at[行，列] : 根据标签索引选择单个值
df.iat[行，列]：根据整数索引选择单个值