代码收藏家技术教程 5天前

Pandas（二）：Python三大数据处理库中的Pandas深度解析

python三大库之—pandas（二）

文章目录

python三大库之—pandas（二）

六，函数

6.1、常用的统计学函数

6.2重置索引

6.3 遍历

6.3.1DataFrame 遍历

6.3.2 itertuples()

6.3.3 使用属性遍历

6.4 排序

6.4.1 sort_index

6.4.2 sort_values

6.5 去重

6.6 分组

6.6.1 groupby

6.6.2 filter

6.7 合并

6.8 随机抽样

6.9空值处理

6.9.1 检测空值

6.9.2 填充空值

6.9.3 删除空值

七，读取CSV文件

7.1 to_csv()

7.2 read_csv()

八，绘图

六，函数

6.1、常用的统计学函数

函数名称	描述说明
count()	统计某个非空值的数量
sum()	求和
mean()	求均值
median()	求中位数
std()	求标准差
min()	求最小值
max()	求最大值
abs()	求绝对值
prod()	求所有数值的乘积

numpy的方差默认为总体方差，pandas默认为样本方差

#常用的统计学函数
data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
print(df.mean())#计算均值
print(df.median())#计算中位数
print(df.mode())#计算众数
print(df.var())#计算方差
print(df.std())#计算标准差
print(df.sum())#计算总和
print(df.min())#计算最小值
print(df.max())#计算最大值
print(df.count())#计算非空值的个数
print(df.prod())#计算乘积
print(df.abs())#计算绝对值

A     2.5
B     6.5
C    10.5
dtype: float64
A     2.5
B     6.5
C    10.5
dtype: float64
   A  B   C
0  1  5   9
1  2  6  10
2  3  7  11
3  4  8  12
A    1.666667
B    1.666667
C    1.666667
dtype: float64
A    1.290994
B    1.290994
C    1.290994
dtype: float64
A    10
B    26
C    42
dtype: int64
A    1
B    5
C    9
dtype: int64
A     4
B     8
C    12
dtype: int64
A    4
B    4
C    4
dtype: int64
A       24
B     1680
C    11880
dtype: int64
   A  B   C
0  1  5   9
1  2  6  10
2  3  7  11
3  4  8  12

6.2重置索引

重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。

reindex

reindex() 方法用于重新索引 DataFrame 或 Series 对象。重新索引意味着根据新的索引标签重新排列数据，并填充缺失值。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。

语法

DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=np.nan, limit=None, tolerance=None)

参数：

labels：
类型：数组或列表，默认为 None。
描述：新的索引标签。
index：
类型：数组或列表，默认为 None。
描述：新的行索引标签。
columns：
类型：数组或列表，默认为 None。
描述：新的列索引标签。
axis：
类型：整数或字符串，默认为 None。
描述：指定重新索引的轴。0 或 ‘index’ 表示行，1 或 ‘columns’ 表示列。
method：
类型：字符串，默认为 None。
描述：用于填充缺失值的方法。可选值包括 ‘ffill’（前向填充）、‘bfill’（后向填充）等。
copy：
类型：布尔值，默认为 True。
描述：是否返回新的 DataFrame 或 Series。
level：
类型：整数或级别名称，默认为 None。
描述：用于多级索引（MultiIndex），指定要重新索引的级别。
fill_value：
类型：标量，默认为 np.nan。
描述：用于填充缺失值的值。
limit：
类型：整数，默认为 None。
描述：指定连续填充的最大数量。
tolerance：
类型：标量或字典，默认为 None。
描述：指定重新索引时的容差。

重置索引行

data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data,index=['a','b','c','d'])
#重置索引行
new_index = ['a','b','c','d','e']
print(df.reindex(new_index))#重置索引

  A    B     C
a  1.0  5.0   9.0
b  2.0  6.0  10.0
c  3.0  7.0  11.0
d  4.0  8.0  12.0
e  NaN  NaN   NaN

重置索引列

data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data,index=['a','b','c','d'])
#重置索引列
new_columns = ['A','B','C','D']
print(df.reindex(columns=new_columns))

  A  B   C   D
a  1  5   9 NaN
b  2  6  10 NaN
c  3  7  11 NaN
d  4  8  12 NaN

重置索引行，并使用向前填充

data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data,index=['a','b','c','d'])
#重置索引行，并使用向前填充
new_index = ['a','b','c','d','e']
print(df.reindex(new_index,method='ffill'))

 A  B   C
a  1  5   9
b  2  6  10
c  3  7  11
d  4  8  12
e  4  8  12

重置索引行，并使用指定值填充

data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data,index=['a','b','c','d'])
#重置索引行，并使用指定值填充
new_index = ['a','b','c','d','e']
print(df.reindex(new_index,method='ffill',fill_value=0))

 A  B   C
a  1  5   9
b  2  6  10
c  3  7  11
d  4  8  12
e  4  8  12

6.3 遍历

6.3.1DataFrame 遍历


# DataFrame 的遍历
data = pd.DataFrame({
    'A': pd.Series([1, 2, 3],index=['a','b','c']),
    'B': pd.Series([5, 6, 7, 8],index=['a','b','c','d']),
})
df = pd.DataFrame(data)
print(df)
for i in df:
    print(i)

     A  B
a  1.0  5
b  2.0  6
c  3.0  7
d  NaN  8
A
B

6.3.2 itertuples()


#使用 itertuples() 遍历行
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
#如果index为False，则打印出的元组过滤掉行索引信息
for i in df.itertuples(index=False):
    print(i)
    for j in i:
        print(j)

Pandas(A=1, B=4, C=7)
1
4
7
Pandas(A=2, B=5, C=8)
2
5
8
Pandas(A=3, B=6, C=9)
3
6

6.3.3 使用属性遍历

#使用属性遍历
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
#使用属性遍历
for inx in df.index:
    for col in df.columns:
        print(df.loc[inx,col])

6.4 排序

6.4.1 sort_index

sort_index 方法用于对 DataFrame 或 Series 的索引进行排序。

DataFrame.sort_index(axis=0, ascending=True, inplace=False)
Series.sort_index(axis=0, ascending=True, inplace=False)

参数：

axis：指定要排序的轴。默认为 0，表示按行索引排序。如果设置为 1，将按列索引排序。

ascending：布尔值，指定是升序排序（True）还是降序排序（False）。

inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。

6.4.2 sort_values

sort_values 方法用于根据一个或多个列的值对 DataFrame 进行排序。

DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')

参数：

by：列的标签或列的标签列表。指定要排序的列。

axis：指定沿着哪个轴排序。默认为 0，表示按行排序。如果设置为 1，将按列排序。

ascending：布尔值或布尔值列表，指定是升序排序（True）还是降序排序（False）。可以为每个列指定不同的排序方向。

inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。

kind：排序算法。默认为 ‘quicksort’，也可以选择 ‘mergesort’(归并排序) 或 ‘heapsort’(堆排序)。

na_position：指定缺失值（NaN）的位置。可以是 ‘first’ 或 ‘last’。

#sort_values排序
data = {
   'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Age': [25, 30, 25, 35, 30],
    'Score': [85, 90, 80, 95, 88]
}
df = pd.DataFrame(data)
print(df)

print(df.sort_values(by='Age'))
print(df.sort_values(by=['Age','Score']))
print(df.sort_values(by=['Age','Score'],ascending=[True,False]))

   Name  Age  Score
0    Alice   25     85
1      Bob   30     90
2  Charlie   25     80
3    David   35     95
4      Eve   30     88
      Name  Age  Score
0    Alice   25     85
2  Charlie   25     80
1      Bob   30     90
4      Eve   30     88
3    David   35     95
      Name  Age  Score
2  Charlie   25     80
0    Alice   25     85
4      Eve   30     88
1      Bob   30     90
3    David   35     95
      Name  Age  Score
0    Alice   25     85
2  Charlie   25     80
1      Bob   30     90
4      Eve   30     88
3    David   35     95

6.5 去重

drop_duplicates 方法用于删除 DataFrame 或 Series 中的重复行或元素。

语法

drop_duplicates(by=None, subset=None, keep='first', inplace=False)
Series.drop_duplicates(keep='first', inplace=False)

参数：

by：用于标识重复项的列名或列名列表。如果未指定，则使用所有列。

subset：与 by 类似，但用于指定列的子集。

keep：指定如何处理重复项。可以是：

‘first’：保留第一个出现的重复项（默认值）。

‘last’：保留最后一个出现的重复项。

False：删除所有重复项。

inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的删除重复项后的对象。

#去重
data = {
    'A':[1,2,2,3],
    'B':[4,5,5,6],
    'C':[7,8,8,9],
}
df = pd.DataFrame(data)

#按照所有列去重
print(df.drop_duplicates())
#按照指定列去重
print(df.drop_duplicates(subset='A'))
print(df.drop_duplicates(keep='last'))

6.6 分组

6.6.1 groupby

groupby 方法用于对数据进行分组操作，这是数据分析中非常常见的一个步骤。通过 groupby，你可以将数据集按照某个列（或多个列）的值分组，然后对每个组应用聚合函数，比如求和、平均值、最大值等。

语法

groupby 方法用于对数据进行分组操作，这是数据分析中非常常见的一个步骤。通过 groupby，你可以将数据集按照某个列（或多个列）的值分组，然后对每个组应用聚合函数，比如求和、平均值、最大值等。

参数**：

by：用于分组的列名或列名列表。

axis：指定沿着哪个轴进行分组。默认为 0，表示按行分组。

level：用于分组的 MultiIndex 的级别。

as_index：布尔值，指定分组后索引是否保留。如果为 True，则分组列将成为结果的索引；如果为 False，则返回一个列包含分组信息的 DataFrame。

sort：布尔值，指定在分组操作中是否对数据进行排序。默认为 True。

group_keys：布尔值，指定是否在结果中添加组键。

squeeze：布尔值，如果为 True，并且分组结果返回一个元素，则返回该元素而不是单列 DataFrame。

observed：布尔值，如果为 True，则只考虑数据中出现的标签。

#分组
data = {
        'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
        'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
        'C': [1, 2, 3, 4, 5, 6, 7, 8],
        'D': [10, 20, 30, 40, 50, 60, 70, 80]
    }
df = pd.DataFrame(data)
print(df)

#按A分组
# 查看分组结果
grouped = df.groupby('A')
print(list(grouped))

# 按Af分组，然后计算每个分组的C的平均值
grouped = df.groupby('A')['C']
print(grouped.mean())

#按A分组，计算所有列(如果报错使有非数字类型的值）
grouped = df.groupby(['A'])
print(grouped.mean)

#通过transform()函数对分组进行操作，保存到DataFrame中
grouped = df.groupby('A')['C'].transform('mean')
df['C_mean'] = grouped
print(df)

#可以使用匿名函数来对分组进行操作，比如正态分布的标准化
grouped = df.groupby('A')['C'].transform(lambda x: (x - x.mean()) / x.std())
df['C_norm'] = grouped
print(df)

  A      B  C   D
0  foo    one  1  10
1  bar    one  2  20
2  foo    two  3  30
3  bar  three  4  40
4  foo    two  5  50
5  bar    two  6  60
6  foo    one  7  70
7  foo  three  8  80
[('bar',      A      B  C   D
1  bar    one  2  20
3  bar  three  4  40
5  bar    two  6  60), ('foo',      A      B  C   D
0  foo    one  1  10
2  foo    two  3  30
4  foo    two  5  50
6  foo    one  7  70
7  foo  three  8  80)]
A
bar    4.0
foo    4.8
Name: C, dtype: float64

     A      B  C   D  C_mean
0  foo    one  1  10     4.8
1  bar    one  2  20     4.0
2  foo    two  3  30     4.8
3  bar  three  4  40     4.0
4  foo    two  5  50     4.8
5  bar    two  6  60     4.0
6  foo    one  7  70     4.8
7  foo  three  8  80     4.8
     A      B  C   D  C_mean    C_norm
0  foo    one  1  10     4.8 -1.327018
1  bar    one  2  20     4.0 -1.000000
2  foo    two  3  30     4.8 -0.628587
3  bar  three  4  40     4.0  0.000000
4  foo    two  5  50     4.8  0.069843
5  bar    two  6  60     4.0  1.000000
6  foo    one  7  70     4.8  0.768273
7  foo  three  8  80     4.8  1.117488

6.6.2 filter

通过 filter() 函数可以实现数据的筛选，该函数根据定义的条件过滤数据并返回一个新的数据集

# # 按列 'A' 分组，并过滤掉列 'C' 的平均值小于 4 的组
# filter
data = {
        'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
        'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
        'C': [1, 2, 3, 4, 5, 6, 7, 8],
        'D': [10, 20, 30, 40, 50, 60, 70, 80]
}
df = pd.DataFrame(data)
filtered_df = df.groupby('A').filter(lambda x: x['C'].mean() > 4)
print(filtered_df)

  A      B  C   D
0  foo    one  1  10
2  foo    two  3  30
4  foo    two  5  50
6  foo    one  7  70
7  foo  three  8  80

6.7 合并

merge 函数用于将两个 DataFrame 对象根据一个或多个键进行合并，类似于 SQL 中的 JOIN 操作。这个方法非常适合用来基于某些共同字段将不同数据源的数据组合在一起，最后拼接成一个新的 DataFrame 数据表。

pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

left：左侧的 DataFrame 对象。

right：右侧的 DataFrame 对象。

how：合并方式，可以是 ‘inner’、‘outer’、‘left’ 或 ‘right’。默认为 ‘inner’。

‘inner’：内连接，返回两个 DataFrame 共有的键。

‘outer’：外连接，返回两个 DataFrame 的所有键。

‘left’：左连接，返回左侧 DataFrame 的所有键，以及右侧 DataFrame 匹配的键。

‘right’：右连接，返回右侧 DataFrame 的所有键，以及左侧 DataFrame 匹配的键。

on：用于连接的列名。如果未指定，则使用两个 DataFrame 中相同的列名。

left_on 和 right_on：分别指定左侧和右侧 DataFrame 的连接列名。

left_index 和 right_index：布尔值，指定是否使用索引作为连接键。

sort：布尔值，指定是否在合并后对结果进行排序。

suffixes：一个元组，指定当列名冲突时，右侧和左侧 DataFrame 的后缀。

copy：布尔值，指定是否返回一个新的 DataFrame。如果为 False，则可能修改原始 DataFrame。

indicator：布尔值，如果为 True，则在结果中添加一个名为 __merge 的列，指示每行是如何合并的。

validate：验证合并是否符合特定的模式。



#合并
# 创建两个示例 DataFrame
left = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K3'],
    'A': ['A0', 'A1', 'A2', 'A3'],
    'B': ['B0', 'B1', 'B2', 'B3']
})

right = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K4'],
    'C': ['C0', 'C1', 'C2', 'C3'],
    'D': ['D0', 'D1', 'D2', 'D3']
})

# 内连接，只连接key相同的行
df = pd.merge(left, right, on='key', how='inner')
print(df)

# 左连接，连接所有左边的行，右边没有的用NaN填充
df = pd.merge(left, right, on='key', how='left')
print(df)

# 右连接，连接所有右边的行，左边没有的用NaN填充
df = pd.merge(left, right, on='key', how='right')
print(df)

# 外连接，连接所有行，没有的用NaN填充
df = pd.merge(left, right, on='key', how='outer')
print(df)

 key   A   B   C   D
0  K0  A0  B0  C0  D0
1  K1  A1  B1  C1  D1
2  K2  A2  B2  C2  D2
  key   A   B    C    D
0  K0  A0  B0   C0   D0
1  K1  A1  B1   C1   D1
2  K2  A2  B2   C2   D2
3  K3  A3  B3  NaN  NaN
  key    A    B   C   D
0  K0   A0   B0  C0  D0
1  K1   A1   B1  C1  D1
2  K2   A2   B2  C2  D2
3  K4  NaN  NaN  C3  D3
  key    A    B    C    D
0  K0   A0   B0   C0   D0
1  K1   A1   B1   C1   D1
2  K2   A2   B2   C2   D2
3  K3   A3   B3  NaN  NaN
4  K4  NaN  NaN   C3   D3

6.8 随机抽样

DataFrame.sample(n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)

参数：

n：要抽取的行数

frac：抽取的比例，比如 frac=0.5，代表抽取总体数据的50%

replace：布尔值参数，表示是否以有放回抽样的方式进行选择，默认为 False，取出数据后不再放回

weights：可选参数，代表每个样本的权重值，参数值是字符串或者数组

random_state：可选参数，控制随机状态，默认为 None，表示随机数据不会重复；若为 1 表示会取得重复数据

axis：表示在哪个方向上抽取数据(axis=1 表示列/axis=0 表示行)


# 随机抽样
def sample_test():
    df = pd.DataFrame({
        "company": ['百度', '阿里', '腾讯'],
        "salary": [43000, 24000, 40000],
        "age": [25, 35, 49]
    })
    print(df.sample(frac=0.4))#随机抽取40%,4舍五入
    print(df.sample(n=2,axis=0))#随机抽取2条数据
    print(df.sample(n=1,axis=1))#随机抽取1列数据
    print(df.sample(n=2,axis=0,random_state=1))#随机抽取2条数据，并指定随机种子
    print(df.sample(frac=0.5, replace=True))#随机抽取50%，允许重复

sample_test()

  company  salary  age
1      阿里   24000   35
  company  salary  age
2      腾讯   40000   49
1      阿里   24000   35
   age
0   25
1   35
2   49
  company  salary  age
0      百度   43000   25
2      腾讯   40000   49
  company  salary  age
0      百度   43000   25
0      百度   43000   25

6.9空值处理

6.9.1 检测空值

isnull()用于检测 DataFrame 或 Series 中的空值，返回一个布尔值的 DataFrame 或 Series。

notnull()用于检测 DataFrame 或 Series 中的非空值，返回一个布尔值的 DataFrame 或 Series。

#空值检测
#isnull，检测DataFrame中的空值，返回一个布尔值矩阵，True表示空值，False表示非空值
def isnull_test():
    df = pd.DataFrame({
        "company": ['百度', '阿里', '腾讯'],
        "salary": [43000,np.nan, 40000],
        "age": [25, 35, 49]
    })
    print(df.isnull())
    print(df.isnull().sum())#统计空值
    print(df.isnull().sum().sum())#统计空值总数

isnull_test()
#notnull，检测DataFrame中的非空值，返回一个布尔值矩阵，True表示非空值，False表示空值
def notnull_test():
    df = pd.DataFrame({
        "company": ['百度', '阿里', '腾讯'],
        "salary": [43000,np.nan, 40000],
        "age": [25, 35, 49]
    })
    print(df.notnull())
    print(df.notnull().sum())#统计非空值
    print(df.notnull().sum().sum())#统计非空值总数

   company  salary    age
0    False   False  False
1    False    True  False
2    False   False  False
company    0
salary     1
age        0
dtype: int64
1

6.9.2 填充空值

fillna() 方法用于填充 DataFrame 或 Series 中的空值。

#空值填充
def fillna_test():
    df = pd.DataFrame({
        "company": ['百度', '阿里', '腾讯'],
        "salary": [43000,np.nan, 40000],
        "age": [25, 35, 49]
    })
    print(df.fillna(0))#填充0
    print(df.fillna(method='ffill'))#填充前一个值

fillna_test()

 company   salary  age
0      百度  43000.0   25
1      阿里      0.0   35
2      腾讯  40000.0   49

6.9.3 删除空值

dropna() 方法用于删除 DataFrame 或 Series 中的空值。

#删除空值
def dropna_test():
    df = pd.DataFrame({
        "company": ['百度', '阿里', '腾讯'],
        "salary": [43000,np.nan, 40000],
        "age": [25, 35, 49]
    })
    print(df.dropna())#删除空值
    print(df.dropna(axis=1))#删除空值所在列

dropna_test()

 company   salary  age
0      百度  43000.0   25
2      腾讯  40000.0   49
  company  age
0      百度   25
1      阿里   35
2      腾讯   49

七，读取CSV文件

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

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

7.1 to_csv()

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

#存csv文件
#to_csv()
def to_csv_test():
    df = pd.DataFrame({
        "company": ['百度', '阿里', '腾讯'],
        "salary": [43000,np.nan, 40000],
        "age": [25, 35, 49]
    })
    df.to_csv('test.csv',index=False)#index=False表示不保存索引
 
to_csv_test()

7.2 read_csv()

read_csv() 表示从 CSV 文件中读取数据，并创建 DataFrame 对象。

#读取csv文件
def read_csv_test():
    df = pd.read_csv('test.csv')
    print(df)

read_csv_test()

  company   salary  age
0      百度  43000.0   25
1      阿里      NaN   35
2      腾讯  40000.0   49

八，绘图

Pandas 在数据分析、数据可视化方面有着较为广泛的应用，Pandas 对 Matplotlib 绘图软件包的基础上单独封装了一个plot()接口，通过调用该接口可以实现常用的绘图操作；

Pandas 之所以能够实现了数据可视化，主要利用了 Matplotlib 库的 plot() 方法，它对 plot() 方法做了简单的封装，因此您可以直接调用该接口；

只用 pandas 绘制图片可能可以编译，但是不会显示图片，需要使用 matplotlib 库，调用 show() 方法显示图形。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

#绘图
import matplotlib.pyplot as plt
data = {
    'A': [1, 2, 3, 4, 5],
    'B': [10, 20, 25, 30, 40]
}
df = pd.DataFrame(data)

# 折线图
df.plot(kind='line')
plt.show()

# 柱状图
df.plot(kind='bar')
plt.show()

#直方图
df['A'].plot(kind='hist')
plt.show()

#散点图
df.plot(kind='scatter',x='A',y='B')
plt.show()

# 饼图
# 创建一个示例 
data = {
    'A': 10,
    'B': 20,
    'C': 30,
    'D': 40
}
pd = pd.Series(data)
# 绘制饼图
pd.plot(kind='pie', autopct='%1.1f%%')
# 显示图表
plt.show()