点击获取AI摘要

Pandas 操作方式笔记

1. Pandas 简介

Pandas 是一个在 Python 编程语言中广泛使用的数据操作和分析的开源库。它建立在另一个基础库 NumPy 之上，NumPy 主要用于数值计算。Pandas 的出现极大地简化了使用 Python 进行数据清洗、转换和分析的过程，提供了高性能且易于使用的数据结构和数据分析工具。在当前数据科学和机器学习的工作流程中，Pandas 扮演着至关重要的角色。

Pandas 依赖于 NumPy，这意味着理解一些基本的 NumPy 概念对于优化 Pandas 的操作非常有益，尤其是在处理大型数据集时。例如，NumPy 的数组操作和广播规则直接影响着 Pandas 的性能。因此，在掌握 Pandas 的基础知识后，进一步探索 NumPy 将有助于用户编写更高效的 Pandas 代码。

此外，Pandas 在数据科学领域被广泛采用，这使得精通 Pandas 成为任何希望在 Python 中处理数据的人的一项非常有价值的技能。无论是进行学术研究、商业分析还是开发机器学习模型，Pandas 都是一个不可或缺的工具。因此，学习 Pandas 的长期收益是显著的，它将为用户打开数据相关职业发展的大门。

相较于标准的 Python 数据结构（如列表和字典），使用 Pandas 进行数据分析具有显著的优势。Pandas 提供了表格数据的表示方式，即 DataFrame，它类似于电子表格和数据库中的表结构。这种结构使得数据的组织和理解更加直观。此外，Pandas 具有带标签的轴（行和列），这使得数据的访问更加方便和有意义。

Pandas 提供了强大且灵活的数据操作功能，包括数据过滤、排序、合并等。它还内置了处理缺失数据的功能，并提供了数据对齐和整合的工具。更重要的是，Pandas 可以与其他 Python 库（如 NumPy、Matplotlib 和 Scikit-learn）无缝集成，形成一个强大的数据分析生态系统。最后，Pandas 在处理大型数据集时也表现出高效性，这使得它成为处理各种规模数据的理想选择。

Pandas DataFrame 中带标签的轴相比于 NumPy 数组或列表的列表仅使用数字索引，极大地提高了数据的可读性和操作性。对于初学者来说，使用有意义的列名和行索引进行复杂的数据操作会更加直观，减少出错的可能性。传统的 Python 数据结构通常依赖于位置索引，当数据集变得复杂时，这种方式可能会显得笨拙。而 Pandas 的标签索引允许用户通过名称引用数据，从而提高了代码的清晰度和可维护性。

Pandas 与其他数据科学库的无缝集成创建了一个强大的端到端数据分析工作流程。从数据加载和清洗到可视化和模型构建，Pandas 都可以作为核心组件。例如，Pandas 可以轻松地将数据传递给 Matplotlib 进行绘图，或传递给 Scikit-learn 进行机器学习模型的训练。这种集成性突显了 Pandas 在更广泛的 Python 数据科学领域中的核心地位。

2. Pandas 数据结构：Series 和 DataFrame

Pandas 中最核心的两个数据结构是 Series 和 DataFrame。理解这两种数据结构是掌握 Pandas 的关键。

Series 介绍

Series 是一种一维的带标签的数组，它可以存储任何数据类型（整数、字符串、浮点数、Python 对象等）。可以将 Series 想象成电子表格中的一列，或者一个带标签的列表。

一个 Series 由两个主要部分组成：索引（Index） 和 值（Values）。索引是数据的标签，可以是整数、字符串或任何其他可哈希的 Python 对象。如果创建 Series 时没有明确指定索引，Pandas 会自动创建一个默认的整数索引，从 0 开始递增。值是 Series 中存储的实际数据。

与普通的 Python 列表不同，Series 拥有显式的索引。这种显式的索引使得数据的访问和对齐更加有意义。尤其是在处理时间序列数据或具有内在标签的数据时，Series 的优势更加明显。例如，在一个存储产品价格的 Series 中，可以使用产品名称作为索引，这样就可以直接通过产品名称来查找其价格，而不需要记住它在列表中的位置。

DataFrame 介绍

DataFrame 是一种二维的带标签的数据结构，可以看作是由多个 Series 组成的表格。DataFrame 的每一列可以是不同的数据类型。它是 Pandas 中最核心的数据结构，用于表示表格数据。

DataFrame 由三个主要部分组成：索引（Index）、列（Columns） 和 值（Values）。索引是行的标签，类似于 Series 中的索引。列是数据的标签，每一列都可以看作是一个 Series。值是实际的数据，以表格的形式排列在行和列中。

可以将 DataFrame 类比为一个电子表格或一个 SQL 数据库中的表。它提供了一种非常直观的方式来组织和处理结构化数据。例如，在一个存储学生信息的 DataFrame 中，每一行可能代表一个学生，而每一列可能代表学生的姓名、年龄、成绩等信息。

DataFrame 能够容纳不同数据类型的列，这与 NumPy 数组通常要求所有元素具有相同类型形成了鲜明的对比。现实世界中的数据往往包含各种不同的类型，例如数值型的测量数据、类别型的标签以及日期时间信息。Pandas DataFrame 的这种灵活性使其非常适合表示和处理各种真实世界的数据集。

此外，Pandas 中一个非常重要的概念是按照索引和列标签对齐数据。这简化了涉及多个 Series 或 DataFrame 的操作。当对两个 Pandas 对象进行操作时（例如，将两个 DataFrame 相加），Pandas 会自动根据它们的行和列标签对齐数据。即使这些对象的初始顺序不同或存在缺失的标签，这种自动对齐也能确保操作在对应的数据点上执行，从而避免了常见的错误，并使得数据操作更加健壮。

3. 创建 Series 和 DataFrame

Pandas 提供了多种灵活的方法来创建 Series 和 DataFrame 对象。了解这些方法对于开始使用 Pandas 至关重要。

创建 Series

• 从列表创建： 可以使用 Python 列表来创建一个 Series。Pandas 会自动为列表中的每个元素分配一个从 0 开始的整数索引。

  import pandas as pd
  data = 
  s = pd.Series(data)
  print(s)

  输出结果会显示每个值及其对应的默认整数索引。

• 从 NumPy 数组创建： 也可以从 NumPy 数组创建 Series。数据会直接从 NumPy 数组转移到 Series 中。

  import numpy as np
  arr = np.array()
  s = pd.Series(arr)
  print(s)

  与从列表创建类似，Pandas 会为数组中的每个元素分配一个默认的整数索引。

• 从字典创建： 从 Python 字典创建 Series 是一种非常强大的方式。字典的键会成为 Series 的索引标签，而字典的值会成为 Series 的值。

  data = {'Alice': 10, 'Bob': 20, 'Charlie': 30}
  s = pd.Series(data)
  print(s)

  在这种情况下，Series 的索引将是 ‘Alice’, ‘Bob’, ‘Charlie’，对应的值分别是 10, 20, 30。这种方式非常适合表示带有明确标签的数据。

• 指定索引： 在从列表或 NumPy 数组创建 Series 时，可以显式地指定索引。

  data = 
  index =
  s = pd.Series(data, index=index)
  print(s)

  通过 index 参数，我们可以自定义 Series 的索引标签。

从字典创建 Series 是一种表示带有内在含义标签的数据的强大方法，例如将产品名称映射到价格。字典本身就存储着键值对，当转换为 Pandas Series 时，这些键会直接转化为有意义的索引标签，使得数据更具描述性。例如，一个字典 {'apple': 2.5, 'banana': 1.0, 'orange': 1.5} 转换为 Series 后，可以直接通过产品名称（如 ‘apple’）来访问其价格（2.5）。

创建 DataFrame

• 从字典列表创建： 可以使用包含字典的列表来创建 DataFrame。列表中的每个字典代表 DataFrame 中的一行，字典的键会成为列名。

  data =
  df = pd.DataFrame(data)
  print(df)

  DataFrame 将会包含 ‘name’ 和 ‘age’ 两列，每一行对应列表中的一个字典。

• 从列表的字典或 NumPy 数组的字典创建： 可以使用字典来创建 DataFrame，其中字典的每个键代表一个列名，而对应的值是一个列表或 NumPy 数组，包含该列的数据。需要确保所有列表或数组的长度相同。

  data = {'name':, 'age': }
  df = pd.DataFrame(data)
  print(df)

  这里，‘name’ 列对应一个包含姓名的列表，‘age’ 列对应一个包含年龄的列表。

• 从 Series 的字典创建： 还可以使用字典来创建 DataFrame，其中字典的每个键代表一个列名，而对应的值是一个 Series。DataFrame 的索引将与 Series 的索引对齐。

  s1 = pd.Series(, index=['a', 'b', 'c'])
  s2 = pd.Series(, index=['a', 'b', 'd'])
  data = {'col1': s1, 'col2': s2}
  df = pd.DataFrame(data)
  print(df)

  在这个例子中，s1 和 s2 的索引略有不同。Pandas 会根据索引进行对齐，对于 s2 中没有 ‘c’ 索引，以及 s1 中没有 ‘d’ 索引的地方，会填充缺失值（NaN）。

• 从 NumPy 数组创建： 可以从一个二维 NumPy 数组创建 DataFrame。可以指定列名。

  arr = np.array([, , ])
  columns =
  df = pd.DataFrame(arr, columns=columns)
  print(df)

  这里，NumPy 数组的数据被放入 DataFrame 中，并使用指定的列名 ‘A’, ‘B’, ‘C’。

• 从另一个 Series 或 DataFrame 创建： 可以通过复制或修改现有的 Series 或 DataFrame 来创建新的 DataFrame。

  s = pd.Series()
  df1 = pd.DataFrame(s)
  print(df1)
  
  df2 = df.DataFrame({'col1': , 'col2': })
  df3 = pd.DataFrame(df2) # 复制 df2
  print(df3)

  这些方法提供了创建 DataFrame 的多种途径，可以根据不同的数据来源和结构选择最合适的方法。

从 Series 的字典创建 DataFrame 提供了处理具有潜在不同索引的数据的灵活性，因为 Pandas 会自动对齐这些索引，并在必要时填充缺失值。当使用不同来源的数据创建 DataFrame 时，各个 Series 可能具有不同的索引标签。Pandas 在将这些 Series 合并为 DataFrame 的列时，会根据它们的索引进行对齐。如果某个 Series 在 DataFrame 的索引中缺少某个标签，Pandas 会在该位置填充 NaN（Not a Number），表示缺失值。这种自动对齐的功能对于整合来自不同来源、可能存在不一致标签的数据非常有用。

创建 DataFrame 的各种方法能够适应不同的数据输入格式，这使得 Pandas 在处理来自各种来源的数据时非常通用。无论数据是以记录列表的形式存在，还是以命名列的集合，或者是一个原始的数值数组，Pandas 都提供了便捷的方式将其导入到 DataFrame 中，而 DataFrame 是进行后续分析的核心数据结构。

创建 Series 和 DataFrame 的方法小结

方法	数据来源	描述	示例代码片段
pd.Series(data)	列表，NumPy 数组	从列表或 NumPy 数组创建 Series，自动生成整数索引。	pd.Series()
pd.Series(data, index=index)	列表，NumPy 数组	从列表或 NumPy 数组创建 Series，并指定索引。	pd.Series(, index=['a', 'b', 'c'])
pd.Series(data)	字典	从字典创建 Series，字典的键成为索引，值成为 Series 的值。	pd.Series({'a': 1, 'b': 2})
pd.DataFrame(data)	字典列表	从字典列表创建 DataFrame，每个字典代表一行，键成为列名。	pd.DataFrame([{'a': 1, 'b': 2}, {'a': 3, 'b': 4}])
pd.DataFrame(data)	字典（列表或 NumPy 数组的值）	从字典创建 DataFrame，每个键代表一列名，值是列表或 NumPy 数组。	pd.DataFrame({'col1': , 'col2': })
pd.DataFrame(data)	字典（Series 的值）	从字典创建 DataFrame，每个键代表一列名，值是 Series，DataFrame 的索引与 Series 的索引对齐。	pd.DataFrame({'col1': pd.Series(), 'col2': pd.Series()})
pd.DataFrame(data)	二维 NumPy 数组	从二维 NumPy 数组创建 DataFrame，可以指定列名。	pd.DataFrame(np.array([, ]), columns=)
pd.DataFrame(series)	Series	从一个 Series 创建 DataFrame，Series 成为 DataFrame 的一列。	pd.DataFrame(pd.Series())
pd.DataFrame(dataframe)	DataFrame	复制现有的 DataFrame。	pd.DataFrame(existing_df)

4. 索引和选择数据

一旦创建了 Series 或 DataFrame，接下来的重要步骤就是如何访问和选择其中的数据。Pandas 提供了多种灵活的方式来实现这一点。

Series 的索引和选择

对于 Series，可以使用索引标签或位置进行数据访问。

• 使用标签索引： 如果 Series 有明确的标签索引，可以直接使用这些标签来访问数据。

  s = pd.Series(, index=)
  print(s['A'])  # 输出 10
  print(s[['A', 'C']]) # 输出包含索引 'A' 和 'C' 的 Series

• 使用位置索引： 即使 Series 有标签索引，仍然可以使用整数位置索引（从 0 开始）来访问数据，类似于 Python 列表。

  print(s)   # 输出 10
  print(s[]) # 输出包含位置 0 和 2 的 Series

• 切片： 可以使用标签或位置进行切片操作来选择 Series 的一部分。

  print(s) # 使用标签切片，注意包含结束标签 'B'
  print(s[0:2])   # 使用位置切片，不包含结束位置 2

• 布尔索引： 可以使用布尔条件来选择满足条件的元素。

  s = pd.Series()
  print(s[s > 20]) # 输出值大于 20 的元素

DataFrame 的索引和选择

DataFrame 的数据选择更加复杂，因为它是二维结构。主要有以下几种方法：

• 选择列： 可以像访问字典的键一样，使用列名来选择 DataFrame 的单个列，返回一个 Series。

  data = {'name':, 'age': }
  df = pd.DataFrame(data)
  print(df['name']) # 输出 'name' 列的 Series

  也可以使用属性访问的方式选择列（当列名是有效的 Python 标识符时）。

  print(df.name) # 与 df['name'] 等效

  要选择多个列，可以使用包含列名的列表。

  print(df[['name', 'age']]) # 输出包含 'name' 和 'age' 列的 DataFrame

• 选择行： 选择行主要使用 .loc 和 .iloc 索引器。

  • .loc： 基于标签进行索引。可以使用行索引标签选择单行或多行。

    df = pd.DataFrame(data, index=['row1', 'row2', 'row3'])
    print(df.loc['row1'])       # 输出标签为 'row1' 的行，以 Series 形式
    print(df.loc[['row1', 'row3']]) # 输出标签为 'row1' 和 'row3' 的行，以 DataFrame 形式

    也可以使用标签进行切片。

    print(df.loc['row1':'row2']) # 选择标签从 'row1' 到 'row2' 的行（包含 'row2'）

  • .iloc： 基于整数位置进行索引。可以使用整数位置选择单行或多行。

    print(df.iloc)        # 输出第一行（位置索引为 0），以 Series 形式
    print(df.iloc[])     # 输出第一行和第三行，以 DataFrame 形式

    也可以使用整数位置进行切片。

    print(df.iloc[0:2])      # 选择位置索引从 0 到 1 的行（不包含 2）

• 选择特定单元格： 可以结合行和列的选择来访问 DataFrame 中的特定单元格。

  • 使用 .loc：先指定行标签，再指定列标签。

    print(df.loc['row1', 'name']) # 输出标签为 'row1' 的行的 'name' 列的值
    print(df.loc[['row1', 'row2'], ['name', 'age']]) # 选择指定行和列的子集

  • 使用 .iloc：先指定行位置，再指定列位置。

    print(df.iloc)      # 输出第一行第一列的值
    print(df.iloc[, ]) # 选择指定位置的行和列的子集

• 布尔索引： 可以使用列的条件来选择满足条件的行。

  print(df[df['age'] > 25]) # 输出 'age' 列中值大于 25 的所有行

  可以组合多个条件，使用 & (and) 和 | (or) 运算符。

  print(df[(df['age'] > 25) & (df['name']!= 'Bob')])

理解不同的索引和选择方法是有效使用 Pandas 进行数据分析的关键。.loc 基于标签，更易于理解数据的含义，而 .iloc 基于位置，更类似于传统的数组索引。在实际应用中，根据具体的需求选择合适的方法。

5. 数据操作

Pandas 提供了丰富的功能来操作 Series 和 DataFrame 中的数据，包括过滤、排序、添加或删除列、以及应用函数等。

过滤数据

在前面的索引和选择部分已经介绍过布尔索引，这是过滤 DataFrame 中数据的常用方法。通过创建一个布尔 Series，根据条件判断每一行是否保留。

data = {'name':, 'age': , 'city':}
df = pd.DataFrame(data)

# 选择年龄大于 25 的行
older_than_25 = df[df['age'] > 25]
print(older_than_25)

# 选择城市为 'New York' 或 'Paris' 的行
in_ny_or_paris = df[df['city'].isin(['New York', 'Paris'])]
print(in_ny_or_paris)

排序数据

可以使用 .sort_values() 方法根据一个或多个列的值对 DataFrame 进行排序。对于 Series，可以使用 .sort_values() 方法按值排序，或使用 .sort_index() 方法按索引排序。

# 按 'age' 列升序排序
sorted_by_age = df.sort_values(by='age')
print(sorted_by_age)

# 按 'age' 列降序排序
sorted_by_age_desc = df.sort_values(by='age', ascending=False)
print(sorted_by_age_desc)

# 按多个列排序，先按 'age' 升序，再按 'name' 升序
sorted_by_age_name = df.sort_values(by=['age', 'name'])
print(sorted_by_age_name)

s = pd.Series(, index=['c', 'a', 'd', 'e', 'b'])
# 按值排序
sorted_series_values = s.sort_values()
print(sorted_series_values)

# 按索引排序
sorted_series_index = s.sort_index()
print(sorted_series_index)

添加或删除列

• 添加新列： 可以像操作字典一样，直接为 DataFrame 添加新的列。

  df['salary'] = 
  print(df)
  
  # 基于现有列计算新列
  df['age_plus_5'] = df['age'] + 5
  print(df)

• 删除列： 可以使用 .drop() 方法删除列。需要指定 axis=1 来表示删除的是列。

  df_dropped_salary = df.drop('salary', axis=1)
  print(df_dropped_salary)
  
  # 删除多个列
  columns_to_drop = ['age_plus_5', 'city']
  df_dropped_multiple = df.drop(columns_to_drop, axis=1)
  print(df_dropped_multiple)

应用函数

Pandas 提供了将函数应用于 Series 或 DataFrame 的强大功能，包括 .apply(), .map() 和 .applymap() 方法。

• .apply()： 可以应用于 Series 的每个值或 DataFrame 的每一行或每一列。

  def square(x):
      return x * x
  
  s = pd.Series()
  squared_series = s.apply(square)
  print(squared_series)
  
  # 应用于 DataFrame 的列
  df_sum_age = df[['age']].apply(sum)
  print(df_sum_age)
  
  # 应用于 DataFrame 的行
  def describe_row(row):
      return f"{row['name']} is {row['age']} years old and lives in {row['city']}."
  
  row_descriptions = df.apply(describe_row, axis=1)
  print(row_descriptions)

• .map()： 主要用于 Series，将函数或字典映射应用于 Series 的每个元素。

  city_map = {'New York': 'NY', 'London': 'LDN', 'Paris': 'PR', 'Tokyo': 'TK'}
  df['city_code'] = df['city'].map(city_map)
  print(df)

• .applymap()： 只能应用于 DataFrame，将函数应用于 DataFrame 的每个元素。

  df_numeric = df[['age', 'salary']]
  def add_100(x):
      return x + 100
  
  df_added = df_numeric.applymap(add_100)
  print(df_added)

这些数据操作功能使得 Pandas 成为处理和转换数据的强大工具。通过灵活地组合这些操作，可以完成复杂的数据清洗和准备任务。

6. 基本数据分析

Pandas 不仅用于数据操作，还提供了进行基本数据分析的功能，例如统计计算、聚合和分组等。

统计计算

Pandas Series 和 DataFrame 提供了许多内置的统计方法，用于快速计算数据的描述性统计信息。

• 常用统计方法：

  • .count()：计算非缺失值的数量。
  • .sum()：计算总和。
  • .mean()：计算均值。
  • .median()：计算中位数。
  • .min()：计算最小值。
  • .max()：计算最大值。
  • .std()：计算标准差。
  • .describe()：生成包含计数、均值、标准差、最小值、四分位数和最大值的描述性统计信息。

  s = pd.Series([1, 2, 3, 4, 5, np.nan])
  print(s.count())   # 输出 5
  print(s.sum())     # 输出 15.0
  print(s.mean())    # 输出 3.0
  print(s.median())  # 输出 3.0
  print(s.describe()) # 输出 Series 的描述性统计信息
  
  data = {'col1': [1, 2, 3, np.nan], 'col2': }
  df = pd.DataFrame(data)
  print(df.mean())   # 输出每列的均值
  print(df.describe()) # 输出 DataFrame 的描述性统计信息

聚合

聚合操作是指将多个值汇总为一个值的过程。Pandas 提供了 .agg() 方法来执行各种聚合操作。

print(df.agg(['sum', 'mean', 'max'])) # 对 DataFrame 的每一列应用多个聚合函数

print(df.agg({'col1': ['sum', 'min'], 'col2': ['mean', 'max']})) # 对不同的列应用不同的聚合函数

分组

分组是指根据一个或多个列的值将数据分成不同的组，然后对每个组应用聚合或其他操作。Pandas 使用 .groupby() 方法来实现分组操作。

data = {'team':,
        'player': ['P1', 'P2', 'P3', 'P4', 'P5', 'P6', 'P7'],
        'points': }
df = pd.DataFrame(data)

# 按 'team' 列分组，并计算每个组的平均 points
grouped_by_team = df.groupby('team')['points'].mean()
print(grouped_by_team)

# 按 'team' 列分组，并计算每个组的 points 的总和和最大值
grouped_agg = df.groupby('team')['points'].agg(['sum', 'max'])
print(grouped_agg)

# 按多个列分组
grouped_multiple = df.groupby(['team', 'player'])['points'].sum()
print(grouped_multiple)

分组操作是数据分析中非常重要的技术，可以帮助我们理解数据中不同类别之间的差异和关系。

7. 处理缺失数据

在实际数据分析中，经常会遇到缺失数据。Pandas 使用 NaN（Not a Number）来表示浮点数和非浮点数组中的缺失值。Python 本身也有一个 None 值，Pandas 在某些情况下也会将其视为缺失值。

检测缺失数据

可以使用 .isnull() 和 .notnull() 方法来检测 DataFrame 或 Series 中的缺失值。这两个方法会返回一个布尔型的 DataFrame 或 Series，指示每个值是否为缺失值。

data = {'col1': [1, 2, np.nan, 4], 'col2': [np.nan, 6, 7, 8]}
df = pd.DataFrame(data)

print(df.isnull())
print(df.notnull())

可以使用 .sum() 方法结合 .isnull() 或 .notnull() 来统计每列或每行的缺失值数量。

print(df.isnull().sum()) # 统计每列的缺失值数量
print(df.isnull().sum(axis=1)) # 统计每行的缺失值数量

处理缺失数据的方法

Pandas 提供了几种处理缺失数据的方法：

• 删除缺失值： 可以使用 .dropna() 方法删除包含缺失值的行或列。

  # 删除包含任何缺失值的行
  df_dropped_rows = df.dropna()
  print(df_dropped_rows)
  
  # 删除包含任何缺失值的列
  df_dropped_cols = df.dropna(axis=1)
  print(df_dropped_cols)
  
  # 删除所有值都缺失的行
  df_dropped_all_na_rows = df.dropna(how='all')
  print(df_dropped_all_na_rows)
  
  # 删除至少有两个非缺失值的行
  df_dropped_thresh_rows = df.dropna(thresh=2)
  print(df_dropped_thresh_rows)

• 填充缺失值： 可以使用 .fillna() 方法用指定的值或方法填充缺失值。

  # 用 0 填充所有缺失值
  df_filled_zero = df.fillna(0)
  print(df_filled_zero)
  
  # 用列的均值填充缺失值
  df_filled_mean = df.fillna(df.mean())
  print(df_filled_mean)
  
  # 使用前一个有效值填充（向前填充）
  df_filled_ffill = df.fillna(method='ffill')
  print(df_filled_ffill)
  
  # 使用后一个有效值填充（向后填充）
  df_filled_bfill = df.fillna(method='bfill')
  print(df_filled_bfill)

选择哪种方法处理缺失数据取决于具体的数据和分析需求。删除缺失值可能会导致数据丢失，而填充缺失值则需要选择合适的填充策略，避免引入偏差。

8. 合并和连接 DataFrame

Pandas 提供了将多个 DataFrame 合并或连接在一起的功能，类似于 SQL 中的 JOIN 操作。主要使用 pd.merge() 和 pd.concat() 函数。

pd.merge()

pd.merge() 函数用于基于一个或多个共同的列将两个 DataFrame 连接起来。

df1 = pd.DataFrame({'key':, 'value': })
df2 = pd.DataFrame({'key':, 'value2': })

# 内连接：只保留两个 DataFrame 中 'key' 列都存在的行
merged_inner = pd.merge(df1, df2, on='key')
print(merged_inner)

# 左连接：保留左边的 DataFrame 的所有行，右边的 DataFrame 中匹配的行。如果右边没有匹配，则填充 NaN。
merged_left = pd.merge(df1, df2, on='key', how='left')
print(merged_left)

# 右连接：保留右边的 DataFrame 的所有行，左边的 DataFrame 中匹配的行。如果左边没有匹配，则填充 NaN。
merged_right = pd.merge(df1, df2, on='key', how='right')
print(merged_right)

# 外连接：保留两个 DataFrame 的所有行。如果某个键在一个 DataFrame 中不存在，则填充 NaN。
merged_outer = pd.merge(df1, df2, on='key', how='outer')
print(merged_outer)

# 基于多个列进行连接
df3 = pd.DataFrame({'key1':, 'key2': ['X', 'Y', 'Z', 'W'], 'value': })
df4 = pd.DataFrame({'key1':, 'key2': ['Y', 'W', 'V', 'U'], 'value2': })
merged_multi_key = pd.merge(df3, df4, on=['key1', 'key2'])
print(merged_multi_key)

pd.concat()

pd.concat() 函数用于沿着指定的轴将多个 Series 或 DataFrame 拼接在一起。

s1 = pd.Series()
s2 = pd.Series()
concatenated_series = pd.concat([s1, s2])
print(concatenated_series)

df5 = pd.DataFrame({'col1': , 'col2': })
df6 = pd.DataFrame({'col1': , 'col2': })
concatenated_df_rows = pd.concat([df5, df6]) # 默认按行拼接 (axis=0)
print(concatenated_df_rows)

concatenated_df_cols = pd.concat([df5, df6], axis=1) # 按列拼接
print(concatenated_df_cols)

# 使用 keys 参数为拼接后的 DataFrame 添加一个额外的层级索引
concatenated_keys = pd.concat([df5, df6], keys=['first', 'second'])
print(concatenated_keys)

合并和连接操作是整合来自不同数据源的数据的关键步骤，使得我们可以进行更全面的分析。

9. 输入与输出

Pandas 提供了方便的方法来读取和写入各种格式的文件，例如 CSV、Excel、SQL 数据库等。

读取文件

• CSV 文件： 使用 pd.read_csv() 函数读取 CSV 文件。

  # df = pd.read_csv('your_file.csv')
  # 可以指定分隔符、编码等参数
  # df = pd.read_csv('your_file.csv', sep=',', encoding='utf-8')

• Excel 文件： 使用 pd.read_excel() 函数读取 Excel 文件。

  # df = pd.read_excel('your_file.xlsx')
  # 可以指定 sheet 名称或索引
  # df = pd.read_excel('your_file.xlsx', sheet_name='Sheet1')

• 其他格式： Pandas 还支持读取 JSON (pd.read_json())、HTML (pd.read_html())、SQL 数据库 (pd.read_sql()) 等多种格式的文件。

写入文件

• CSV 文件： 使用 .to_csv() 方法将 DataFrame 写入 CSV 文件。

  # df.to_csv('output.csv')
  # 可以设置是否包含索引、分隔符等参数
  # df.to_csv('output.csv', index=False, sep=';')

• Excel 文件： 使用 .to_excel() 方法将 DataFrame 写入 Excel 文件。

  # df.to_excel('output.xlsx')
  # 可以设置 sheet 名称、是否包含索引等参数
  # df.to_excel('output.xlsx', sheet_name='Sheet2', index=False)

• 其他格式： 类似地，Pandas 也提供了将 DataFrame 写入 JSON (.to_json())、HTML (.to_html())、SQL 数据库 (.to_sql()) 等格式的方法。

输入输出功能使得 Pandas 能够方便地与外部数据进行交互，是数据分析流程中不可或缺的一环。

10. 总结

Pandas 是 Python 中用于数据操作和分析的核心库。本指南介绍了 Pandas 的基本概念，包括其核心数据结构 Series 和 DataFrame，以及如何创建、索引、选择、操作、分析、处理缺失数据、合并连接数据以及进行文件输入输出。掌握这些基本操作是使用 Pandas 进行更高级数据分析的基础。

对于 Python 初学者来说，Pandas 提供了一种强大且直观的方式来处理和理解数据。通过不断地练习和应用，可以更深入地掌握 Pandas 的各种功能，并将其应用于实际的数据分析项目中。建议在掌握本指南中的内容后，进一步探索 Pandas 的高级特性，例如时间序列分析、更复杂的数据聚合和转换等，以提升数据分析的能力。