dataframe数据分析常用操作汇总

dataframe的常用操作汇总

目录
1.建 1
2.读 2
3.存 2
4.阅 2
5.取 2
6.改 4
7.增 4
8.删 5
9.并 5
10.序 7

1.建

创建只有一列的数据框

df = pd.DataFrame([1, 2, 3, 4, 5], columns=[‘宽度’], index=[‘a’, ‘b’, ‘c’, ‘d’, ‘e’])

创建3行2列的数据框

df = pd.DataFrame([[1, 2], [3, 4], [5, 6]], columns=[‘分数’, ‘长度’], index=[‘a’, ‘b’, ‘c’])

对行命名

df.index.name = ‘公司’

创建3行2列的数据框

df = pd.DataFrame({‘key1’: [1, 2, 3], ‘key2’: [4, 5, 6]})

创建2行3列的数据框

df = pd.DataFrame.from_dict({‘a’: [1, 3, 5], ‘b’: [2, 4, 6]}, orient=“index”)

创建3行4列的数据框

df = pd.DataFrame(np.arange(12).reshape(3, 4), index=[1, 2, 3], columns=[‘A’, ‘B’, ‘C’, ‘D’])

对索引重命名

df = df.rename(index={‘A’: ‘万科’, ‘B’: ‘阿里’, ‘C’: ‘百度’}, columns={‘date’: ‘日期’, ‘score’: ‘分数’})

把某列设置为行索引

df = df.set_index(‘日期’)

重置行索引，把索引变成数字索引格式

df = df.reset_index()

重新建立索引

df = df.reset_index(drop=True) # 删除原来的索引，重新建立由0开始的索引

2.读

df = pd.read_excel(r’D:\codes\dataframe\wine.xls’) # 读取excel文件
df = pd.read_csv(r’D:\codes\dataframe\bigfile.csv’) # 读取csv文件

3.存

df.to_excel(r’D:\codes\dataframe\wine1.xls’, index=False) # 保存为excel文件
df.to_excel(r’D:\codes\dataframe\data_0.xlsx’, columns=[‘a’, ‘f’], index=False) # 保存a列和f列
df.to_csv(r’D:\codes\bigfile1.csv’, encoding=‘utf-8’, index=False) # 保存为csv文件
df.to_csv(r’D:\codes\bigfile1.csv’, encoding=‘gb18030’, index=False) # 保存为csv文件

4.阅

df.index # 展示数据框的行的名称
df.columns # 展示数据框的列的名称
df.values # 数控框中间的取值
df.size # 数据框值的个数
df.ndim
df.T.shape
df.head() # 查看前5行的数据
df.tail() # 查看最后5行的数据
df.shape # 查看数据库的要素
df.dtypes # 查看数据表的类型
df.info() # 查看数据的基本信息
df[‘b’].value_counts() # 统计b列中数值出现的次数
df.describe() # 查看基本的统计信息（最大、最小、平均、中位、四分位、标准差）

5.取

取元素

df.iloc[0][‘d’] # 选取第1行d列的值
df[[‘b’, ‘d’]][0:2] # 选取b列、d列；第1行和第2行的值
df.iloc[6, 5] # 选取第7行第6列的值
df.iloc[3, 2:4] # 选取第4行，第3、第4列的值
df.iloc[6, [5]] # 选取第7行第6列的值，结果类型为Series
df.iloc[[6], 5] # 选取第7行第6列的值，结果类型为Series
df.iloc[[6], [5]] # 选取第7行第6列的值，结果类型为DataFrame
df.iloc[1:3, 2] # 选取第2、第3行叁列的值
df.iloc[1:3, [2]] # 选取第2、第3行叁列的值
df.iloc[1:3, 2:4] # 选取第2、3行，第3、4列的值
df.iloc[1:3, [2, 4]] # 选取第2、3行，第3、4列的值
df.iloc[[1, 3], [0]] # 选取第2、3行，第1列的值
df.iloc[[1, 3], [0, 4]] # 选取第2、第4行，第1、第5列的值
df.iloc[:2, :3] # 选取前两行，前三列的值
df.loc[‘one’, [‘b’, ‘d’]] # 返回‘a’行’w’、'x’列，这种用于选取行索引列索引已知
df.loc[‘four’, ‘f’] # 选取four行f列的值
df1 = df[(df[‘d’] > 1) & (df[‘g’] == 6)] # 取d列大于1且g列等于6的行

取行 ——单行

df[1:2] # 选取第2行，返回的是DataFrame
df[-1:] # 选取最后1行，返回的是DataFrame
df.loc[‘four’] # 选取four列，返回的是Series
df.loc[[‘four’]] # 选取four列，返回的是DataFrame
df.iloc[-1] # 选取DataFrame最后一行，返回的是Series
df.iloc[-1:] # 选取DataFrame最后一行，返回的是DataFrame
df.iloc[[-1]] # 选取DataFrame最后一行，返回的是DataFrame
df.iloc[0, :] # 选取第1行，返回的是Series
df.iloc[0] # 选取第1行，返回的是Series
df.iloc[[0]] # 选取第1行，返回的是DataFrame

取行 ——多行

df[‘three’:‘six’] # 选取three到six，返回的是前闭后闭的DataFrame
df.loc[[‘three’, ‘six’]] # 选取three行和six行
df.iloc[:2, :] # 选取第1行到第2行
df.iloc[:-2] # 选取第1行到倒数第3行
df.iloc[[0, 3, 5]] # 选取第1、第4、第6行
df.iloc[0:4] # 选取第1到第4行共4行
df[0:2] # 取第1行到第2行的所有行，前闭后开，包括前不包括后
df.head() # 选取前5行，需要前10行则dta.head(10)
df.tail() # 选取后5行，需要后10行则data.tail(10)

取列 ——单列

df.e # 取e列, 使用点属性,返回的是Series类型
df[‘e’] # 取e列, 使用类字典属性,返回的是Series类型
df[[‘e’]] # 取e列，返回的是DataFrame属性
df.叁 # 选取叁列, 使用点属性,返回的是Series类型
df[‘叁’] # 选取叁列, 使用类字典属性,返回的是Series类型
df[[‘叁’]] # 选取叁列，返回的是DataFrame属性
df.iloc[:, 0] # 选取第1列，返回的是Series类型
df.iloc[:, [0]] # 选取第1列，返回的是DataFrame

取列 ——多列

df[[‘a’, ‘d’]] # 选取a、d两列，返回的是DataFrame
df.loc[:, ‘a’:‘e’] # 选取从a到e的所有列，返回的是DataFrame
df.iloc[:, :3] # 选取第1到第3列，返回的是DataFrame
df.iloc[:, 0:4] # 选取第1到第4列，返回的是DataFrame
df.iloc[:, [0, 3, 5]] # 选取第1、第4、第6列

6.改

df.columns=[‘name1’, ‘name2’] # 修改列索引名称
df1 = df.rename({‘one’: ‘一’}) # 把“one”行的名称修改为“一”
df1 = df.rename(columns={‘d’: ‘D’}) # 把“d”列的名称修改为“D”
df1 = df.rename(index={‘three’: ‘三’, ‘four’: ‘四’}, columns={‘e’: ‘E’, ‘g’: ‘G’}) # 修改行，列的名称
df1 = df.set_index(‘g’) # 把g列变成行索引
df[‘d’].astype(‘string’) # 把“d”列的int32数据变为字符串
df1 = df.reset_index(drop=True) # 删除原来的索引，重新建立由0开始的索引
df1 = df.reset_index() # 把行索引变成列名为index的列，行索引修改成按数字排列
df1.index.name = ‘中文’ # 对行索引命名为中文
print(df1)

7.增

增加列
df[‘列名称’] = list_data # 增加新的一列
df.insert(3,‘列名称’,list_data) # 在索引为3的位置插入新的一行

增加行
df.iloc[1] = list_data # 在索引为1的位置插入行

合并dataframe
df = pd.merge(df1, df2, how=‘left’, on=[‘key1’, ‘key2’])

df = df1.join(df2, on=[‘key1’, ‘key2’], how=‘inner’)

df = df.append(df_new)

df = pd.concat([df1, df2])

8.删

df1 = df.drop(columns=‘e’) # 删掉“e”列
df1 = df.drop(columns=[‘b’, ‘d’]) # 删掉“b”列和“d”列
df1 = df.drop([‘b’, ‘d’], axis=1) # 删掉“b”列和“d”列
df1 = df.drop([‘three’, ‘six’]) # 删掉“three”行和“six”行
df1 = df.drop([‘three’, ‘six’], axis=0) # 删掉“three”行和“six”行
df1 = df.drop(‘four’) # 删掉“four”行
df1 = df.drop(index=[‘five’, ‘seven’]) # 删掉“five”行和“seven”行
df1 = df[~df[‘a’].isin([0])] # 删除’a’列数据中为0的行（或理解为取出’a’列数据不为0的行）
df1 = df[df[‘a’].isin([0])] # 删除’a’列数据不为0的值（或理解为取出’a’列数据为0的行）
df1 = df[df[‘f’] > 19] # 删除’f’列数据小于19的行（或理解为取出数据大于19的行）

9.并

df = pd.DataFrame(np.arange(49).reshape(7, 7), index=[‘one’, ‘二’, ‘three’, ‘four’, ‘five’, ‘six’, ‘seven’], columns=[‘a’, ‘b’, ‘叁’, ‘d’, ‘e’, ‘f’, ‘g’])
df1 = pd.DataFrame(np.arange(14).reshape(2, 7), index=[‘eight’, ‘nine’], columns=[‘a’, ‘b’, ‘叁’, ‘d’, ‘e’, ‘f’, ‘g’])
df2 = pd.DataFrame(np.arange(14).reshape(7, 2), index=[‘one’, ‘二’, ‘three’, ‘four’, ‘five’, ‘six’, ‘seven’], columns=[‘h’, ‘i’])
df3 = pd.DataFrame(np.arange(14).reshape(2, 7), index=[‘one’, ‘nine’], columns=[‘a’, ‘b’, ‘叁’, ‘d’, ‘e’, ‘f’, ‘g’])
df4 = pd.DataFrame(np.arange(14).reshape(7, 2), index=[‘one’, ‘二’, ‘three’, ‘four’, ‘five’, ‘six’, ‘seven’], columns=[‘b’, ‘i’])

result = pd.concat([df, df2, df4], axis=0) # 3个数据框简单叠加
result = pd.concat([df, df1], axis=0) # 两个列索引相同、行索引不同的dataframe按行相加
result = pd.concat([df, df1], axis=1) # 两个列索引相同、行索引不同的dataframe按列相加
result = pd.concat([df, df3], axis=0) # 两个列索引相同、行索引部分相同的dataframe按行相加
result = pd.concat([df, df3], axis=1) # 两个列索引相同、行索引部分相同的dataframe按列相加
result = pd.concat([df1, df3], axis=0) # 两个列索引相同、行索引部分相同的dataframe按行相加
result = pd.concat([df1, df3], axis=1) # 两个列索引相同、行索引部分相同的dataframe按列相加

result = df.merge(df3) # 自动找相同的元素合并两个表
result = pd.merge(df, df1) # 根据两个表格中相同列中相同元素合并，自动找相同的元素
result = pd.merge(df, df1, on=‘a’) # 根据a列合并，两个表中a列相同元素的行保留，
result = pd.merge(df, df1, on=[‘a’, ‘f’]) # 根据a列和f列合并，两个表中a列和f列相同元素的行保留
result = pd.merge(df, df2) # 没有相同列的两个表格合并，保留最多的列，最少的行
result = pd.merge(df2, df) # 没有相同列的两个表格合并，
result = pd.merge(df, df4, how=‘outer’) # 两个表合并，取并集，保留所有的行和列
result = pd.merge(df, df4, how=‘inner’) # 两个表合并，取交集，保留左右表的共同内容
result = pd.merge(df, df4, how=‘left’) # 两个表合并，左表所有内容都保留，右表保留和左表相同的内容
result = pd.merge(df, df4, how=‘right’) # 两个表合并，右表所有内容都保留，左表保留和左表相同的内容
result = pd.merge(df, df1, left_index=True, right_index=True) # 以两个数据框的行索引合并，相同的索引保留，没有相同的就是空集

result = df.append(df1) # 两个数据行相加

pd.merge(df1, # 第1个数据表
df2, # 第2个数据表
how=‘inner’, # inner交集/outer并集/left左全保留右保留相同的/right右全保留
on=None, # 根据某个字段进行连接，必须存在于两个DateFrame中（若未同时存在，则需要分别使用left_on和right_on来设置）
left_on=None, # 左连接，以DataFrame1中用作连接键的列
right_on=None, # 右连接，以DataFrame2中用作连接键的列
left_index=False, # 将DataFrame1行索引用作连接键
right_index=False, # 将DataFrame2行索引用作连接键
sort=False, # 根据连接键对合并后的数据进行排列，默认为True
suffixes=(‘_x’, ‘_y’), # 对两个数据集中出现的重复列，新数据集中加上后缀_x,_y进行区别
copy=True,
indicator=False,
validate=None
)
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.join(other,
on=None,
how=‘left’,
lsuffix=‘’,
rsuffix=‘’,
sort=False
)

10.序

df1 = df.sort_index() # 根据行索引升序排列
df1 = df.sort_index(axis=0) # 根据行索引升序排列
df1 = df.sort_index(axis=1) # 根据列索引升序排列
df1 = df.sort_index(ascending=False) # 根据行索引降序排列
df1 = df.sort_index(ascending=True) # 根据行索引升序排列
df1 = df.sort_index(inplace=False) # 根据索引值排序，原数组df不变。
df1 = df.sort_index(inplace=True) # 根据索引值排序，原数组df变化。
df1 = df.sort_values(by=‘b’) # 把b列的数据升序排序，其他数据跟随变化
df1 = df.sort_values(by=‘b’, ascending=True) # 把b列的数据升序排序，其他数据跟随变化
df1 = df.sort_values(by=‘b’, ascending=False) # 把b列的数据降序排序，其他数据跟随变化
df1 = df.sort_values(by=[‘a’, ‘d’], ascending=False) # 把a和d列的数据降序排列