pandas使用

tools
教程
发布日期:   2025-01-12
更新日期:   2025-01-12
文章字数:   4.7k
阅读时长:   22 分
阅读次数:  

pandas使用

教程框架：

  1. Pandas 简介与安装
    • 什么是 pandas？
    • 为什么使用 pandas？
    • 如何安装 pandas？
  2. Pandas 数据结构：Series
    • Series 的创建
    • Series 的索引与切片
    • Series 的基本操作（算术、逻辑、函数应用）
    • Series 的常用属性和方法
  3. Pandas 数据结构：DataFrame
    • DataFrame 的创建
    • DataFrame 的索引与选择数据
    • DataFrame 的基本操作
      • 添加、删除列
      • 修改数据
      • 排序
    • DataFrame 的常用属性和方法
    • 数据清洗
  4. Pandas 数据操作
    • 数据分组 (GroupBy)
    • 数据聚合 (Aggregation)
    • 数据合并 (Merge, Join)
    • 数据连接 (Concat)
    • 数据透视表 (Pivot Table)
  5. Pandas 文件读写
    • 读取 CSV 文件
    • 读取 Excel 文件
    • 读取其他类型文件
    • 写入文件
  6. Pandas 时间序列数据处理
    • 时间戳 (Timestamp)
    • 时间范围 (Date Range)
    • 时间重采样 (Resampling)
  7. Pandas 高级应用
    • apply 和 applymap 函数
    • 窗口函数
    • 数据可视化
  8. 总结与进阶
    • 常用技巧
    • 学习资源

1. Pandas 简介与安装

1.1 什么是 pandas？

Pandas 是一个强大的 Python 数据分析库，它提供了高效的数据结构和数据分析工具。Pandas 的核心是两种数据结构：Series 和 DataFrame，它们使得数据处理变得简单快捷。

  • Series: 一维的、带标签的数组，类似于带索引的列表。
  • DataFrame: 二维的、表格型的数据结构，可以看作是 Series 的容器。

1.2 为什么使用 pandas？

  • 数据处理能力强: Pandas 提供了各种数据操作功能，如数据清洗、转换、切片、聚合、合并等。
  • 高效的数据结构: Series 和 DataFrame 的设计使得数据操作和分析速度快。
  • 与 NumPy 集成: Pandas 基于 NumPy 构建，可以无缝地与 NumPy 数组进行交互。
  • 文件读写方便: Pandas 可以轻松读取和写入各种格式的文件，如 CSV、Excel、JSON、SQL 等。
  • 数据可视化支持: Pandas 可以与 Matplotlib 等可视化库结合，方便进行数据可视化。
  • 易用性: Pandas 的 API 设计简洁易懂，上手快。

1.3 如何安装 pandas？

推荐使用 pip 来安装 pandas：

pip install pandas

如果你使用的是 Anaconda，pandas 通常会预装，如果没有，也可以用 conda 安装：

conda install pandas

安装验证:

打开你的 Python 解释器或 Jupyter Notebook，输入以下代码：

import pandas as pd

print(pd.__version__)

如果正确打印出 pandas 的版本号，就说明安装成功了。

2. Pandas 数据结构：Series

2.1 Series 的创建

Series 是一种一维的、带有标签（索引）的数据结构。它可以存储各种数据类型，如整数、浮点数、字符串、布尔值等。

2.1.1 从列表创建 Series

最简单的创建方式是从 Python 的列表创建：

import pandas as pd

data = [10, 20, 30, 40, 50]
s = pd.Series(data)
print(s)
print(type(s))

输出：

0    10
1    20
2    30
3    40
4    50
dtype: int64
<class 'pandas.core.series.Series'>
  • 默认情况下，Series 会自动创建从 0 开始的整数索引。
  • dtype: int64 表示数据类型是 64 位整数。

2.1.2 从 NumPy 数组创建 Series

import pandas as pd
import numpy as np

arr = np.array([1.1, 2.2, 3.3, 4.4, 5.5])
s = pd.Series(arr)
print(s)

输出:

0    1.1
1    2.2
2    3.3
3    4.4
4    5.5
dtype: float64
  • dtype: float64 表示数据类型是 64 位浮点数。

2.1.3 从字典创建 Series

字典的键会成为 Series 的索引，值会成为 Series 的数据：

import pandas as pd

data = {'a': 100, 'b': 200, 'c': 300}
s = pd.Series(data)
print(s)

输出：

a    100
b    200
c    300
dtype: int64

2.1.4 自定义索引

可以在创建 Series 时指定索引：

import pandas as pd

data = [10, 20, 30]
index = ['x', 'y', 'z']
s = pd.Series(data, index=index)
print(s)

输出：

x    10
y    20
z    30
dtype: int64

2.2 Series 的索引与切片

类似于列表和字典，可以使用索引来访问 Series 的元素。

2.2.1 通过位置索引访问

使用默认的整数索引：

import pandas as pd

s = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])

print(s[0])  # 输出 10
print(s[1:3]) # 输出 b    20
             #      c    30
             #      dtype: int64

2.2.2 通过自定义索引访问

import pandas as pd

s = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])

print(s['a'])  # 输出 10
print(s['b':'d']) # 输出 b    20
                #      c    30
                #      d    40
                #      dtype: int64

2.3 Series 的基本操作

2.3.1 算术运算

import pandas as pd

s1 = pd.Series([1, 2, 3, 4])
s2 = pd.Series([10, 20, 30, 40])

print(s1 + s2)   # 加法
print(s1 * s2)   # 乘法
print(s2 / s1)   # 除法

Series 会按照索引对齐进行计算。

2.3.2 逻辑运算

import pandas as pd

s = pd.Series([10, 20, 30, 40])
print(s > 20)   # 布尔值 Series
print(s[s > 20])   # 选择大于20的元素

2.3.3 函数应用

可以使用 apply() 方法将函数应用于 Series 的每个元素：

import pandas as pd

s = pd.Series([1, 2, 3, 4])
def square(x):
    return x**2
print(s.apply(square))

2.4 Series 的常用属性和方法

  • values: 返回 Series 的值，以 NumPy 数组的形式。
  • index: 返回 Series 的索引。
  • dtype: 返回 Series 的数据类型。
  • size: 返回 Series 的元素个数。
  • unique(): 返回 Series 中唯一的值。
  • value_counts(): 返回每个值出现的次数。
  • head(n): 返回前 n 个元素。
  • tail(n): 返回后 n 个元素。
  • sort_values(): 对 Series 的值进行排序。

示例：

import pandas as pd

s = pd.Series([10, 20, 10, 30, 20])

print(s.values)      # 输出 [10 20 10 30 20]
print(s.index)       # 输出 RangeIndex(start=0, stop=5, step=1)
print(s.dtype)       # 输出 int64
print(s.size)        # 输出 5
print(s.unique())    # 输出 [10 20 30]
print(s.value_counts()) #输出 10    2
                         #  20    2
                         #  30    1
                         # dtype: int64
print(s.head(2))     # 输出 0    10
                         #      1    20
                         #      dtype: int64
print(s.sort_values()) # 输出 0    10
                       #      2    10
                       #      1    20
                       #      4    20
                       #      3    30
                       #      dtype: int64

3. Pandas 数据结构：DataFrame

3.1 DataFrame 的创建

DataFrame 是一个二维的表格型数据结构，可以看作是 Series 的容器。它由行和列组成，每一列可以是不同的数据类型。

3.1.1 从字典创建 DataFrame

字典的键会成为 DataFrame 的列名，值会成为 DataFrame 的列数据：

import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 28],
    'city': ['New York', 'London', 'Paris']
}

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

输出：

name  age      city
0    Alice   25  New York
1      Bob   30    London
2  Charlie   28     Paris

3.1.2 从列表创建 DataFrame

可以使用列表的列表或 NumPy 数组创建 DataFrame，需要指定列名：

import pandas as pd

data = [
    ['Alice', 25, 'New York'],
    ['Bob', 30, 'London'],
    ['Charlie', 28, 'Paris']
]

df = pd.DataFrame(data, columns=['name', 'age', 'city'])
print(df)

输出：

name  age      city
0    Alice   25  New York
1      Bob   30    London
2  Charlie   28     Paris

3.1.3 从 Series 创建 DataFrame

可以将多个 Series 组合成一个 DataFrame：

import pandas as pd

name = pd.Series(['Alice', 'Bob', 'Charlie'])
age = pd.Series([25, 30, 28])
city = pd.Series(['New York', 'London', 'Paris'])

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

输出：

name  age      city
0    Alice   25  New York
1      Bob   30    London
2  Charlie   28     Paris

3.2 DataFrame 的索引与选择数据

3.2.1 选择列

可以使用列名来选择 DataFrame 的一列或多列：

import pandas as pd
data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 28],
    'city': ['New York', 'London', 'Paris']
}
df = pd.DataFrame(data)
print(df['name']) # 选择 'name' 列
print(df[['name', 'age']]) # 选择 'name' 和 'age' 列

3.2.2 选择行

可以使用 loc 和 iloc 来选择行：

  • loc：通过行标签（索引）选择行。
  • iloc：通过行位置（整数索引）选择行。
import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 28],
    'city': ['New York', 'London', 'Paris']
}
df = pd.DataFrame(data)
df = df.set_index('name')

print(df.loc['Alice']) # 通过标签选择 Alice 这行，按标签
print(df.iloc[0]) # 通过位置选择 第一行，按位置
print(df.iloc[0:2,:]) # 选择前两行所有列
print(df.loc['Alice':'Bob',:]) # 通过标签选择 Alice 到 Bob 行的所有列

3.2.3 选择特定元素

可以使用行和列的标签或位置来选择特定的元素：

import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 28],
    'city': ['New York', 'London', 'Paris']
}

df = pd.DataFrame(data)

print(df.loc[0, 'name']) # 选择第 0 行 'name' 列的元素
print(df.iloc[0, 0]) # 选择第 0 行 第 0 列的元素

3.3 DataFrame 的基本操作

3.3.1 添加列

import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 28]
}

df = pd.DataFrame(data)
df['gender'] = ['Female', 'Male', 'Male'] # 添加 'gender' 列
print(df)

3.3.2 删除列

import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 28],
    'gender': ['Female', 'Male', 'Male']
}

df = pd.DataFrame(data)
df = df.drop('gender', axis=1) # 删除 'gender' 列，axis=1 表示列
print(df)

3.3.3 修改数据

import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 28]
}

df = pd.DataFrame(data)
df.loc[0, 'age'] = 26 # 修改第 0 行 'age' 列的值
print(df)

3.3.4 排序

import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 28]
}

df = pd.DataFrame(data)
df = df.sort_values('age', ascending=False) # 按 'age' 列降序排序
print(df)

3.4 DataFrame 的常用属性和方法

  • shape: 返回 DataFrame 的形状（行数，列数）。
  • index: 返回 DataFrame 的行索引。
  • columns: 返回 DataFrame 的列索引。
  • dtypes: 返回 DataFrame 每列的数据类型。
  • head(n): 返回 DataFrame 的前 n 行。
  • tail(n): 返回 DataFrame 的后 n 行。
  • info(): 显示 DataFrame 的基本信息，包括列名，数据类型，非空值数量等。
  • describe(): 返回 DataFrame 的统计摘要。
  • dropna(): 删除包含缺失值的行或列。
  • fillna(): 填充缺失值。

3.5 数据清洗

数据清洗是数据分析中重要的一步，包括处理缺失值、重复值等。

import pandas as pd
import numpy as np

data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Bob', np.nan],
    'age': [25, np.nan, 28, 30, np.nan],
    'city': ['New York', 'London', 'Paris', 'London', 'Unknown']
}

df = pd.DataFrame(data)

print(df.isnull())  # 检测缺失值
df = df.dropna()  # 删除包含缺失值的行
df = df.drop_duplicates() # 删除重复行
df = df.fillna({'age':df['age'].mean()}) # 用平均值填充年龄缺失值
print(df)

4. Pandas 数据操作

4.1 数据分组 (GroupBy)

groupby() 方法允许你根据一个或多个列的值将 DataFrame 分组，然后可以对每个组进行聚合操作。

import pandas as pd

data = {
    'category': ['A', 'A', 'B', 'B', 'A', 'C', 'C'],
    'value': [10, 20, 15, 25, 30, 12, 18]
}
df = pd.DataFrame(data)

grouped = df.groupby('category')
print(grouped.groups) # 查看分组情况

print(grouped.sum()) # 对每个分组求和
print(grouped.mean()) # 对每个分组求平均值

4.2 数据聚合 (Aggregation)

聚合操作是对分组后的数据进行汇总计算，如求和、平均值、最大值、最小值等。

import pandas as pd
import numpy as np

data = {
    'category': ['A', 'A', 'B', 'B', 'A', 'C', 'C'],
    'value': [10, 20, 15, 25, 30, 12, 18]
}
df = pd.DataFrame(data)
grouped = df.groupby('category')

print(grouped.agg(['sum', 'mean', 'max','min']))  # 同时执行多个聚合函数
print(grouped.agg({'value':['sum', np.std]}))  # 对指定列执行不同的聚合函数

4.3 数据合并 (Merge, Join)

merge() 方法用于将两个 DataFrame 根据共同的列合并在一起，类似于 SQL 的 JOIN 操作。

import pandas as pd

df1 = pd.DataFrame({
    'key': ['A', 'B', 'C', 'D'],
    'value1': [1, 2, 3, 4]
})

df2 = pd.DataFrame({
    'key': ['B', 'D', 'E', 'F'],
    'value2': [5, 6, 7, 8]
})
print('原始数据')
print(df1)
print(df2)
print('=======================')
# 内连接(inner join)
merged_inner = pd.merge(df1, df2, on='key', how='inner')
print("inner join:")
print(merged_inner)
print('=======================')

# 左连接(left join)
merged_left = pd.merge(df1, df2, on='key', how='left')
print("left join:")
print(merged_left)

print('=======================')
# 右连接(right join)
merged_right = pd.merge(df1, df2, on='key', how='right')
print("right join:")
print(merged_right)

print('=======================')
# 外连接(outer join)
merged_outer = pd.merge(df1, df2, on='key', how='outer')
print("outer join:")
print(merged_outer)

4.4 数据连接 (Concat)

concat() 方法用于将两个或多个 DataFrame 沿着指定的轴连接在一起。

import pandas as pd

df1 = pd.DataFrame({
    'A': [1, 2],
    'B': [3, 4]
})

df2 = pd.DataFrame({
    'A': [5, 6],
    'B': [7, 8]
})
print("原始数据:")
print(df1)
print(df2)
print('=======================')

# 垂直连接(默认axis=0)
concatenated_vertical = pd.concat([df1, df2], ignore_index=True)
print("垂直连接:")
print(concatenated_vertical)
print('=======================')

# 水平连接(axis=1)
concatenated_horizontal = pd.concat([df1, df2], axis=1)
print("水平连接:")
print(concatenated_horizontal)

4.5 数据透视表 (Pivot Table)

pivot_table() 方法用于创建数据透视表，可以根据指定的列对数据进行重塑和汇总。

import pandas as pd

data = {
    'date': ['2023-01-01', '2023-01-01', '2023-01-02', '2023-01-02', '2023-01-03', '2023-01-03'],
    'product': ['A', 'B', 'A', 'B', 'A', 'B'],
    'sales': [100, 200, 150, 250, 120, 220]
}

df = pd.DataFrame(data)

pivot_df = df.pivot_table(index='date', columns='product', values='sales', aggfunc='sum', fill_value=0)
print(pivot_df)

5. Pandas 文件读写

Pandas 提供了强大的文件读写功能，可以方便地处理各种数据文件。

5.1 读取 CSV 文件

CSV (Comma Separated Values) 是一种常见的文本文件格式，用于存储表格数据。

import pandas as pd

# 读取 CSV 文件
df = pd.read_csv('data.csv')
print(df)

# 指定分隔符，如果不是逗号，使用 sep 参数
df = pd.read_csv('data.txt', sep='\t')
print(df)

# 读取指定列
df = pd.read_csv('data.csv', usecols=['name', 'age'])
print(df)

5.2 读取 Excel 文件

Pandas 可以直接读取 Excel 文件（.xls 和 .xlsx）。

import pandas as pd

# 读取 Excel 文件
df = pd.read_excel('data.xlsx', sheet_name='Sheet1')
print(df)

# 读取指定 sheet
df = pd.read_excel('data.xlsx', sheet_name='Sheet2')
print(df)

# 读取指定列
df = pd.read_excel('data.xlsx', sheet_name='Sheet1', usecols=['name', 'age'])
print(df)

5.3 读取其他类型文件

Pandas 还支持读取其他类型的文件，例如：

  • JSON: pd.read_json()
  • HTML: pd.read_html()
  • SQL: pd.read_sql()

5.4 写入文件

可以将 DataFrame 写入到不同的文件格式。

5.4.1 写入 CSV 文件

import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 28]
}
df = pd.DataFrame(data)

# 写入 CSV 文件
df.to_csv('output.csv', index=False) # index=False 表示不写入行索引

5.4.2 写入 Excel 文件

import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 28]
}
df = pd.DataFrame(data)

# 写入 Excel 文件
df.to_excel('output.xlsx', sheet_name='Sheet1', index=False)

5.4.3 写入其他类型文件

  • JSON: df.to_json()
  • HTML: df.to_html()
  • SQL: df.to_sql()

6. Pandas 时间序列数据处理

Pandas 提供了强大的时间序列数据处理能力，可以方便地分析和处理时间序列数据。

6.1 时间戳 (Timestamp)

时间戳是表示特定时间点的对象。Pandas 可以使用 pd.Timestamp 创建时间戳。

import pandas as pd

# 创建时间戳
ts = pd.Timestamp('2023-10-26 12:30:00')
print(ts)
print(type(ts))

# 从字符串创建时间戳
ts = pd.to_datetime('2023-10-26')
print(ts)

6.2 时间范围 (Date Range)

pd.date_range() 方法可以创建指定时间范围内的一系列时间戳。

import pandas as pd

# 创建时间范围
date_range = pd.date_range('2023-10-01', periods=10, freq='D')
print(date_range)

date_range = pd.date_range('2023-10-01', '2023-10-10', freq='W')
print(date_range)
  • periods: 时间戳的数量。
  • freq: 时间间隔，如 ‘D’ (天), ‘W’ (周), ‘M’ (月), ‘H’ (小时), ‘T’ (分钟), ‘S’ (秒) 等。

6.3 时间序列索引

可以将时间序列数据作为 DataFrame 或 Series 的索引，方便时间序列数据的分析。

import pandas as pd
import numpy as np

# 创建时间序列索引
date_range = pd.date_range('2023-10-01', periods=10, freq='D')
data = np.random.randn(10)
ts = pd.Series(data, index=date_range)
print(ts)

# 使用时间序列索引选择数据
print(ts['2023-10-03'])
print(ts['2023-10-01':'2023-10-05'])

6.4 时间重采样 (Resampling)

resample() 方法可以对时间序列数据进行重采样，例如，将数据从天转换为周或月。

import pandas as pd
import numpy as np

date_range = pd.date_range('2023-10-01', periods=30, freq='D')
data = np.random.randint(10, 100, size=30)
ts = pd.Series(data, index=date_range)

# 将日数据重采样为周数据
weekly_ts = ts.resample('W').mean()
print(weekly_ts)

# 将日数据重采样为月数据
monthly_ts = ts.resample('M').sum()
print(monthly_ts)
  • .mean()：计算重采样后的平均值。
  • .sum()：计算重采样后的总和。
  • .min()：计算重采样后的最小值。
  • .max()：计算重采样后的最大值。
  • .first()：计算重采样后的第一个值。
  • .last()：计算重采样后的最后一个值。

6.5 时间序列常用方法

  • shift()：移动时间序列数据。
  • diff()：计算时间序列数据的差分。
  • asfreq()：转换为指定频率。
  • rolling()：计算滑动窗口统计量。
import pandas as pd
import numpy as np

date_range = pd.date_range('2023-10-01', periods=10, freq='D')
data = np.arange(10,20)
ts = pd.Series(data, index=date_range)

print(ts.shift(2))   # 向下移动两个时间单位
print(ts.diff(1))  # 计算一阶差分
print(ts.asfreq('H', fill_value=0)) #转换为小时频率
print(ts.rolling(window=3).mean())  # 计算窗口为 3 的移动平均

7. Pandas 高级应用

7.1.1 apply() 函数

import pandas as pd
import numpy as np

data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data)

# 对 Series 应用函数
def square(x):
    return x ** 2
print(df['A'].apply(square))

# 对 DataFrame 的行或列应用函数
def row_sum(row):
    return row.sum()

print(df.apply(row_sum, axis=1)) # 对每一行应用求和操作
print(df.apply(row_sum, axis=0)) # 对每一列应用求和操作

7.1.2 applymap() 函数

import pandas as pd
import numpy as np

data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data)

# 对 DataFrame 的每个元素应用函数
def add_one(x):
  return x + 1

print(df.applymap(add_one))

7.2 窗口函数

窗口函数可以对数据窗口进行计算，例如移动平均、滚动求和等。

import pandas as pd
import numpy as np

data = {'value': [1, 2, 3, 4, 5, 6, 7, 8, 9]}
df = pd.DataFrame(data)

# 移动平均
df['rolling_mean'] = df['value'].rolling(window=3).mean()
print(df)

# 累加
df['cumsum'] = df['value'].cumsum()
print(df)

# 窗口最大值
df['rolling_max'] = df['value'].rolling(window=3).max()
print(df)

# 窗口最小值
df['rolling_min'] = df['value'].rolling(window=3).min()
print(df)

7.3 数据可视化

Pandas 可以与 Matplotlib 等可视化库结合，方便进行数据可视化。

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

data = {
    'value': np.random.randn(100).cumsum()
}
df = pd.DataFrame(data)

# 绘制折线图
df.plot(figsize=(8, 6))
plt.title('Random Data Visualization')
plt.xlabel('Index')
plt.ylabel('Value')
plt.show()

# 绘制直方图
data = np.random.randn(1000)
df = pd.DataFrame(data, columns=['value'])
df.plot.hist(bins=20, figsize=(8, 6))
plt.title('Hist Data Visualization')
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.show()

# 绘制散点图
data = {
    'x': np.random.randn(100),
    'y': np.random.randn(100)
}
df = pd.DataFrame(data)
df.plot.scatter(x='x', y='y', figsize=(8, 6))
plt.title('Scatter Data Visualization')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

# 绘制箱线图
data = {
    'A': np.random.randn(100),
    'B': np.random.randn(100)
}
df = pd.DataFrame(data)
df.plot.box(figsize=(8, 6))
plt.title('Box Data Visualization')
plt.ylabel('Value')
plt.show()

# 绘制饼图
data = [10, 20, 30, 40]
labels = ['A', 'B', 'C', 'D']
df = pd.Series(data, index=labels)
df.plot.pie(figsize=(8, 8), autopct='%.2f')
plt.title('Pie Chart Data Visualization')
plt.show()

8. 总结与进阶

8.1 常用技巧

在实际使用 pandas 时，以下一些技巧可能会很有帮助：

  • 链式操作： 可以将多个操作链接在一起，提高代码的可读性：

    df = (
    pd.read_csv('data.csv')
    .dropna()
    .sort_values('age')
    .groupby('city')
    .mean()
)

  • 使用 query() 方法： 可以用更简洁的语法进行数据筛选：

    df.query('age > 30 and city == "New York"')

  • 使用 isin() 方法： 可以检查 Series 或 DataFrame 中的元素是否在给定的列表中：

    cities = ['New York', 'London']
    df[df['city'].isin(cities)]

  • 使用 assign() 方法： 可以添加新的列，同时保留原始 DataFrame：

    df = df.assign(age_plus_ten = lambda x: x['age']+10)

  • 使用 pipe() 方法： 可以将 DataFrame 传递给一系列函数：

    def clean_data(df):
  return df.dropna()
def add_age(df):
  return df.assign(age_plus_ten = lambda x: x['age']+10)

df.pipe(clean_data).pipe(add_age)

8.2 学习资源

  • 官方文档： pandas documentation
    • 这是学习 pandas 最权威的资源，包含了所有函数、方法的详细说明和示例。
  • 在线教程：
  • 书籍：
    • “Python for Data Analysis” by Wes McKinney： pandas 的作者写的书，是学习 pandas 的经典之作。
  • 实践项目：
    • 可以尝试一些 Kaggle 上的数据分析项目，将 pandas 应用到实际问题中。
  • 社区：
    • Stack Overflow：在遇到问题时，可以在 Stack Overflow 上搜索或提问。
    • GitHub：pandas 也是一个开源项目，可以在 GitHub 上查看源代码，参与贡献。
文章作者: 0xdadream
文章链接: https://0xdadream.github.io/2025/01/12/pandas-shi-yong/
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 0xdadream !
tools
赏
评论
  目录