Pandas数据框操作进阶

Pandas为Python营造了一个高水平的操作环境，还提供了便于操作的数据结构和分析工具。无需更多介绍，Pandas已经是Python中数据分析的常用工具了。作为一个数据爱好者，Pandas是我日常使用的工具，我总会惊叹于它强大的功能，并且极大提升了工作效率的Pandas技巧。对于pandas新手而言，Pandas为Python编程语言营造了一个高水平的操作环境，还提供了便于操作的数据结构和分析工具。Pandas这个名字是由“面板数据”（panel data）衍生而来，这是一个计量经济学中的术语，它是一个数据集，由同一个个体在多个时间段内所观察的结果组成。

Pandas进阶提纲

Pandas是Python中用于数据处理和分析的重要库，进阶使用可以帮助更高效地处理复杂的数据。以下是Pandas数据处理的进阶内容提纲：

1. 数据清洗与处理

• 处理缺失数据：使用dropna或fillna方法，或者插值方法进行缺失值处理。
• 异常值处理：通过统计方法、箱线图等识别和处理异常值。
• 重复值处理：使用drop_duplicates方法剔除重复值。

2. 数据合并与连接

• 合并：使用merge函数将多个数据集按照指定列进行合并。
• 连接：通过concat函数按照行或列连接多个数据集。

3. 分组与聚合操作

• 利用groupby方法对数据进行分组，以实现按组进行聚合操作。
• 使用聚合函数如sum、mean、count等进行数据汇总。

4. 时间序列数据处理

• 时间索引：将时间列设置为索引，以便进行时间序列数据的处理。
• 时间重采样：通过resample方法对时间序列进行重新采样，如降采样或升采样。

5. 多层索引与透视表

• 创建多层索引：使用set_index方法创建多层行或列索引。
• 透视表：利用pivot_table`法进行数据透视，方便汇总和分析。

6. 自定义函数与映射

• 使用apply方法应用自定义函数到DataFrame或Series。
• 利用map方法进行元素级别的映射操作。

7. 数据可视化

• 利用matplotlib和seaborn库对数据进行可视化，更直观地理解数据。
• 使用plot方法直接在Pandas中绘制简单的图表。

8. 性能优化技巧

• 向量化操作：通过使用向量化的NumPy操作提高性能。
• 使用eval和query方法优化表达式和查询的性能。

通过掌握以上进阶内容，用户可以更灵活、高效地处理各类数据，从而提升数据分析的效果和效率。

一、空值检查和填充

在Pandas中，可以使用isnull()和notnull()方法进行空值检查，以及使用fillna()方法进行空值填充。
空值检查：
- isnull()方法会返回一个布尔型的DataFrame，其中值为True表示对应位置上的元素为空值。
- notnull()方法与isnull()相反，返回一个布尔型的DataFrame，其中值为True表示对应位置上的元素不为空值。

import pandas as pd
# 创建一个包含空值的DataFrame对象
df = pd.DataFrame({'A': [1, 2, None],
                   'B': [4, None, 6],
                   'C': [None, 8, 9]})

print("原始DataFrame:")
print(df)
# 检查DataFrame中的空值
null_check = df.isnull()
print("空值检查结果:")
print(null_check)

输出结果为：

原始DataFrame:
     A    B    C
0  1.0  4.0  NaN
1  2.0  NaN  8.0
2  NaN  6.0  9.0

空值检查结果:
       A      B      C
0  False  False   True
1  False   True  False
2   True  False  False

在上面的例子中，我们创建了一个包含空值的DataFrame对象df。然后，使用isnull()方法对DataFrame进行空值检查，并将结果保存在null_check中。输出的结果显示了DataFrame中每个位置上的元素是否为空值。
空值填充：
- fillna()方法用于填充DataFrame中的空值。它接受一个参数，用于指定要使用的填充值。
- 可以使用单个值、字典或Series来指定填充值。填充可以针对整个DataFrame、特定列或特定行进行。

import pandas as pd
# 创建一个包含空值的DataFrame对象
df = pd.DataFrame({'A': [1, 2, None],
                   'B': [4, None, 6],
                   'C': [None, 8, 9]})

print("原始DataFrame:")
print(df)

# 填充整个DataFrame中的空值为特定值
df_filled = df.fillna(0)

print("填充空值后的DataFrame:")
print(df_filled)

# 填充特定列中的空值为特定值
df['A'] = df['A'].fillna(10)

print("填充'A'列空值后的DataFrame:")
print(df)

# 使用字典指定不同列的填充值
fill_values = {'B': 20, 'C': 30}
df_filled_columns = df.fillna(fill_values)

print("填充不同列空值后的DataFrame:")
print(df_filled_columns)

输出结果为：

原始DataFrame:
     A    B    C
0  1.0  4.0  NaN
1  2.0  NaN  8.0
2  NaN  6.0  9.0

填充空值后的DataFrame:
     A    B    C
0  1.0  4.0  0.0
1  2.0  0.0  8.0
2  0.0  6.0  9.0

填充'A'列空值后的DataFrame:
      A    B    C
0   1.0  4.0  NaN
1   2.0  NaN  8.0
2  10.0  6.0  9.0

填充不同列空值后的DataFrame:
      A     B     C
0   1.0   4.0  30.0
1   2.0  20.0   8.0
2  10.0   6.0   9.0

在上面的示例中，我们首先创建了一个包含空值的DataFrame对象df。然后，使用fillna()方法对DataFrame中的空值进行填充。在第一个示例中，我们使用单个值0来填充整个DataFrame；在第二个示例中，我们使用特定值10来填充列'A'中的空值；在第三个示例中，我们使用字典指定了不同列的填充值。输出的结果显示了填充空值后的DataFrame。

二、对数据集DataFrame去重

要对DataFrame数据集进行去重操作，可以使用drop_duplicates()方法。drop_duplicates()方法会删除DataFrame中的重复行，并返回一个去重后的DataFrame。

import pandas as pd
# 创建一个带有重复行的DataFrame对象
df = pd.DataFrame({'A': [1, 2, 2, 3, 4],
                   'B': [4, 5, 5, 6, 7],
                   'C': [7, 8, 8, 9, 10]})

print("原始DataFrame:")
print(df)

# 对DataFrame进行去重
df_deduplicated = df.drop_duplicates()

print("去重后的DataFrame:")
print(df_deduplicated)

输出结果为：

原始DataFrame:
   A  B   C
0  1  4   7
1  2  5   8
2  2  5   8
3  3  6   9
4  4  7  10

去重后的DataFrame:
   A  B   C
0  1  4   7
1  2  5   8
3  3  6   9
4  4  7  10

在上面的例子中，我们创建了一个带有重复行的DataFrame对象df。然后，使用drop_duplicates()方法对DataFrame进行去重，并将去重后的结果保存在df_deduplicated中。输出的结果显示了去重后的DataFrame，其中重复的行被删除。
drop_duplicates()方法默认会对所有列进行去重判断，如果一行中所有列的值都相同，则判定为重复行。如果只想针对特定列进行去重，可以通过subset参数指定要考虑的列名，例如df.drop_duplicates(subset=['A', 'B'])。
在处理DataFrame数据集时，去重操作是常见的数据清洗步骤，可以去除重复的数据行，确保数据的唯一性。

三、对DataFrame分组

在Pandas中，可以使用groupby()方法对DataFrame进行分组操作。groupby()方法根据指定的列或多个列对DataFrame进行分组，并返回一个GroupBy对象。

import pandas as pd

# 创建一个DataFrame对象
data = {'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
        'B': ['one', 'one', 'two', 'two', 'two', 'one', 'two', 'one'],
        'C': [1, 2, 3, 4, 5, 6, 7, 8],
        'D': [9, 10, 11, 12, 13, 14, 15, 16]}
df = pd.DataFrame(data)

print("原始DataFrame:")
print(df)

# 按列'A'进行分组
grouped = df.groupby('A')

# 对分组后的数据进行聚合操作（例如求和）
sum_by_group = grouped.sum()

print("按列'A'分组后的聚合结果:")
print(sum_by_group)

输出结果为：

原始DataFrame:
     A    B  C   D
0  foo  one  1   9
1  bar  one  2  10
2  foo  two  3  11
3  bar  two  4  12
4  foo  two  5  13
5  bar  one  6  14
6  foo  two  7  15
7  foo  one  8  16

按列'A'分组后的聚合结果:
     C   D
A        
bar  12  36
foo  24  64

在上面的例子中，我们创建了一个DataFrame对象df，包含了’A’、‘B’、'C’和’D’四个列。然后，使用groupby()方法对DataFrame按列’A’进行分组，得到一个GroupBy对象grouped。接下来，我们可以对该分组对象进行聚合操作，例如求和，通过调用sum()方法。最终得到按列’A’分组后的聚合结果sum_by_group。
可以根据具体的需求，选择不同的列或多个列进行分组。除了groupby()方法外，GroupBy对象还提供了许多其他方法和操作，如count()、mean()、max()、min()、agg()等，用于对分组后的数据进行统计和聚合。

四、数据合并merge和连接concat

在Pandas中，数据合并与连接是处理多个数据集的重要操作，通过merge函数进行合并和连接。常见的连接方法有四种：

左连接（Left Merge）：保留左侧DataFrame的所有行，并与右侧DataFrame进行匹配，未匹配到的部分填充为缺失值。
右连接（Right Merge）：保留右侧DataFrame的所有行，并与左侧DataFrame进行匹配，未匹配到的部分填充为缺失值。
内连接（Inner Merge）：保留两个DataFrame中的交集部分。
外连接（Outer Join）：保留两个DataFrame的所有行，并进行匹配，未匹配到的部分填充为缺失值。

左连接	右连接	内连接	外连接

以下是合并与连接的方法和示例：

import pandas as pd

# 创建两个DataFrame对象
df1 = pd.DataFrame({'key': ['A', 'B', 'C'], 'value': [1, 2, 3]})
df2 = pd.DataFrame({'key': ['A', 'B', 'D'], 'value': [4, 5, 6]})

# Inner Merge
merged_inner = pd.merge(df1, df2, on='key')
print("Inner Merge:")
print(merged_inner)

# Left Merge
merged_left = pd.merge(df1, df2, on='key', how='left')
print("\nLeft Merge:")
print(merged_left)

# Right Merge
merged_right = pd.merge(df1, df2, on='key', how='right')
print("\nRight Merge:")
print(merged_right)

# Outer Merge
merged_outer = pd.merge(df1, df2, on='key', how='outer')
print("\nOuter Merge:")
print(merged_outer)

# Concatenation
concatenated = pd.concat([df1, df2], axis=0)
print("\nConcatenation:")
print(concatenated)` 

在上述示例中，我们创建了两个DataFrame对象df1和df2，然后通过merge函数进行不同方式的合并操作，以及通过concat函数进行连接操作。这些方法使得可以根据不同的需求进行数据集的合并和连接，灵活处理多个数据来源。

五、使用pivot_table 透视DateFrame

pivot_table()是Pandas中的一个函数，用于创建透视表（pivot table）。透视表是一种根据一个或多个键对数据进行聚合的方式，可以在不同维度上汇总和分析数据。

下面展示如何使用pivot_table()函数创建透视表：

import pandas as pd

# 创建一个DataFrame对象
data = {'A': ['foo', 'foo', 'bar', 'bar', 'foo', 'foo'],
        'B': ['one', 'two', 'one', 'two', 'one', 'two'],
        'C': [1, 2, 3, 4, 5, 6],
        'D': [7, 8, 9, 10, 11, 12]}
df = pd.DataFrame(data)

print("原始DataFrame:")
print(df)

# 创建透视表
pivot_table = pd.pivot_table(df, values='C', index='A', columns='B', aggfunc='sum')

print("透视表:")
print(pivot_table)

输出结果为：

原始DataFrame:
     A    B  C   D
0  foo  one  1   7
1  foo  two  2   8
2  bar  one  3   9
3  bar  two  4  10
4  foo  one  5  11
5  foo  two  6  12

透视表:
B    one  two
A            
bar    3    4
foo    6    8

在上面的例子中，我们创建了一个DataFrame对象df，包含了’A’、‘B’、‘C’和’D’四个列。然后，使用pivot_table()函数创建了一个透视表，通过指定values参数为’C’列、index参数为’A’列、columns参数为’B’列，以及aggfunc参数为’sum’，进行聚合操作。聚合的结果以透视表的形式输出。
透视表中的行表示’A’列的唯一值，列表示’B’列的唯一值，单元格中的值表示’C’列在对应’A’和’B’的组合上的聚合结果（这里使用了求和操作）。如果在数据中有多个相同的’A’和’B’组合，则会对相同组合的值进行聚合。
pivot_table()函数还可以接受其他参数，如fill_value用于填充缺失值、margins用于添加边际汇总等，可以根据具体需求进行调整。

六、使用query查询DateFrame

mport pandas as pd
df = pd.read_csv('titanic_train.csv')
df.query('Embarked == "S"')

query() 方法接受字符串作为查询条件串，因此，如果要查询字符串列，则需要确保字符串被正确括起来：

很多时候，我们可能希望将变量值传递到查询字符串中，可以使用 @ 字符执行此操作：

embarked = 'S'
df.query('Embarked == @embarked')
df.query(f'Embarked == "{embarked}"')
df.query('`Embarked On` == @embarked')

参考文献

1. Python数据分析之Pandas核心使用进阶
2. Python 教学 | Pandas 数据匹配（含实操案例）
3. Pandas Query 方法深度总结