import pandas as pd
import numpy as np

# 由np直接生成的ndarray
stock_change = np.random.normal(0, 1, (10, 8))

stock_change

array([[ 0.74057955,  0.78604657, -0.15264135,  0.05680483,  0.09388135,
         0.7313751 , -1.52338443,  1.71156505],
       [ 0.42204925,  0.62541715, -1.41583042, -0.27434654,  0.98587136,
        -0.55797884,  0.31026482, -0.47964535],
       [ 0.99741102, -0.94397298, -0.40782973, -1.33631227, -0.0124836 ,
         1.1873408 , -0.25430393, -0.74264106],
       [ 0.34156662, -0.40621262,  0.82861416,  0.1272128 ,  1.04101412,
         0.79061324, -0.60325544,  1.29954581],
       [-1.23289547,  0.83789748,  1.19276989,  0.45092868, -1.7418129 ,
        -0.65362211, -0.17752493,  1.87679286],
       [-0.4268705 ,  1.14017572,  0.18261009, -0.28947877,  0.82489897,
         0.11566058, -0.53191371, -0.96065812],
       [ 0.92792797,  0.26086313,  0.08316582, -0.94533007, -0.77956139,
         0.23006703, -0.81971461, -1.36742474],
       [ 0.82241768,  0.54201367, -0.19331564,  0.50576697, -0.42545839,
        -0.24247517, -0.03526651, -0.02268451],
       [ 1.67480093, -1.23265948, -2.88199942, -1.07761987, -1.37844497,
        -0.13581683,  2.06013919,  1.18986057],
       [ 0.60744357,  0.52348326,  0.76418263, -0.73385554,  0.54857341,
         0.27310645, -0.26464179,  0.77370496]])

# 通过pd.DataFrame生成    (pd.DataFrame(ndarray))
stock_df = pd.DataFrame(stock_change)

stock_df

stock_df.shape

(10, 8)

# 添加行索引
stock_name = ['股票{}'.format(i+1) for i in range(stock_df.shape[0])]
stock_df = pd.DataFrame(data=stock_change, index=stock_name)

stock_df

# 添加列索引
# 引入df.date_range(),start-开始日期, end: 结束日期,  periods - 持续时间, frep- B:工作日, M:月, D:天
date = pd.date_range(start='2020-3-30', periods=stock_df.shape[1], freq='d')
date

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

stock_df = pd.DataFrame(stock_change, index=stock_name, columns=date)
stock_df

1. Pandas 主要数据结构

1.1 DataFrame

stock_df

# 查看DataFrame形状,类似于2d array
stock_df.shape

(10, 8)

# 取行索引
stock_df.index

Index(['股票1', '股票2', '股票3', '股票4', '股票5', '股票6', '股票7', '股票8', '股票9', '股票10'], dtype='object')

# 取列索引
stock_df.columns

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

# 取ndarray的值
stock_df.values

array([[ 0.74057955,  0.78604657, -0.15264135,  0.05680483,  0.09388135,
         0.7313751 , -1.52338443,  1.71156505],
       [ 0.42204925,  0.62541715, -1.41583042, -0.27434654,  0.98587136,
        -0.55797884,  0.31026482, -0.47964535],
       [ 0.99741102, -0.94397298, -0.40782973, -1.33631227, -0.0124836 ,
         1.1873408 , -0.25430393, -0.74264106],
       [ 0.34156662, -0.40621262,  0.82861416,  0.1272128 ,  1.04101412,
         0.79061324, -0.60325544,  1.29954581],
       [-1.23289547,  0.83789748,  1.19276989,  0.45092868, -1.7418129 ,
        -0.65362211, -0.17752493,  1.87679286],
       [-0.4268705 ,  1.14017572,  0.18261009, -0.28947877,  0.82489897,
         0.11566058, -0.53191371, -0.96065812],
       [ 0.92792797,  0.26086313,  0.08316582, -0.94533007, -0.77956139,
         0.23006703, -0.81971461, -1.36742474],
       [ 0.82241768,  0.54201367, -0.19331564,  0.50576697, -0.42545839,
        -0.24247517, -0.03526651, -0.02268451],
       [ 1.67480093, -1.23265948, -2.88199942, -1.07761987, -1.37844497,
        -0.13581683,  2.06013919,  1.18986057],
       [ 0.60744357,  0.52348326,  0.76418263, -0.73385554,  0.54857341,
         0.27310645, -0.26464179,  0.77370496]])

# 取转置
stock_df.T

# 查看头部几行数据, 默认5行
stock_df.head(5)
# 查看倒数几行数据
stock_df.tail()

1.1.1 设置索引

# 只能通过对整个index 重新赋值, 整行或者整列
data_index = [['股票__{}'.format(i+1) for i in range(stock_df.shape[0])]]
stock_df.index = data_index

stock_df

# stock_df.index[3] ='hahha'
# stock_df

1.1.2 重设索引

# reset_index在原来基础上新增一列索引
# drop=False(默认) - 不丢弃原来索引
# drop=True - 丢掉原来索引 index
stock_df.reset_index()

stock_df.reset_index(drop=True)

1.1.3 以某列为索引

stock_df.set_index(keys='2020-03-30', drop=False) #此处因为类型问题,都是drop 原来的index

# 字典方式创建DataFrame
df = pd.DataFrame({'month': [1, 4, 7, 10],
                    'year': [2012, 2014, 2013, 2014],
                    'sale':[55, 40, 84, 31]})

df

df.set_index(keys='month')

# 设置2个index, 就是MultiIndex (三维数据结构)
# df.set_index(keys=['month', 'year'])
df.set_index(['month', 'year'])

1.2 MultiIndex

df_m = df.set_index(['year', 'month'])

df_m

# index属性
# - names: levers的名称
# - levels: 每个level的列表值
df_m.index

MultiIndex([(2012,  1),
            (2014,  4),
            (2013,  7),
            (2014, 10)],
           names=['year', 'month'])

df_m.index.names

FrozenList(['year', 'month'])

df_m.index.levels

FrozenList([[2012, 2013, 2014], [1, 4, 7, 10]])

1.3 Series

# 自动生成从0开始的行索引 index
# Data must be 1-dimensional
pd.Series(np.arange(10))

0    0
1    1
2    2
3    3
4    4
5    5
6    6
7    7
8    8
9    9
dtype: int32

# 手动指定index值
pd.Series([6.7,5.6,3,10,2], index=['a', 'b', 'c', 'd', 'e'])

a     6.7
b     5.6
c     3.0
d    10.0
e     2.0
dtype: float64

# 通过字典创建
se = pd.Series({'red':100, 'blue':200, 'green': 500, 'yellow':1000})

se

red        100
blue       200
green      500
yellow    1000
dtype: int64

# 取索引
se.index

Index(['red', 'blue', 'green', 'yellow'], dtype='object')

# 取array值
se.values

array([ 100,  200,  500, 1000], dtype=int64)

pd.Series(np.random.normal(0, 1, (10)))

0   -0.975747
1    0.021589
2   -0.384579
3   -0.412900
4    0.218133
5   -0.866525
6   -0.777209
7   -1.032130
8    0.202134
9    0.295274
dtype: float64

2.基本数据操作

2.1 索引操作

# 使用pd.read_csv()读取本地数据
data = pd.read_csv('./data/stock_day.csv')

data

# 去除一些列,简化数据
data = data.drop(["ma5","ma10","ma20","v_ma5","v_ma10","v_ma20"], axis=1)  # axis=1 去除对应的列,与numpy相反

data

2.1.1 直接使用行列索引

# 必须先列后行
data['high']['2018-02-27']

25.88

# data['2018-02-27']['high']

2.1.2 使用loc和iloc取索引

# loc取字符串, 先行后列
data.loc['2018-02-27']['high'] 

25.88

# 两种取值方式都可以
data.loc['2018-02-27','high'] 

25.88

data.loc['2018-02-27':'2018-02-22', 'open']

2018-02-27    23.53
2018-02-26    22.80
2018-02-23    22.88
2018-02-22    22.25
Name: open, dtype: float64

# data.loc['high']['2018-02-27']

# iloc取索引数字,先行后列
data.iloc[:3, 3:5]

2.1.3 使用ix取混合索引

# ix可以去数字和字符串, 先行后列
# 现版本中已被取消
# data.ix[0:4, ['open', 'close', 'high', 'low']]

# 先通过data.index去除索引并切片
data.loc[data.index[0:4], ['open', 'close', 'high', 'low']]

data.index

Index(['2018-02-27', '2018-02-26', '2018-02-23', '2018-02-22', '2018-02-14',
       '2018-02-13', '2018-02-12', '2018-02-09', '2018-02-08', '2018-02-07',
       ...
       '2015-03-13', '2015-03-12', '2015-03-11', '2015-03-10', '2015-03-09',
       '2015-03-06', '2015-03-05', '2015-03-04', '2015-03-03', '2015-03-02'],
      dtype='object', length=643)

data.iloc[0:4, data.columns.get_indexer(['open', 'close', 'high', 'low'])]

data.columns.get_indexer(['close'])

array([2], dtype=int64)

data

2.2 赋值操作

data

# 赋值方式1, 直接取对应的属性值
data.volume = 100

data.head()

# 赋值方式2, 类似于取切片
data['low'] = 100

data.head()

# 直接取出Series
data.open.head()

2018-02-27    23.53
2018-02-26    22.80
2018-02-23    22.88
2018-02-22    22.25
2018-02-14    21.49
Name: open, dtype: float64

# 直接取出Series
data['open'].head()

2018-02-27    23.53
2018-02-26    22.80
2018-02-23    22.88
2018-02-22    22.25
2018-02-14    21.49
Name: open, dtype: float64

2.3 排序

data.head()

2.3.1 以特征值排序

# by --> 传入特征值, 可以传一个或者多个,以列表形式,排前面的作为高优先级,默认升序
data.sort_values(by='open', ascending=False)

data.sort_values(by=['open', 'high'], ascending=True)

# Series 排序因为只有一个特征值,所以不需要传参
data.close.sort_values()

2015-09-02    12.36
2015-03-02    12.52
2015-03-03    12.70
2015-09-07    12.77
2015-03-04    12.90
              ...  
2017-11-01    33.83
2015-06-10    33.85
2015-06-11    34.39
2017-10-31    34.44
2015-06-12    35.21
Name: close, Length: 643, dtype: float64

2.3.2 以索引排序

# DataFrame 使用sort_index 以索引排序
data.sort_index()

# Series 排序
data.high.sort_index()

2015-03-02    12.67
2015-03-03    13.06
2015-03-04    12.92
2015-03-05    13.45
2015-03-06    14.48
              ...  
2018-02-14    21.99
2018-02-22    22.76
2018-02-23    23.37
2018-02-26    23.78
2018-02-27    25.88
Name: high, Length: 643, dtype: float64

3. DataFrame运算

3.1 算数运算

data.head()

# 推荐使用pd.方法
data['close'].add(100).head()

2018-02-27    124.16
2018-02-26    123.53
2018-02-23    122.82
2018-02-22    122.28
2018-02-14    121.92
Name: close, dtype: float64

# 使用符号运算
(data.close + 100).head()

2018-02-27    124.16
2018-02-26    123.53
2018-02-23    122.82
2018-02-22    122.28
2018-02-14    121.92
Name: close, dtype: float64

data.close.sub(10).head()

2018-02-27    14.16
2018-02-26    13.53
2018-02-23    12.82
2018-02-22    12.28
2018-02-14    11.92
Name: close, dtype: float64

3.2 逻辑运算

3.2.1 逻辑运算符 （ <, > , |, &)

data.head()

# data.open 返回数据 True, False
# data[data.open] 逻辑判断的结果作为筛选依据
data['open'] > 23

2018-02-27     True
2018-02-26    False
2018-02-23    False
2018-02-22    False
2018-02-14    False
              ...  
2015-03-06    False
2015-03-05    False
2015-03-04    False
2015-03-03    False
2015-03-02    False
Name: open, Length: 643, dtype: bool

data[data.open>23].head()

# 利用与或 (& |)完成逻辑判断 
# 优先级问题，多加括号
data[(data.close>23) & (data.close<24)].head()

3.2.2 逻辑运算函数

# query（str) 传入字符串
data.query('close>23 & close<24').head()

# isin() 可以传一个值, 也可以传一个列表范围, 判断是否在某个范围内
data['open'].isin([22.80, 23.00])

2018-02-27    False
2018-02-26     True
2018-02-23    False
2018-02-22    False
2018-02-14    False
              ...  
2015-03-06    False
2015-03-05    False
2015-03-04    False
2015-03-03    False
2015-03-02    False
Name: open, Length: 643, dtype: bool

data[data['open'].isin([22.80, 23.00])]

3.3 统计运算

3.3.1 describe()

# describe()方法可以快速的查看DataFrame的整体属性
# 25% - 第一四分位数(Q1),样本中从小到大排列后第25%的数据
# 50% - 中位数
data.describe()

3.3.2 统计函数

# max(), min()
data.max()

open             34.99
high             36.35
close            35.21
low             100.00
volume          100.00
price_change      3.03
p_change         10.03
turnover         12.56
dtype: float64

data.std()
# data.var()

open            3.930973
high            4.077578
close           3.942806
low             0.000000
volume          0.000000
price_change    0.898476
p_change        4.079698
turnover        2.079375
dtype: float64

data.median()

open             21.44
high             21.97
close            21.45
low             100.00
volume          100.00
price_change      0.05
p_change          0.26
turnover          2.50
dtype: float64

# idxmax ( index-max) 最大值的索引值
data.idxmax()
# data,idxmin()

open            2015-06-15
high            2015-06-10
close           2015-06-12
low             2018-02-27
volume          2018-02-27
price_change    2015-06-09
p_change        2015-08-28
turnover        2017-10-26
dtype: object

3.4 累计统计函数

# 常见累计统计函数为:
# cumsum - 累加
# cummax - 累计取最大值, 新的最大值替换原来的最大值
# cummin - 累计取最小值
# cumprod - 累积

data = data.sort_index()
data.p_change

2015-03-02    2.62
2015-03-03    1.44
2015-03-04    1.57
2015-03-05    2.02
2015-03-06    8.51
              ... 
2018-02-14    2.05
2018-02-22    1.64
2018-02-23    2.42
2018-02-26    3.02
2018-02-27    2.68
Name: p_change, Length: 643, dtype: float64

data.p_change.cumsum()

2015-03-02      2.62
2015-03-03      4.06
2015-03-04      5.63
2015-03-05      7.65
2015-03-06     16.16
               ...  
2018-02-14    112.59
2018-02-22    114.23
2018-02-23    116.65
2018-02-26    119.67
2018-02-27    122.35
Name: p_change, Length: 643, dtype: float64

# 利用Pandas自带的绘图功能, 需要运行2次才能出结果
data.p_change.cumsum().plot()

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

data.p_change.cummax().plot()

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

3.5 自定义函数

# apply(func), fun - lambda函数
data[['open']] # [[]]取出DataFrame

data[['open']].apply(lambda x: x.max()-x.min()) # 默认axis=0

open    22.74
dtype: float64

4. Pandas内置画图

# DataFrame(x, y, kind='line')
# kind: 绘图的类型, line, bar, barh, hist, pie, scatter

# DataFrame
data['open'].plot(kind='hist')

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

5. 文件读取与存储

5.1 csv文件

# usecols -abs 读取特定列,列表形式传入
# sep=',' 分隔

# 读取文件
data = pd.read_csv('./data/stock_day.csv', usecols=['open', 'high', 'low'], sep=',')

data

# 存储文件
# columns ：存储指定列,
# index：是否存储index
data[:10].to_csv('./data/test_write_in.csv',columns=['high', 'low'], index=False)

5.2 hdf文件

# hdf文件格式是官方推荐的格式，存储读取速度快
# 压缩方式读取速度快，节省空间
# 支持跨平台

day_eps = pd.read_hdf('./data/stock_data/day/day_close.h5')

# 需要安装tables模块才能显示
# hdf文件不能直接打开，需要导入后才能打开
day_eps

# 存储格式为 .h5
day_eps_test = day_eps.to_hdf('./data/day_eps_test.h5', key='day_eps')

pd.read_hdf('./data/day_eps_test.h5')

5.3 json文件

# oritent: 读取方式
# lines: 是否按行读取

json_read = pd.read_json("./data/Sarcasm_Headlines_Dataset.json", orient="records", lines=True)

json_read

# lines 表示存储数据分行， 否则全部为一整行
json_read.to_json('./data/test.json', orient='records', lines=True)

6.高级处理

6.1 处理缺失值

# 缺失值一般使用nan(not a number)来表示
type(np.nan)

float

# 导入数据
movie = pd.read_csv('./data/IMDB-Movie-Data.csv')
movie.head()

# 判断缺失值是否存在
# isnull() :nan - True
# notnull()：nan - False
pd.isnull(movie)

np.any(pd.isnull(movie))  # 其中有任何一个为True(nan值存在), 则返回True

True

np.all(pd.notnull(movie)) # 所有的元素都非nan

False

6.1.1 丢弃缺失值

# 直接丢弃含有nan的一行数据
data = movie.dropna()

np.any(pd.isnull(data))

False

6.1.2 替换缺失值 （常见：平均值或者0）

# 使用平均值替换
# inplace=True , 表示直接对原来movie值进行修改
data = movie['Revenue (Millions)'].fillna(movie['Revenue (Millions)'].mean())

# inplace默认为False, 返回了新的替换后的一个data数据, 原来的movie中仍含有nan
np.any(pd.isnull(movie['Revenue (Millions)']))

True

movie['Revenue (Millions)'].fillna(movie['Revenue (Millions)'].mean(), inplace=True)

# movie['Revenue (Millions)'] 中的nan 已经被替换
np.any(pd.isnull(movie['Revenue (Millions)']))

False

6.1.3 缺失值不是nan

# 全局取消证书验证
# 读取数据
import ssl
ssl._create_default_https_context = ssl._create_unverified_context

wis = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data")

# 先将? 数据替换成nan
# 再对nan进行处理

wis

# to_replace: 被替换的值, value:去替换的值
wis = wis.replace(to_replace='?', value=np.nan)
wis = wis.dropna()

wis

6.2 数据离散化

# 数据离散化可以简化数据结构,将数据划分到若干离散的区间,可以简化数据结构, 常用于搭配one-hot编码

# 获取数据
data = pd.read_csv("./data/stock_day.csv")
data_p= data['p_change']

data_p

2018-02-27    2.68
2018-02-26    3.02
2018-02-23    2.42
2018-02-22    1.64
2018-02-14    2.05
              ... 
2015-03-06    8.51
2015-03-05    2.02
2015-03-04    1.57
2015-03-03    1.44
2015-03-02    2.62
Name: p_change, Length: 643, dtype: float64

# pd.qcut() 智能分组
# q: 分组数量
q_cut = pd.qcut(data_p, q=10)
q_cut

2018-02-27    (1.738, 2.938]
2018-02-26     (2.938, 5.27]
2018-02-23    (1.738, 2.938]
2018-02-22     (0.94, 1.738]
2018-02-14    (1.738, 2.938]
                   ...      
2015-03-06     (5.27, 10.03]
2015-03-05    (1.738, 2.938]
2015-03-04     (0.94, 1.738]
2015-03-03     (0.94, 1.738]
2015-03-02    (1.738, 2.938]
Name: p_change, Length: 643, dtype: category
Categories (10, interval[float64]): [(-10.030999999999999, -4.836] < (-4.836, -2.444] < (-2.444, -1.352] < (-1.352, -0.462] ... (0.94, 1.738] < (1.738, 2.938] < (2.938, 5.27] < (5.27, 10.03]]

# value_counts(): 每个分组区间内的数据数量
q_cut.value_counts()

(5.27, 10.03]                    65
(0.26, 0.94]                     65
(-0.462, 0.26]                   65
(-10.030999999999999, -4.836]    65
(2.938, 5.27]                    64
(1.738, 2.938]                   64
(-1.352, -0.462]                 64
(-2.444, -1.352]                 64
(-4.836, -2.444]                 64
(0.94, 1.738]                    63
Name: p_change, dtype: int64

# pd.cut(data, bins): 自己指定分组区间
bins  = [-100, -7, -5, -3, 0, 3, 5, 7, 100]
cut = pd.cut(data_p, bins=bins)

cut

2018-02-27      (0, 3]
2018-02-26      (3, 5]
2018-02-23      (0, 3]
2018-02-22      (0, 3]
2018-02-14      (0, 3]
                ...   
2015-03-06    (7, 100]
2015-03-05      (0, 3]
2015-03-04      (0, 3]
2015-03-03      (0, 3]
2015-03-02      (0, 3]
Name: p_change, Length: 643, dtype: category
Categories (8, interval[int64]): [(-100, -7] < (-7, -5] < (-5, -3] < (-3, 0] < (0, 3] < (3, 5] < (5, 7] < (7, 100]]

cut.value_counts()

(0, 3]        215
(-3, 0]       188
(3, 5]         57
(-5, -3]       51
(7, 100]       35
(5, 7]         35
(-100, -7]     34
(-7, -5]       28
Name: p_change, dtype: int64

# get_dummies() 取独热矩阵
pd.get_dummies(q_cut)

data_dummy = pd.get_dummies(q_cut)

6.3 数据拼接

6.3.1 pd.concat()

# 不指定axis 可能会造成拼接错位,产生很多nan
pd.concat([data, data_dummy], axis=1)

6.3.2 pd.merge()

# 获取数据
left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                        'key2': ['K0', 'K1', 'K0', 'K1'],
                        'A': ['A0', 'A1', 'A2', 'A3'],
                        'B': ['B0', 'B1', 'B2', 'B3']})

right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                        'key2': ['K0', 'K0', 'K0', 'K0'],
                        'C': ['C0', 'C1', 'C2', 'C3'],
                        'D': ['D0', 'D1', 'D2', 'D3']})
# 默认内连接
# on: 以什么作为键来拼接
result = pd.merge(left, right, on=['key1', 'key2'])

# 内连接就是取交集
result

# 外连接
pd.merge(left, right, on=['key1', 'key2'], how='outer')

# 左连接
pd.merge(left, right, on=['key1', 'key2'], how='left')

# 右连接
pd.merge(left, right, on=['key1', 'key2'], how='right')

6.4 交叉表和透视表

data.head()

# 将date.index 转化为datetime格式
date = pd.to_datetime(data.index).weekday
data['week'] = date

data

# 把p_change 划分为0, 1两类
data['posi_neg'] = np.where(data['p_change']>0, 1, 0)

data.head()

# 手动构造交叉表
count = pd.crosstab(data['week'], data['posi_neg'])

sum = count.sum(axis=1).astype(np.float32)
pro = count.div(sum, axis=0)

pro.plot(kind='bar', stacked=True)

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

# 自动构造交叉表
data.pivot_table(['posi_neg'], index='week')

6.5 分组和聚合

6.5.1 pd.groupby()

# 创建数据
col =pd.DataFrame({'color': ['white','red','green','red','green'], 'object': ['pen','pencil','pencil','ashtray','pen'],'price1':[5.56,4.20,1.30,0.56,2.75],'price2':[4.75,4.12,1.60,0.75,3.15]})

col

# DataFrame 分组, 推荐使用
# 单独的分组没有意义,进行聚合(求值)才有价值
col.groupby(['color'])['price1'].mean()

color
green    2.025
red      2.380
white    5.560
Name: price1, dtype: float64

# 如果设置as_index= False 会创建一列新索引
col.groupby(['color'], as_index= False)['price1'].mean()

col.price1

0    5.56
1    4.20
2    1.30
3    0.56
4    2.75
Name: price1, dtype: float64

# Series 分组
col.price1.groupby(col['color']).mean()

color
green    2.025
red      2.380
white    5.560
Name: price1, dtype: float64

6.5.2 分组实例

# 获取数据
starbucks = pd.read_csv("./data/starbucks/directory.csv")

starbucks.head()

# 以一个值为分组依据
starbucks.groupby(['Country']).count()

starbucks_count = starbucks.groupby(['Country']).count()
starbucks_count['Brand'].plot(kind='bar', figsize=(20, 8))

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

# 为了阅读方便,对数据进行排序后画图
starbucks_count.sort_values(by='Brand', ascending=False).head(20)['Brand'].plot(kind='bar', figsize=(20, 8))

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

# 多种分组依据
starbucks.groupby(['Country', 'State/Province']).count().head(20)