Pandas 一个强大的分析结构化数据的工具集，基础是 Numpy（提供高性能的矩阵运算）。
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 字段的空值最多。

# Pandas 简介

# 数据结构

# 安装 Pandas

# 一个简单的 Pandas 示例

# Pandas Series

# Series 特点

# 创建 Series

# 指定索引值

# 使用 key/value

# 设置 Series 名称参数

# Series 方法

# 更多 Series 说明

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

# 基本操作

# 基本运算

# 计算统计数据

# 属性和方法

# 使用布尔表达式

# 查看数据类型

# 转换数据类型

# 注意事项

# Pandas DataFrame

# DataFrame 特点

# 创建 DataFrame

# DataFrame 方法

# 更多 DataFrame 说明

# 创建 DataFrame

# DataFrame 的属性和方法

# Pandas CSV

# 读取 CSV 文件

# 写入 CSV 文件

# 数据处理

# head ()

# tail ()

# info ()

Asyncio

# `head ()`

# `tail ()`

# `info ()`