机器学习_Pandas

前言🔖

Pandas 是针对 Python 编程语言进行数据操作和数据分析的热门软件库。

Pandas 是基于 Python 构建的用于数据操作和数据分析的软件库。pandas 库提供各种数据结构，专门用于通过简化的 Python API 来处理表格数据集。pandas 是对 Python 的扩展，可用于处理和操作表格数据，从而高效对数据集执行加载、对齐、合并和转换等操作。

作为一个数据分析工具，pandas 之所以受到欢迎，主要得益于它的多功能性和高效的性能。“pandas”的名称源自术语“panel data”，用于描述包含多个时间段观察结果的数据集，强调其专注于处理现实世界数据集的多样化数据结构。

Pandas Python API 支持表格、矩阵和时间序列等结构化数据格式，提供各种工具来处理杂乱或原始数据集，将其整理为简明的结构化格式，以便进行分析。为提高性能，会在后端源代码中使用 C 或 Cython 来执行计算密集型操作。pandas 库本质上不支持多线程，这限制了其利用现代化多核平台的能力，并且无法高效处理大量数据。但是，Python 生态系统中的新库和扩展程序有助于打破这一限制。

Pandas 库可与更广泛的 Python 数据分析生态系统内的其他科学工具相集成。

Pandas 的工作原理🔖

pandas 开源库的核心是用于处理表格和统计数据的 DataFrame 数据结构。pandas DataFrame 为二维数组式数据表，其中每列代表特定变量值，每行包含一组与这些变量对应的值。DataFrame 中存储的数据可包括数字、类别或文本等类型，以便 pandas 操作和处理多样性数据集。

pandas 支持导入和导出 CSV、SQL 和电子表格等各种文件格式的数据集。这些操作与其数据操作功能相结合，有助于 pandas 清理、调整并分析表格和统计数据。

从根本上说，DataFrame 是 pandas 的主干，可帮助用户高效管理和分析结构化数据集 — 从导入和导出原始数据，到执行用于机器学习等的高级数据操作任务。

pandas 支持导入和导出各种不同格式的表格数据，如 CSV、SQL 和电子表格文件。

pandas 还支持各种数据处理操作和数据清洗功能，包括选择子集、创建衍生列、排序、联接、填充、替换、汇总统计和绘图。

Pandas 数据结构：Series 和 DataFrame🔖

Pandas 主要引入了两种新的数据结构：Series 和 DataFrame。

Series：类似于一维数组或列表，是由一组数据以及与之相关的数据标签（索引）构成。Series 可以看作是 DataFrame 中的一列，也可以是单独存在的一维数据结构。

DataFrame：类似于一个二维表格，它是 Pandas 中最重要的数据结构。DataFrame 可以看作是由多个 Series 按列排列构成的表格，它既有行索引也有列索引，因此可以方便地进行行列选择、过滤、合并等操作。

DataFrame 可视为由多个 Series 组成的数据结构：

下面这张图展示了两个 Series 对象相加得到一个 DataFrame 对象：

DataFrame 由 Index、Key、Value 组成：

import pandas as pd

# 创建两个Series对象
series_apples = pd.Series([1, 3, 7, 4])
series_bananas = pd.Series([2, 6, 3, 5])

# 将两个Series对象相加，得到DataFrame，并指定列名
df = pd.DataFrame({ 'Apples': series_apples, 'Bananas': series_bananas })

# 显示DataFrame
print(df)

输出结果为：

   Apples  Bananas
0       1        2
1       3        6
2       7        3
3       4        5

Pandas 特点🔖

高效的数据结构：

Series：一维数据结构，类似于列表（List），但拥有更强的功能，支持索引。
DataFrame：二维数据结构，类似于表格或数据库中的数据表，行和列都具有标签（索引）。

数据清洗与预处理：

Pandas 提供了丰富的函数来处理缺失值、重复数据、数据类型转换、字符串操作等，帮助用户轻松清理和转换数据。

数据操作与分析：

支持高效的数据选择、筛选、切片，按条件提取数据、合并、连接多个数据集、数据分组、汇总统计等操作。
可以进行复杂的数据变换，如数据透视表、交叉表、时间序列分析等。

数据读取与导出：

支持从各种格式的数据源读取数据，如 CSV、Excel、JSON、SQL 数据库等。
也可以将处理后的数据导出为不同格式，如 CSV、Excel 等。

数据可视化：

通过与 Matplotlib 和其他可视化工具的集成，Pandas 可以快速生成折线图、柱状图、散点图等常见图表。

时间序列分析：

支持强大的时间序列处理功能，包括日期的解析、重采样、时区转换等。

性能与优化：

Pandas 优化了大规模数据处理，提供高效的向量化操作，避免了使用 Python 循环处理数据的低效。
还支持一些内存优化技术，比如使用 category 类型处理重复的数据。

Pandas 安装🔖

安装 pandas 需要基础环境是 Python，Pandas 是一个基于 Python 的库，因此你需要先安装 Python，然后再通过 Python 的包管理工具 pip 安装 Pandas。

使用 pip 安装 pandas:

pip install pandas

安装成功后，我们就可以导入 pandas 包使用：

import pandas

导入 pandas 一般使用别名 pd 来代替：

import pandas as pd

一个简单的 pandas 实例：

import pandas as pd

mydataset = {
  'sites': ["Google", "Runoob", "Wiki"],
  'number': [1, 2, 3]
}

myvar = pd.DataFrame(mydataset)

print(myvar)

执行以上代码，输出结果为：

    sites  number
0  Google       1
1  Runoob       2
2    Wiki       3

Pandas 数据结构 – Series🔖

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

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

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)

输出结果为：

0    1
1    2
2    3
3    4
Name: A, dtype: int64
1    1
2    2
3    3
4    4
Name: A, dtype: int64

Series 是 Pandas 中的一种基本数据结构，类似于一维数组或列表，但具有标签（索引），使得数据在处理和分析时更具灵活性。

以下是关于 Pandas 中的 Series 的详细介绍。

🔹创建 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)

import pandas as pd

a = [1, 2, 3]

myvar = pd.Series(a)

print(myvar)

输出结果如下：

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

import pandas as pd

a = [1, 2, 3]

myvar = pd.Series(a)

print(myvar[1])

输出结果如下：

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

import pandas as pd

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

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

print(myvar)

输出结果如下：

根据索引值读取数据:

import pandas as pd

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

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

print(myvar["y"])

输出结果如下：

Runoob

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

import pandas as pd

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

myvar = pd.Series(sites)

print(myvar)

输出结果如下：

从上图可知，字典的 key 变成了索引值。

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

import pandas as pd

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

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

print(myvar)

输出结果如下：

设置 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 特点：

二维结构： 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 构造方法如下：

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 是一个二维的数组结构，类似二维数组。

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)

输出结果如下：

以下实例使用 ndarrays 创建，ndarray 的长度必须相同，如果传递了 index，则索引的长度应等于数组的长度。如果没有传递索引，则默认情况下，索引将是range(n)，其中n是数组长度。

实例 – 使用 ndarrays 创建

import numpy as np
import pandas as pd

# 创建一个包含网站和年龄的二维ndarray
ndarray_data = np.array([
    ['Google', 10],
    ['Runoob', 12],
    ['Wiki', 13]
])

# 使用DataFrame构造函数创建数据帧
df = pd.DataFrame(ndarray_data, columns=['Site', 'Age'])

# 打印数据帧
print(df)

输出结果如下：

从以上输出结果可以知道， DataFrame 数据类型一个表格，包含 rows（行）和 columns（列）：

还可以使用字典（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]})

从列表的列表创建：外层列表代表行，内层列表代表列。# 通过列表的列表创建 DataFrame

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 的数据类型

查看数据类型：使用 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:])        # 位置索引提取指定列

🔹注意事项

DataFrame 是一种灵活的数据结构，可以容纳不同数据类型的列。
列名和行索引可以是字符串、整数等。
DataFrame 可以通过多种方式进行数据选择、过滤、修改和分析。
通过对 DataFrame 的操作，可以进行数据清洗、转换、分析和可视化等工作。

92IT

Just love IT.

机器学习_Pandas