目录

• 第三章 pandas库基础
  • 3.1 数据结构
    • 3.1.1 Series
      • 3.1.1.1 用列表创建
      • 3.1.1.2 用一维numpy数组创建
      • 3.1.1.3 用字典创建
      • 3.1.1.4 data为标量的情况
      • 3.1.1.5 时间戳索引
    • 3.1.2 DataFrame
      • 3.1.2.1 通过Series对象创建
      • 3.1.2.2 通过字典创建
      • 3.1.2.3 通过字典列表对象创建
      • 3.1.2.4 通过Numpy二维数组创建**
  • 3.2 DataFrame属性
    • 3.2.1 .values返回numpy数组表示的数据
    • 3.2.2 .index返回行索引
    • 3.2.3 .columns返回列索引
    • 3.2.4 .shape返回形状
    • 3.2.5 .size 元素的个数
    • 3.2.6 .dtypes 返回每列数据类型
  • 3.3 索引操作
    • 3.3.1 索引对象
      • 3.3.1.1 获取列
      • 3.3.1.2 获取行
      • 3.3.1.3 获取标量
    • 3.3.2 切片
      • 3.3.2.1 行切片
      • 3.3.2.2 列切片
      • 3.3.2.3 花式切片
    • 3.3.3 布尔索引
    • 3.3.4 分层索引
      • 3.3.4.1 分层索引的创建
      • 3.3.4.2 使用分层索引访问数据
    • 3.3.5 重新索引
    • 3.3.6 切片获取的series或者dataframe是视图还是副本？
      • 3.3.6.1 返回连续块的是视图
      • 3.3.6.2 花式索引得到的是副本
  • 3.4 数据处理常用的操作：增、删、查、改
    • 3.4.1 增
      • 3.4.1.1 增加行
      • 3.4.1.2 增加列
    • 3.4.2 删
      • 3.4.2.1 删除列
      • 3.4.2.2 删除行
    • 3.4.3 查
      • 3.4.3.1 在某列或者全局中查找某个具体的值
      • 3.4.3.2 查找空值
      • 3.4.3.3 定位重复数据
      • 3.4.3.4 删除重复数据
      • 3.4.3.5 利用ix查询
    • 3.4.4 改
      • 3.4.4.1 更改数据值
      • 3.4.4.2 更改数据类型
      • 3.4.4.3 更改索引名称
  • 3.5 数据排序
    • 3.5.1 按索引排序
    • 3.5.2 按值排序
  • 3.6 统计计算于统计描述
    • 3.6.1 数据总览查看
      • 3.6.1.1 查看前面的行 .head()
      • 3.6.1.2 查看后面的行.tail()
      • 3.6.1.3 查看数据的总体信息 .info()
      • 3.6.1.4 查看数据的统计信息描述 .describe()
    • 3.6.2 常见的统计计算
      • 3.6.2.1 计算非nan值的个数 .count()
      • 3.6.2.2 计算和 .sum()
      • 3.6.2.3 计算平均值 .mean()
      • 3.6.2.4 计算最大值.max()、最小值.min()
      • 3.6.2.5 计算最大索引值.idxmax()、最小索引值idxmin()
      • 3.6.2.6 计算方差.var()
      • 3.6.2.7 计算标准差.std()
      • 3.6.2.8 计算样本值的累计和cumsum()、样本值的累计积cumprod()
  • 3.7 绘制图表
    • 3.7.1 中文字符显示设置
    • 3.7.2 DataFrame.plot()函数
    • 3.7.3 线形图
    • 3.7.4 条形图
      • 3.7.4.1 垂直条形图
      • 3.7.4.2 水平条形图
    • 3.7.5 饼图
    • 3.7.6 散点图
      • 3.7.6.1 普通散点图
      • 3.7.6.2 气泡图
      • 3.7.6.3 多组散点图
    • 3.7.7 面积图
      • 3.7.7.1 一般面积图
      • 3.7.7.2 堆积图
    • 3.7.8 箱线图
    • 3.7.9 直方图
    • 3.7.10 核密度分布

第三章 pandas库基础

3.1 数据结构

3.1.1 Series

Series 是带标签数据的一维数组
Series对象的创建

3.1.1.1 用列表创建

• index缺省，默认为整数序列

import pandas as pd                          # 导入pandas库
# 根据列表创建Series类对象
ser_obj = pd.Series(['Python', 'Java', 'PHP'])   
ser_obj

0    Python
1      Java
2       PHP
dtype: object

• 增加index

# 导入pandas库
import pandas as pd                          
# 创建Series类对象，同时为该对象指定索引
ser_obj = pd.Series(['Python', 'Java', 'PHP'],
index = ['one', 'two', 'three'])              
ser_obj

one      Python
two        Java
three       PHP
dtype: object

• 增加数据类型

  缺省则从传入的数据自动判断
  

data = pd.Series([1, 2, 3, 4], index=["a", "b", "c", "d"])    
data

a    1
b    2
c    3
d    4
dtype: int64

data = pd.Series([1, 2, 3, 4], index=["a", "b", "c", "d"], dtype="float")
data

a    1.0
b    2.0
c    3.0
d    4.0
dtype: float64

注意：数据支持多种类型

data = pd.Series([1, 2, "3", 4], index=["a", "b", "c", "d"])
data

a    1
b    2
c    3
d    4
dtype: object

data['b']

2

data['c']

'3'

3.1.1.2 用一维numpy数组创建

import numpy as np

x = np.arange(5)
pd.Series(x)

0    0
1    1
2    2
3    3
4    4
dtype: int32

3.1.1.3 用字典创建

• 默认以键为index，值为data

population_dict = {"BeiJing": 2154,
                   "ShangHai": 2424,
                   "ShenZhen": 1303,
                   "HangZhou": 981 }
population = pd.Series(population_dict)    
population

BeiJing     2154
ShangHai    2424
ShenZhen    1303
HangZhou     981
dtype: int64

• 字典创建，如果指定index，则会到字典的键中筛选，找不到的，值设为NaN

population = pd.Series(population_dict, index=["BeiJing", "HangZhou", "c", "d"])    
population

BeiJing     2154.0
HangZhou     981.0
c              NaN
d              NaN
dtype: float64

3.1.1.4 data为标量的情况

pd.Series(5, index=[100, 200, 300])

100    5
200    5
300    5
dtype: int64

3.1.1.5 时间戳索引

import pandas as pd
from datetime import datetime
# 创建时间戳索引
date_index = pd.to_datetime(['20180820', '20180828', '20180908'])
print(date_index)
# 创建Series类对象，指定索引为时间戳索引
date_ser = pd.Series([11, 22, 33], index=date_index)
print(date_ser)

DatetimeIndex(['2018-08-20', '2018-08-28', '2018-09-08'], dtype='datetime64[ns]', freq=None)
2018-08-20    11
2018-08-28    22
2018-09-08    33
dtype: int64

3.1.2 DataFrame

DataFrame 是带标签数据的多维数组

DataFrame对象的创建

3.1.2.1 通过Series对象创建

population

BeiJing     2154.0
HangZhou     981.0
c              NaN
d              NaN
dtype: float64

population

BeiJing     2154
ShangHai    2424
ShenZhen    1303
HangZhou     981
dtype: int64

population_dict = {"BeiJing": 2154,
                   "ShangHai": 2424,
                   "ShenZhen": 1303,
                   "HangZhou": 981 }

population = pd.Series(population_dict)    
pd.DataFrame(population)

3.1.2.2 通过字典创建

GDP_dict = {"BeiJing": 30320,
            "ShangHai": 32680,
            "ShenZhen": 24222,
            "HangZhou": 13468 }

GDP = pd.Series(GDP_dict)
GDP

BeiJing     30320
ShangHai    32680
ShenZhen    24222
HangZhou    13468
dtype: int64

population

BeiJing     2154
ShangHai    2424
ShenZhen    1303
HangZhou     981
dtype: int64

pd.DataFrame({"population": population,
              "GDP": GDP})

若行索引index不一致时

GDP_dict2 = {"BeiJing": 30320,
            "ShangHai": 32680,
            "ShenZhen": 24222,
            "HangZhou": 13468,
            "Chongqing":10000}

GDP2 = pd.Series(GDP_dict2)
GDP2

BeiJing      30320
ShangHai     32680
ShenZhen     24222
HangZhou     13468
Chongqing    10000
dtype: int64

population

BeiJing     2154
ShangHai    2424
ShenZhen    1303
HangZhou     981
dtype: int64

pd.DataFrame({"population": population,
              "GDP": GDP2})

注意：标量时会自动补齐

pd.DataFrame({"population": population,
              "GDP": GDP,
              "country": "China"})

3.1.2.3 通过字典列表对象创建

• 字典索引作为index，字典键作为columns

import numpy as np
import pandas as pd

data = [{"a": i, "b": 2*i} for i in range(3)]
data

[{'a': 0, 'b': 0}, {'a': 1, 'b': 2}, {'a': 2, 'b': 4}]

data = pd.DataFrame(data)
data

• 不存在的键，会默认值为NaN

data = [{"a": 1, "b":1},{"b": 3, "c":4}]
pd.DataFrame(data)

3.1.2.4 通过Numpy二维数组创建**

import numpy as np
import pandas as pd
# 创建二维数组
demo_arr = np.array([['a', 'b', 'c'], ['d', 'e', 'f']])    
df_obj = pd.DataFrame(demo_arr)       # 根据二维数组创建DataFrame类对象
df_obj

# 创建DataFrame类对象，同时指定行索引与列索引
df_obj = pd.DataFrame(demo_arr, index = ['row_01','row_02'],
                          columns=['col_01', 'col_02', 'col_03'])
df_obj

3.2 DataFrame属性

data = pd.DataFrame({"population": population,
              "GDP": GDP})
data

3.2.1 .values返回numpy数组表示的数据

data.values

array([[ 2154, 30320],
       [ 2424, 32680],
       [ 1303, 24222],
       [  981, 13468]], dtype=int64)

type(data.values)

numpy.ndarray

3.2.2 .index返回行索引

data.index

Index(['BeiJing', 'ShangHai', 'ShenZhen', 'HangZhou'], dtype='object')

type(data.index)

pandas.core.indexes.base.Index

3.2.3 .columns返回列索引

data.columns

Index(['population', 'GDP'], dtype='object')

type(data.columns)

pandas.core.indexes.base.Index

3.2.4 .shape返回形状

data.shape

(4, 2)

3.2.5 .size 元素的个数

data.size # = data.shape[0]*data.shape[1]

8

3.2.6 .dtypes 返回每列数据类型

data.dtypes

population    int64
GDP           int64
dtype: object

3.3 索引操作

3.3.1 索引对象

data

3.3.1.1 获取列

• 字典式

# 获取单列, 注意返回值的类型
data['GDP']

BeiJing     30320
ShangHai    32680
ShenZhen    24222
HangZhou    13468
Name: GDP, dtype: int64

type(data['GDP'])

pandas.core.series.Series

# 获取单列, 注意返回值的类型
data[['GDP']]

type(data[['GDP']])

pandas.core.frame.DataFrame

# 获取多列  ,注意是双中括号
data[['GDP','population']]

• 对象属性式

data.GDP

BeiJing     30320
ShangHai    32680
ShenZhen    24222
HangZhou    13468
Name: GDP, dtype: int64

data.population

BeiJing     2154
ShangHai    2424
ShenZhen    1303
HangZhou     981
Name: population, dtype: int64

3.3.1.2 获取行

• 绝对索引 df.loc[索引名]
  .loc[索引名] 索引名是自己定义的绝对名称

data

data.loc['BeiJing']

population     2154
GDP           30320
Name: BeiJing, dtype: int64

for ind in data.index:
    print(ind)
    print(data.loc[ind])
    print("="*30)

BeiJing
population     2154
GDP           30320
Name: BeiJing, dtype: int64
==============================
ShangHai
population     2424
GDP           32680
Name: ShangHai, dtype: int64
==============================
ShenZhen
population     1303
GDP           24222
Name: ShenZhen, dtype: int64
==============================
HangZhou
population      981
GDP           13468
Name: HangZhou, dtype: int64
==============================

• 相对索引 df.iloc[整数相对索引值]
  .iloc[ ] 中括号内是整数索引值

data

data.iloc[0]

population     2154
GDP           30320
Name: BeiJing, dtype: int64

for i in range(len(data.index)):
    print(data.index[i])
    print(data.iloc[i])
    print("="*30)

BeiJing
population     2154
GDP           30320
Name: BeiJing, dtype: int64
==============================
ShangHai
population     2424
GDP           32680
Name: ShangHai, dtype: int64
==============================
ShenZhen
population     1303
GDP           24222
Name: ShenZhen, dtype: int64
==============================
HangZhou
population      981
GDP           13468
Name: HangZhou, dtype: int64
==============================

3.3.1.3 获取标量

data

• .loc[行索引名称,列索引名称]方式

data.loc['BeiJing','GDP']

30320

• .loc[行索引名称][列索引名称]方式

data.loc['BeiJing']['GDP']

30320

# 本质是先获取series，在用series取值的方式
data.loc["BeiJing"]

population     2154
GDP           30320
Name: BeiJing, dtype: int64

• .iloc[行索引值,列索引值]方式

data.iloc[0,1]

30320

• .iloc[行索引值][列索引值]方式

data.iloc[0][1]

30320

• .at[行索引名称,列索引名称]方式

data.at["BeiJing",'GDP']

30320

• .iat[行索引值,列索引值]方式

data.iat[0,1]

30320

3.3.2 切片

dates = pd.date_range(start='2019-01-01', periods=6)
dates

DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04',
               '2019-01-05', '2019-01-06'],
              dtype='datetime64[ns]', freq='D')

df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=["A", "B", "C", "D"])
df

3.3.2.1 行切片

df["2019-01-01": "2019-01-03"]

df["2019-01-01": "2019-01-05":2]

df.loc["2019-01-01": "2019-01-03"]

# .iloc[起始索引值：终止索引值]
df.iloc[0: 3]

# .iloc[起始索引值：终止索引值:步长]
df.iloc[0: 5: 2]

3.3.2.2 列切片

df

df.loc[:,"A":"C"]

df.loc[:,"A":"C":2]

df.iloc[:,0:3:2]

3.3.2.3 花式切片

• 行、列同时切片

df.loc["2019-01-02": "2019-01-03", "C":"D"]

df.iloc[1: 3, 2:]

• 行切片，列分散取值

df.loc["2019-01-04": "2019-01-06", ["A", "C"]]

df.iloc[3:, [0, 2]]

• 行分散取值，列切片

df.loc[["2019-01-02", "2019-01-06"], "C": "D"]

• 行、列均分散取值

df.loc[["2019-01-04", "2019-01-06"], ["A", "D"]]

df.iloc[[1, 5], [0, 3]]

3.3.3 布尔索引

df

# 找出大于0的值
df>0

df[df > 0]

#找出A列值大于0的行
df.A > 0

2019-01-01    False
2019-01-02    False
2019-01-03    False
2019-01-04    False
2019-01-05     True
2019-01-06     True
Freq: D, Name: A, dtype: bool

df[df.A>0]

• isin（）方法

df2 = df.copy()
df2['E'] = ['one', 'one', 'two', 'three', 'four', 'three']
df2

ind = df2["E"].isin(["two", "four"])
ind   

2019-01-01    False
2019-01-02    False
2019-01-03     True
2019-01-04    False
2019-01-05     True
2019-01-06    False
Freq: D, Name: E, dtype: bool

df2[df2["E"].isin(["two","four"])]

3.3.4 分层索引

3.3.4.1 分层索引的创建

• from_tuples() 根据元组列表创建分层索引

• from_arrays() 根据数组列表创建分层索引

• from_product() 从集合的笛卡尔乘积中创建分层索引

• from_frame() 根据DataFrame类对象创建分层索引

• from_tuples() 根据元组列表创建分层索引

import  pandas as pd
tuple_clo = [('ca', 0),('ca', 1),('cb', 2),('cb', 2)]
tuple_row = [('ra', 0),('ra', 1),('rb', 2),('rb', 2)]
multi_index_col = pd.MultiIndex.from_tuples(tuples=tuple_clo)
multi_index_row = pd.MultiIndex.from_tuples(tuples=tuple_row)
data = [['A','B','C','D'],['E','F','G','H'],
         ['I','J','K','L'],['M','N','O','P']]
df = pd.DataFrame(data,index=multi_index_row,columns=multi_index_col)
df

tuple_clo

[('ca', 0), ('ca', 1), ('cb', 2), ('cb', 2)]

multi_index_col

MultiIndex([('ca', 0),
            ('ca', 1),
            ('cb', 2),
            ('cb', 2)],
           )

• from_arrays() 根据数组列表创建分层索引

arrays = [[1, 1, 2, 2], ['red', 'blue', 'red', 'blue']]
multi_row =pd.MultiIndex.from_arrays(arrays, names=('number', 'color'))
multi_row

MultiIndex([(1,  'red'),
            (1, 'blue'),
            (2,  'red'),
            (2, 'blue')],
           names=['number', 'color'])

pd.DataFrame(data,index=multi_row)

 df = pd.DataFrame([['HI', 'Temp'], ['HI', 'Precip'],
...                    ['NJ', 'Temp'], ['NJ', 'Precip']],
...                   columns=['a', 'b'])

df

• from_frame() 根据DataFrame类对象创建分层索引

multi_index_row = pd.MultiIndex.from_frame(df)
multi_index_row

MultiIndex([('HI',   'Temp'),
            ('HI', 'Precip'),
            ('NJ',   'Temp'),
            ('NJ', 'Precip')],
           names=['a', 'b'])

pd.DataFrame(data, index=multi_index_row)

• from_product() 根据两个列表的笛卡尔积方式创建

data = np.random.randint(0,100,size=(6,3))
names = ['张三','李四','王五']
exam = ['期中','期末']
index = pd.MultiIndex.from_product([names,exam])
df = pd.DataFrame(data,index=index,columns=['Java','Web','Python'])
# print(df)
df

3.3.4.2 使用分层索引访问数据

• Series的分层索引

mult_series = pd.Series([95, 103, 80, 80, 90, 91, 91],
               index=[['计算机专业', '计算机专业', '计算机专业', '计算机专业',
                         '体育专业', '体育专业', '体育专业'],
                        ['物联网工程', '软件工程', '网络安全', '信息安全',
                         '体育教育', '休闲体育', '运动康复']])
mult_series

计算机专业  物联网工程     95
       软件工程     103
       网络安全      80
       信息安全      80
体育专业   体育教育      90
       休闲体育      91
       运动康复      91
dtype: int64

计算机专业  物联网工程    95
            软件工程     103
            网络安全      80
            信息安全      80
体育专业    体育教育      90
            休闲体育      91
            运动康复      91

mult_series["计算机专业"]

物联网工程     95
软件工程     103
网络安全      80
信息安全      80
dtype: int64

mult_series["计算机专业"]["网络安全"]

80

mult_series["体育专业"]

体育教育    90
休闲体育    91
运动康复    91
dtype: int64

type(mult_series)

pandas.core.series.Series

# 访问第一层索引为'计算机专业'的数据
print(mult_series['计算机专业'])

物联网工程     95
软件工程     103
网络安全      80
信息安全      80
dtype: int64

# 访问第二层索引为'软件工程'的数据
print(mult_series['计算机专业']['软件工程'])

103

• dataframe的分层索引

import numpy as np
arrays = ['a','a','b','b'],[1,2,1,2]
frame = pd.DataFrame(np.arange(12).reshape((4,3)),
                 index=pd.MultiIndex.from_arrays(arrays),
                 columns=[['A','A','B'],
                           ['Green','Red','Green']])
print(frame)

        A         B
    Green Red Green
a 1     0   1     2
  2     3   4     5
b 1     6   7     8
  2     9  10    11

frame["A"]

frame["A"]["Green"]

a  1    0
   2    3
b  1    6
   2    9
Name: Green, dtype: int32

frame["B"]

# 访问第一层索引为'A'的数据
print(frame['A'])

     Green  Red
a 1      0    1
  2      3    4
b 1      6    7
  2      9   10

# 访问'A'嵌套的索引为'Green'的数据
print(frame['A']['Green'])

a  1    0
   2    3
b  1    6
   2    9
Name: Green, dtype: int32

frame

frame.loc["a","A"]

frame.loc["a"]["A"]

frame.loc["a"]["A"]["Green"]

1    0
2    3
Name: Green, dtype: int32

(frame.loc["a"]["A"]).loc[1]

Green    0
Red      1
Name: 1, dtype: int32

frame.loc["a"]

# 访问列索引标签为a的数据，第一层索引
print(frame.loc['a'])

      A         B
  Green Red Green
1     0   1     2
2     3   4     5

# 访问列索引标签为A的数据，第二层索引
print(frame.loc['a', 'A'])

   Green  Red
1      0    1
2      3    4

frame

frame.iloc[2]

A  Green    6
   Red      7
B  Green    8
Name: (b, 1), dtype: int32

3.3.5 重新索引

import pandas as pd
from pandas import Series, DataFrame
obj = Series([4.5, 7.2, -5.3, 3.6], index = ['d', 'b', 'a', 'c'])
obj

d    4.5
b    7.2
a   -5.3
c    3.6
dtype: float64

#reindex用法示例
obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
obj2

a   -5.3
b    7.2
c    3.6
d    4.5
e    NaN
dtype: float64

obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value = 9.9)

a   -5.3
b    7.2
c    3.6
d    4.5
e    9.9
dtype: float64

obj3 = Series(['blue', 'purple', 'yellow'], index = [0, 2, 4])
obj3

0      blue
2    purple
4    yellow
dtype: object

#使用ffill实现前向值填充
obj3.reindex(range(6), method = 'ffill')

0      blue
1      blue
2    purple
3    purple
4    yellow
5    yellow
dtype: object

index = ['Firefox', 'Chrome', 'Safari', 'IE10', 'Konqueror']
df = pd.DataFrame({'http_status': [200, 200, 404, 404, 301],
                       'response_time': [0.04, 0.02, 0.07, 0.08, 1.0]},
                        index=index)
print('重新索引前：')
print(df)
print('--------------')
# 重新索引
new_index = ['Safari', 'Iceweasel', 'Comodo Dragon', 'IE10','Chrome']
new_df = df.reindex(new_index)
print('重新索引后：')
print(new_df)

重新索引前：
           http_status  response_time
Firefox            200           0.04
Chrome             200           0.02
Safari             404           0.07
IE10               404           0.08
Konqueror          301           1.00
--------------
重新索引后：
               http_status  response_time
Safari               404.0           0.07
Iceweasel              NaN            NaN
Comodo Dragon          NaN            NaN
IE10                 404.0           0.08
Chrome               200.0           0.02

# 通过fill_value参数，使用指定值对缺失值进行填充
new_df = df.reindex(new_index, fill_value='missing')
print(new_df)

              http_status response_time
Safari                404          0.07
Iceweasel         missing       missing
Comodo Dragon     missing       missing
IE10                  404          0.08
Chrome                200          0.02

col_df = df.reindex(columns=['http_status', 'user_agent'])
print(col_df)

           http_status  user_agent
Firefox            200         NaN
Chrome             200         NaN
Safari             404         NaN
IE10               404         NaN
Konqueror          301         NaN

3.3.6 切片获取的series或者dataframe是视图还是副本？

3.3.6.1 返回连续块的是视图

arr1 = np.random.randint(0,100,12).reshape(3,4)
df = pd.DataFrame(arr1,list("ABC"),list("abcd"))
df

ser1 = df['a']
ser1

A    10
B    54
C    51
Name: a, dtype: int32

ser1["A"] = 100
ser1

A    100
B     54
C     51
Name: a, dtype: int32

df

df2 = df.loc["A":"B","a":"c"]
print(type(df2))
df2

<class 'pandas.core.frame.DataFrame'>

df2.loc["B","b"] = 888
df2

df

# 利用.copy（）得到副本
df22 = df.loc["A":"B","a":"c"].copy()
print(type(df22))
df22

<class 'pandas.core.frame.DataFrame'>

df22.loc["A","b"]=444
df22

df

3.3.6.2 花式索引得到的是副本

df31 = df.loc[["A","C"],"a":"c"]
df31

df31.loc["C","b"] = 333
df31

df31

df

df3 = df.loc[["A","C"],["a","c"]]
print(type(df3))
df3

<class 'pandas.core.frame.DataFrame'>

df3.iloc[1,1] = 999
df3

df

3.4 数据处理常用的操作：增、删、查、改

3.4.1 增

3.4.1.1 增加行

• 插入数据行

#创建一个数据框
arr = np.arange(9)
ar = arr.reshape(3,3)
df = pd.DataFrame(ar)
df

##【插入数据行】
df.loc[6]=['a','b','c']     #指定的位置插入一行，行的索引名必须是不存在的，且长度同现有的行数据长度
df

• 合并数据框

df0 = pd.DataFrame([6,6,6]).T #创建一个新数据框
df0

pd.concat([df,df0],ignore_index=False)  #将df0合并到df中并生成新的数据框，ignore_index=True表示新的数据框的索引被默认改变顺延

pd.concat([df,df0],ignore_index=True)  #将df0合并到df中并生成新的数据框，ignore_index=True表示新的数据框的索引被默认改变顺延

# concat后的结果是副本非原有两个df的视图
df1 = pd.concat([df,df0],ignore_index=True)  #将df0合并到df中并生成新的数据框，ignore_index=True表示新的数据框的索引被默认改变顺延
df1

df0.iloc[0,1]=666
df0

df1

3.4.1.2 增加列

增加一列很简单，类似于字典，若存在则覆盖，没有则新增一列，前提是该列与已有的列长度相等。

df 

df['new'] = ['a','b','c','d']#插入列
df

df.insert(2,'colunm_b',[4,0,2,1])    #在指定的位置插入一列
df

3.4.2 删

3.4.2.1 删除列

df

####【删除1列】
df.drop('colunm_b' ,axis=1, inplace = True) #删除列，inplace = True表示在原数据上
df

#删除多列
df.drop(df.columns[[0,1]], axis=1,inplace= False)   

df

3.4.2.2 删除行

df.drop(1, axis=0, inplace = False)   #按照索引号/名删除行时 axis=0可省略，inplace = False时也可以省略

df 

#按照索引号删除
df.drop(df.index[3], inplace = True)  
df

#删除多个行
df.drop(df.index[[1,2]], inplace = False)  

• 删除特定数值的行,其实是筛选

df

df[~df['new'].str.contains('c')]    #删除列名为2的包含字母c的行

df

# 也可以如下操作布尔索引
df[df['new']!='c']

3.4.3 查

3.4.3.1 在某列或者全局中查找某个具体的值

d = {'a':[1,2,3,2],'b':[0,2,1,2],'c':[0,2,1,2]}
df = pd.DataFrame(d)
df

#查找a列数据为3的行
df[df['a']==3]

#也可以用where处理
np.where(df==3) #查找制定的元素或者值

(array([2], dtype=int64), array([0], dtype=int64))

df==3

3.4.3.2 查找空值

#创建一个含空值的数据框
d = {'a':[1,2,3,2],'b':[0,2,1,2],'c':[0,2,np.NAN,2]}
df = pd.DataFrame(d)
df

np.where(np.isnan(df))  #但是查找空值Nan时最好用np.isnan(df)

(array([2], dtype=int64), array([2], dtype=int64))

3.4.3.3 定位重复数据

df

df_0 = df.duplicated('a')  #显示各行是否重复， bool类型
df_0

0    False
1    False
2    False
3     True
dtype: bool

df_1 = df.duplicated('a',keep="last")
df_1

0    False
1     True
2    False
3    False
dtype: bool

df_0=df_0[df_0]  #显示重复的行，确定重复数据索引
df_0

3    True
dtype: bool

3.4.3.4 删除重复数据

使用drop_duplicates方法

df

#也可以直接用删除行操作
df.drop(3, axis=0, inplace = False) 

3.4.3.5 利用ix查询

pandas中有iloc、loc、ix数据提取方法，其中

3.4.4 改

• 改数据则是能够访问到元素的时候，进行赋值即可。
• .astype()将一列的数据类型

3.4.4.1 更改数据值

data = [["1",11,12],
        ["2",21,22],
        ["3",31,32],
        ["4",41,42]]
df = pd.DataFrame(data,list("ABCD"),list("abc"))
df

• 更改某一个确切位置的值

df.loc["A","a"] = "11"

df

• 更改某列的值

df['a'] = ['1','2','3','4']

df

• 更改某行的值

df.loc['D'] = ["4",41,420]
df

3.4.4.2 更改数据类型

# 如下操作会出错
df["a"]+df["b"]

df.info()  #课件第1行数据类型为object（str)

<class 'pandas.core.frame.DataFrame'>
Index: 4 entries, A to D
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
 0   a       4 non-null      object
 1   b       4 non-null      int64 
 2   c       4 non-null      int64 
dtypes: int64(2), object(1)
memory usage: 300.0+ bytes

df["a"] = df["a"].astype("int64") #对原始数据进行转换并覆盖原始数据列
df.info()

<class 'pandas.core.frame.DataFrame'>
Index: 4 entries, A to D
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype
---  ------  --------------  -----
 0   a       4 non-null      int64
 1   b       4 non-null      int64
 2   c       4 non-null      int64
dtypes: int64(3)
memory usage: 300.0+ bytes

df["a"]+df["b"]

A    12
B    23
C    34
D    45
dtype: int64

3.4.4.3 更改索引名称

df

# 更改行索引名
df.index = [i for i in range(len(df))]
df

# 更改列索引名
df.columns = [i for i in range(df.shape[1])]
df

3.5 数据排序

3.5.1 按索引排序

import numpy as np
import pandas as pd

df = pd.DataFrame(np.arange(9).reshape((3, 3)), 
                     columns=['c', 'a', 'b'],index=['B','C','A'])
# 显示创建的df对象
print(df)
print('--------------')
row_sort =df.sort_index()
print(row_sort)

   c  a  b
B  0  1  2
C  3  4  5
A  6  7  8
--------------
   c  a  b
A  6  7  8
B  0  1  2
C  3  4  5

df

df

df.sort_index(inplace=True)

col_sort = df.sort_index(axis=1)
col_sort

arrays = ['a','a','b','b'],[5,2,3,1]
df2 = pd.DataFrame(np.arange(12).reshape((4,3)),
                 index=pd.MultiIndex.from_arrays(arrays),
                 columns=[['A','A','B'],
                           ['Green','Red','Green']])

df2

df2.sort_index(level=1)

3.5.2 按值排序

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

import numpy as np
df = pd.DataFrame({'col_A':[5,1,4,6],
                       'col_B':[4,np.nan,4,2],
                       'col_C':[6,3,8,0]})
df

new_df = df.sort_values(by='col_B')
new_df

new_df2 = df.sort_values(by=['col_B','col_A'])
new_df2

new_df3 = df.sort_values(by=['col_B','col_A'],ascending=[True, False])
new_df3

df.sort_values(by='col_B', na_position='first')

3.6 统计计算于统计描述

3.6.1 数据总览查看

• DataFrame.head()
• DataFrame.tail()
• DataFrame.describe()
• DataFrame.info()

# 构建一个dataframe  12个同学，5个科目成绩列表
score = np.random.randint(60,100,60).reshape(12,5)
studentNames = ["李思艺",
                "刘昕",
                "朱银莎",
                "张德荣",
                "张维涛",
                "牟伦聪",
                "谭汶江",
                "唐周润",
                "张淑琪",
                "宋越",
                "曾尧",
                "李良鱼"]
cousreNames = ['python','c','java','math','English']
scoreOfClass1 = pd.DataFrame(score, index = studentNames,columns=cousreNames)
scoreOfClass1

3.6.1.1 查看前面的行 .head()

scoreOfClass1.head()#默认前5行

scoreOfClass1.head(3) # 查看前3行

3.6.1.2 查看后面的行.tail()

scoreOfClass1.tail()#默认最后5行

scoreOfClass1.tail(3)  # 查看最后3行

3.6.1.3 查看数据的总体信息 .info()

scoreOfClass1.info()

<class 'pandas.core.frame.DataFrame'>
Index: 12 entries, 李思艺 to 李良鱼
Data columns (total 5 columns):
 #   Column   Non-Null Count  Dtype
---  ------   --------------  -----
 0   python   12 non-null     int32
 1   c        12 non-null     int32
 2   java     12 non-null     int32
 3   math     12 non-null     int32
 4   English  12 non-null     int32
dtypes: int32(5)
memory usage: 336.0+ bytes

3.6.1.4 查看数据的统计信息描述 .describe()

scoreOfClass1.describe()

3.6.2 常见的统计计算

• count() 计算非NAN值的个数
• sum() 计算和
• mean() 计算平均值
• max()、min() 计算最大值、最小值
• idxmax()、idxmin() 计算最大索引值、最小索引值
• var() 计算样本值的方差
• std() 计算样本值的标准差
• cumsum()、cumprod() 计算样本值的累计和、样本值的累计积
• cummin()、cummax() 计算样本值累计最小值、样本值累计最大值

说明： 其中的参数skipna=True表示nan不计入

3.6.2.1 计算非nan值的个数 .count()

# 输出各科参考学生数
scoreOfClass1.count() 

python     12
c          12
java       12
math       12
English    12
dtype: int64

3.6.2.2 计算和 .sum()

# 求每个同学的总分
scoreOfClass1.sum(axis=1,skipna=True)

李思艺    387
刘昕     448
朱银莎    375
张德荣    417
张维涛    389
牟伦聪    413
谭汶江    375
唐周润    400
张淑琪    396
宋越     463
曾尧     411
李良鱼    355
dtype: int64

3.6.2.3 计算平均值 .mean()

# 计算每个学生的平均分
scoreOfClass1.mean(axis=1)

李思艺    77.4
刘昕     89.6
朱银莎    75.0
张德荣    83.4
张维涛    77.8
牟伦聪    82.6
谭汶江    75.0
唐周润    80.0
张淑琪    79.2
宋越     92.6
曾尧     82.2
李良鱼    71.0
dtype: float64

# 计算全班的平均分
scoreOfClass1.mean()

python     83.583333
c          75.916667
java       79.250000
math       78.833333
English    84.833333
dtype: float64

3.6.2.4 计算最大值.max()、最小值.min()

# 列出各科目的最高分
scoreOfClass1.max()

python     98
c          95
java       97
math       95
English    98
dtype: int32

# 列出各科目的最低分
scoreOfClass1.min()

python     63
c          61
java       61
math       60
English    63
dtype: int32

3.6.2.5 计算最大索引值.idxmax()、最小索引值idxmin()

# 找出各课最高分的同学
scoreOfClass1.idxmax(axis = 0)

python     张维涛
c           刘昕
java        宋越
math       牟伦聪
English     宋越
dtype: object

# 找出各个同学最高分的科目
scoreOfClass1.idxmax(axis='columns')

李思艺     python
刘昕           c
朱银莎    English
张德荣          c
张维涛     python
牟伦聪       math
谭汶江     python
唐周润    English
张淑琪       java
宋越     English
曾尧      python
李良鱼     python
dtype: object

# 找出各课最低分的同学
scoreOfClass1.idxmin(axis = 'index')

python     朱银莎
c          朱银莎
java       张维涛
math       李良鱼
English    谭汶江
dtype: object

# 找出各个同学最低分的科目
scoreOfClass1.idxmin(axis='columns')

李思艺    English
刘昕      python
朱银莎          c
张德荣       java
张维涛       java
牟伦聪    English
谭汶江          c
唐周润          c
张淑琪     python
宋越        math
曾尧        math
李良鱼       math
dtype: object

3.6.2.6 计算方差.var()

# 计算各科成绩的方差
scoreOfClass1.var()

python     161.901515
c          152.992424
java       202.931818
math       130.515152
English    145.606061
dtype: float64

3.6.2.7 计算标准差.std()

# 计算各科成绩的标准差
scoreOfClass1.std()

python     12.724053
c          12.369011
java       14.245414
math       11.424323
English    12.066734
dtype: float64

3.6.2.8 计算样本值的累计和cumsum()、样本值的累计积cumprod()

numpy也支持

a= np.array([[1,2,3],[4,5,6]])
a

array([[1, 2, 3],
       [4, 5, 6]])

np.cumsum(a)

array([ 1,  3,  6, 10, 15, 21], dtype=int32)

np.cumprod(a)

array([  1,   2,   6,  24, 120, 720], dtype=int32)

df = pd.DataFrame([[2.0, 1.0,3],
                   [3.0, np.nan,4],
                   [1.0, 0.0,5]],
                   columns=list('ABC'))
df

# 默认情况下迭代行并在每列中查找总和。这相当于axis=None或axis='index'
df.cumsum()

df

# 要迭代列并在每行中查找总和，请使用 axis=1
df.cumsum(axis=1)

cumprod()类似

df.cumprod()

df.cumprod(axis='columns')

3.7 绘制图表

import pandas as pd
df = pd.DataFrame({'商品A':[2,34,25,4],
                    '商品B':[1,3,45,9],
                    '商品C':[7,5,5,3]},
                    index=['第1季度','第2季度','第3季度','第4季度'])
df

df.plot(kind='bar', xlabel='季度', ylabel='销售额（万元）', rot=0)

<matplotlib.axes._subplots.AxesSubplot at 0x1e16174f388>



D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:211: RuntimeWarning: Glyph 31532 missing from current font.
  font.set_text(s, 0.0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:211: RuntimeWarning: Glyph 23395 missing from current font.
  font.set_text(s, 0.0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:211: RuntimeWarning: Glyph 24230 missing from current font.
  font.set_text(s, 0.0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:180: RuntimeWarning: Glyph 31532 missing from current font.
  font.set_text(s, 0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:180: RuntimeWarning: Glyph 23395 missing from current font.
  font.set_text(s, 0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:180: RuntimeWarning: Glyph 24230 missing from current font.
  font.set_text(s, 0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:211: RuntimeWarning: Glyph 38144 missing from current font.
  font.set_text(s, 0.0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:211: RuntimeWarning: Glyph 21806 missing from current font.
  font.set_text(s, 0.0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:211: RuntimeWarning: Glyph 39069 missing from current font.
  font.set_text(s, 0.0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:211: RuntimeWarning: Glyph 65288 missing from current font.
  font.set_text(s, 0.0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:211: RuntimeWarning: Glyph 19975 missing from current font.
  font.set_text(s, 0.0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:211: RuntimeWarning: Glyph 20803 missing from current font.
  font.set_text(s, 0.0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:211: RuntimeWarning: Glyph 65289 missing from current font.
  font.set_text(s, 0.0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:180: RuntimeWarning: Glyph 38144 missing from current font.
  font.set_text(s, 0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:180: RuntimeWarning: Glyph 21806 missing from current font.
  font.set_text(s, 0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:180: RuntimeWarning: Glyph 39069 missing from current font.
  font.set_text(s, 0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:180: RuntimeWarning: Glyph 65288 missing from current font.
  font.set_text(s, 0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:180: RuntimeWarning: Glyph 19975 missing from current font.
  font.set_text(s, 0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:180: RuntimeWarning: Glyph 20803 missing from current font.
  font.set_text(s, 0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:180: RuntimeWarning: Glyph 65289 missing from current font.
  font.set_text(s, 0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:211: RuntimeWarning: Glyph 21830 missing from current font.
  font.set_text(s, 0.0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:211: RuntimeWarning: Glyph 21697 missing from current font.
  font.set_text(s, 0.0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:180: RuntimeWarning: Glyph 21830 missing from current font.
  font.set_text(s, 0, flags=flags)
D:\ProgramFiles\Anaconda3\lib\site-packages\matplotlib\backends\backend_agg.py:180: RuntimeWarning: Glyph 21697 missing from current font.
  font.set_text(s, 0, flags=flags)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9I1iC3HO-1647707912990)(output_361_2.png)]

画出来了，但感觉有点儿不对劲儿？？
汉字没有显示出来

3.7.1 中文字符显示设置

Pandas在绘图时,会显示中文为方块,主要原因有二: matplotlib 字体问题，seaborn 字体问题。
没有中文字体，所以我们只要手动添加中文字体的名称就可以了，不过并不是添加我们熟悉的“宋体”或“黑体”这类的名称，而是要添加字体管理器识别出的字体名称，matplotlib自身实现的字体管理器在文件font_manager.py中，自动生成的可用字体信息在保存在文件fontList.cache里，可以搜索这个文件查看对应字体的名称，例如simhei.ttf对应的名称为’SimHei’，simkai.ttf对应的名称为’KaiTi_GB2312’等。因此我们只要把这些名称添加到配置文件中去就可以让matplotlib显示中文。

import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['font.serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False # 解决保存图像是负号'-'显示为方块的问题,或者转换负号为字符串

import seaborn as sns
sns.set_style("darkgrid",{"font.sans-serif":['KaiTi', 'Arial']})   #这是方便seaborn绘图得时候得字体设置

# 重新绘制
df.plot(kind='bar', xlabel='季度', ylabel='销售额（万元）', rot=0)

<matplotlib.axes._subplots.AxesSubplot at 0x1e1649c4dc8>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TDQAZkow-1647707912992)(output_365_1.png)]

3.7.2 DataFrame.plot()函数

一般格式:

DataFrame.plot(x=None, y=None, kind='line', ax=None, subplots=False, 
                sharex=None, sharey=False, layout=None, figsize=None, 
                use_index=True, title=None, grid=None, legend=True, 
                style=None, logx=False, logy=False, loglog=False, 
                xticks=None, yticks=None, xlim=None, ylim=None, rot=None, 
                fontsize=None, colormap=None, position=0.5, table=False, yerr=None, 
                xerr=None, stacked=True/False, sort_columns=False, 
                secondary_y=False, mark_right=True, **kwds)

主要参数解释:

3.7.3 线形图

普通折线图以折线的上升或下降来表示统计数量的增减变化的统计图，叫作折线统计图。折线统计图不仅可以表示数量的多少，而且可以反映同一事物在不同时间里的发展变化的情况，虽然它不直接给出精确的数据（当然你也可以加上去），但是能够显示数据的变化趋势，反映事物的变化情况。

pandas 有两种绘制线形图的方法:

• 一种是前面介绍的DataFrame.plot()
• 另外一种是DataFrame.plot.line
  推荐使用后一种，前一种在新的pandas版本中可能将取消

test_dict = {'销售量':[1000,2000,5000,2000,4000,3000],'收藏':[1500,2300,3500,2400,1900,3000]}
df = pd.DataFrame(test_dict,index=['一月','二月','三月','四月','五月','六月'])
df.plot();

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mR3da4bT-1647707912993)(output_368_0.png)]

df.plot.line();

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-55vai7IX-1647707912993)(output_369_0.png)]

# 带子图的形式
df.plot.line(subplots=True);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-85L9K5ox-1647707912994)(output_370_0.png)]

3.7.4 条形图

条形统计图可以清楚地表明各种数量的多少。
条形图是统计图资料分析中最常用的图形。
按照排列方式的不同，可分为纵式条形图和横式条形图;
按照分析作用的不同，可分为条形比较图和条形结构图。

条形统计图的特点：
　(1)能够使人们一眼看出各个数据的大小。
　(2)易于比较数据之间的差别。
　(3）能清楚的表示出数量的多少

3.7.4.1 垂直条形图

• DataFrame.plot(kind=‘bar’)

• DataFrame.plot.bar()

• 普通条形图

df.plot(kind='bar');

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ydQXfgPG-1647707912994)(output_375_0.png)]

df.plot.bar();

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2tDSQHoS-1647707912995)(output_376_0.png)]

• 堆积条形图

df.plot(kind='bar',stacked=True);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z6WLevKF-1647707912995)(output_378_0.png)]

df.plot.bar(stacked=True);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wuEEGwIC-1647707912996)(output_379_0.png)]

• 子图并调整x轴标签的旋装方向

df.plot(kind='bar',subplots=True,rot=0);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u9EjBdsM-1647707912997)(output_381_0.png)]

df.plot.bar(subplots=True,rot=0);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3hnM3IFi-1647707912997)(output_382_0.png)]

3.7.4.2 水平条形图

• DataFrame.plot(kind=‘barh’)
• DataFrame.plot.barh()

df.plot(kind='barh');

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tOmoZUZU-1647707912998)(output_384_0.png)]

df.plot.barh(title="销售售业绩图");

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aylbb1l4-1647707912998)(output_385_0.png)]

3.7.5 饼图

适用场景：显示各项的大小与各项总和的比例。适用简单的占比比例图，在不要求数据精细的情况适用。

优势：明确显示数据的比例情况，尤其合适渠道来源分析等场景。

df.plot(kind='pie',
        subplots=True,
        figsize=(10, 8),
        autopct='%.2f%%',# 饼图中添加数值标签的格式
        radius = 1.2, # 设置饼图的半径
        startangle = 250, # 设置饼图的初始角度
        counterclock=False,  #将饼图的顺序设置为顺时针方向
        legend=False,    # 设置不显示图例
        pctdistance = 0.8, # 百分比的text离圆心的距离
        explode = (0,0,0.1,0,0,0), # 将第3各数据抽取出来
        shadow=True, #显示阴影,立体感觉
        colormap='viridis'); # 颜色

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7tinCfte-1647707912999)(output_387_0.png)]

df.plot.pie(subplots=True,
            figsize=(10, 8),
            autopct='%.2f%%',
            radius = 1.2,
            startangle = 250,
            legend=False,
            colormap='viridis');

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qsqm9GCG-1647707912999)(output_388_0.png)]

3.7.6 散点图

适用场景：显示若干数据系列中各数值之间的关系，类似XY轴，判断两变量之间是否存在某种关联。散点图适用于三维数据集，但其中只有两维需要比较。

优势：对于处理值的分布和数据点的分簇，散点图都很理想。如果数据集中包含非常多的点，那么散点图便是最佳图表类型。

3.7.6.1 普通散点图

df

df.plot(kind='scatter',x='收藏',y='销售量');

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6lVgMNFC-1647707913000)(output_392_0.png)]

df.plot.scatter(x='收藏',y='销售量');

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GeMv9rCr-1647707913000)(output_393_0.png)]

3.7.6.2 气泡图

注 气泡（散点）作为大小值（三维关系）

test_dict1 = {'销售量':[1000,2000,5000,2000,4000,3000],'收藏':[1500,2300,3500,2400,1900,3000],'评价数':[20,400,30,50,500,80]}
df1 = pd.DataFrame(test_dict1,index=['一月','二月','三月','四月','五月','六月'])
df1.plot.scatter(x='收藏',y='销售量',s=df1['评价数']);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OgMzzCTU-1647707913001)(output_395_0.png)]

3.7.6.3 多组散点图

ax=df1.plot.scatter(x='评价数',y='收藏',label='评价-收藏',color='c')
df1.plot.scatter(x='评价数',y='销售量',label='评价-销售量',ax=ax);