Python之DataFrame常用方法小结

【Series】

性质：一维数组对象，类似NumPy 的一维array。

（除了包含一组数据还包含一组索引，所以可以把它理解为一组带索引的数组。）

obj = Series([1,2,3,4], index = ['a', 'b', 'c', 'd'])	# 通过 index 参数显示指定索引
obj.index、obj.values	# 单独获取 Series 对象的索引或者数组内容
obj*2、obj+1、obj[obj>10]	# 对Series对象的运算（索引不变）

from pandas import Series
obj = Series([1,2,3,4], index = ['a', 'b', 'c', 'd'])

> obj
a    1
b    2
c    3
d    4
dtype: int64

> obj.index 
Index(['a', 'b', 'c', 'd'], dtype='object')

> obj.values
array([1, 2, 3, 4], dtype=int64)

> obj*2
a    2
b    4
c    6
d    8
dtype: int64

> obj+1
a    2
b    3
c    4
d    5
dtype: int64

> obj[obj>10]
Series([], dtype: int64)

【DataFrame】

性质：一个表格型的数据结构。它提供有序的列和不同类型的列值。

创建：

将一个{key:list[]}转换成DataFrame	key为列名
DataFrame(data,columns = ['col1','col0'])	data形式为{key:list[]}的字典 columns参数-指定列的顺序
DataFrame(data,columns = ['col1','col0','col2'])	如果columns中传入的列名找不到，不会报错，而是产生一列 NA 值

获取数据：frame[‘col1’]、frame.col1

删除数据：del frame[‘col1’]

from pandas import DataFrame

## 创建DataFrame ##

In [0]:
DataFrame({'col0':[1,2,3], 'col1':[4,5,6]})
Out[0]:
col0	col1
0	1	4
1	2	5
2	3	6

In [1]:
data = {'col0':[1,2,3], 'col1':[4,5,6]}
DataFrame(data,columns = ['col1','col0'])
Out[1]:
col1	col0
0	4	1
1	5	2
2	6	3

In [2]:
DataFrame(data,columns = ['col1','col0','col2'])
Out[2]:
col1	col0	col2
0	4	1	NaN
1	5	2	NaN
2	6	3	NaN

## 获取数据 ##
frame = DataFrame({'col0':[1,2,3], 'col1':[4,5,6]})

​In [3]:
frame['col1']
Out[3]:
0    4
1    5
2    6
Name: col1, dtype: int64

In [4]:
frame.col1
Out[4]:
0    4
1    5
2    6
Name: col1, dtype: int64


## 删除数据 ##
del frame['col1']

In [5]:
frame
Out[5]:
col0
0	1
1	2
2	3

【产生日期】

date_index = pd.date_range('11/19/2017', periods=10, freq='D')

import pandas as pd
date_index = pd.date_range('11/19/2017', periods=10, freq='D')
> date_index
DatetimeIndex(['2017-11-19', '2017-11-20', '2017-11-21', '2017-11-22',
               '2017-11-23', '2017-11-24', '2017-11-25', '2017-11-26',
               '2017-11-27', '2017-11-28'],
              dtype='datetime64[ns]', freq='D')

——————————————————————常用方法———————————————————————

(1) reindex()方法 —— 重新索引

根据index参数重新进行排序。如果传入的索引值在数据里不存在，则不会报错，而是添加缺失值的新行。不想用缺失值，可以用 fill_value 参数指定填充值。

obj1 = obj.reindex([‘a’,’b’,’c’],fill_value = 0)	#fill_value 会让所有的缺失值都填充为同一个值，如果不想这样而是用相邻的元素（左或者右）的值填充，则可以用 method 参数，可选的参数值为 ffill 和 bfill，分别为用前值填充和用后值填充。
obj2 = obj.reindex(range(6),method = ‘fill’)

(2) drop() 方法 —— 丢弃数据

data.drop([‘idx1’,’idx2’])	#删除行
data.drop([‘col1’,’col2’],axis = 1)	#添加axis参数删除列

(3) 索引、选取和过滤

[注意] 利用索引的切片运算与普通的 Python 切片运算不同，其末端是包含的，既包含最后一个的项。

obj[‘b’:’d’]包含’d’，但是obj[1:3]不包含3

loc和iloc

df.loc[index,column_names]	# 知道column names和index,且两者都很好输入
df.iloc[index,col_index]	# column_name太长；

ix操作：混合使用下标和名称进行选取

data.ix[‘idx’,[‘col1’,’col2’]]
data.ix[2]	#第2行
data.ix[data.col1<5,:3]	# data.col1<5的前2列

(4) 算术运算和数据对齐

- Series：将2个对象相加时，具有重叠索引的索引值会相加处理；不重叠的索引则取并集，值为 NA；

- 对齐操作会同时发生在行和列上，把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) 排序

DataFrame:

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)和外连接[并集](outer)
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

Ref

https://www.cnblogs.com/sirkevin/p/5726306.html