我将通过一个完整连贯的实例，带你从零开始掌握 Pandas 的核心操作。每个示例都包含完整代码和对应输出，确保你能直观看到每一步的结果。
1.1 DataFrame：你的数据主战场
import pandas as pd
print("=== 1.1 创建DataFrame的多种方式 ===")
# 方式1：从字典创建（最常用）
data = {
'员工ID': [101, 102, 103, 104, 105],
'姓名': ['张三', '李四', '王五', '赵六', '钱七'],
'年龄': [25, 30, 35, 28, 32],
'部门': ['技术部', '市场部', '技术部', '人事部', '市场部'],
'月薪': [8500, 9200, 11000, 7800, 9500],
'入职年份': [2020, 2019, 2018, 2021, 2019]
}
df = pd.DataFrame(data)
print("从字典创建的DataFrame:")
print(df)
完整输出：
=== 1.1 创建DataFrame的多种方式 ===
从字典创建的DataFrame:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25 技术部 8500 2020
1 102 李四 30 市场部 9200 2019
2 103 王五 35 技术部 11000 2018
3 104 赵六 28 人事部 7800 2021
4 105 钱七 32 市场部 9500 2019
1.2 Series：单列数据对象
print("=== 1.2 Series对象示例 ===")
# 提取单列（得到一个Series）
age_series = df['年龄']
print("年龄列（Series对象）:")
print(age_series)
print()
# 查看Series的类型和统计信息
print(f"类型: {type(age_series)}")
print(f"描述统计:")
print(age_series.describe())
print(f"平均值: {age_series.mean()}")
print(f"中位数: {age_series.median()}")
完整输出：
text
=== 1.2 Series对象示例 ===
年龄列（Series对象）:
0 25
1 30
2 35
3 28
4 32
Name: 年龄, dtype: int64
类型: <class 'pandas.core.series.Series'>
描述统计:
count 5.000000
mean 30.000000
std 3.807887
min 25.000000
25% 28.000000
50% 30.000000
75% 32.000000
max 35.000000
Name: 年龄, dtype: float64
平均值: 30.0
中位数: 30.0
第二章：数据查看与探索
2.1 基本信息查看
print("=== 2.1 数据基本信息 ===")
print("1. 查看前3行:")
print(df.head(3))
print()
print("2. 查看后2行:")
print(df.tail(2))
print()
print("3. 查看数据形状（行数, 列数）:")
print(f"df.shape = {df.shape}")
print(f"总行数: {df.shape[0]}, 总列数: {df.shape[1]}")
print()
print("4. 查看列名:")
print(f"df.columns = {df.columns.tolist()}")
print()
print("5. 查看数据类型:")
print(df.dtypes)
print()
print("6. 查看详细信息:")
df.info()
print()
print("7. 数值列的描述性统计:")
print(df.describe())
完整输出：
=== 2.1 数据基本信息 ===
1. 查看前3行:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25 技术部 8500 2020
1 102 李四 30 市场部 9200 2019
2 103 王五 35 技术部 11000 2018
2. 查看后2行:
员工ID 姓名 年龄 部门 月薪 入职年份
3 104 赵六 28 人事部 7800 2021
4 105 钱七 32 市场部 9500 2019
3. 查看数据形状（行数, 列数）:
df.shape = (5, 6)
总行数: 5, 总列数: 6
4. 查看列名:
df.columns = ['员工ID', '姓名', '年龄', '部门', '月薪', '入职年份']
5. 查看数据类型:
员工ID int64
姓名 object
年龄 int64
部门 object
月薪 int64
入职年份 int64
dtype: object
6. 查看详细信息:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5 entries, 0 to 4
Data columns (total 6 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 员工ID 5 non-null int64
1 姓名 5 non-null object
2 年龄 5 non-null int64
3 部门 5 non-null object
4 月薪 5 non-null int64
5 入职年份 5 non-null int64
dtypes: int64(4), object(2)
memory usage: 368.0+ bytes
7. 数值列的描述性统计:
员工ID 年龄 月薪 入职年份
count 5.000000 5.000000 5.000000 5.000000
mean 103.000000 30.000000 9200.000000 2019.400000
std 1.581140 3.807887 1252.998405 1.140175
min 101.000000 25.000000 7800.000000 2018.000000
25% 102.000000 28.000000 8500.000000 2019.000000
50% 103.000000 30.000000 9200.000000 2019.000000
75% 104.000000 32.000000 9500.000000 2020.000000
max 105.000000 35.000000 11000.000000 2021.000000
2.2 唯一值与计数
print("=== 2.2 唯一值与计数 ===")
print("1. 部门唯一值:")
print(f"df['部门'].unique() = {df['部门'].unique()}")
print()
print("2. 各部门员工数量:")
print(df['部门'].value_counts())
print()
print("3. 各部门员工数量（百分比）:")
print(df['部门'].value_counts(normalize=True))
完整输出：
=== 2.2 唯一值与计数 ===
1. 部门唯一值:
df['部门'].unique() = ['技术部' '市场部' '人事部']
2. 各部门员工数量:
部门
市场部 2
技术部 2
人事部 1
Name: count, dtype: int64
3. 各部门员工数量（百分比）:
部门
市场部 0.4
技术部 0.4
人事部 0.2
Name: proportion, dtype: float64
第三章：数据选择与筛选
3.1 选择列数据
print("=== 3.1 选择列数据 ===")
print("1. 选择单列（返回Series）:")
names = df['姓名']
print(names)
print()
print("2. 选择多列（返回DataFrame）:")
subset = df[['姓名', '部门', '月薪']]
print(subset)
print()
print("3. 使用点表示法（列名无空格时可用）:")
ages = df.年龄
print(ages)
完整输出：
=== 3.1 选择列数据 ===
1. 选择单列（返回Series）:
0 张三
1 李四
2 王五
3 赵六
4 钱七
Name: 姓名, dtype: object
2. 选择多列（返回DataFrame）:
姓名 部门 月薪
0 张三 技术部 8500
1 李四 市场部 9200
2 王五 技术部 11000
3 赵六 人事部 7800
4 钱七 市场部 9500
3. 使用点表示法（列名无空格时可用）:
0 25
1 30
2 35
3 28
4 32
Name: 年龄, dtype: int64
3.2 选择行数据
print("=== 3.2 选择行数据 ===")
print("1. 按位置选择（iloc）:")
print("第2行（索引为2）:")
print(df.iloc[2])
print()
print("第1-3行（不含第3行）:")
print(df.iloc[1:3])
print()
print("2. 按标签选择（loc）:")
print("选择索引为0和3的行:")
print(df.loc[[0, 3]])
print()
print("3. 选择特定行列组合:")
print("选择第0、2行和姓名、月薪列:")
print(df.loc[[0, 2], ['姓名', '月薪']])
完整输出：
=== 3.2 选择行数据 ===
1. 按位置选择（iloc）:
第2行（索引为2）:
员工ID 103
姓名 王五
年龄 35
部门 技术部
月薪 11000
入职年份 2018
Name: 2, dtype: object
第1-3行（不含第3行）:
员工ID 姓名 年龄 部门 月薪 入职年份
1 102 李四 30 市场部 9200 2019
2 103 王五 35 技术部 11000 2018
2. 按标签选择（loc）:
选择索引为0和3的行:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25 技术部 8500 2020
3 104 赵六 28 人事部 7800 2021
3. 选择特定行列组合:
选择第0、2行和姓名、月薪列:
姓名 月薪
0 张三 8500
2 王五 11000
3.3 条件筛选（最重要的功能！）
print("=== 3.3 条件筛选 ===")
print("1. 简单条件：月薪大于9000的员工:")
high_salary = df[df['月薪'] > 9000]
print(high_salary)
print()
print("2. 多条件筛选（注意括号）:")
print("市场部且月薪大于9000的员工:")
marketing_high = df[(df['部门'] == '市场部') & (df['月薪'] > 9000)]
print(marketing_high)
print()
print("3. 年龄在25-30岁之间的员工:")
young = df[df['年龄'].between(25, 30)]
print(young)
print()
print("4. 部门在特定列表中:")
dept_filter = df[df['部门'].isin(['技术部', '人事部'])]
print(dept_filter)
print()
print("5. 字符串包含筛选:")
print("姓名中包含'三'的员工:")
name_filter = df[df['姓名'].str.contains('三')]
print(name_filter)
print()
print("6. 复杂条件组合:")
complex_filter = df[
(df['月薪'] > 8000) &
(df['年龄'] < 35) &
(df['部门'].isin(['技术部', '市场部']))
]
print("月薪>8000, 年龄<35, 且是技术部或市场部:")
print(complex_filter)
完整输出：
=== 3.3 条件筛选 ===
1. 简单条件：月薪大于9000的员工:
员工ID 姓名 年龄 部门 月薪 入职年份
2 103 王五 35 技术部 11000 2018
4 105 钱七 32 市场部 9500 2019
2. 多条件筛选（注意括号）:
市场部且月薪大于9000的员工:
员工ID 姓名 年龄 部门 月薪 入职年份
4 105 钱七 32 市场部 9500 2019
3. 年龄在25-30岁之间的员工:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25 技术部 8500 2020
1 102 李四 30 市场部 9200 2019
3 104 赵六 28 人事部 7800 2021
4. 部门在特定列表中:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25 技术部 8500 2020
2 103 王五 35 技术部 11000 2018
3 104 赵六 28 人事部 7800 2021
5. 字符串包含筛选:
姓名中包含'三'的员工:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25 技术部 8500 2020
6. 复杂条件组合:
月薪>8000, 年龄<35, 且是技术部或市场部:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25 技术部 8500 2020
1 102 李四 30 市场部 9200 2019
2 103 王五 35 技术部 11000 2018
4 105 钱七 32 市场部 9500 2019
第四章：数据清洗与处理
4.1 处理缺失值（创建含缺失值的数据）
print("=== 4.1 处理缺失值 ===")
# 创建含有缺失值的数据
data_with_nan = {
'员工ID': [101, 102, 103, 104, 105],
'姓名': ['张三', '李四', None, '赵六', '钱七'],
'年龄': [25, 30, None, 28, 32],
'部门': ['技术部', '市场部', '技术部', None, '市场部'],
'月薪': [8500, 9200, 11000, 7800, None],
'入职年份': [2020, 2019, 2018, 2021, 2019]
}
df_nan = pd.DataFrame(data_with_nan)
print("原始数据（包含缺失值）:")
print(df_nan)
print()
print("1. 检查缺失值:")
print(df_nan.isnull())
print()
print("2. 每列缺失值数量:")
print(df_nan.isnull().sum())
print()
print("3. 删除包含缺失值的行（默认删除任何包含NaN的行）:")
df_dropped = df_nan.dropna()
print(df_dropped)
print()
print("4. 删除所有值都为NaN的行:")
df_dropped_all = df_nan.dropna(how='all')
print(df_dropped_all)
print()
print("5. 填充缺失值:")
print("用固定值填充:")
df_filled_const = df_nan.fillna('未知')
print(df_filled_const)
print()
print("用每列的平均值填充:")
df_filled_mean = df_nan.copy()
df_filled_mean['年龄'] = df_filled_mean['年龄'].fillna(df_filled_mean['年龄'].mean())
df_filled_mean['月薪'] = df_filled_mean['月薪'].fillna(df_filled_mean['月薪'].mean())
print(df_filled_mean)
print()
print("向前填充（用上一行的值填充）:")
df_ffill = df_nan.fillna(method='ffill')
print(df_ffill)
完整输出（部分关键输出）：
=== 4.1 处理缺失值 ===
原始数据（包含缺失值）:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25.0 技术部 8500.0 2020
1 102 李四 30.0 市场部 9200.0 2019
2 103 None NaN 技术部 11000.0 2018
3 104 赵六 28.0 None 7800.0 2021
4 105 钱七 32.0 市场部 NaN 2019
每列缺失值数量:
员工ID 0
姓名 1
年龄 1
部门 1
月薪 1
入职年份 0
dtype: int64
删除包含缺失值的行（默认删除任何包含NaN的行）:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25.0 技术部 8500.0 2020
1 102 李四 30.0 市场部 9200.0 2019
用每列的平均值填充:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25.0 技术部 8500.0 2020
1 102 李四 30.0 市场部 9200.0 2019
2 103 None 28.75 技术部 11000.0 2018
3 104 赵六 28.0 未知 7800.0 2021
4 105 钱七 32.0 市场部 9125.0 2019
4.2 处理重复值
print("=== 4.2 处理重复值 ===")
# 创建含有重复值的数据
data_dup = {
'员工ID': [101, 102, 103, 101, 104, 102],
'姓名': ['张三', '李四', '王五', '张三', '赵六', '李四'],
'部门': ['技术部', '市场部', '技术部', '技术部', '人事部', '市场部'],
'月薪': [8500, 9200, 11000, 8500, 7800, 9200]
}
df_dup = pd.DataFrame(data_dup)
print("原始数据（包含重复值）:")
print(df_dup)
print()
print("1. 检查重复行（完全相同的行）:")
print(f"重复行数量: {df_dup.duplicated().sum()}")
print()
print("2. 查看重复行:")
duplicates = df_dup[df_dup.duplicated()]
print(duplicates)
print()
print("3. 删除所有重复行:")
df_no_dup = df_dup.drop_duplicates()
print(df_no_dup)
print()
print("4. 基于特定列检查重复（如员工ID）:")
print(f"重复的员工ID数量: {df_dup['员工ID'].duplicated().sum()}")
print()
print("5. 删除基于员工ID的重复行（保留第一个）:")
df_unique_id = df_dup.drop_duplicates(subset=['员工ID'])
print(df_unique_id)
完整输出：
=== 4.2 处理重复值 ===
原始数据（包含重复值）:
员工ID 姓名 部门 月薪
0 101 张三 技术部 8500
1 102 李四 市场部 9200
2 103 王五 技术部 11000
3 101 张三 技术部 8500
4 104 赵六 人事部 7800
5 102 李四 市场部 9200
1. 检查重复行（完全相同的行）:
重复行数量: 2
2. 查看重复行:
员工ID 姓名 部门 月薪
3 101 张三 技术部 8500
5 102 李四 市场部 9200
3. 删除所有重复行:
员工ID 姓名 部门 月薪
0 101 张三 技术部 8500
1 102 李四 市场部 9200
2 103 王五 技术部 11000
4 104 赵六 人事部 7800
5. 删除基于员工ID的重复行（保留第一个）:
员工ID 姓名 部门 月薪
0 101 张三 技术部 8500
1 102 李四 市场部 9200
2 103 王五 技术部 11000
4 104 赵六 人事部 7800
4.3 数据类型转换
print("=== 4.3 数据类型转换 ===")
# 创建混合类型数据
data_types = {
'字符串数字': ['100', '200', '300'],
'布尔字符串': ['True', 'False', 'True'],
'日期字符串': ['2023-01-01', '2023-02-01', '2023-03-01'],
'带逗号的数字': ['1,000', '2,500', '3,750.50']
}
df_types = pd.DataFrame(data_types)
print("原始数据:")
print(df_types)
print(f"原始数据类型:\n{df_types.dtypes}")
print()
print("1. 字符串转整数:")
df_types['字符串数字'] = df_types['字符串数字'].astype('int')
print(df_types['字符串数字'])
print()
print("2. 字符串转浮点数:")
df_types['字符串数字_float'] = df_types['字符串数字'].astype('float')
print(df_types[['字符串数字', '字符串数字_float']])
print()
print("3. 字符串转布尔:")
df_types['布尔值'] = df_types['布尔字符串'].map({'True': True, 'False': False})
print(df_types[['布尔字符串', '布尔值']])
print()
print("4. 字符串转日期:")
df_types['日期'] = pd.to_datetime(df_types['日期字符串'])
print(df_types[['日期字符串', '日期']])
print()
print("5. 处理带逗号的数字字符串:")
df_types['清洗后数字'] = df_types['带逗号的数字'].str.replace(',', '').astype('float')
print(df_types[['带逗号的数字', '清洗后数字']])
print()
print("最终数据类型:")
print(df_types.dtypes)
完整输出（部分）：
=== 4.3 数据类型转换 ===
原始数据:
字符串数字 布尔字符串 日期字符串 带逗号的数字
0 100 True 2023-01-01 1,000
1 200 False 2023-02-01 2,500
2 300 True 2023-03-01 3,750.50
原始数据类型:
字符串数字 object
布尔字符串 object
日期字符串 object
带逗号的数字 object
dtype: object
1. 字符串转整数:
0 100
1 200
2 300
Name: 字符串数字, dtype: int64
最终数据类型:
字符串数字 int64
布尔字符串 object
日期字符串 object
带逗号的数字 object
字符串数字_float float64
布尔值 bool
日期 datetime64[ns]
清洗后数字 float64
dtype: object
4.4 使用apply和lambda表达式进行数据转化
假设我们有以下数据：
import pandas as pd
# 示例数据：每个人的上级/父级名称
mapped_df = pd.DataFrame({
'Name': ['张三', '李四', '王五', '赵六'],
'Parent.Name': ['经理A', '经理B', '经理A', '总监C']
})
print("原始数据:")
print(mapped_df)
输出：
Name Parent.Name
0 张三 经理A
1 李四 经理B
2 王五 经理A
3 赵六 总监C
定义映射字典
# 父级名称到ID的映射关系
parent_id_map = {
'经理A': 'P001',
'经理B': 'P002',
'总监C': 'P003',
# 注意：这里没有 总监D
}
print("\n映射字典:", parent_id_map)
执行映射
# 创建ParentId列
mapped_df['ParentId'] = mapped_df['Parent.Name'].apply(lambda x: parent_id_map.get(x, ''))
print("\n映射后的数据:")
print(mapped_df)
输出：
Name Parent.Name ParentId
0 张三 经理A P001
1 李四 经理B P002
2 王五 经理A P001
3 赵六 总监C P003
第五章：数据分析与计算
5.1 基本统计计算
print("=== 5.1 基本统计计算 ===")
# 使用原始df数据
print("原始数据:")
print(df)
print()
print("1. 单列统计:")
print(f"月薪总和: {df['月薪'].sum()}")
print(f"平均年龄: {df['年龄'].mean():.2f}")
print(f"月薪最大值: {df['月薪'].max()}")
print(f"月薪最小值: {df['月薪'].min()}")
print(f"月薪中位数: {df['月薪'].median()}")
print(f"月薪标准差: {df['月薪'].std():.2f}")
print(f"月薪方差: {df['月薪'].var():.2f}")
print()
print("2. 多列统计:")
print("各数值列的总和:")
print(df[['年龄', '月薪', '入职年份']].sum())
print()
print("3. 累计计算:")
df['月薪累计'] = df['月薪'].cumsum()
df['年龄累计平均'] = df['年龄'].expanding().mean()
print(df[['姓名', '月薪', '月薪累计', '年龄', '年龄累计平均']])
完整输出：
=== 5.1 基本统计计算 ===
原始数据:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25 技术部 8500 2020
1 102 李四 30 市场部 9200 2019
2 103 王五 35 技术部 11000 2018
3 104 赵六 28 人事部 7800 2021
4 105 钱七 32 市场部 9500 2019
1. 单列统计:
月薪总和: 46000
平均年龄: 30.00
月薪最大值: 11000
月薪最小值: 7800
月薪中位数: 9200
月薪标准差: 1253.00
月薪方差: 1570000.00
3. 累计计算:
姓名 月薪 月薪累计 年龄 年龄累计平均
0 张三 8500 8500 25 25.000000
1 李四 9200 17700 30 27.500000
2 王五 11000 28700 35 30.000000
3 赵六 7800 36500 28 29.500000
4 钱七 9500 46000 32 30.000000
5.2 分组聚合（强大功能）
print("=== 5.2 分组聚合操作 ===")
print("原始数据:")
print(df)
print()
print("1. 按部门分组，计算平均月薪:")
dept_avg_salary = df.groupby('部门')['月薪'].mean()
print(dept_avg_salary)
print()
print("2. 按部门分组，多个统计指标:")
dept_stats = df.groupby('部门').agg({
'月薪': ['mean', 'min', 'max', 'sum', 'count'],
'年龄': ['mean', 'min', 'max'],
'员工ID': 'count'
})
print(dept_stats)
print()
print("3. 按部门和入职年份分组:")
dept_year_stats = df.groupby(['部门', '入职年份']).agg({
'月薪': 'mean',
'年龄': 'mean',
'员工ID': 'count'
}).rename(columns={'员工ID': '人数'})
print(dept_year_stats)
print()
print("4. 分组后重置索引（转换为普通DataFrame）:")
dept_stats_reset = df.groupby('部门')['月薪'].mean().reset_index()
print(dept_stats_reset)
print()
print("5. 按部门分组，显示每个部门所有员工:")
for dept, group in df.groupby('部门'):
print(f"\n部门: {dept}")
print(group[['姓名', '年龄', '月薪']])
完整输出：
=== 5.2 分组聚合操作 ===
原始数据:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25 技术部 8500 2020
1 102 李四 30 市场部 9200 2019
2 103 王五 35 技术部 11000 2018
3 104 赵六 28 人事部 7800 2021
4 105 钱七 32 市场部 9500 2019
1. 按部门分组，计算平均月薪:
部门
人事部 7800.0
市场部 9350.0
技术部 9750.0
Name: 月薪, dtype: float64
2. 按部门分组，多个统计指标:
月薪 年龄 员工ID
mean min max sum count mean min max count
部门
人事部 7800.0 7800 7800 7800 1 28.0 28 28 1
市场部 9350.0 9200 9500 18700 2 31.0 30 32 2
技术部 9750.0 8500 11000 19500 2 30.0 25 35 2
3. 按部门和入职年份分组:
月薪 年龄 人数
部门 入职年份
人事部 2021 7800.0 28.0 1
市场部 2019 9350.0 31.0 2
技术部 2018 11000.0 35.0 1
2020 8500.0 25.0 1
4. 分组后重置索引（转换为普通DataFrame）:
部门 月薪
0 人事部 7800.0
1 市场部 9350.0
2 技术部 9750.0
5.3 排序与排名
print("=== 5.3 排序与排名 ===")
print("原始数据:")
print(df)
print()
print("1. 按单列排序（默认升序）:")
sorted_by_age = df.sort_values('年龄')
print(sorted_by_age)
print()
print("2. 按单列降序排序:")
sorted_by_salary_desc = df.sort_values('月薪', ascending=False)
print(sorted_by_salary_desc)
print()
print("3. 按多列排序:")
sorted_multi = df.sort_values(['部门', '月薪'], ascending=[True, False])
print(sorted_multi)
print()
print("4. 添加排名:")
df['月薪排名'] = df['月薪'].rank(ascending=False, method='dense').astype(int)
df['年龄排名'] = df['年龄'].rank(ascending=True, method='min').astype(int)
print(df.sort_values('月薪排名'))
print()
print("5. 按索引排序:")
df_sorted_index = df.sort_index(ascending=False)
print(df_sorted_index)
完整输出：
=== 5.3 排序与排名 ===
原始数据:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25 技术部 8500 2020
1 102 李四 30 市场部 9200 2019
2 103 王五 35 技术部 11000 2018
3 104 赵六 28 人事部 7800 2021
4 105 钱七 32 市场部 9500 2019
1. 按单列排序（默认升序）:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25 技术部 8500 2020
3 104 赵六 28 人事部 7800 2021
1 102 李四 30 市场部 9200 2019
4 105 钱七 32 市场部 9500 2019
2 103 王五 35 技术部 11000 2018
2. 按单列降序排序:
员工ID 姓名 年龄 部门 月薪 入职年份
2 103 王五 35 技术部 11000 2018
4 105 钱七 32 市场部 9500 2019
1 102 李四 30 市场部 9200 2019
0 101 张三 25 技术部 8500 2020
3 104 赵六 28 人事部 7800 2021
4. 添加排名:
员工ID 姓名 年龄 部门 月薪 入职年份 月薪排名 年龄排名
2 103 王五 35 技术部 11000 2018 1 5
4 105 钱七 32 市场部 9500 2019 2 4
1 102 李四 30 市场部 9200 2019 3 3
0 101 张三 25 技术部 8500 2020 4 1
3 104 赵六 28 人事部 7800 2021 5 2
第六章：数据输入输出
6.1 读写文件
print("=== 6.1 读写文件 ===")
# 先保存示例数据到文件
print("1. 保存到CSV文件:")
df.to_csv('employees.csv', index=False, encoding='utf-8-sig')
print("已保存到 employees.csv")
print()
print("2. 从CSV文件读取:")
df_from_csv = pd.read_csv('employees.csv')
print(df_from_csv)
print()
print("3. 保存到Excel文件:")
df.to_excel('employees.xlsx', sheet_name='员工数据', index=False)
print("已保存到 employees.xlsx")
print()
print("4. 从Excel文件读取:")
df_from_excel = pd.read_excel('employees.xlsx', sheet_name='员工数据')
print(df_from_excel)
print()
print("5. 保存到JSON文件:")
df.to_json('employees.json', orient='records', force_ascii=False)
print("已保存到 employees.json")
print()
print("6. 从JSON文件读取:")
df_from_json = pd.read_json('employees.json')
print(df_from_json)
完整输出：
=== 6.1 读写文件 ===
1. 保存到CSV文件:
已保存到 employees.csv
2. 从CSV文件读取:
员工ID 姓名 年龄 部门 月薪 入职年份
0 101 张三 25 技术部 8500 2020
1 102 李四 30 市场部 9200 2019
2 103 王五 35 技术部 11000 2018
3 104 赵六 28 人事部 7800 2021
4 105 钱七 32 市场部 9500 2019
| 任务类别 | 常用方法 | 示例 |
|---|---|---|
| 数据查看 | head(), tail(), info(), describe() | df.head(5) |
| 数据选择 | loc[], iloc[], 条件筛选 | df.loc[0, '姓名'] |
| 数据筛选 | 布尔索引, isin(), between() | df[df['月薪'] > 9000] |
| 数据清洗 | dropna(), fillna(), drop_duplicates() | df.dropna() |
| 数据类型 | astype(), to_datetime() | df['年龄'].astype('float') |
| 数据排序 | sort_values(), sort_index() | df.sort_values('月薪', ascending=False) |
| 分组聚合 | groupby(), agg() | df.groupby('部门')['月薪'].mean() |
| 统计计算 | mean(), sum(), min(), max() | df['月薪'].mean() |
| 数据转换 | apply(), map(), str方法 | df['姓名'].str.upper() |
| 文件读写 | to_csv(), read_csv(), to_excel() | pd.read_csv('data.csv') |
总结
- 生成csv还是用pandas比较好
