文章目录
1.增加
1.增加数据
new_row={'列名':数据}
df._append(new_row)
import pandas as pd
# 创建一个空的数据库
df=pd.DataFrame()
# 增加一行数据
new_row = {'A':1,'B':2,'C':3}
df = df._append(new_row, ignore_index=True)
print(df)结果:
A B C
0 1 2 3
2.新增一列数据
df['新增列名'] =[数据]
mport pandas as pd
# 创建一个空的数据库
df=pd.DataFrame()
# 增加一行数据
new_row = {'A':1,'B':2,'C':3}
df = df._append(new_row, ignore_index=True)
#print(df)
df['D'] =[4]
print(df)
# 结果
# A B C D
# 0 1 2 3 43.根据条件来增加数据
query('条件')
import pandas as pd
# 创建一个空的数据库
df=pd.DataFrame()
# 增加一行数据
new_row = {'A':1,'B':2,'C':3}
df = df._append(new_row, ignore_index=True)
print(df)
# A B C
# 0 1 2 3
df = df.query('B >4')
print(df)
# Empty DataFrame
# Columns: [A, B, C]
# Index: []
df['D'] =[4]
print(df)
# A B C D
# 0 NaN NaN NaN 4
4.根据索引来增加数据
1.加了fd.loc['行名']，就是添加行名的数据
new_row = {'列名'：数据}
fd.loc['行名'] = new_row
2.fd.loc[n],n是对第几行进行操作，
fd.loc[n] = new_row
3.fd['列名']没有加loc,就是添加列名的数据
d['列名']=[数据]
# import pandas as pd
# # 创建一个空的数据库
# df=pd.DataFrame()
# # 增加一行数据
# new_row = {'A':1,'B':2,'C':3}
# df = df._append(new_row, ignore_index=True)
# print(df)
# # A B C
# # 0 1 2 3
# df = df.query('B >4')
# print(df)
# # Empty DataFrame
# # Columns: [A, B, C]
# # Index: []
# df['D'] =[4]
# print(df)
# # A B C D
# # 0 NaN NaN NaN 4
import pandas as pd
# 创建一个数据框
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
print(df)
# A B
# 0 1 4
# 1 2 5
# 2 3 6
# 在索引为0的位置添加一行
# new_row = {'A': 10, 'B': 20}
# df.loc[0] = new_row
# print(df)
# # A B
# # 0 10 20
# # 1 2 5
# # 2 3 6
# 前面注释，不然一二行都变成10,20
# 说明里面是的几个【n】,就注释第n行
# 在索引为1的位置添加一行
new_row = {'A': 10, 'B': 20}
df.loc[1] = new_row
print(df)
# A B
# 0 1 4
# 1 10 20
# 2 3 6
# 在索引为'new_index'的位置添加一行
# 加了loc['行名']，就是添加行名的数据
# 没有加就是添加列名的数据
new_row = {'A': 100, 'B': 200}
df.loc['new_index'] = new_row
print(df)
# A B
# 0 1 4
# 1 10 20
# 2 3 6
# new_index 100 200
# 在'C'列末尾添加一列
new_col = [1, 2, 3, 4] # 数据的长度应与索引的长度相匹配
df['C'] = new_col
print(df)
# A B C
# 0 1 4 1
# 1 10 20 2
# 2 3 6 3
# new_index 100 200 4
2.删除
1.删除数据整个数据框
# 使用del关键字删除整个数据框
del df
# 使用drop()方法删除整个数据框
df.drop(df.index, inplace=True)
2.删除指定的数据
movie.drop(movie[movie['指定的列'] == '指定值'].index,axis=1)
# 删除指定的行（索引为0和1）
df.drop([0, 1], inplace=True)
# 删除指定的列（'A'和'B'列）
df.drop(['A', 'B'], axis=1, inplace=True)
3.删除有条件的数据
# 使用query方法删除满足特定条件的行
df = df.query('B != "apple"') # 删除'B'列值为'apple'的行
import pandas as pd
# 创建一个示例数据框
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
'B': ['apple', 'banana', 'cherry', 'apple', 'orange'],
'C': [True, False, True, True, False]})
# 使用query方法删除满足特定条件的行
df = df.query('B != "apple"') # 删除'B'列值为'apple'的行
print(df)
# A B C
# 1 2 banana False
# 2 3 cherry True
# 4 5 orange False
# 使用 query 方法筛选满足条件的行，并通过 loc 方法选择特定的列
result = df.query('条件').loc[ : , ['列名'] ]
# 假设有一个数据框 df，包含列 A、B 和 C
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
'B': [10, 20, 30, 40, 50],
'C': [100, 200, 300, 400, 500]})
# 使用 query 方法筛选满足条件的行，并通过 loc 方法选择特定的列
result = df.query('A > 2').loc[:, ['B', 'C']]
print(result)
# B C
# 2 30 300
# 3 40 400
# 4 50 5003.修改
1.修改指定的数据
df.loc[行数，‘列名’] = 数据
# 假设有一个数据框 df，包含列 A、B 和 C
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
'B': [10, 20, 30, 40, 50],
'C': [100, 200, 300, 400, 500]})
# 修改指定位置的数据
df.loc[2, 'B'] = 35
print(df)
# A B C
# 0 1 10 100
# 1 2 20 200
# 2 3 35 300
# 3 4 40 400
# 4 5 50 5002.修改有条件的数据
df.loc[df['列名']>（行的条件），‘修改的列’] = 列的数据
# 假设有一个数据框 df，包含列 A、B 和 C
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
'B': [10, 20, 30, 40, 50],
'C': [100, 200, 300, 400, 500]})
# 根据条件修改数据
df.loc[df['A'] > 2, 'C'] = 999
print(df)
# A B C
# 0 1 10 100
# 1 2 20 200
# 2 3 30 999
# 3 4 40 999
# 4 5 50 999
4.查询
1.指定查询
quer(‘条件’)[ [查询的字段] ]
# 假设有一个数据框 df，包含列 A、B 和 C
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
'B': [10, 20, 30, 40, 50],
'C': [100, 200, 300, 400, 500]})
# 查询指定列
df_query = df.query('A > 2')[['A', 'C']]
print(df_query)
# A C
# 2 3 300
# 3 4 400
# 4 5 500
2.条件查询
# 假设有一个数据框 df，包含列 A、B 和 C
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
'B': [10, 20, 30, 40, 50],
'C': [100, 200, 300, 400, 500]})
# 条件查询
df_filtered = df[(df['A'] > 2) & (df['C'] < 400)]
print(df_filtered)
# A B C
# 2 3 30 3003.分组和聚合查询
df.groupby('列名').聚会函数
df = pd.DataFrame({'A': [1, 1, 2, 2, 3],
'B': [10, 20, 30, 40, 50],
'C': [100, 200, 300, 400, 500]})
# 按列 A 进行分组，并计算每个分组的均值
grouped = df.groupby('A').mean()
# 输出结果
print(grouped)
# B C
# A
# 1 15.0 150.0
# 2 35.0 350.0
# 3 50.0 500.04.合表查询
1.按方向合并
pd.concat((a,b), axis=)
# 假设有两个数据框 a 和 b
a = pd.DataFrame({'A': [1, 2, 3],
'B': [4, 5, 6]})
b = pd.DataFrame({'C': [7, 8, 9],
'D': [10, 11, 12]})
# 按行方向合并（纵向合并）
concatenated = pd.concat((a, b), axis=0)
# 输出结果
print(concatenated)
# A B C D
# 0 1.0 4.0 NaN NaN
# 1 2.0 5.0 NaN NaN
# 2 3.0 6.0 NaN NaN
# 0 NaN NaN 7.0 10.0
# 1 NaN NaN 8.0 11.0
# 2 NaN NaN 9.0 12.0
2.按索引合并
pd.merge(left,right,how='inner', on=[索引])
# 假设有两个数据框 df1 和 df2，包含列 key、A 和 B
df1 = pd.DataFrame({'key': ['foo', 'bar', 'baz', 'qux'],
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8]})
df2 = pd.DataFrame({'key': ['foo', 'bar', 'baz', 'qux'],
'C': [9, 10, 11, 12],
'D': [13, 14, 15, 16]})
# 合并两个数据框，根据 key 列进行合并
merged = pd.merge(df1, df2, on='key')
# 输出结果
print(merged)
# key A B C D
# 0 foo 1 5 9 13
# 1 bar 2 6 10 14
# 2 baz 3 7 11 15
# 3 qux 4 8 12 16
5.交叉表查询
pd.crosstab() 函数用于创建交叉表（cross-tabulation），也称为列联表。它可以统计两个或多个变量之间的频数或频率，并以表格形式展示。
函数的语法如下：
pd.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None)
其中：
index 是要在行方向上进行分组的变量；
columns 是要在列方向上进行分组的变量；
values 是可选的，用于指定要聚合的数据列；
rownames 和 colnames 是可选的，用于指定行和列的名称；
aggfunc 是可选的，用于定义对聚合值进行计算的函数，默认为计数。
# 假设有一个数据框 df，包含列 A、B、C 和 D
df = pd.DataFrame({'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
'C': np.random.randn(8),
'D': np.random.randn(8)})
# 创建透视表，按 A 和 B 列分组，并计算 C 和 D 列的均值
pivot_table = df.pivot_table(values=['C', 'D'], index='A', columns='B', aggfunc=np.mean)
# 输出结果
print(pivot_table)
# C D
# B one three two one three two
# A
# bar 1.821440 -0.407843 0.114514 0.337398 -1.026214 -0.418785
# foo 0.677367 0.889548 -0.128189 -0.747733 -1.760644 -0.286292
6.透视表查询
df.pivot_table(values, index, columns, aggfunc='mean', fill_value=None)
其中：
values 是要进行聚合的字段或字段列表；
index 是用作新表格的索引的字段；
columns 是用作新表格列的字段；
aggfunc 是指定聚合函数的参数，默认为 'mean'；
fill_value 是可选的，用于指定替换缺失值的值。
# 假设有一个数据框 df，包含列 A、B 和 C
df = pd.DataFrame({'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
'C': np.random.randn(8)})
# 创建交叉表，按 A 和 B 列进行分组，并计算 C 列的频次
cross_table = pd.crosstab(index=df['A'], columns=df['B'], values=df['C'], aggfunc='count')
# 输出结果
print(cross_table)
# B one three two
# A
# bar 1 1 1
# foo 2 1 2
1.交叉表和透视表的差别
交叉表（crosstab）和透视表（pivot table）是在 Pandas 中用于数据分析和汇总的两种常见操作。它们之间有一些差别，主要体现在以下几个方面：
-
数据结构：交叉表是一个用于计算频率或统计指标的特殊数据表格，其中行和列分别表示不同的分类变量，并显示它们之间的交叉计数。透视表是根据一个或多个列中的值对数据进行聚合，并将它们重塑为新的数据表格，其中行和列表示不同的指标变量。
-
聚合方式：交叉表主要用于计算分类变量之间的频率或交叉计数。它默认使用计数作为聚合函数，但也可以使用其他聚合函数，如求和、均值等。透视表则是根据需要选择不同的聚合函数，可以使用各种聚合函数进行数据聚合，如求和、均值、最大值、最小值等。
-
灵活性：透视表在对数据进行聚合时更加灵活，可以根据需求自定义聚合函数、添加过滤条件、设置多级索引等。而交叉表相对简单，主要用于计算频率或统计指标，对数据的灵活处理能力较弱。
下面是交叉表和透视表的示例代码：
交叉表示例:
pd.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None)
# 创建示例数据
data = {'Gender': ['Male', 'Female', 'Male', 'Female', 'Male'],
'Age': [20, 25, 30, 35, 40],
'Smoker': ['Yes', 'No', 'No', 'No', 'Yes']}
df = pd.DataFrame(data)
# 计算交叉表
cross_tab = pd.crosstab(df['Gender'], df['Smoker'])
# 输出结果
print('-'*28)
print(cross_tab)
# Smoker No Yes
# Gender
# Female 2 0
# Male 1 2
透视表示例：
df.pivot_table(values, index, columns, aggfunc='mean', fill_value=None)
# 创建示例数据
data = {'Gender': ['Male', 'Female', 'Male', 'Female', 'Male'],
'Age': [20, 25, 30, 35, 40],
'Smoker': ['Yes', 'No', 'No', 'No', 'Yes']}
df = pd.DataFrame(data)
# 计算透视表
pivot_table = df.pivot_table(index='Gender', columns='Smoker', values='Age', aggfunc='mean')
# 输出结果
print('_'*34)
print(pivot_table)
# Smoker No Yes
# Gender
# Female 30.0 NaN
# Male 30.0 30.0
在上面的示例中，交叉表计算了性别和吸烟情况之间的频率统计，而透视表根据性别和吸烟情况对年龄进行了平均值的汇总。
希望这个解释有助于理解交叉表和透视表的差异。如果还有其他问题，请随时提问！
3135
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
