Pandas为Python营造了一个高水平的操作环境，还提供了便于操作的数据结构和分析工具。无需更多介绍，Pandas已经是Python中数据分析的常用工具了。作为一个数据科学家，Pandas是我日常使用的工具，我总会惊叹于它强大的功能，并且极大提升了工作效率的Pandas技巧。对于pandas新手而言，Pandas为Python编程语言营造了一个高水平的操作环境，还提供了便于操作的数据结构和分析工具。Pandas这个名字是由“面板数据”（panel data）衍生而来，这是一个计量经济学中的术语，它是一个数据集，由同一个个体在多个时间段内所观察的结果组成。
一、空值检查和填充
在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()等，用于对分组后的数据进行统计和聚合。
四、使用join连接两个DataFrame和四种join方法
要连接两个DataFrame，可以使用join()方法。join()方法在Pandas中用于按照索引或列进行连接操作，并返回连接后的新DataFrame。下面是一个示例，展示如何使用join()方法连接两个DataFrame：
import pandas as pd
# 创建两个DataFrame对象
df1 = pd.DataFrame({'A': [1, 2, 3],
'B': [4, 5, 6]})
df2 = pd.DataFrame({'C': [7, 8, 9],
'D': [10, 11, 12]})
# 使用join()方法连接两个DataFrame，默认使用索引进行连接
df_join = df1.join(df2)
print("连接后的DataFrame:")
print(df_join)
输出结果为：
连接后的DataFrame:
A B C D
0 1 4 7 10
1 2 5 8 11
2 3 6 9 12
在上面的例子中，我们创建了两个DataFrame对象df1和df2，每个DataFrame包含两列。然后，我们使用join()方法将它们连接起来，由于没有指定连接的列，所以默认使用索引进行连接。连接后的结果保存在df_join中，输出显示了连接后的DataFrame。
除了默认的索引连接，join()方法还提供了不同的连接方法，可以通过how参数进行指定。常见的连接方法有四种：
左连接（Left Join）：保留左侧DataFrame的所有行，并与右侧DataFrame进行匹配，未匹配到的部分填充为缺失值，使用how='left'进行指定。
右连接（Right Join）：保留右侧DataFrame的所有行，并与左侧DataFrame进行匹配，未匹配到的部分填充为缺失值，使用how='right'进行指定。
内连接（Inner Join）：保留两个DataFrame中的交集部分，使用how='inner'进行指定。
外连接（Outer Join）：保留两个DataFrame的所有行，并进行匹配，未匹配到的部分填充为缺失值，使用how='outer'进行指定。
| 左连接 | 右连接 | 内连接 | 外连接 |
|---|---|---|---|
 |
 |
 |
 |
下面是一个示例，展示如何使用不同的连接方法：
import pandas as pd
# 创建两个DataFrame对象
df1 = pd.DataFrame({'A': [1, 2, 3],
'B': [4, 5, 6]})
df2 = pd.DataFrame({'B': [4, 5, 6],
'C': [7, 8, 9]})
# 内连接
df_inner = df1.join(df2, how='inner')
print("内连接:")
print(df_inner)
# 左连接
df_left = df1.join(df2, how='left')
print("左连接:")
print(df_left)
# 右连接
df_right = df1.join(df2, how='right')
print("右连接:")
print(df_right)
# 外连接
df_outer = df1.join(df2, how='outer')
print("外连接:")
print(df_outer)
输出结果为：
内连接:
A B B C
0 1 4 4 7
1 2 5 5 8
2 3 6 6 9
左连接:
A B B C
0 1 4 4.0 7.0
1 2 5 5.0 8.0
2 3 6 6.0 9.0
右连接:
A B B C
0 1 4.0 4 7
1 2 5.0 5 8
2 3 6.0 6 9
外连接:
A B B C
0 1 4.0 4.0 7.0
1 2 5.0 5.0 8.0
2 3 6.0 6.0 9.0
在上面的例子中，我们创建了两个DataFrame对象df1和df2，其中df1包含列’A’和’B’，df2包含列’B’和’C’。然后，我们使用join()方法并通过how参数指定不同的连接方法进行连接。输出结果显示了使用不同连接方法得到的连接后的DataFrame。
五、使用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')