pandas 表格操作

最新推荐文章于 2024-09-05 12:28:36 发布

猿心不灭

最新推荐文章于 2024-09-05 12:28:36 发布

阅读量1.2k

点赞数

本文链接：https://blog.csdn.net/weixin_46297209/article/details/112237552

版权

Data Analysis 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

pandas 表格操作

假设有一张表格，为它赋值为data，data里面有一个列索引为"order_time"，类型为字符串

一：时间处理

注：以下的操作都是针对时间类型来处理的

to_datetime

将其它类型转换为时间类型

# 将字符串类型的order_time转换为时间类型，并代替原表格中的order_time列
data["order_time"] = pd.to_datetime(data["order_time"])

时间类型提取

series.dt.时间属性

时间属性：year/month/day/hour/minute/second/date/week(一年中第几周)/dayofyear(一年中的第几天)/weekday_name(星期名称)/quarter(季节)/is_leap_year(是否是闰年)/daysinmonth(当前月有几天)

# 提取年份
year = data["order_time"].dt.year
# 提取日期
date = data["order_time"].dt.date

时间运算(计算时间间隔)

索引不同无法进行正确的运算

reset_index()：重置索引，重置索引后原来的索引不会删除，会作为新的一列添加到表格中

time1 = data["order_time"].head()
# 在重置索引后会将原来的索引作为新的一列添加到当前类前面，故需要再取一次order_time
time2 = data["order_time"].tail().reset_index()["order_time"]

整体+时间戳

将整个时间进行平移

series +/- pd.Timedelta(days/weeks…=num)

data["order_time"] + pd.Timedelta(days=1)

二：分组聚合

by用来指定分组或排序的列，如果是二维就必须传by值，如果是一维就不存在行和列的概念，所以就不能传入by值。

分组和聚合是在一起使用的

data.groupby(by=“分组键”)[""].聚合方法

# 按order_id分组，并将分组中的amounts进行求和
data.groupby(by="order_id")["amounts"].sum()

# 按order_id分组，并将分组中的amounts和counts两列分别求和
data.groupby(by="order_id")[["amounts","counts"]].sum().head()

# sort_values为排序，ascending=True为降序，False为升序
data.groupby(by="order_id")[["amounts","counts"]].sum().head().sort_values(by="counts",ascending=False)

三：聚合

利用pandas/numpy中的统计分析方法来实现聚合

特殊函数完成聚合操作

# 对data表中的amounts和counts两列分别做相应的聚合运算
data[["amount","counts"]].agg([np.sum, np.mean, np.ptp])

特殊函数指定聚合操作

# 对amounts列求平均数，对counts求和和标准差
data[["amounts","counts"]].agg(["amounts":np.mean,"counts":[np.sum,np.std]])

# 按order_id分组后，最amounts和counts列求平均数和和，最后只显示amounts列

data.group(by="order_id")[["amounts","counts"]].agg([np.mean,np.sum])["amounts"]

transform聚合方法

在pandas或者numpy中没有现成的函数可以使用，可以通过transform使用自定义的函数。

transform需传入一个函数对象参数
```
# 定义一个使data["counts"]每个数*2的聚合函数
data["counts"].transform(lambda x:x*2)
```
透视表

index：指定行分组键，当传入多个值时则进行递归分组

aggfunc：分组后求各分组的相关运算值，进行运算的分组为最底层分组

values：指定聚合的列

columns：列分组键，用法与index类似

fill_value：将数据为NAN的值填充为指定值

margins：将每一行和每一列数据进行汇总处理，默认为False

margins_name：汇总的行或列的索引名称，默认为All

# 将数组先按order_id进行分组，在分组内再对amounts进行分组，之后对分组内的各列数据进行相应的聚合运算，并只显示counts和add_inprice两个字段

pd.pivot_table(data,index=["order_id","amounts"],aggfunc=[np.mean,np.sum],values=["counts","add_inprice"])

# 将行按order_id分组，将列按dish_name分组，对每一个分组的数据求和，显示counts字段，并进行汇总求和

pd.pivot_table(data,index=["order_id"],columns=["dishes_name"],values="counts",aggfunc=[np.sum],fill_value=0,margins=True)

交叉表

必须指定index和column，相当于透视表中同时指定index和column的方法

pd.crosstab(index=data["order_id"],columns=data["dishes_name"],values=data["counts"],aggfunc=np.sum)

四：series中字符串处理的方法

data.info()，

查看表的详细信息
删除符号，比如换行符，

用的是python中字符串的方法，当进行连续操作时，需多次使用.str去连接方法

data["dishes_name"].str.strip()
mask = data["dishes_name"].str.contains("str")
data.loc[mask,"dishes_name"]

五：df中去重的操作

drop_duplicates()

一维可以直接使用，不可以传入subset参数。二维必须传入subset参数， subset可传入一个字符串或是一个列表。当列表传入了多个值时，这几个值将视为一个元素，即这几个列的元素都相等时才算重复。

# 一维
data["dishes_name"].drop_duplicates()

# 二维,当order_id和dishes_name的值都相等时进行去重
data.drop_duplicates(subset=["order_id","dishes_name"])

六：表格合并

纵向合并

pd.concat((df1,df2,…,dfn),axis=0)

根据列索引名称来进行拼接，自动将两张表列索引名称相同的列拼接在一起，所以在拼接时会无视表格列的排列

join：out表示外连接，求并集，inner为内连接，表示交集，默认为outer

# 创建两张表格

left = pd.DataFrame({
	'key1': ['K0', 'K0', 'K1', 'K2'],
	'key2': ['K0', 'K1', 'K0', 'K1'],
	'A': ['A0', 'A1', 'A2', 'A3'],
	'B': ['B0', 'B1', 'B2', 'B3']
	})

right = pd.DataFrame({
	'key1': ['K0', 'K1', 'K1', 'K2'],
	'key2': ['K0', 'K0', 'K0', 'K0'],
	'C': ['C0', 'C1', 'C2', 'C3'],
	'D': ['D0', 'D1', 'D2', 'D3']
	})

# 合并left和right表

ret = pd.concat((left,right),axis=0)
print(ret)

# 结果

key1 key2    A    B    C    D

0   K0   K0   A0   B0  NaN  NaN
1   K0   K1   A1   B1  NaN  NaN
2   K1   K0   A2   B2  NaN  NaN
3   K2   K1   A3   B3  NaN  NaN
0   K0   K0  NaN  NaN   C0   D0
1   K1   K0  NaN  NaN   C1   D1
2   K1   K0  NaN  NaN   C2   D2
3   K2   K0  NaN  NaN   C3   D3

# 取交集合并
ret = pd.concat((left,right),axis=0,join="inner")

# 结果
key1 key2
0   K0   K0
1   K0   K1
2   K1   K0
3   K2   K1
0   K0   K0
1   K1   K0
2   K1   K0
3   K2   K0

横向合并

解决行索引没有意义情况下，数据行不匹配问题(解决concat中横向拼接问题)

merge：主键合并方法

on：必须是两张表中公共的字段，即两张表的共有字段，才能作为主键，可指定多个主键

how：指定连接方式，默认为内连接(inner)，取两张表字段的交集；如果使用外连接则取两张表字段的并集(outer)；如果左连接(left)，则以左表为基，根据左表的字段进行合并；右连接(right)与左连接相反

left_on,right_on：指定两个表不同的字段作为主键

# 设置一个主键进行合并
# 将key1的值key1和右表的每个key1值进行比较，如果相同则组成一行。
# key2_x:左表的key2值
# key2_y:右表的key_2值
ret = pd.merge(left,right,on="key1")
print(ret)

# 结果
key1 key2_x   A   B key2_y   C   D
0   K0     K0  A0  B0     K0  C0  D0
1   K0     K1  A1  B1     K0  C0  D0
2   K1     K0  A2  B2     K0  C1  D1
3   K1     K0  A2  B2     K0  C2  D2
4   K2     K1  A3  B3     K0  C3  D3

# 设置两个主键进行合并
# 将两个字段的值看成一组，当都相等时才会合并
ret = pd.merge(left,right,on=["key1","key2"])
print(ret)

# 结果
key1 key2   A   B   C   D
0   K0   K0  A0  B0  C0  D0
1   K1   K0  A2  B2  C1  D1
2   K1   K0  A2  B2  C2  D2

# 指定两表中不同的主键进行合并
ret2 = pd.merge(left,right,left_on="key1",right_on="C")
print(ret2)

# 结果
Empty DataFrame
Columns: [key1_x, key2_x, A, B, key1_y, key2_y, C, D]
Index: []

补存合并

创建表格

dict1 = {
	'ID':[1,2,3,4,5,6,7,8,9],
	'System':['W10','w10',np.nan,'w10',np.nan,np.nan,'w7','w7','w8']}

dict2 = {
	'ID':[1,2,3,4,5,6,7,8,9],
	'System':[np.nan,np.nan,'w7','w7','w7','w7','w8',np.nan,np.nan]}
	
df1 = pd.DataFrame(dict1)
df2 = pd.DataFrame(dict2)

# 以df1为主表，利用df2表去填充df1表，当df2中数据与df1不一致的时候以主表为主
ret3 = df1.combine_first(df2)
print(ret3)

# 结果
	ID System
0   1    NaN
1   2    NaN
2   3     w7
3   4     w7
4   5     w7
5   6     w7
6   7     w8
7   8    NaN
8   9    NaN
	ID System
0   1    W10
1   2    w10
2   3     w7
3   4    w10
4   5     w7
5   6     w7
6   7     w7
7   8     w7
8   9     w8

补存：更改表格名称的方法

inplace：是否在原表上进行修改，默认为False

# 将表格的列索引名称key1改为key222

ret4 = left.rename(columns={"key1":"key111"},inplace=False)
print(ret4)

# 结果

  key111 key2   A   B
0     K0   K0  A0  B0
1     K0   K1  A1  B1
2     K1   K0  A2  B2
3     K2   K1  A3  B3