pandas库时基于numpy的库，该工具是为了解决数据分析任务而创建的。pandas库纳入了大量库和一节标准库的数据模型，提供了高效的操作大型数据集所需的工具。pandans体哦那个了大量能快速便捷的处理数据的函数和方法。
在pandas中有两类非常重要的数据结构，即序列（Series）和数据框（DataFrame）。Series类似于numpy中的一维数组，除了利用一维数组可用的函数或方法，也可以通过索引标签的方式获取数据。DataFrame是一个表格型的数据结构，它既有行索引也有列索引。他每一列可以是不同的数据类型的值，可以是字符串，数字，布尔型。构建DataFrame的方法，可以用字典dict，但是dict里面的值不像Series里面一样每个key匹配一个单一的value，他是每个key对应一个list，而key也变为了DataFrame的列索引。
1. 数据创建
1. 创建Series
Series 是带标签的一维数组，这里的标签可以理解为索引，但这个索引并不局限于整数，它也可以是字符类型，比如 a、b、c 等；
Pandas 使用 Series() 函数来创建 Series 对象，通过这个对象可以调用相应的方法和属性，从而达到处理数据的目的：
import pandas as pd
s = pd.Series(data, index, dtype, copy)
参数说明如下所示：
| 参数名称 | 描述 |
|---|---|
data |
输入的数据，可以是列表、常量、ndarray 数组等。 |
index |
索引值必须是惟一的，如果没有传递索引，则默认为 np.arrange(n)。 |
dtype |
dtype表示数据类型，如果没有提供，则会自动判断得出。 |
copy |
表示对 data 进行拷贝，默认为 False。 |
1. 从列表创建 Series
你可以使用 Python 列表来创建 Series，若不指定索引，Pandas 会默认使用从 0 开始的整数作为索引。
import pandas as pd
# 从列表创建 Series
data = [10, 20, 30, 40, 50]
s = pd.Series(data)
print(s)
你也可以自定义索引：
import pandas as pd
data = [10, 20, 30, 40, 50]
index = ['a', 'b', 'c', 'd', 'e']
s = pd.Series(data, index=index)
print(s)
也可以显示定义索引：
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
#自定义索引标签（即显示索引）
s = pd.Series(data,index=[100,101,102,103])
2. 从字典创建 Series
字典的键会被当作索引，值则成为 Series 中的数据。
import pandas as pd
# 从字典创建 Series
data = {'a': 10, 'b': 20, 'c': 30, 'd': 40, 'e': 50}
s = pd.Series(data)
print(s)
3. 从标量值创建 Series
若传入一个标量值，Pandas 会复制该值以匹配索引的长度。
import pandas as pd
# 从标量值创建 Series
value = 100
index = ['a', 'b', 'c', 'd', 'e']
s = pd.Series(value, index=index)
print(s)
2. 创建DataFrame
DataFrame 是一种表格型数据结构，它既有行索引（index），也有列索引（columns）。下面对 DataFrame 数据结构的特点做简单地总结，如下所示：
-
DataFrame 每一列的标签值允许使用不同的数据类型；
-
DataFrame 是表格型的数据结构，具有行和列；
-
DataFrame 中的每个数据值都可以被修改。
-
DataFrame 结构的行数、列数允许增加或者删除；
-
DataFrame 有两个方向的标签轴，分别是行标签和列标签；
-
DataFrame 可以对行和列执行算术运算。
创建 DataFrame 对象的语法格式如下：
python
import pandas as pd
pd.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)
参数说明：
| 参数名称 | 说明 |
|---|---|
| data | 输入的数据，可以是 ndarray，series，list，dict，标量以及一个 DataFrame。 |
| index | 行标签，如果没有传递 index 值，则默认行标签是 np.arange(n)，n 代表 data 的元素个数。 |
| columns | 列标签，如果没有传递 columns 值，则默认列标签是 np.arange(n)。 |
| dtype | dtype表示每一列的数据类型。 |
| copy | 默认为 False，表示复制数据 data。 |
1. 从字典创建
字典的键会成为列名，值可以是列表、数组等可迭代对象，每个可迭代对象的元素会依次填充到对应列的每一行中。
import pandas as pd
# 使用字典创建 DataFrame，键为列名，值为列表
data = {
'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)
print("从字典创建的 DataFrame：")
print(df)
2. 从列表的列表创建
可以将一个嵌套列表传递给 DataFrame 构造函数，每个内部列表代表一行数据。同时，可以通过 columns 参数指定列名。
import pandas as pd
# 列表的列表，每个子列表是一行数据
data = [
['Alice', 25, 'New York'],
['Bob', 30, 'Los Angeles'],
['Charlie', 35, 'Chicago']
]
# 指定列名
columns = ['Name', 'Age', 'City']
df = pd.DataFrame(data, columns=columns)
print("\n从列表的列表创建的 DataFrame：")
print(df)
3. 从字典的列表创建
列表中的每个字典代表一行数据，字典的键为列名，值为对应单元格的数据。如果某个字典中缺少某个键，对应的单元格会填充为 NaN。
import pandas as pd
# 字典的列表，每个字典是一行数据
data = [
{'Name': 'Alice', 'Age': 25, 'City': 'New York'},
{'Name': 'Bob', 'Age': 30, 'City': 'Los Angeles'},
{'Name': 'Charlie', 'Age': 35, 'City': 'Chicago'}
]
df = pd.DataFrame(data)
print("\n从字典的列表创建的 DataFrame：")
print(df)
4. 从 NumPy 数组创建
可以使用 NumPy 数组来创建 DataFrame，同时可以指定行索引和列名。
import pandas as pd
import numpy as np
# 创建一个 3x3 的 NumPy 数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 指定列名
columns = ['A', 'B', 'C']
# 指定行索引
index = ['row1', 'row2', 'row3']
df = pd.DataFrame(arr, index=index, columns=columns)
print("\n从 NumPy 数组创建的 DataFrame：")
print(df)
5. Series创建DataFrame对象
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df)
2. 数据访问
1. 访问Series数据
Series数据访问分为两种方式：一种是位置索引访问，另一种是索引标签访问。
1. 位置索引访问
这种访问方式与 ndarray 和 list 相同，使用元素自身的下标进行访问。我们知道数组的索引计数从 0 开始，这表示第一个元素存储在第 0 个索引位置上，以此类推，就可以获得 Series 序列中的每个元素。下面看一组简单的示例：
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
print(s[0]) #位置下标
print(s['a']) #标签下标
输出结果：
1
1
通过切片的方式访问 Series 序列中的数据，示例如下：
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
print(s[:3])
输出结果：
a 1
b 2
c 3
dtype: int64
如果想要获取最后三个元素，也可以使用下面的方式：
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
print(s[-3:])
输出结果：
c 3
d 4
e 5
dtype: int64
2. 索引标签访问
Series 类似于固定大小的 dict，把 index 中的索引标签当做 key，而把 Series 序列中的元素值当做 value，然后通过 index 索引标签来访问或者修改元素值。
示例1，使用索标签访问单个元素值
import pandas as pd
s = pd.Series([6,7,8,9,10],index = ['a','b','c','d','e'])
print(s['a']）
输出结果：
6
示例 2，使用索引标签访问多个元素值
import pandas as pd
s = pd.Series([6,7,8,9,10],index = ['a','b','c','d','e'])
print(s[['a','c','d']])
输出结果：
a 6
c 8
d 9
dtype: int64
示例3，如果使用了 index 中不包含的标签，则会触发异常：
import pandas as pd
s = pd.Series([6,7,8,9,10],index = ['a','b','c','d','e']) #不包含f值
print(s['f'])
输出结果：
......
KeyError: 'f'
2. 访问DataFrame数据
DataFrame 可以使用列索（columns index）引来完成数据的选取、添加和删除操作。
1. 访问列数据
方法一：使用列名作为属性
ages = df.Age
print(ages)
方法二：使用方括号
ages = df['Age']
print(ages)
2. 访问行数据
方法一：使用loc按标签索引
first_row = df.loc[0]
print(first_row)
方法二：使用iloc按整数位置索引
first_row = df.iloc[0]
print(first_row)
3. 访问特定的单元格
方法一：使用loc
cell_value = df.loc[0, 'Name']
print(cell_value)
注意：loc 允许接两个参数分别是行和列，参数之间需要使用“逗号”隔开，但该函数只能接收标签索引。
方法二：使用iloc
cell_value = df.iloc[0, 0]
print(cell_value)
注意：iloc 允许接受两个参数分别是行和列，参数之间使用“逗号”隔开，但该函数只能接收整数索引。
4. 切片访问
访问多行
rows_1_to_2 = df[1:3]
print(rows_1_to_2)
访问多列
columns_name_age = df[['Name', 'Age']]
print(columns_name_age)
3. 常用属性
1. Series常用属性
| 名称 | 属性 |
|---|---|
| axes | 以列表的形式返回所有行索引标签。 |
| dtype | 返回对象的数据类型。 |
| empty | 返回一个布尔值，判断Series是否为空。 |
| ndim | 返回输入数据的维数。Series 是一维数据结构，因此它始终返回 1。 |
| size | 返回输入数据的元素数量。 |
| values | 以 ndarray 的形式返回 Series 对象。 |
| index | 返回一个RangeIndex对象，用来描述索引的取值范围。 |
2. DataFrame常用属性
| 属性名称 | 描述 |
|---|---|
shape |
返回 DataFrame 的行数和列数，格式为 (行数, 列数)。 |
columns |
获取列标签，以 Index 对象形式返回。 |
index |
获取行标签，以 Index 对象形式返回。 |
dtypes |
显示每列的数据类型。 |
values |
以 NumPy 数组形式返回 DataFrame 的数据。 |
axes |
返回行和列的索引对象列表，格式为 [行索引, 列索引]。 |
empty |
判断 DataFrame 是否为空（无数据）。 |
ndim |
返回 DataFrame 的维度（始终为 2）。 |
size |
返回 DataFrame 中元素的总数（行数 × 列数）。 |
T 或 transpose() |
转置 DataFrame（交换行和列）。 |
import pandas as pd
# 创建一个示例DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)
# shape属性
rows, columns = df.shape
print(f"行数: {rows}, 列数: {columns}") #行数: 3, 列数: 3
# columns属性
print("列名:", df.columns) # 列名: Index(['Name', 'Age', 'City'], dtype='object')
# index属性
print("行索引:", df.index) # 行索引: RangeIndex(start=0, stop=3, step=1)
# dtypes属性
print("各列的数据类型:")
print(df.dtypes)
'''
各列的数据类型:
Name object
Age int64
City object
dtype: object
'''
# values属性
print("DataFrame的数据:")
print(df.values)
'''
DataFrame的数据:
[['Alice' 25 'New York']
['Bob' 30 'Los Angeles']
['Charlie' 35 'Chicago']]
'''
# empty属性
empty_df = pd.DataFrame()
print("df是否为空:", df.empty) # df是否为空: False
print("empty_df是否为空:", empty_df.empty) # empty_df是否为空: True
4. 常用方法
1. 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[] |
通过标签索引来选择数据 |
2. 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（行列交换） |
3. Pandas方法
1. 数据读取与写入
1. pd.read_csv()
pd.read_csv(filepath_or_buffer, sep=',', header='infer', index_col=None, usecols=None)
- 常用参数说明：
filepath_or_buffer：CSV 文件的路径或可读取对象。sep：分隔符，默认是逗号,。header：指定哪一行作为列名，默认自动推断。index_col：指定作为索引的列。usecols：指定要读取的列。
import pandas as pd
# 从csv文件中读取数据
df = pd.read_csv('data.csv')
2. pd.read_excel()
pd.read_excel(io, sheet_name=0, header=0, index_col=None, usecols=None)
- 常用参数说明：
io：Excel 文件的路径或可读取对象。sheet_name：要读取的工作表名称或索引，默认读取第一个工作表。header：指定哪一行作为列名。index_col：指定作为索引的列。usecols：指定要读取的列。
# 从Excel文件中读取数据
df = pd.read_excel('data.xlsx')
3. pd.read_json()
pd.read_json(path_or_buf=None, orient=None, typ='frame', dtype=True, convert_axes=True, convert_dates=True, keep_default_dates=True, numpy=False, precise_float=False, date_unit=None, encoding=None, lines=False, chunksize=None, compression='infer')
常用参数说明
path_or_buf：JSON 文件的路径、URL 或者包含 JSON 数据的字符串。- orient：指定 JSON 数据的格式，常见取值有：
'split'：dict形式{index -> [index], columns -> [columns], data -> [values]}。'records'：list形式[{column -> value}, ... , {column -> value}]。'index'：dict形式{index -> {column -> value}}。'columns'：dict形式{column -> {index -> value}}。'values'：仅包含数据的嵌套list。typ：返回对象的类型，'frame'表示返回DataFrame，'series'表示返回Series，默认是'frame'。lines：如果为True，则将文件按行解析，每行是一个独立的 JSON 对象。
示例代码
import pandas as pd
# 从 JSON 文件中读取数据
df = pd.read_json('data.json')
# 如果 JSON 文件是每行一个 JSON 对象
df_lines = pd.read_json('data_lines.json', lines=True)
4. pd.read_html()
方法原型
pd.read_html(io, match='.+', flavor=None, header=None, index_col=None, skiprows=None, attrs=None, parse_dates=False, thousands=',', encoding=None, decimal='.', converters=None, na_values=None, keep_default_na=True, displayed_only=True)
常用参数说明
io：可以是 URL、文件路径或者包含 HTML 代码的字符串。当使用pd.read_html(url)时，这里的url就是该参数的值，用于指定包含 HTML 表格的网页地址。match：一个正则表达式，用于匹配表格的内容，只有匹配上的表格才会被解析，默认匹配任意非空字符串。flavor：解析 HTML 的库，可选值为'lxml'、'bs4'等，默认会自动选择合适的库。header：指定作为列名的行号，默认不指定列名。index_col：指定作为索引的列号。skiprows：要跳过的行数，可以是整数、整数列表或者函数。attrs：一个字典，用于指定要解析的表格的 HTML 属性，例如{'id': 'table_id'}可以指定解析特定id的表格。
示例代码
import pandas as pd
# 从网页中读取 HTML 表格
url = 'https://example.com' # 替换为实际的网页 URL
tables = pd.read_html(url)
# 打印读取到的表格数量
print(f"读取到的表格数量: {len(tables)}")
# 遍历每个表格并打印信息
for i, table in enumerate(tables):
print(f"表格 {i + 1} 的基本信息：")
table.info()
print(table.head())
2. 数据类型转换
1. pd.to_datetime()
pd.to_datetime(arg, errors='raise', dayfirst=False, yearfirst=False)
- 常用参数说明：
arg：要转换为日期时间的对象。errors：处理错误的方式，可选'raise'、'coerce'、'ignore'。dayfirst：是否将日期中的日放在前面。yearfirst：是否将日期中的年放在前面。
# 将日期字符串转换为datetime类型
dates = pd.to_datetime(['2023-01-01', '2023-01-02'])
2. pd.to_numeric()
pd.to_numeric(arg, errors='raise', downcast=None)
- 常用参数说明：
arg：要转换为数值的对象。errors：处理错误的方式，可选'raise'、'coerce'、'ignore'。downcast：指定向下转换的类型。
# 将字符串转换为数值类型
numbers = pd.to_numeric(['1', '2', '3'])
3. 数据合并与连接
1. pd.concat()
pd.concat(objs, axis=0, join='outer', ignore_index=False)
- 常用参数说明：
objs：要连接的 DataFrame 或 Series 对象序列。axis：连接的轴，0表示按行，1表示按列。join：连接方式，'outer'为并集，'inner'为交集。ignore_index：是否忽略原索引，重新生成索引。
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})
# 按行连接两个DataFrame
result = pd.concat([df1, df2])
2. pd.merge()
pd.merge(left, right, on=None, left_on=None, right_on=None, how='inner')
- 常用参数说明：
left：左侧的 DataFrame 对象。right：右侧的 DataFrame 对象。on：用于合并的列名，必须在两个 DataFrame 中都存在。left_on：左侧 DataFrame 中用于合并的列名。right_on：右侧 DataFrame 中用于合并的列名。how：合并方式，可选'inner'、'outer'、'left'、'right'。
left = pd.DataFrame({'key': ['K0', 'K1'], 'A': ['A0', 'A1']})
right = pd.DataFrame({'key': ['K0', 'K1'], 'B': ['B0', 'B1']})
# 根据key列合并两个DataFrame
merged = pd.merge(left, right, on='key')
4. 数据统计与汇总
1. pd.crosstab()
pd.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None)
- 常用参数说明：
index：行索引对应的列。columns：列索引对应的列。values：用于聚合的值。rownames：行索引的名称。colnames：列索引的名称。aggfunc：聚合函数。
df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['x', 'y', 'x']})
# 计算交叉表
cross_tab = pd.crosstab(df['A'], df['B'])
2. pd.pivot_table()
pd.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean')
- 常用参数说明：
data：要创建透视表的 DataFrame 对象。values：要聚合的列。index：作为行索引的列。columns：作为列索引的列。aggfunc：聚合函数，默认是'mean'。
df = pd.DataFrame({'A': ['foo', 'foo', 'bar'], 'B': ['one', 'two', 'one'], 'C': [1, 2, 3]})
# 创建数据透视表
pivot = pd.pivot_table(df, values='C', index='A', columns='B')
5. 时间序列处理
1. pd.date_range()
pd.date_range(start=None, end=None, periods=None, freq='D')
- 常用参数说明：
start：开始日期。end：结束日期。periods：生成的日期数量。freq：日期频率，默认是'D'（每日）。
# 生成从2023-01-01到2023-01-10的日期序列
dates = pd.date_range(start='2023-01-01', end='2023-01-10')
2. pd.period_range()
pd.period_range(start=None, end=None, periods=None, freq='D')
- 常用参数说明：
start：开始周期。end：结束周期。periods：生成的周期数量。freq：周期频率，默认是'D'（每日）。
# 生成从2023年1月到2023年12月的月度周期序列
periods = pd.period_range(start='2023-01', end='2023-12', freq='M')
5. 数据可视化
数据可视化是数据分析中的重要环节，它帮助我们更好地理解和解释数据的模式、趋势和关系。通过图形、图表等形式，数据可视化将复杂的数字和统计信息转化为易于理解的图像，从而便于做出决策。Pandas 提供了与 Matplotlib 和 Seaborn 等可视化库的集成，使得数据的可视化变得简单而高效。在 Pandas 中，数据可视化功能主要通过 DataFrame.plot() 和 Series.plot() 方法实现，这些方法实际上是对 Matplotlib 库的封装，简化了图表的绘制过程。
| 图表类型 | 描述 | 方法 |
|---|---|---|
| 折线图 | 展示数据随时间或其他连续变量的变化趋势 | df.plot(kind='line') |
| 柱状图 | 比较不同类别的数据 | df.plot(kind='bar') |
| 水平柱状图 | 比较不同类别的数据，但柱子水平排列 | df.plot(kind='barh') |
| 直方图 | 显示数据的分布 | df.plot(kind='hist') |
| 散点图 | 展示两个数值型变量之间的关系 | df.plot(kind='scatter', x='col1', y='col2') |
| 箱线图 | 显示数据分布，包括中位数、四分位数等 | df.plot(kind='box') |
| 密度图 | 展示数据的密度分布 | df.plot(kind='kde') |
| 饼图 | 显示不同部分在整体中的占比 | df.plot(kind='pie') |
| 区域图 | 展示数据的累计数值 | df.plot(kind='area') |
1. 基本plot()方法
| 参数 | 说明 |
|---|---|
kind |
图表类型，支持 'line', 'bar', 'barh', 'hist', 'box', 'kde', 'density', 'area', 'pie' 等类型 |
x |
设置 x 轴的数据列 |
y |
设置 y 轴的数据列 |
title |
图表的标题 |
xlabel |
x 轴的标签 |
ylabel |
y 轴的标签 |
color |
设置图表的颜色 |
figsize |
设置图表的大小（宽, 高） |
legend |
是否显示图例 |
发表评论