目录:
pandas 用于数据处理和分析，提供了 DataFrame 和 Series 两种数据结构，DataFrame 用于处理表格数据/二维数据，Series 用于处理一维数据。在处理金融、统计、社会科学、工程等领域经常使用。
$ pip3 install pandas
Series 是一种类似于一维数组的对象，由一组数据（值数组）和一组与之相关的数据标签（索引）组成。它可以容纳任何数据类型（整数、字符串、浮点数、Python对象等）。
import pandas as pd
import numpy as np
# 通过列表创建，不指定索引则默认生成 0, 1, 2... 索引
s1 = pd.Series([1, 2, 3, 4])
print(f's1:\n{s1}')
# 输出：
# 0 1
# 1 2
# 2 3
# 3 4
# dtype: int64
# 通过列表创建并指定索引
s2 = pd.Series([11, 12, 13, 14], index=['a', 'b', 'c', 'd'])
print(f's2:\n{s2}')
# 输出：
# a 11
# b 12
# c 13
# d 14
# dtype: int64
# 通过 NumPy 数组创建
s3 = pd.Series(np.arange(3))
print(f's3:\n{s3}')
# 通过字典创建，字典的键将成为索引
dic = {'calvin': 7, 'kobe': 24}
s4 = pd.Series(dic)
print(f's4:\n{s4}')
常见属性
import pandas as pd
s = pd.Series([1, 2, 3, 4])
print(s.values) # 值数组: [1 2 3 4]
print(s.index) # 索引数组: RangeIndex(start=0, stop=4, step=1)
print(s.name) # 序列的名称: None
print(s.dtype) # 数据类型: int64
DataFrame 是一个二维的、表格型的数据结构，类似于电子表格或 SQL 数据库中的表。它由行和列组成，每列可以包含不同的数据类型。DataFrame 是 Pandas 中最常用、功能最强大的对象。
import pandas as pd
import numpy as np
# 从字典创建（最常用）
data = {'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['NYC', 'LA', 'Chicago']}
df1 = pd.DataFrame(data)
print(f'df1:\n{df1}')
# 从列表的列表创建，并指定列名
data_list = [['Alice', 25], ['Bob', 30], ['Charlie', 35]]
df2 = pd.DataFrame(data_list, columns=['Name', 'Age'])
print(f'df2:\n{df2}')
# 从 Series 的字典创建
data_series = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df3 = pd.DataFrame(data_series)
print(f'df3:\n{df3}')
# 创建带指定索引和列名的 DataFrame
dates = pd.date_range('20230101', periods=6)
df4 = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
print(f'df4:\n{df4}')
常见属性
import pandas as pd
import numpy as np
# 从字典创建（最常用）
data = {'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['NYC', 'LA', 'Chicago']}
df = pd.DataFrame(data)
print(df.columns) # 列索引: Index(['Name', 'Age', 'City'], dtype='object')
print(df.index) # 行索引: RangeIndex(start=0, stop=3, step=1)
print(df.values) # 值二维数组
print(df.dtypes) # 每列数据类型
print(df.shape) # 数据形状: (3, 3)
print(df.T) # 行和列转置
在数据处理前，快速查看数据概览是重要一步。
import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [10, 20, 30, 40], 'C': ['a', 'b', 'c', 'd']})
print(df.head(3)) # 查看前 3 行，默认 5 行
print()
print(df.tail(2)) # 查看后 2 行，默认 5 行
print()
print(df.sample(1)) # 随机查看 1 行
print()
print(df.info()) # 显示索引、列数据类型、非空值数量等信息
print()
print(df.describe()) # 生成描述性统计摘要（针对数值列）
print()
print(df.shape) # 输出 (4, 3)
print()
print(df.columns.tolist()) # 输出 ['A', 'B', 'C']
print()
print(df['C'].value_counts()) # 查看某列唯一值及计数
import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [10, 20, 30, 40], 'C': ['a', 'b', 'c', 'd']})
# 选择单列，返回 Series
series_a = df['A'] # 只选择 A 列
print(series_a)
# 0 1
# 1 2
# 2 3
# 3 4
# 选择多列，返回DataFrame
df_subset = df[['A', 'C']] # 只选择 A 和 C 列
print(df_subset)
# Name: A, dtype: int64
# A C
# 0 1 a
# 1 2 b
# 2 3 c
# 3 4 d
import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [10, 20, 30, 40], 'C': ['a', 'b', 'c', 'd']})
# 使用 .iloc[] 基于整数位置选择
print(df.iloc) # 第一行
# 输出: <pandas.core.indexing._iLocIndexer object at 0x118bc2ad0>
print(df.iloc[1:3]) # 第 2 到第 3 行（切片）
# A B C
# 1 2 20 b
# 2 3 30 c
print(df.iloc[[0, 2]]) # 第 1 行和第 3 行（花式索引）
# A B C
# 0 1 10 a
# 2 3 30 c
# 使用 .loc[] 基于标签选择
df_indexed = df.set_index('C')
print(df_indexed.loc['a']) # 索引标签为 'a' 的行
# A 1
# B 10
# Name: a, dtype: int64
print(df_indexed.loc[['a', 'c']]) # 索引标签为 'a' 和 'c' 的行
# A B
# C
# a 1 10
# c 3 30
import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [10, 20, 30, 40], 'C': ['a', 'b', 'c', 'd']})
print(f'df:\n{df}')
# A B C
# 0 1 10 a
# 1 2 20 b
# 2 3 30 c
# 3 4 40 d
# 增加列
df['D'] = df['A'] * 2
df['Category'] = pd.cut(df['A'], bins=2, labels=['Low', 'High']) # 分箱
print(f'df:\n{df}')
# A B C D Category
# 0 1 10 a 2 Low
# 1 2 20 b 4 Low
# 2 3 30 c 6 High
# 3 4 40 d 8 High
# 删除列
df_dropped = df.drop(['D'], axis=1) # axis=1 表示列
print(f'df_dropped:\n{df_dropped}')
# A B C Category
# 0 1 10 a Low
# 1 2 20 b Low
# 2 3 30 c High
# 3 4 40 d High
# 删除行
df_dropped_row = df.drop([0, 1], axis=0) # axis=0 表示行，或省略axis
print(f'df_dropped_row:\n{df_dropped_row}')
# A B C D Category
# 2 3 30 c 6 High
# 3 4 40 d 8 High
print(f'df:\n{df}')
# A B C D Category
# 0 1 10 a 2 Low
# 1 2 20 b 4 Low
# 2 3 30 c 6 High
# 3 4 40 d 8 High
# 添加行（通常使用 concat）
new_row = pd.DataFrame({'A': [5], 'B': [50], 'C': ['e']})
df_appended = pd.concat([df, new_row], ignore_index=True)
print(f'df_appended:\n{df_appended}')
# A B C D Category
# 0 1 10 a 2.0 Low
# 1 2 20 b 4.0 Low
# 2 3 30 c 6.0 High
# 3 4 40 d 8.0 High
# 4 5 50 e NaN NaN
# 检测缺失值
print(df.isnull().sum()) # 每列缺失值数量
print(df[df['A'].isnull()]) # 提取某列含有空值的行
# 删除缺失值
df_dropna = df.dropna() # 删除任何包含 NaN 的行
df_dropna_col = df.dropna(axis=1) # 删除任何包含 NaN 的列
# 填充缺失值
df_filled = df.fillna(0) # 用 0 填充
df_filled_mean = df['A'].fillna(df['A'].mean()) # 用均值填充
df_filled_mode = df['C'].fillna(df['C'].mode()) # 用众数填充
df['A'] = df['A'].astype('float64')
# 更安全的数值转换，错误处理
df['B'] = pd.to_numeric(df['B'], errors='coerce') # 无法转换的变为 NaN
# 删除重复行
df_dedup = df.drop_duplicates()
df_dedup_subset = df.drop_duplicates(subset=['C']) # 基于特定列去重
df_sorted = df.sort_values('A', ascending=False) # 按 A 列降序
df_sorted_multi = df.sort_values(['A', 'B']) # 按多列排序
Pandas 支持从多种数据源读写数据。
# 读取数据
df_csv = pd.read_csv('filename.csv')
df_excel = pd.read_excel('filename.xlsx')
df_sql = pd.read_sql('SELECT * FROM table_name', connection_object)
# 写入数据
df.to_csv('output.csv', index=False) # 不保存行索引
df.to_excel('output.xlsx')
df.to_sql('table_name', connection_object, if_exists='replace')
↶ 返回首页 ↶