Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据。可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征。
参考 pandas教程

Pandas 简介

Pandas 是数据分析的利器，它不仅提供了高效、灵活的数据结构，还能帮助你以极低的成本完成复杂的数据操作和分析任务。

Pandas 提供了丰富的功能，包括：

• 数据清洗：处理缺失数据、重复数据等。
• 数据转换：改变数据的形状、结构或格式。
• 数据分析：进行统计分析、聚合、分组等。
• 数据可视化：通过整合 Matplotlib 和 Seaborn 等库，可以进行数据可视化。

数据结构

Pandas 的主要数据结构是 Series （一维数据）与 DataFrame（二维数据）。

• Series 是一种类似于一维数组的对象，它由一组数据（各种 Numpy 数据类型）以及一组与之相关的数据标签（即索引）组成。

• DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。

安装Pandas

使用 pip 安装 pandas:

pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple/

安装成功后，我们就可以导入 pandas 包使用，导入 pandas 一般使用别名 pd 来代替：import pandas as pd

一个简单的Pandas示例

以下实例创建一个简单的 DataFrame：

# 导入 pandas 库，指定别名 pd
import pandas as pd

# 创建一个简单的 DataFrame
data = {'Name': ['Google', 'Runoob', 'Taobao'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)

# 查看 DataFrame
print(df)

以上示例输出为：

     Name  Age
0  Google   25
1  Runoob   30
2  Taobao   35

Pandas Series

Series 是 Pandas 中的一个核心数据结构，类似于一个一维的数组，具有数据和索引。

Series 可以存储任何数据类型（整数、浮点数、字符串等），并通过标签（索引）来访问元素。

Series 特点

• 一维数组：Series 中的每个元素都有一个对应的索引值。

• 索引： 每个数据元素都可以通过标签（索引）来访问，默认情况下索引是从 0 开始的整数，但你也可以自定义索引。

• 数据类型： Series 可以容纳不同数据类型的元素，包括整数、浮点数、字符串、Python 对象等。

• 大小不变性：Series 的大小在创建后是不变的，但可以通过某些操作（如 append 或 delete）来改变。

• 操作：Series 支持各种操作，如数学运算、统计分析、字符串处理等。

• 缺失数据：Series 可以包含缺失数据，Pandas 使用NaN（Not a Number）来表示缺失或无值。

• 自动对齐：当对多个 Series 进行运算时，Pandas 会自动根据索引对齐数据，这使得数据处理更加高效。

我们可以使用 Pandas 库来创建一个 Series 对象，并且可以为其指定索引（Index）、名称（Name）以及值（Values）：

实例：

import pandas as pd

# 创建一个Series对象，指定名称为'A'，值分别为1, 2, 3, 4
# 默认索引为0, 1, 2, 3
series = pd.Series([1, 2, 3, 4], name='A')

# 显示Series对象
print(series)

# 如果你想要显式地设置索引，可以这样做：
custom_index = [1, 2, 3, 4]  # 自定义索引
series_with_index = pd.Series([1, 2, 3, 4], index=custom_index, name='A')

# 显示带有自定义索引的Series对象
print(series_with_index)

创建 Series

使用 pd.Series() 构造函数创建一个 Series 对象，传递一个数据数组（可以是列表、NumPy 数组等）和一个可选的索引数组

pandas.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)

参数说明：

• data：Series 的数据部分，可以是列表、数组、字典、标量值等。如果不提供此参数，则创建一个空的 Series。
• index：Series 的索引部分，用于对数据进行标记。可以是列表、数组、索引对象等。如果不提供此参数，则创建一个默认的整数索引。
• dtype：指定 Series 的数据类型。可以是 NumPy 的数据类型，例如 np.int64、np.float64 等。如果不提供此参数，则根据数据自动推断数据类型。
• name：Series 的名称，用于标识 Series 对象。如果提供了此参数，则创建的 Series 对象将具有指定的名称。
• copy：是否复制数据。默认为 False，表示不复制数据。如果设置为 True，则复制输入的数据。
• fastpath：是否启用快速路径。默认为 False。启用快速路径可能会在某些情况下提高性能。

创建一个简单的 Series 实例：

import pandas as pd

a = [1, 2, 3]

myvar = pd.Series(a)

print(myvar)

索引    数据
↓       ↓
0       1
1       2
2       3
dtype: int64    ← 数据类型

从上图可知，如果没有指定索引，索引值就从 0 开始，我们可以根据索引值读取数据：print(myvar[1])

指定索引值

我们可以指定索引值，如下实例：

import pandas as pd

a = ["Google", "Runoob", "Wiki"]

myvar = pd.Series(a, index = ["x", "y", "z"])

print(myvar)

输出结果如下

x    Google
y    Runoob
z      Wiki
dtype: object

根据索引值读取数据: print(myvar["y"])

使用 key/value

我们也可以使用 key/value 对象，类似字典来创建 Series：

import pandas as pd

sites = {1: "Google", 2: "Runoob", 3: "Wiki"}

myvar = pd.Series(sites)

print(myvar)

输出结果如下，字典的 key 变成了索引值：

1    Google
2    Runoob
3      Wiki
dtype: object

如果我们只需要字典中的一部分数据，只需要指定需要数据的索引即可，如下实例：

import pandas as pd

sites = {1: "Google", 2: "Runoob", 3: "Wiki"}

myvar = pd.Series(sites, index = [1, 2])

print(myvar)

输出结果如下：

1    Google
2    Runoob
dtype: object

设置 Series 名称参数

import pandas as pd

sites = {1: "Google", 2: "Runoob", 3: "Wiki"}

myvar = pd.Series(sites, index = [1, 2], name="RUNOOB-Series-TEST" )

print(myvar)

Series 方法

下面是 Series 中一些常用的方法：

方法名称	功能描述
index	获取 Series 的索引
values	获取 Series 的数据部分（返回 NumPy 数组）
head(n)	返回 Series 的前 n 行（默认为 5）
tail(n)	返回 Series 的后 n 行（默认为 5）
dtype	返回 Series 中数据的类型
shape	返回 Series 的形状（行数）
describe()	返回 Series 的统计描述（如均值、标准差、最小值等）
isnull()	返回一个布尔 Series，表示每个元素是否为 NaN
notnull()	返回一个布尔 Series，表示每个元素是否不是 NaN
unique()	返回 Series 中的唯一值（去重）
value_counts()	返回 Series 中每个唯一值的出现次数
map(func)	将指定函数应用于 Series 中的每个元素
apply(func)	将指定函数应用于 Series 中的每个元素，常用于自定义操作
astype(dtype)	将 Series 转换为指定的类型
sort_values()	对 Series 中的元素进行排序（按值排序）
sort_index()	对 Series 的索引进行排序
dropna()	删除 Series 中的缺失值（NaN）
fillna(value)	填充 Series 中的缺失值（NaN）
replace(to_replace, value)	替换 Series 中指定的值
cumsum()	返回 Series 的累计求和
cumprod()	返回 Series 的累计乘积
shift(periods)	将 Series 中的元素按指定的步数进行位移
rank()	返回 Series 中元素的排名
corr(other)	计算 Series 与另一个 Series 的相关性（皮尔逊相关系数）
cov(other)	计算 Series 与另一个 Series 的协方差
to_list()	将 Series 转换为 Python 列表
to_frame()	将 Series 转换为 DataFrame
iloc[]	通过位置索引来选择数据
loc[]	通过标签索引来选择数据

示例：

import pandas as pd

# 创建 Series
data = [1, 2, 3, 4, 5, 6]
index = ['a', 'b', 'c', 'd', 'e', 'f']
s = pd.Series(data, index=index)

# 查看基本信息
print("索引：", s.index)
print("数据：", s.values)
print("数据类型：", s.dtype)
print("前两行数据：", s.head(2))

# 使用 map 函数将每个元素加倍
s_doubled = s.map(lambda x: x * 2)
print("元素加倍后：", s_doubled)

# 计算累计和
cumsum_s = s.cumsum()
print("累计求和：", cumsum_s)

# 查找缺失值（这里没有缺失值，所以返回的全是 False）
print("缺失值判断：", s.isnull())

# 排序
sorted_s = s.sort_values()
print("排序后的 Series：", sorted_s)

输出结果：

索引： Index(['a', 'b', 'c', 'd', 'e', 'f'], dtype='object')
数据： [1 2 3 4 5 6]
数据类型： int64
前两行数据： a    1
b    2
dtype: int64
元素加倍后： a     2
b     4
c     6
d     8
e    10
f    12
dtype: int64
累计求和： a     1
b     3
c     6
d    10
e    15
f    21
dtype: int64
缺失值判断： a    False
b    False
c    False
d    False
e    False
f    False
dtype: bool
排序后的 Series： a    1
b    2
c    3
d    4
e    5
f    6
dtype: int64

更多 Series 说明

使用列表、字典或数组创建一个默认索引的 Series。

# 使用列表创建 Series
s = pd.Series([1, 2, 3, 4])

# 使用 NumPy 数组创建 Series
s = pd.Series(np.array([1, 2, 3, 4]))

# 使用字典创建 Series
s = pd.Series({'a': 1, 'b': 2, 'c': 3, 'd': 4})

基本操作

# 指定索引创建 Series
s = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])

# 获取值
value = s[2]  # 获取索引为2的值
print(s['a'])  # 返回索引标签 'a' 对应的元素

# 获取多个值
subset = s[1:4]  # 获取索引为1到3的值

# 使用自定义索引
value = s['b']  # 获取索引为'b'的值

# 索引和值的对应关系
for index, value in s.items():
    print(f"Index: {index}, Value: {value}")


# 使用切片语法来访问 Series 的一部分
print(s['a':'c'])  # 返回索引标签 'a' 到 'c' 之间的元素
print(s[:3])  # 返回前三个元素

# 为特定的索引标签赋值
s['a'] = 10  # 将索引标签 'a' 对应的元素修改为 10

# 通过赋值给新的索引标签来添加元素
s['e'] = 5  # 在 Series 中添加一个新的元素，索引标签为 'e'

# 使用 del 删除指定索引标签的元素。
del s['a']  # 删除索引标签 'a' 对应的元素

# 使用 drop 方法删除一个或多个索引标签，并返回一个新的 Series。
s_dropped = s.drop(['b'])  # 返回一个删除了索引标签 'b' 的新 Series

基本运算

# 算术运算
result = series * 2  # 所有元素乘以2

# 过滤
filtered_series = series[series > 2]  # 选择大于2的元素

# 数学函数
import numpy as np
result = np.sqrt(series)  # 对每个元素取平方根

计算统计数据

使用 Series 的方法来计算描述性统计。

print(s.sum())  # 输出 Series 的总和
print(s.mean())  # 输出 Series 的平均值
print(s.max())  # 输出 Series 的最大值
print(s.min())  # 输出 Series 的最小值
print(s.std())  # 输出 Series 的标准差

属性和方法

# 获取索引
index = s.index

# 获取值数组
values = s.values

# 获取描述统计信息
stats = s.describe()

# 获取最大值和最小值的索引
max_index = s.idxmax()
min_index = s.idxmin()

# 其他属性和方法
print(s.dtype)   # 数据类型
print(s.shape)   # 形状
print(s.size)    # 元素个数
print(s.head())  # 前几个元素，默认是前 5 个
print(s.tail())  # 后几个元素，默认是后 5 个
print(s.sum())   # 求和
print(s.mean())  # 平均值
print(s.std())   # 标准差
print(s.min())   # 最小值
print(s.max())   # 最大值

使用布尔表达式

根据条件过滤 Series。

print(s > 2)  # 返回一个布尔 Series，其中的元素值大于 2

查看数据类型

使用 dtype 属性查看 Series 的数据类型。

print(s.dtype)  # 输出 Series 的数据类型

转换数据类型

使用 astype 方法将 Series 转换为另一种数据类型。

s = s.astype('float64')  # 将 Series 中的所有元素转换为 float64 类型

注意事项

• Series 中的数据是有序的。
• 可以将 Series 视为带有索引的一维数组。
• 索引可以是唯一的，但不是必须的。
• 数据可以是标量、列表、NumPy 数组等。

Pandas DataFrame

DataFrame 是 Pandas 中的另一个核心数据结构，类似于一个二维的表格或数据库中的数据表。

DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。

DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。

DataFrame 提供了各种功能来进行数据访问、筛选、分割、合并、重塑、聚合以及转换等操作。

DataFrame 特点

DataFrame 数据类型一个表格，包含 rows（行） 和 columns（列），DataFrame 具有特点：

• 二维结构： DataFrame 是一个二维表格，可以被看作是一个 Excel 电子表格或 SQL 表，具有行和列。可以将其视为多个 Series 对象组成的字典。

• 列的数据类型： 不同的列可以包含不同的数据类型，例如整数、浮点数、字符串或 Python 对象等。

• 索引：DataFrame 可以拥有行索引和列索引，类似于 Excel 中的行号和列标。

• 大小可变：可以添加和删除列，类似于 Python 中的字典。

• 自动对齐：在进行算术运算或数据对齐操作时，DataFrame 会自动对齐索引。

• 处理缺失数据：DataFrame 可以包含缺失数据，Pandas 使用 NaN（Not a Number）来表示。

• 数据操作：支持数据切片、索引、子集分割等操作。

• 时间序列支持：DataFrame 对时间序列数据有特别的支持，可以轻松地进行时间数据的切片、索引和操作。

• 丰富的数据访问功能：通过 .loc、.iloc 和 .query() 方法，可以灵活地访问和筛选数据。

• 灵活的数据处理功能：包括数据合并、重塑、透视、分组和聚合等。

• 数据可视化：虽然 DataFrame 本身不是可视化工具，但它可以与 Matplotlib 或 Seaborn 等可视化库结合使用，进行数据可视化。

• 高效的数据输入输出：可以方便地读取和写入数据，支持多种格式，如 CSV、Excel、SQL 数据库和 HDF5 格式。

• 描述性统计：提供了一系列方法来计算描述性统计数据，如 .describe()、.mean()、.sum() 等。

• 灵活的数据对齐和集成：可以轻松地与其他 DataFrame 或 Series 对象进行合并、连接或更新操作。

• 转换功能：可以对数据集中的值进行转换，例如使用 .apply() 方法应用自定义函数。

• 滚动窗口和时间序列分析：支持对数据集进行滚动窗口统计和时间序列分析。

创建 DataFrame

DataFrame 构造方法如下：

pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)

参数说明：

• data：DataFrame 的数据部分，可以是字典、二维数组、Series、DataFrame 或其他可转换为 DataFrame 的对象。如果不提供此参数，则创建一个空的 DataFrame。
• index：DataFrame 的行索引，用于标识每行数据。可以是列表、数组、索引对象等。如果不提供此参数，则创建一个默认的整数索引。
• columns：DataFrame 的列索引，用于标识每列数据。可以是列表、数组、索引对象等。如果不提供此参数，则创建一个默认的整数索引。
• dtype：指定 DataFrame 的数据类型。可以是 NumPy 的数据类型，例如 np.int64、np.float64 等。如果不提供此参数，则根据数据自动推断数据类型。
• copy：是否复制数据。默认为 False，表示不复制数据。如果设置为 True，则复制输入的数据。

Pandas DataFrame 是一个二维的数组结构，类似二维数组。

以下示例创建一个 Pandas DataFrame

# 使用列表创建
import pandas as pd

data = [['Google', 10], ['Runoob', 12], ['Wiki', 13]]

# 创建DataFrame
df = pd.DataFrame(data, columns=['Site', 'Age'])

# 使用astype方法设置每列的数据类型
df['Site'] = df['Site'].astype(str)
df['Age'] = df['Age'].astype(float)

print(df)

# 使用字典创建
import pandas as pd

data = {'Site':['Google', 'Runoob', 'Wiki'], 'Age':[10, 12, 13]}

df = pd.DataFrame(data)

print (df)

输出结果如下：

     Site  Age
0  Google   10
1  Runoob   12
2    Wiki   13

还可以使用字典（key/value），其中字典的 key 为列名:

import pandas as pd

data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]

df = pd.DataFrame(data)

print (df)

输出结果如下：

   a   b     c
0  1   2   NaN
1  5  10  20.0

没有对应的部分数据为 NaN。

Pandas 可以使用 loc 属性返回指定行的数据，如果没有设置索引，第一行索引为 0，第二行索引为 1，以此类推：

import pandas as pd

data = {
  "calories": [420, 380, 390],
  "duration": [50, 40, 45]
}

# 数据载入到 DataFrame 对象
df = pd.DataFrame(data)

# 返回第一行
print(df.loc[0])
# 返回第二行
print(df.loc[1])

输出结果如下：

calories    420
duration     50
Name: 0, dtype: int64
calories    380
duration     40
Name: 1, dtype: int64

注意：返回结果其实就是一个 Pandas Series 数据。

也可以返回多行数据，使用 [[ … ]] 格式，… 为各行的索引，以逗号隔开：

import pandas as pd

data = {
  "calories": [420, 380, 390],
  "duration": [50, 40, 45]
}

# 数据载入到 DataFrame 对象
df = pd.DataFrame(data)

# 返回第一行和第二行
print(df.loc[[0, 1]])

输出结果为：

   calories  duration
0       420        50
1       380        40

注意：返回结果其实就是一个 Pandas DataFrame 数据。

我们可以指定索引值，如下实例：

import pandas as pd

data = {
  "calories": [420, 380, 390],
  "duration": [50, 40, 45]
}

df = pd.DataFrame(data, index = ["day1", "day2", "day3"])

print(df)

输出结果为：

      calories  duration
day1       420        50
day2       380        40
day3       390        45

Pandas 可以使用 loc 属性返回指定索引对应到某一行：

import pandas as pd

data = {
  "calories": [420, 380, 390],
  "duration": [50, 40, 45]
}

df = pd.DataFrame(data, index = ["day1", "day2", "day3"])

# 指定索引
print(df.loc["day2"])

输出结果为：

calories    380
duration     40
Name: day2, dtype: int64

DataFrame 方法

DataFrame 的常用操作和方法如下表所示：

方法名称	功能描述
head(n)	返回 DataFrame 的前 n 行数据（默认前 5 行）
tail(n)	返回 DataFrame 的后 n 行数据（默认后 5 行）
info()	显示 DataFrame 的简要信息，包括列名、数据类型、非空值数量等
describe()	返回 DataFrame 数值列的统计信息，如均值、标准差、最小值等
shape	返回 DataFrame 的行数和列数（行数, 列数）
columns	返回 DataFrame 的所有列名
index	返回 DataFrame 的行索引
dtypes	返回每一列的数值数据类型
sort_values(by)	按照指定列排序
sort_index()	按行索引排序
dropna()	删除含有缺失值（NaN）的行或列
fillna(value)	用指定的值填充缺失值
isnull()	判断缺失值，返回一个布尔值 DataFrame
notnull()	判断非缺失值，返回一个布尔值 DataFrame
loc[]	按标签索引选择数据
iloc[]	按位置索引选择数据
at[]	访问 DataFrame 中单个元素（比 loc[] 更高效）
iat[]	访问 DataFrame 中单个元素（比 iloc[] 更高效）
apply(func)	对 DataFrame 或 Series 应用一个函数
applymap(func)	对 DataFrame 的每个元素应用函数（仅对 DataFrame）
groupby(by)	分组操作，用于按某一列分组进行汇总统计
pivot_table()	创建透视表
merge()	合并多个 DataFrame（类似 SQL 的 JOIN 操作）
concat()	按行或按列连接多个 DataFrame
to_csv()	将 DataFrame 导出为 CSV 文件
to_excel()	将 DataFrame 导出为 Excel 文件
to_json()	将 DataFrame 导出为 JSON 格式
to_sql()	将 DataFrame 导出为 SQL 数据库
query()	使用 SQL 风格的语法查询 DataFrame
duplicated()	返回布尔值 DataFrame，指示每行是否是重复的
drop_duplicates()	删除重复的行
set_index()	设置 DataFrame 的索引
reset_index()	重置 DataFrame 的索引
transpose()	转置 DataFrame（行列交换）

示例

import pandas as pd

# 创建 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie', 'David'],
    'Age': [25, 30, 35, 40],
    'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']
}
df = pd.DataFrame(data)

# 查看前两行数据
print(df.head(2))

# 查看 DataFrame 的基本信息
print(df.info())

# 获取描述统计信息
print(df.describe())

# 按年龄排序
df_sorted = df.sort_values(by='Age', ascending=False)
print(df_sorted)

# 选择指定列
print(df[['Name', 'Age']])

# 按索引选择行
print(df.iloc[1:3])  # 选择第二到第三行（按位置）

# 按标签选择行
print(df.loc[1:2])  # 选择第二到第三行（按标签）

# 计算分组统计（按城市分组，计算平均年龄）
print(df.groupby('City')['Age'].mean())

# 处理缺失值（填充缺失值）
df['Age'] = df['Age'].fillna(30)

# 导出为 CSV 文件
df.to_csv('output.csv', index=False)

输出结果为：

# 查看前两行数据
     Name  Age         City
0   Alice   25     New York
1     Bob   30  Los Angeles

# 查看 DataFrame 的基本信息
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   Name    4 non-null      object 
 1   Age     4 non-null      int64  
 2   City    4 non-null      object 
dtypes: int64(1), object(2)
memory usage: 148.0+ bytes

# 获取描述统计信息
             Age
count   4.000000
mean   32.500000
std     6.454972
min    25.000000
25%    27.500000
50%    32.500000
75%    37.500000
max    40.000000

# 按年龄排序
      Name  Age         City
3    David   40     Houston
2  Charlie   35      Chicago
1      Bob   30  Los Angeles
0    Alice   25     New York

# 按标签选择行
      Name  Age         City
1     Bob   30  Los Angeles
2  Charlie   35      Chicago

# 计算分组统计（按城市分组，计算平均年龄）
City
Chicago        35.0
Houston        40.0
Los Angeles    30.0
New York       25.0
Name: Age, dtype: float64

更多 DataFrame 说明

创建 DataFrame

从字典创建：字典的键成为列名，值成为列数据。

import pandas as pd

# 通过字典创建 DataFrame
df = pd.DataFrame({'Column1': [1, 2, 3], 'Column2': [4, 5, 6]})

从列表的列表创建：外层列表代表行，内层列表代表列。

df = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
                  columns=['Column1', 'Column2', 'Column3'])

从 NumPy 数组创建：提供一个二维 NumPy 数组。

import numpy as np

# 通过 NumPy 数组创建 DataFrame
df = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))

从 Series 创建 DataFrame：通过 pd.Series() 创建。

# 从 Series 创建 DataFrame
s1 = pd.Series(['Alice', 'Bob', 'Charlie'])
s2 = pd.Series([25, 30, 35])
s3 = pd.Series(['New York', 'Los Angeles', 'Chicago'])
df = pd.DataFrame({'Name': s1, 'Age': s2, 'City': s3})

DataFrame 的属性和方法

DataFrame 对象有许多属性和方法，用于数据操作、索引和处理，例如：shape、columns、index、head()、tail()、info()、describe()、mean()、sum() 等。

# DataFrame 的属性和方法
print(df.shape)     # 形状
print(df.columns)   # 列名
print(df.index)     # 索引
print(df.head())    # 前几行数据，默认是前 5 行
print(df.tail())    # 后几行数据，默认是后 5 行
print(df.info())    # 数据信息
print(df.describe())# 描述统计信息
print(df.mean())    # 求平均值
print(df.sum())     # 求和

访问 DataFrame 元素

访问列：使用列名作为属性或通过 .loc[]、.iloc[] 访问，也可以使用标签或位置索引。

# 通过列名访问
print(df['Column1'])

# 通过属性访问
print(df.Name)     
   
# 通过 .loc[] 访问
print(df.loc[:, 'Column1'])

# 通过 .iloc[] 访问
print(df.iloc[:, 0])  # 假设 'Column1' 是第一列

# 访问单个元素
print(df['Name'][0])

访问行：使用行的标签和 .loc[] 访问。

# 通过行标签访问
print(df.loc[0, 'Column1'])

修改 DataFrame

修改列数据：直接对列进行赋值。

df['Column1'] = [10, 11, 12]

添加新列：给新列赋值。

df['NewColumn'] = [100, 200, 300]

添加新行：使用 loc、append 或 concat 方法。

# 使用 loc 为特定索引添加新行
df.loc[3] = [13, 14, 15, 16]

# 使用 append 添加新行到末尾
new_row = {'Column1': 13, 'Column2': 14, 'NewColumn': 16}
df = df.append(new_row, ignore_index=True)

注意：append() 方法在 pandas 版本 1.4.0 中已经被标记为弃用，并将在未来的版本中被移除，官方推荐使用 concat() 作为替代方法来进行数据的合并操作。

concat() 方法用于合并两个或多个 DataFrame，当你想要添加一行到另一个 DataFrame 时，可以将新行作为一个新的 DataFrame，然后使用 concat()：

# 使用concat添加新行
new_row = pd.DataFrame([[4, 7]], columns=['A', 'B'])  # 创建一个只包含新行的DataFrame
df = pd.concat([df, new_row], ignore_index=True)  # 将新行添加到原始DataFrame

print(df)

删除 DataFrame 元素

删除列：使用 drop 方法。

df_dropped = df.drop('Column1', axis=1)

删除行：同样使用 drop 方法。

df_dropped = df.drop(0)  # 删除索引为 0 的行

DataFrame 的统计分析

描述性统计：使用 .describe() 查看数值列的统计摘要。

df.describe()

计算统计数据：使用聚合函数如 .sum()、.mean()、.max() 等。

df['Column1'].sum()
df.mean()

DataFrame 的索引操作

重置索引：使用 .reset_index()。

df_reset = df.reset_index(drop=True)

设置索引：使用 .set_index()。

df_set = df.set_index('Column1')

DataFrame 的布尔索引

使用布尔表达式：根据条件过滤 DataFrame。

df[df['Column1'] > 2]

DataFrame 的数据类型

查看数据类型：使用 dtypes 属性。

df.dtypes

转换数据类型：使用 astype 方法。

df['Column1'] = df['Column1'].astype('float64')

DataFrame 的合并与分割

合并：使用 concat 或 merge 方法。

# 纵向合并
pd.concat([df1, df2], ignore_index=True)

# 横向合并
pd.merge(df1, df2, on='Column1')

分割：使用 pivot、melt 或自定义函数。

# 长格式转宽格式
df_pivot = df.pivot(index='Column1', columns='Column2', values='Column3')

# 宽格式转长格式
df_melt = df.melt(id_vars='Column1', value_vars=['Column2', 'Column3'])

索引和切片

DataFrame 支持对行和列进行索引和切片操作。

# 索引和切片
print(df[['Name', 'Age']])  # 提取多列
print(df[1:3])               # 切片行
print(df.loc[:, 'Name'])     # 提取单列
print(df.loc[1:2, ['Name', 'Age']])  # 标签索引提取指定行列
print(df.iloc[:, 1:])        # 位置索引提取指定列

Pandas CSV

CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）。

CSV 是一种通用的、相对简单的文件格式，被用户、商业和科学广泛应用。

Pandas 可以很方便的处理 CSV 文件，常用方法有：

方法名称	功能描述	常用参数
pd.read_csv()	从 CSV 文件读取数据并加载为 DataFrame	filepath_or_buffer (路径或文件对象)，sep (分隔符)，header (行标题)，names (自定义列名)，dtype (数据类型)，index_col (索引列)
DataFrame.to_csv()	将 DataFrame 写入到 CSV 文件	path_or_buffer (目标路径或文件对象)，sep (分隔符)，index (是否写入索引)，columns (指定列)，header (是否写入列名)，mode (写入模式)

本文以 nba.csv 为例，你可以下载 nba.csv 或打开 nba.csv 查看。

读取 CSV 文件

read_csv() 是从 CSV 文件中读取数据的主要方法，将数据加载为一个 DataFrame。

read_csv 常用参数:

参数	说明	默认值
filepath_or_buffer	CSV 文件的路径或文件对象（支持 URL、文件路径、文件对象等）	必需参数
sep	定义字段分隔符，默认是逗号（,），可以改为其他字符，如制表符（\t）	’,‘
header	指定行号作为列标题，默认为 0（表示第一行），或者设置为 None 没有标题	0
names	自定义列名，传入列名列表	None
index_col	用作行索引的列的列号或列名	None
usecols	读取指定的列，可以是列的名称或列的索引	None
dtype	强制将列转换为指定的数据类型	None
skiprows	跳过文件开头的指定行数，或者传入一个行号的列表	None
nrows	读取前 N 行数据	None
na_values	指定哪些值应视为缺失值（NaN）	None
skipfooter	跳过文件结尾的指定行数	0
encoding	文件的编码格式（如 utf-8，latin1 等）	None

读取 nba.csv 文件数据

import pandas as pd

df = pd.read_csv('nba.csv')

print(df.to_string())

print(df)

to_string() 用于返回 DataFrame 类型的数据，如果不使用该函数，则输出结果为数据的前面 5 行和末尾 5 行，中间部分以 … 代替。

写入 CSV 文件

to_csv() 是将 DataFrame 写入 CSV 文件的方法，支持自定义分隔符、列名、是否包含索引等设置。

to_csv 常用参数:

使用 to_csv() 方法将 DataFrame 存储为 csv 文件：

import pandas as pd 
   
# 三个字段 name, site, age
nme = ["Google", "Runoob", "Taobao", "Wiki"]
st = ["www.google.com", "www.runoob.com", "www.taobao.com", "www.wikipedia.org"]
ag = [90, 40, 80, 98]
   
# 字典
dict = {'name': nme, 'site': st, 'age': ag} 
     
df = pd.DataFrame(dict)
  
# 保存 dataframe
df.to_csv('site.csv')

数据处理

head()

head( n ) 方法用于读取前面的 n 行，如果不填参数 n ，默认返回 5 行。

import pandas as pd

df = pd.read_csv('nba.csv')

print(df.head())
print(df.head(3))

tail()

tail( n ) 方法用于读取尾部的 n 行，如果不填参数 n ，默认返回 5 行，空行各个字段的值返回 NaN。

import pandas as pd

df = pd.read_csv('nba.csv')

print(df.tail())
print(df.tail(3))

info()

info() 方法返回表格的一些基本信息：

import pandas as pd

df = pd.read_csv('nba.csv')

print(df.info())

输出结果为

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 458 entries, 0 to 457          # 行数，458 行，第一行编号为 0
Data columns (total 9 columns):            # 列数，9列
 #   Column    Non-Null Count  Dtype       # 各列的数据类型
---  ------    --------------  -----  
 0   Name      457 non-null    object 
 1   Team      457 non-null    object 
 2   Number    457 non-null    float64
 3   Position  457 non-null    object 
 4   Age       457 non-null    float64
 5   Height    457 non-null    object 
 6   Weight    457 non-null    float64
 7   College   373 non-null    object         # non-null，意思为非空的数据    
 8   Salary    446 non-null    float64
dtypes: float64(4), object(5)                 # 类型

non-null 为非空数据，我们可以看到上面的信息中，总共 458 行，College 字段的空值最多。