Pandas DataFrame 常用方法实践
常见的对象类型
其实在API 文档里面有很多数据类型 Pandas API Reference
- Series【文章后面有说明】
- DataFrame【文章后面有说明】
- Panel
- Index
- Numeric Index
- CategoricalIndex
- IntervalIndex
- MultiIndex
- DatetimeIndex
- TimedeltaIndex
- PeriodIndex
- Scalars
- Frequencies
- Window
- GroupBy
好像有蛮多的，这里不一一列举了，有空我再补充一下每个接口的作用数据
【pandas.core.series.Series】
Series对象 是一维的数组对象，自带了数组的索引，与 numpy中的一维array类似
这个对象的所有方法可以参考官网 pandas.Series
"""=================================
1. 创建 Series 对象
"""
In [1]: s = pd.Series([1,2,3,4],index = ['a','b','c','d']) # 通过 list 传入一维数据, index 属性指定索引
In [2]: s # 输出数组内容
Out[2]:
a 1
b 2
c 3
d 4
dtype: int64
"""=================================
2. 读取 Series 对象 的 索引和值
"""
In [3]: s.index # 通过 index 输出索引信息
Out[3]: Index(['a', 'b', 'c', 'd'], dtype='object')
In [4]: s.values # 通过 values 输出数组内容
Out[4]: array([1, 2, 3, 4], dtype=int64)
In [5]: s*2 # 对 values 的值进行操作(索引不会改变)
Out[5]:
a 2
b 4
c 6
d 8
dtype: int64
"""=================================
3. 对 Series 对象的值进行操作
"""
In [6]: s + 1 # 对 values 的值进行操作(索引不会改变)
Out[6]:
a 2
b 3
c 4
d 5
dtype: int64
"""=================================
4. 对 Series 对象的值进行筛选
"""
In [7]: s[s > 2] # 对 values 的值筛选
Out[7]:
c 3
d 4
dtype: int64
In [8]: s[s > 12] 对 values 的值筛选, 返回值是一个空的 Series
Out[8]: Series([], dtype: int64)
【pandas.core.frame.DataFrame】
是一个表格型的数据结构，提供有序的列和不同类型的列值
这个对象的所有方法可以参考官网 pandas.DataFrame
"""=================================
1. 创建 DataFrame 的对象
"""
In [1]: df1 = pd.DataFrame({'col0':[1,2,3], 'col1':[4,5,6]})
In [2]: df1
Out[2]:
col0 col1
0 1 4
1 2 5
2 3 6
In [3]: data = {'col0':[1,2,3], 'col1':[4,5,6]} # 通过字典创建 DataFrame 对象,可以指定指点中的 key
...: df2 = pd.DataFrame(data,columns = ['col1'])
In [4]: df2
Out[4]:
col1 col0
0 4 1
1 5 2
2 6 3
In [5]: df3 = pd.DataFrame(data,columns = ['col1','col0','col2']) # 如果指定不存在的key, 会使用 NaN 来补充
In [6]: df3
Out[6]:
col1 col0 col2
0 4 1 NaN
1 5 2 NaN
2 6 3 NaN
"""=================================
2. 读取 DataFrame 对象的某一列
"""
In [7]: df3["col1"]
Out[7]:
0 4
1 5
2 6
Name: col1, dtype: int64
In [8]: type(df3["col1"])
Out[8]: pandas.core.series.Series
In [9]: df3.col1
Out[9]:
0 4
1 5
2 6
Name: col1, dtype: int64
"""=================================
3. 删除 DataFrame 对象的数据
"""
In [10]: del df3['col1']
In [11]: df3
Out[11]:
col0 col2
0 1 NaN
1 2 NaN
2 3 NaN
常用方法实践
1） 重新索引
根据index参数重新进行排序。如果传入的索引值在数据里不存在，则不会报错，而是添加缺失值的新行。不想用缺失值，可以用 fill_value 参数指定填充值。
In [1]: df1 = pd.DataFrame({'col0':[1,2,3], 'col1':[4,5,6]})
In [2]: df1
Out[2]:
col0 col1
0 1 4
1 2 5
2 3 6
In [3]: df1.index
Out[3]: RangeIndex(start=0, stop=3, step=1)
In [4]: df2 = df1.reindex(['a','b','c'],fill_value = 0)
In [5]: df2
Out[5]:
col0 col1
a 0 0
b 0 0
c 0 0
In [6]: df2.index
Out[6]: Index(['a', 'b', 'c'], dtype='object')
根据 Out[2] 和 Out[4] 的显示，你会发现索引已经由 RangeIndex(start=0, stop=3, step=1) 变成了 Index([‘a’, ‘b’, ‘c’], dtype=‘object’)
#fill_value 会让所有的缺失值都填充为同一个值，如果不想这样而是用相邻的元素（左或者右）的值填充，则可以用 method 参数，可选的参数值为 ffill 和 bfill，分别为用前值填充和用后值填充。
In [1]: df3 = df1.reindex(range(5),method = 'ffill')
In [2]: df3
Out[2]:
col0 col1
0 1 4
1 2 5
2 3 6
3 3 6
4 3 6
In [4]: df3 = df1.reindex(range(5),method = 'bfill')
In [5]: df3
Out[5]:
col0 col1
0 1.0 4.0
1 2.0 5.0
2 3.0 6.0
3 NaN NaN
4 NaN NaN
2） 丢弃数据
data.drop([‘idx1’,‘idx2’])#删除行
data.drop([‘col1’,‘col2’],axis = 1) #添加axis参数删除列
3） 索引、选取和过滤
[注意]利用索引的切片运算与普通的 Python 切片运算不同，其末端是包含的，既包含最后一个的项。
e.gobj[‘b’:‘d’]包含’d’，但是obj[1:3]不包含3
loc和iloc
df.loc[index,column_names]#知道column names 和index,且两者都很好输入
df.iloc[index,col_index]#column_name太长；index是时间序列不好输入 i_index
ix操作：混合使用下标和名称进行选取
data.ix[‘idx’,[‘col1’,‘col2’]]
data.ix[2] #第2行
data.ix[data.col1<5,:3] # data.col1<5的前2列
4） 算术运算和数据对齐
1）Series：将2个对象相加时，具有重叠索引的索引值会相加处理；不重叠的索引则取并集，值为 NA；
2）对齐操作会同时发生在行和列上，把2个对象相加会得到一个新的对象，其索引为原来2个对象的索引的并集；和Series 对象一样，不重叠的索引会取并集，值为 NA；如果不想这样，试试使用 add() 方法进行数据填充：
df1+df2 #会出现NaN
df1.add(df2,fill_value = 0)#无NaN
5） 函数应用和映射
df1.astype(np.int32)
df2.apply(f) #f = lambda x:x+1
6） 排序
df.sort_index(ascending = False)frame.sort_index(axis = 1)
Series: obj.sort_values()obj.sort_index()
排名
obj.rank(ascending = False) #索引位上的数的排名
带有重复值的轴索引
obj.index.is_unique#False
索引时，同时输出多个值
7） 汇总统计和计算
df.sum() #纵向汇总（行求和） aixs=1为横向汇总
df.cumsum() #纵向汇总_累计汇总
df.idxmax() #获取最大值对应的索引
obj.unique() #返回数据里的唯一值array
obj. value_counts()#统计各值出现的频率,返回Series索引为值
obj. isin([‘c’])#判断成员资格，在原表基础上修正为bool
8） 处理缺失数据
使用isnull()和notnull()函数来判断缺失情况。
对于缺失数据一般处理方法为滤掉或者填充。
滤除缺失数据
data.dropna() #返回一个包含非空数据和索引值的表，等价于data[data.notnull()]
data.dropna(how = ‘all’) #只有行里的数据全部为空时才丢弃,axis=1按列丢弃
填充缺失数据
df.fillna(0) #用默认值填充缺失数据
df.fillna({0:10,1:20,2:200})#可以传入字典对不同的列填充不同的值(键表示列)
9） 层次化索引：能在一个数组上拥有多个索引，有点像Excel里的合并单元格
根据索引选择数据子集
data[‘a’] #以外层索引的方式选择数据子集
data[:,2] #以内层索引的方式选择数据
data.unstack() #多重索引Series转换为DataFrame，第二层索引为列
重排分级顺序
df. swaplevel(‘idx1_name’, ‘idx2_name’)#将两个级别的数据进行交换
df. sortlevel(0,ascending = False)#以行按第一层(0)进行排序
df. sortlevel(1,ascending = False，axis=1)#列按第二层(1)进行排序
根据级别汇总统计
多层次索引的数据，汇总的时候可以单独按照级别进行
df.sum(level=‘idx1_name’)
10） 数据合并
a）pandas.merge()：数据库风格的合并
pd.merge(df1,df2,on=‘col_coname’) #以col_coname列当作键，默认内连接（inner）,即键的交集
pd.merge(df1,df2,on=‘col_coname’,how=‘left’)#左连接(left)，右连接(right)和外连接并集
left.join(right) #以索引作为连接键
b）pandas.concat()方法：轴向连接，即沿着一条轴将多个对象堆叠到一起
pd.concat([s1,s2,s3]) #默认concat在竖轴(axis=0)上连接，即产生新的Series。
c）实例方法combine_first()方法：合并重叠数据
s1.combine_first(s2) #等价于np.where(pd.isnull(s1),s2,s1)
这是一个矢量化的if-else操作，如果s1里某个位置上的数据为空，则用s2同位置上的元素来补，你可以理解为“打补丁”操作。
11） 数据重塑/轴向旋转
重塑指的是将数据重新排列，也叫轴向旋转。
stack: 将数据的列“旋转”为行。unstack:将数据的行“旋转”为列。
处理堆叠格式
堆叠格式也叫长格式，一般关系型数据库存储时间序列的数据会采用此种格式
df.pivot(‘col1’,‘col2’,‘col3’)
12） 数据转换：对数据的过滤、清理以及其他的转换操作。
移除重复数据
df.duplicated() #检测各行是否重复，默认判断全部列，默认保留第一个出现的值
df.duplicated([‘col1’]) #判断指定列
df.drop_duplicates() #丢弃重复行
df.drop_duplicates(keep=‘lost’) #或传入take_last=True保留最后一个值
利用映射进行数据转换
data[‘new_col’] = data[‘col1’].map(col1_to_new_col)#map到一个dict
data[‘col1’].map(lambda x: col1_to_new_col[x]) #等价于使用函数
替换值
data.replace(value,np.nan)
data.replace([value1, value2],[ np.nan,0])
重命名轴索引
data.rename(index=str.title,columns=str.upper)
将数据划分成不同的组
scores=[40,54,60,85,87,81]
score_levels=[0,60,80,95]
cats = pd.cut(scores,score_levels) #输出内容为区间的列表
pd.value_counts(cats) #统计区间个数
检测和过滤异常值
data.decsribe() #产生数据的count,mean,std,min…
data[np.abs(data)>2] #找出绝对值大于2的值,不满足的为nan
data[np.abs(data)>2.any(1)] #找出绝对值大于2的行
data[np.abs(data)>2]=0 #将异常值设置为0