Pandas基础知识整理

原创于 2025-12-05 00:52:05 发布 · 629 阅读

28 ·

CC 4.0 BY-SA版权

文章标签：

#pandas

python 同时被 2 个专栏收录

30 篇文章

订阅专栏

Pandas

2 篇文章

订阅专栏

Pandas基础知识整理

Pandas基础知识
Pandas构建DataFrame的各种方法
Pandas构建Series的各种方法
Pandas中DataFrame和Series的关系

Pandas基础知识

Pandas是Python中用于数据分析和处理的核心库,它提供了高效、灵活的数据结构来处理结构化数据。

一、核心数据结构

1. Series(一维数据)

Series是带标签的一维数组,可以存储任何数据类型。

import pandas as pd
import numpy as np

# 创建Series
s = pd.Series([1, 3, 5, 7, 9])
print(s)

# 带自定义索引的Series
s = pd.Series([1, 3, 5, 7, 9], index=['a', 'b', 'c', 'd', 'e'])
print(s)

# 从字典创建
data = {'a': 1, 'b': 2, 'c': 3}
s = pd.Series(data)

2. DataFrame(二维数据)

DataFrame是带标签的二维表格结构,类似Excel表格或SQL表。

# 从字典创建DataFrame
data = {
    'name': ['张三', '李四', '王五'],
    'age': [25, 30, 35],
    'city': ['北京', '上海', '广州']
}
df = pd.DataFrame(data)
print(df)

# 从列表创建
data = [
    ['张三', 25, '北京'],
    ['李四', 30, '上海'],
    ['王五', 35, '广州']
]
df = pd.DataFrame(data, columns=['name', 'age', 'city'])

二、数据读取与保存

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

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

# 读取JSON文件
df = pd.read_json('data.json')

# 保存为CSV
df.to_csv('output.csv', index=False)

# 保存为Excel
df.to_excel('output.xlsx', index=False)

三、数据查看与基本信息

# 查看前几行
df.head()  # 默认前5行
df.head(10)  # 前10行

# 查看后几行
df.tail()

# 查看数据维度
df.shape

# 查看列名
df.columns

# 查看索引
df.index

# 查看数据类型
df.dtypes

# 查看基本统计信息
df.describe()

# 查看数据信息
df.info()

四、数据选择与索引

# 选择列
df['name']  # 单列,返回Series
df[['name', 'age']]  # 多列,返回DataFrame

# 选择行(通过位置)
df.iloc[0]  # 第一行
df.iloc[0:3]  # 前三行
df.iloc[0, 1]  # 第一行第二列

# 选择行(通过标签)
df.loc[0]  # 索引为0的行
df.loc[0:2, 'name':'age']  # 切片选择

# 条件筛选
df[df['age'] > 25]
df[(df['age'] > 25) & (df['city'] == '北京')]

五、数据清洗

# 检查缺失值
df.isnull()
df.isnull().sum()

# 删除缺失值
df.dropna()  # 删除包含缺失值的行
df.dropna(axis=1)  # 删除包含缺失值的列

# 填充缺失值
df.fillna(0)  # 用0填充
df.fillna(df.mean())  # 用平均值填充

# 删除重复值
df.drop_duplicates()

# 重命名列
df.rename(columns={'old_name': 'new_name'})

# 修改数据类型
df['age'] = df['age'].astype(int)

六、数据操作

# 添加新列
df['salary'] = [5000, 6000, 7000]

# 删除列
df.drop('salary', axis=1, inplace=True)

# 排序
df.sort_values('age')  # 按age升序
df.sort_values('age', ascending=False)  # 降序

# 分组统计
df.groupby('city')['age'].mean()
df.groupby('city').agg({'age': ['mean', 'max', 'min']})

# 数据合并
pd.concat([df1, df2])  # 纵向合并
pd.merge(df1, df2, on='key')  # 横向合并(类似SQL JOIN)

# 应用函数
df['age'].apply(lambda x: x + 1)
df.apply(lambda x: x.max() - x.min())

七、常用统计方法

# 求和
df['age'].sum()

# 平均值
df['age'].mean()

# 中位数
df['age'].median()

# 最大值/最小值
df['age'].max()
df['age'].min()

# 标准差
df['age'].std()

# 计数
df['city'].value_counts()

# 相关性
df.corr()

八、数据透视表

# 创建数据透视表
pivot = pd.pivot_table(df, 
                       values='age', 
                       index='city', 
                       aggfunc='mean')

# 交叉表
pd.crosstab(df['city'], df['gender'])

九、时间序列处理

# 创建日期范围
dates = pd.date_range('2024-01-01', periods=10, freq='D')

# 转换为日期格式
df['date'] = pd.to_datetime(df['date'])

# 提取日期组件
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day

# 设置日期为索引
df.set_index('date', inplace=True)

# 重采样
df.resample('M').mean()  # 按月聚合

十、实用技巧

# 链式操作
result = (df
    .query('age > 25')
    .groupby('city')['age']
    .mean()
    .sort_values(ascending=False)
)

# 条件赋值
df['category'] = np.where(df['age'] > 30, 'Senior', 'Junior')

# 使用map映射
city_map = {'北京': 'BJ', '上海': 'SH', '广州': 'GZ'}
df['city_code'] = df['city'].map(city_map)

# 重置索引
df.reset_index(drop=True, inplace=True)

学习建议

动手实践:通过实际数据集练习各种操作
查阅文档:熟悉官方文档 https://pandas.pydata.org/docs/
结合可视化:配合matplotlib或seaborn进行数据可视化
处理真实问题:尝试解决实际的数据分析任务

Pandas构建DataFrame的各种方法

1. 从字典创建DataFrame

方法1：列表字典（每个键对应一列）

import pandas as pd

# 字典的值是列表
data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'city': ['New York', 'London', 'Tokyo']
}
df = pd.DataFrame(data)

方法2：字典列表（每个字典是一行）

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

2. 从列表/数组创建

方法1：二维列表

data = [
    ['Alice', 25, 'New York'],
    ['Bob', 30, 'London'],
    ['Charlie', 35, 'Tokyo']
]
df = pd.DataFrame(data, columns=['name', 'age', 'city'])

方法2：NumPy数组

import numpy as np

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

3. 从其他数据结构创建

从Series创建

s1 = pd.Series([1, 2, 3], name='A')
s2 = pd.Series([4, 5, 6], name='B')
df = pd.concat([s1, s2], axis=1)

从元组列表创建

data = [('Alice', 25), ('Bob', 30), ('Charlie', 35)]
df = pd.DataFrame(data, columns=['name', 'age'])

4. 从文件读取

# CSV文件
df = pd.read_csv('file.csv')

# Excel文件
df = pd.read_excel('file.xlsx')

# JSON文件
df = pd.read_json('file.json')

# SQL数据库
import sqlite3
conn = sqlite3.connect('database.db')
df = pd.read_sql('SELECT * FROM table_name', conn)

5. 创建空DataFrame后添加数据

方法1：先创建空框架

df = pd.DataFrame(columns=['name', 'age', 'city'])
df.loc[0] = ['Alice', 25, 'New York']
df.loc[1] = ['Bob', 30, 'London']

方法2：使用append（注意：在新版本中推荐使用concat）

df = pd.DataFrame(columns=['name', 'age'])
new_row = pd.DataFrame([['Alice', 25]], columns=['name', 'age'])
df = pd.concat([df, new_row], ignore_index=True)

6. 指定索引和列名

data = [[1, 2], [3, 4], [5, 6]]
df = pd.DataFrame(
    data,
    index=['row1', 'row2', 'row3'],
    columns=['col1', 'col2']
)

7. 从剪贴板创建

# 复制Excel或CSV数据后
df = pd.read_clipboard()

8. 使用特殊方法创建

创建随机数据

df = pd.DataFrame(
    np.random.randn(5, 3),
    columns=['A', 'B', 'C']
)

创建日期范围数据

dates = pd.date_range('20230101', periods=6)
df = pd.DataFrame(
    np.random.randn(6, 4),
    index=dates,
    columns=list('ABCD')
)

9. 从字典的字典创建（嵌套字典）

data = {
    'A': {0: 1, 1: 2, 2: 3},
    'B': {0: 4, 1: 5, 2: 6}
}
df = pd.DataFrame(data)

10. 实用技巧

指定数据类型

df = pd.DataFrame(
    data,
    dtype=float  # 或指定每列: {'A': int, 'B': float}
)

从现有DataFrame复制

df_copy = df.copy()  # 深拷贝
df_view = df  # 浅拷贝（引用）

Pandas构建Series的各种方法

1. 从列表创建Series

基本方法

import pandas as pd

# 从普通列表创建
s = pd.Series([1, 2, 3, 4, 5])
print(s)
# 输出：
# 0    1
# 1    2
# 2    3
# 3    4
# 4    5
# dtype: int64

指定索引

s = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
print(s)
# 输出：
# a    1
# b    2
# c    3
# d    4
# e    5
# dtype: int64

指定名称

s = pd.Series([1, 2, 3], name='数值')

2. 从字典创建Series

# 字典的键自动成为索引
data = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
s = pd.Series(data)

# 指定特定的键顺序
s = pd.Series(data, index=['d', 'c', 'b', 'a'])

# 索引中有字典没有的键，值为NaN
s = pd.Series(data, index=['a', 'b', 'c', 'e'])

3. 从标量值创建Series

# 需要提供索引
s = pd.Series(5, index=[0, 1, 2, 3])
# 输出：
# 0    5
# 1    5
# 2    5
# 3    5
# dtype: int64

# 字符串标量
s = pd.Series('hello', index=range(3))

4. 从NumPy数组创建

import numpy as np

# 一维数组
arr = np.array([1, 2, 3, 4, 5])
s = pd.Series(arr)

# 指定索引
s = pd.Series(arr, index=['a', 'b', 'c', 'd', 'e'])

# 随机数组
s = pd.Series(np.random.randn(5))

5. 从其他Series创建

# 复制Series
s1 = pd.Series([1, 2, 3])
s2 = s1.copy()  # 深拷贝

# 从Series的一部分创建
s_new = s1[s1 > 1]  # 筛选后创建新Series

# 重新索引
s_reindex = s1.reindex([0, 1, 2, 3, 4], fill_value=0)

6. 从DataFrame的列创建

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

# 提取某一列
s = df['A']
# 或
s = df.A

# 提取某一行
s = df.loc[0]

7. 使用range创建

# 使用Python的range
s = pd.Series(range(10))

# 使用步长
s = pd.Series(range(0, 100, 10))

# 指定自定义索引
s = pd.Series(range(5), index=list('abcde'))

8. 从文件读取（单列数据）

# 从CSV读取单列
s = pd.read_csv('file.csv', squeeze=True)  # 注意：squeeze在新版本已弃用
# 新版本推荐：
s = pd.read_csv('file.csv', usecols=[0]).squeeze()

# 或者先读DataFrame再转换
df = pd.read_csv('file.csv')
s = df['column_name']

9. 指定数据类型

# 整数
s = pd.Series([1, 2, 3], dtype='int64')

# 浮点数
s = pd.Series([1, 2, 3], dtype='float64')

# 字符串
s = pd.Series([1, 2, 3], dtype='str')

# 布尔值
s = pd.Series([True, False, True], dtype='bool')

# 日期时间
s = pd.Series(['2023-01-01', '2023-01-02'], dtype='datetime64[ns]')

# 分类类型
s = pd.Series(['a', 'b', 'c', 'a'], dtype='category')

10. 创建特殊类型的Series

日期时间Series

# 日期范围
dates = pd.date_range('2023-01-01', periods=10, freq='D')
s = pd.Series(dates)

# 或直接创建
s = pd.Series(pd.date_range('2023-01-01', '2023-01-10'))

时间增量Series

s = pd.Series(pd.timedelta_range('1 day', periods=5))

分类Series

s = pd.Series(['low', 'medium', 'high', 'low'], dtype='category')
s = s.cat.set_categories(['low', 'medium', 'high'], ordered=True)

11. 从元组创建

# 元组列表
data = [('a', 1), ('b', 2), ('c', 3)]
# 只能取一列
s = pd.Series([x[1] for x in data], index=[x[0] for x in data])

12. 使用构造函数参数

s = pd.Series(
    data=[1, 2, 3, 4, 5],
    index=['a', 'b', 'c', 'd', 'e'],
    name='my_series',
    dtype='float64'
)

13. 从生成器创建

# 使用生成器表达式
s = pd.Series((x**2 for x in range(10)))

# 使用生成器函数
def gen():
    for i in range(5):
        yield i * 2

s = pd.Series(gen())

14. 创建空Series

# 完全空的Series
s = pd.Series(dtype='float64')

# 指定索引的空Series
s = pd.Series(index=['a', 'b', 'c'], dtype='float64')

# 填充NaN值
s = pd.Series([None, None, None])

15. 数学序列

# 等差序列
s = pd.Series(np.linspace(0, 10, 11))

# 等比序列
s = pd.Series(np.logspace(0, 2, 5))

# 正弦波
s = pd.Series(np.sin(np.linspace(0, 2*np.pi, 100)))

16. 从字符串创建

# 分割字符串
s = pd.Series('apple,banana,cherry'.split(','))

# 字符列表
s = pd.Series(list('abcdef'))

17. 实用技巧

设置和修改属性

s = pd.Series([1, 2, 3])
s.name = '数值列'
s.index = ['第一', '第二', '第三']
s.index.name = '序号'

转换其他对象为Series

# 列表转Series
s = pd.Series([1, 2, 3]).astype('float')

# 数组转Series
s = pd.Series(np.array([1, 2, 3]))

# 字典转Series
s = pd.Series({'a': 1, 'b': 2})

合并多个值

# 重复值
s = pd.Series([1, 2] * 5)

# 拼接Series
s1 = pd.Series([1, 2, 3])
s2 = pd.Series([4, 5, 6])
s = pd.concat([s1, s2], ignore_index=True)

18. 常见应用示例

# 创建带有缺失值的Series
s = pd.Series([1, 2, np.nan, 4, None, 6])

# 创建带有重复索引的Series
s = pd.Series([1, 2, 3], index=['a', 'a', 'b'])

# 从字典创建，部分索引缺失
data = {'a': 1, 'b': 2}
s = pd.Series(data, index=['a', 'b', 'c', 'd'])  # c和d将是NaN

Pandas中DataFrame和Series的关系

一、基本概念

Series：一维数组结构，包含数据值和索引
DataFrame：二维表格结构，可以看作是多个Series的集合

二、DataFrame与Series的关系

1. DataFrame的列是Series

DataFrame的每一列都是一个Series对象：

import pandas as pd

# 创建DataFrame
df = pd.DataFrame({
    '姓名': ['张三', '李四', '王五'],
    '年龄': [25, 30, 35],
    '城市': ['北京', '上海', '广州']
})

# 提取列，返回Series
age_series = df['年龄']
print(type(age_series))  # <class 'pandas.core.series.Series'>
print(age_series)
# 输出:
# 0    25
# 1    30
# 2    35
# Name: 年龄, dtype: int64

2. DataFrame的行也可以是Series

使用.loc或.iloc提取行时，返回Series对象：

# 提取行，返回Series
row_series = df.loc[0]  # 或 df.iloc[0]
print(type(row_series))  # <class 'pandas.core.series.Series'>
print(row_series)
# 输出:
# 姓名    张三
# 年龄    25
# 城市    北京
# Name: 0, dtype: object

注意：行Series的索引是DataFrame的列名

三、相互转换

Series → DataFrame

# 方法1：to_frame()
s = pd.Series([1, 2, 3], name='数值')
df = s.to_frame()

# 方法2：构造函数
df = pd.DataFrame(s)
df = pd.DataFrame({'列名': s})

DataFrame → Series

# 单列DataFrame转Series
single_col_df = df[['年龄']]  # 这是DataFrame
series = df['年龄']  # 这是Series
# 或
series = single_col_df.squeeze()

四、关键区别

特性	Series	DataFrame
维度	一维	二维
索引	单一索引	行索引+列索引
数据类型	单一dtype	每列可以不同dtype
列名	有name属性	有columns属性

五、实际应用示例

import pandas as pd

df = pd.DataFrame({
    '产品': ['A', 'B', 'C'],
    '销量': [100, 200, 150],
    '价格': [10.5, 20.0, 15.5]
})

# 1. 对某一列(Series)进行操作
df['销量'] = df['销量'] * 1.1  # 销量增长10%

# 2. 添加新列(从Series创建)
df['总额'] = df['销量'] * df['价格']

# 3. 遍历行(每行是Series)
for index, row in df.iterrows():
    print(f"{row['产品']}的总额是{row['总额']}")

# 4. 应用函数到每一列(Series)
df[['销量', '价格']].apply(lambda x: x.max())