[机器学习][基础编程][pandas]pandas基本操作

红太狼 2023-05-30 09:13 16阅读 0赞

### 文章目录 ###

*  pandas基本数据结构
 *  Series：通过一维数组创建
 *  Series值的获取
 *  Series的运算
 *  Series缺失值检测
 *  Series自动对齐
 *  Series及其索引的name属性
 *  DataFrame: 通过二维数组创建
 *  DataFrame: 通过字典的方式创建
 *  索引对象
 *  DataFrame数据获取
 *  pandas基本功能
 *   *  pandas：数据文件读取
     *  pandas：数据过滤获取
     *  pandas：缺省值NaN处理方法
     *  pandas：常用的数学统计方法
     *   *  pandas：相关系数与协方差
     *  pandas：唯一值、值计数以及成员资格
     *  pandas：层次索引
     *  pandas：按照层次索引进行统计数据

# pandas基本数据结构 #

*  pandas中主要有两种数据结构，分别是：Series和DataFrame。
 *  Series：一种类似于一维数组的对象，是由一组数据(各种NumPy数据类型)以及一组与之相关的数据标签(即索引)组成。仅由一组数据也可产生简单的Series对象。注意：Series中的索引值是可以重复的。
 *  DataFrame：一个表格型的数据结构，包含有一组有序的列，每列可以是不同的值类型(数值、字符串、布尔型等)，DataFrame即有行索引也有列索引，可以被看做是由Series组成的字典。

# Series：通过一维数组创建 #

import numpy as np
    from pandas import Series, DataFrame
    import pandas as pd

arr = np.array([1,3,5,np.NaN,10])
    series01 = Series(arr)
    series01

0     1.0
    1     3.0
    2     5.0
    3     NaN
    4    10.0
    dtype: float64

series02 = Series([87,90,89])
    series02

0    87
    1    90
    2    89
    dtype: int64

series02.index=[u'语文',u'数学',u'英语']
    series02

语文    87
    数学    90
    英语    89
    dtype: int64

series03 = Series(data=[87,90,89],dtype=np.float64,index=[u'语文',u'数学',u'英语'])
    series03

语文    87.0
    数学    90.0
    英语    89.0
    dtype: float64

dict1 = { 'name':'Twiss','university':'CMU','degree':'graduate'}
    series04 = Series(dict1)
    series04

name             Twiss
    university         CMU
    degree        graduate
    dtype: object

# Series值的获取 #

Series值的获取主要有两种方式：

*  通过方括号+索引的方式读取对应索引的数据，有可能返回多条数据
 *  通过方括号+下标值的方式读取对应下标值的数据，下标值的取值范围为：\[0，len(Series.values))；另外下标值也可以是负数，表示从右往左获取数据

Series获取多个值的方式类似NumPy中的ndarray的切片操作，通过方括号+下标值/索引值+冒号(:)的形式来截取series对象中的一部分数据。

# Series的运算 #

NumPy中的数组运算，在Series中都保留了，均可以使用，并且Series进行数组运算的时候，索引与值之间的映射关系不会发生改变。  
注意：其实在操作Series的时候，基本上可以把Series看成NumPy中的ndarray数组来进行操作。ndarray数组的绝大多数操作都可以应用到Series上。

series = Series({ '001':879,'002':888,'003':897})
    series

001    879
    002    888
    003    897
    dtype: int64

series[series>880]

002    888
    003    897
    dtype: int64

series/100

001    8.79
    002    8.88
    003    8.97
    dtype: float64

series2 = Series([-1,-2,3,4])
    series2

0   -1
    1   -2
    2    3
    3    4
    dtype: int64

np.exp(series2)

0     0.367879
    1     0.135335
    2    20.085537
    3    54.598150
    dtype: float64

np.fabs(series2)

0    1.0
    1    2.0
    2    3.0
    3    4.0
    dtype: float64

# Series缺失值检测 #

scores = Series({ "Twiss":90,"Evan":89,"Iran":86})
    scores

Twiss    90
    Evan     89
    Iran     86
    dtype: int64

new_index = ["Twiss","Max","Evan","Iran"]
    scores=Series(scores,index=new_index)
    scores

Twiss    90.0
    Max       NaN
    Evan     89.0
    Iran     86.0
    dtype: float64

pandas中的isnull和notnull两个函数可以用于在Series中检测缺失值，这两个函数的返回时一个布尔类型的Series

pd.isnull(scores)

Twiss    False
    Max       True
    Evan     False
    Iran     False
    dtype: bool

pd.notnull(scores)

Twiss     True
    Max      False
    Evan      True
    Iran      True
    dtype: bool

scores[pd.isnull(scores)]

Max   NaN
    dtype: float64

scores[pd.notnull(scores)]

Twiss    90.0
    Evan     89.0
    Iran     86.0
    dtype: float64

# Series自动对齐 #

当多个series对象之间进行运算的时候，如果不同series之间具有不同的索引值，那么运算会自动对齐不同索引值的数据，如果某个series没有某个索引值，那么最终结果会赋值为NaN。

s1 = Series([12,23,45],index=['p1','p2','p3'])
    s2 = Series([54,43,32,21],index=['p2','p3','p4','p5'])

s1+s2

p1     NaN
    p2    77.0
    p3    88.0
    p4     NaN
    p5     NaN
    dtype: float64

s1*s2

p1       NaN
    p2    1242.0
    p3    1935.0
    p4       NaN
    p5       NaN
    dtype: float64

s1/s2

p1         NaN
    p2    0.425926
    p3    1.046512
    p4         NaN
    p5         NaN
    dtype: float64

# Series及其索引的name属性 #

Series对象本身以及索引都具有一个name属性，默认为空，根据需要可以进行赋值操作

scores = Series({ "Twiss":99,"Evan":88,"Iran":85})
    scores.name = u'语文'
    scores.index.name = u'考试成绩'
    scores

考试成绩
    Twiss    99
    Evan     88
    Iran     85
    Name: 语文, dtype: int64

# DataFrame: 通过二维数组创建 #

df01 = DataFrame(["Twiss","Rvan","Wind"],[99,70,88])
    df01

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>0</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>99</th> 
   <td>Twiss</td> 
  </tr> 
  <tr> 
   <th>70</th> 
   <td>Rvan</td> 
  </tr> 
  <tr> 
   <th>88</th> 
   <td>Wind</td> 
  </tr> 
 </tbody> 
</table>

df02 = DataFrame([
        ['Twiss',99],
        ['Rvan',70],
        ['Wind',88]
    ],columns=[u'姓名',u'成绩'])
    df02

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>姓名</th> 
   <th>成绩</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>Twiss</td> 
   <td>99</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>Rvan</td> 
   <td>70</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>Wind</td> 
   <td>88</td> 
  </tr> 
 </tbody> 
</table>

df02.columns

Index(['姓名', '成绩'], dtype='object')

df02.index

RangeIndex(start=0, stop=3, step=1)

df02.values

array([['Twiss', 99],
           ['Rvan', 70],
           ['Wind', 88]], dtype=object)

# DataFrame: 通过字典的方式创建 #

data = { 
        "name":["Twiss","Evan","Wind","Like","Cliera"],
        "score":[998,887,897,878,777],
        "year":2019
    }
    df = DataFrame(data)
    df

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>name</th> 
   <th>score</th> 
   <th>year</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>Twiss</td> 
   <td>998</td> 
   <td>2019</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>Evan</td> 
   <td>887</td> 
   <td>2019</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>Wind</td> 
   <td>897</td> 
   <td>2019</td> 
  </tr> 
  <tr> 
   <th>3</th> 
   <td>Like</td> 
   <td>878</td> 
   <td>2019</td> 
  </tr> 
  <tr> 
   <th>4</th> 
   <td>Cliera</td> 
   <td>777</td> 
   <td>2019</td> 
  </tr> 
 </tbody> 
</table>

df.index=["one","two","three","four","five"]

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>name</th> 
   <th>score</th> 
   <th>year</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>one</th> 
   <td>Twiss</td> 
   <td>998</td> 
   <td>2019</td> 
  </tr> 
  <tr> 
   <th>two</th> 
   <td>Evan</td> 
   <td>887</td> 
   <td>2019</td> 
  </tr> 
  <tr> 
   <th>three</th> 
   <td>Wind</td> 
   <td>897</td> 
   <td>2019</td> 
  </tr> 
  <tr> 
   <th>four</th> 
   <td>Like</td> 
   <td>878</td> 
   <td>2019</td> 
  </tr> 
  <tr> 
   <th>five</th> 
   <td>Cliera</td> 
   <td>777</td> 
   <td>2019</td> 
  </tr> 
 </tbody> 
</table>

# 索引对象 #

*  不管是Series还是DataFrame对象，都有索引对象。
 *  索引对象负责管理轴标签和其它元数据(eg：轴名称等等)
 *  通过索引可以从Series、DataFrame中获取值或者对某个索引值进行重新赋值
 *  Series或者DataFrame的自动对齐功能是通过索引实现的

# DataFrame数据获取 #

*  可以直接通过列索引获取指定列的数据， eg: df\[column\_name\]
 *  如果需要获取指定行的数据的话，需要通过ix方法来获取对应行索引的行数据，eg: df.ix\[index\_name\]

df["year"]

one      2019
    two      2019
    three    2019
    four     2019
    five     2019
    Name: year, dtype: int64

df.loc['one']

name     Twiss
    score      998
    year      2019
    Name: one, dtype: object

df['score']=[990,888,890,870,770]
    df['university'] = np.NaN
    df.loc['five'] = np.NaN
    df

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>name</th> 
   <th>score</th> 
   <th>year</th> 
   <th>university</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>one</th> 
   <td>Twiss</td> 
   <td>990.0</td> 
   <td>2019.0</td> 
   <td>NaN</td> 
  </tr> 
  <tr> 
   <th>two</th> 
   <td>Evan</td> 
   <td>888.0</td> 
   <td>2019.0</td> 
   <td>NaN</td> 
  </tr> 
  <tr> 
   <th>three</th> 
   <td>Wind</td> 
   <td>890.0</td> 
   <td>2019.0</td> 
   <td>NaN</td> 
  </tr> 
  <tr> 
   <th>four</th> 
   <td>Like</td> 
   <td>870.0</td> 
   <td>2019.0</td> 
   <td>NaN</td> 
  </tr> 
  <tr> 
   <th>five</th> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>NaN</td> 
  </tr> 
 </tbody> 
</table>

# pandas基本功能 #

*  数据文件读取/文本数据读取
 *  索引、选取和数据过滤
 *  算法运算和数据对齐
 *  函数的应用和映射
 *  重置索引

## pandas：数据文件读取 ##

通过pandas提供的read\_xxx相关的函数可以读取文件中的数据，并形成DataFrame,常用的数据读取方法为：read\_csv，主要可以读取文本类型的数据

df = pd.read_csv("data1.csv")
    df

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>name</th> 
   <th>age</th> 
   <th>score</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>Twiss</td> 
   <td>24</td> 
   <td>99</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>Wind</td> 
   <td>22</td> 
   <td>98</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>Evan</td> 
   <td>25</td> 
   <td>97</td> 
  </tr> 
 </tbody> 
</table>

df = pd.read_csv("data2.text",sep=';',header=None)
    df

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>0</th> 
   <th>1</th> 
   <th>2</th> 
   <th>3</th> 
   <th>4</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>Twiss</td> 
   <td>24</td> 
   <td>99</td> 
   <td>98</td> 
   <td>78</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>Wind</td> 
   <td>25</td> 
   <td>98</td> 
   <td>97</td> 
   <td>77</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>Evan</td> 
   <td>22</td> 
   <td>97</td> 
   <td>55</td> 
   <td>67</td> 
  </tr> 
 </tbody> 
</table>

## pandas：数据过滤获取 ##

通过DataFrame的相关方式可以获取对应的列或者数据形成一个新的DataFrame, 方便后续进行统计计算。

columns = ['name','age',u'高等数学',u'线性代数',u'离散数学']
    df.columns = columns
    df

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>name</th> 
   <th>age</th> 
   <th>高等数学</th> 
   <th>线性代数</th> 
   <th>离散数学</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>Twiss</td> 
   <td>24</td> 
   <td>99</td> 
   <td>98</td> 
   <td>78</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>Wind</td> 
   <td>25</td> 
   <td>98</td> 
   <td>97</td> 
   <td>77</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>Evan</td> 
   <td>22</td> 
   <td>97</td> 
   <td>55</td> 
   <td>67</td> 
  </tr> 
 </tbody> 
</table>

## pandas：缺省值NaN处理方法 ##

对于DataFrame/Series中的NaN一般采取的方式为删除对应的列/行或者填充一个默认值

*  dropna:根据标签的值中是否存在缺失数据对轴标签进行过滤(删除), 可以通过阈值的调节对缺失值的容忍度
 *  fillna:用指定值或者插值的方式填充缺失数据，比如: ffill或者bfill
 *  isnull:返回一个含有布尔值的对象，这些布尔值表示那些值是缺失值NA
 *  notnull: isnull的否定式

df2 = DataFrame([
        ['Twiss',np.NaN,667,'M'],
        ['JackSon',np.NaN,np.NaN,np.NaN],
        ['Evan',23,np.NaN,'M'],
        ['Wind',18,555,'F']
    ],columns=['name','age','salary','gender'])
    df2

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>name</th> 
   <th>age</th> 
   <th>salary</th> 
   <th>gender</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>Twiss</td> 
   <td>NaN</td> 
   <td>667.0</td> 
   <td>M</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>JackSon</td> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>NaN</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>Evan</td> 
   <td>23.0</td> 
   <td>NaN</td> 
   <td>M</td> 
  </tr> 
  <tr> 
   <th>3</th> 
   <td>Wind</td> 
   <td>18.0</td> 
   <td>555.0</td> 
   <td>F</td> 
  </tr> 
 </tbody> 
</table>

df2.isnull()

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>name</th> 
   <th>age</th> 
   <th>salary</th> 
   <th>gender</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>False</td> 
   <td>True</td> 
   <td>False</td> 
   <td>False</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>False</td> 
   <td>True</td> 
   <td>True</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>False</td> 
   <td>False</td> 
   <td>True</td> 
   <td>False</td> 
  </tr> 
  <tr> 
   <th>3</th> 
   <td>False</td> 
   <td>False</td> 
   <td>False</td> 
   <td>False</td> 
  </tr> 
 </tbody> 
</table>

df2.notnull()

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>name</th> 
   <th>age</th> 
   <th>salary</th> 
   <th>gender</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>True</td> 
   <td>False</td> 
   <td>True</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>True</td> 
   <td>False</td> 
   <td>False</td> 
   <td>False</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>True</td> 
   <td>True</td> 
   <td>False</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <th>3</th> 
   <td>True</td> 
   <td>True</td> 
   <td>True</td> 
   <td>True</td> 
  </tr> 
 </tbody> 
</table>

df2.dropna()

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>name</th> 
   <th>age</th> 
   <th>salary</th> 
   <th>gender</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>3</th> 
   <td>Wind</td> 
   <td>18.0</td> 
   <td>555.0</td> 
   <td>F</td> 
  </tr> 
 </tbody> 
</table>

df2.dropna(how='all')

df2.dropna(axis=1)

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>name</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>Twiss</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>JackSon</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>Evan</td> 
  </tr> 
  <tr> 
   <th>3</th> 
   <td>Wind</td> 
  </tr> 
 </tbody> 
</table>

df = DataFrame(np.random.randn(7,3))
    df.loc[:4,1] = np.nan
    df.loc[:2,2] = np.nan
    df

df.fillna(0)

df.fillna({ 1:0.5,2:-1,3:1})

## pandas：常用的数学统计方法 ##

*  count 计算非NA值的数量
 *  describe 针对Series或各DataFrame列计算总统计值
 *  min/max 计算最大值、最小值
 *  idxmin、idxmax 计算能够获取到最小值和最大值的索引位置(整数)
 *  idxmin、idxmaxe’zui’da’zhi 计算能够获取到最小值和最大值的索引值
 *  quantile 计算样本的分位数(0到1)
 *  sum 值的总和
 *  mean 值的平均数
 *  median 值的中位数
 *  mad 根据平均值计算平均绝对距离差
 *  var 样本数值的方差
 *  std 样本值的标准差
 *  cumsum 样本值的累计和
 *  cummin、cummax 样本的累计最小值、最大值
 *  cumprod 样本值的累计积
 *  pct\_change 计算百分数变化

df = DataFrame({ 
        'GDP':[900,1000,1100,1200,1300],
        'Output_count':[300,400,500,550,600],
        'Year':['2012','2013','2014','2015','2016']
    })
    df

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>GDP</th> 
   <th>Output_count</th> 
   <th>Year</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>900</td> 
   <td>300</td> 
   <td>2012</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>1000</td> 
   <td>400</td> 
   <td>2013</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>1100</td> 
   <td>500</td> 
   <td>2014</td> 
  </tr> 
  <tr> 
   <th>3</th> 
   <td>1200</td> 
   <td>550</td> 
   <td>2015</td> 
  </tr> 
  <tr> 
   <th>4</th> 
   <td>1300</td> 
   <td>600</td> 
   <td>2016</td> 
  </tr> 
 </tbody> 
</table>

df.cov()

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>GDP</th> 
   <th>Output_count</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>GDP</th> 
   <td>25000.0</td> 
   <td>18750.0</td> 
  </tr> 
  <tr> 
   <th>Output_count</th> 
   <td>18750.0</td> 
   <td>14500.0</td> 
  </tr> 
 </tbody> 
</table>

### pandas：相关系数与协方差 ###

协方差  
如果有X,Y两个变量，每个时刻的“X值与其均值之差”乘以“Y值与其均值之差”得到一个乘积，再对这每时刻的乘积求和并求出均值。  
如果协方差为正，说明X，Y同向变化，协方差越大说明同向程度越高；如果协方差为负，说明X，Y反向运动，协方差越小说明反向程度越高。

df['GDP'].cov(df['Output_count'])

18750.0

相关系数  
就是用X、Y的协方差除以X的标准差和Y的标准差。所以，相关系数也可以看成协方差：一种剔除了两个变量量纲影响、标准化后的特殊协方差。  
1.也可以反映两个变量变化时是同向还是反向，如果同向变化为正，反向变化为负  
2.由于它是标准化后的协方差，因此更重的特性是，它消除了两个变量变化幅度的影响，而只是单纯反应两个变量单位变化的相似程度。  
注意：  
相关系数不像协方差一样可以在 ＋ ∞ ＋\\infty ＋∞ 到 － ∞ －\\infty －∞ 间变化，它只能在＋1到－1之间变化  
当相关系数为1的时候两者相识度最大，同向正相关  
当相关系数为0的时候两者没有任何相似度，两个变量无关

df.corr()

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>GDP</th> 
   <th>Output_count</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>GDP</th> 
   <td>1.000000</td> 
   <td>0.984798</td> 
  </tr> 
  <tr> 
   <th>Output_count</th> 
   <td>0.984798</td> 
   <td>1.000000</td> 
  </tr> 
 </tbody> 
</table>

df['GDP'].corr(df['Output_count'])

0.9847982464479191

## pandas：唯一值、值计数以及成员资格 ##

*  unique方法用于获取Series中的唯一值数组(去重数据后的数组)
 *  value\_counts方法用于计算一个Series中各值的出现频率
 *  isin方法用于判断矢量化集合的成员资格，可用于选取Series中或者DataFrame中列中数据的子集

ser = Series(['a','b','c','a'])
    ser

0    a
    1    b
    2    c
    3    a
    dtype: object

ser.unique()

array(['a', 'b', 'c'], dtype=object)

df = DataFrame({ 
        "order_id":['1001','1002','1003','1004','1005'],
        "member_id":['m01','m02','m01','m03','mo4'],
        "order_amount":[111,222,333,444,555]
    })
    df

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>order_id</th> 
   <th>member_id</th> 
   <th>order_amount</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>1001</td> 
   <td>m01</td> 
   <td>111</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>1002</td> 
   <td>m02</td> 
   <td>222</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>1003</td> 
   <td>m01</td> 
   <td>333</td> 
  </tr> 
  <tr> 
   <th>3</th> 
   <td>1004</td> 
   <td>m03</td> 
   <td>444</td> 
  </tr> 
  <tr> 
   <th>4</th> 
   <td>1005</td> 
   <td>mo4</td> 
   <td>555</td> 
  </tr> 
 </tbody> 
</table>

df["member_id"].unique()

array(['m01', 'm02', 'm03', 'mo4'], dtype=object)

ser.value_counts()

a    2
    b    1
    c    1
    dtype: int64

ser.value_counts(ascending=False)

a    2
    b    1
    c    1
    dtype: int64

mask = ser.isin(['b','c'])
    mask

0    False
    1     True
    2     True
    3    False
    dtype: bool

ser[mask]

1    b
    2    c
    dtype: object

## pandas：层次索引 ##

*  在某一个方向拥有多个(两个及两个以上)索引级别
 *  通过层次化索引，pandas能够以较低维度形式处理高纬度的数据
 *  通过层次化索引，可以按照层次统计数据
 *  层次索引包括Series层次索引和DataFrame层次索引

data = pd.Series([100,200,122,150,180],index=[['2019','2019','2019','2018','2018'],
                                                  ['apple','banana','orange','apple','orange']])
    data

2019  apple     100
          banana    200
          orange    122
    2018  apple     150
          orange    180
    dtype: int64

data['2019']

apple     100
    banana    200
    orange    122
    dtype: int64

data[:,'apple']

2019    100
    2018    150
    dtype: int64

# 交换分层索引
    data01 = data.swaplevel().sort_index()
    data01

apple   2018    150
            2019    100
    banana  2019    200
    orange  2018    180
            2019    122
    dtype: int64

#转变DF索引的堆
    data02 = data.unstack(level=1)
    #level等于那一列 那一列就消失出现在column中
    data02

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>apple</th> 
   <th>banana</th> 
   <th>orange</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>2018</th> 
   <td>150.0</td> 
   <td>NaN</td> 
   <td>180.0</td> 
  </tr> 
  <tr> 
   <th>2019</th> 
   <td>100.0</td> 
   <td>200.0</td> 
   <td>122.0</td> 
  </tr> 
 </tbody> 
</table>

data02 = data.unstack(level=0)
    data02

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>2018</th> 
   <th>2019</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>apple</th> 
   <td>150.0</td> 
   <td>100.0</td> 
  </tr> 
  <tr> 
   <th>banana</th> 
   <td>NaN</td> 
   <td>200.0</td> 
  </tr> 
  <tr> 
   <th>orange</th> 
   <td>180.0</td> 
   <td>122.0</td> 
  </tr> 
 </tbody> 
</table>

df = DataFrame({ 
        'year':[2018,2018,2018,2019,2019],
        'fruit':['apple','banana','apple','banana','apple'],
        'account':[2345,3214,4444,5555,2234],
        'profit':[111,222,333,444,555]
    })
    df

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>year</th> 
   <th>fruit</th> 
   <th>account</th> 
   <th>profit</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>2018</td> 
   <td>apple</td> 
   <td>2345</td> 
   <td>111</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>2018</td> 
   <td>banana</td> 
   <td>3214</td> 
   <td>222</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>2018</td> 
   <td>apple</td> 
   <td>4444</td> 
   <td>333</td> 
  </tr> 
  <tr> 
   <th>3</th> 
   <td>2019</td> 
   <td>banana</td> 
   <td>5555</td> 
   <td>444</td> 
  </tr> 
  <tr> 
   <th>4</th> 
   <td>2019</td> 
   <td>apple</td> 
   <td>2234</td> 
   <td>555</td> 
  </tr> 
 </tbody> 
</table>

df = df.set_index(['year','fruit'])
    df

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th></th> 
   <th>account</th> 
   <th>profit</th> 
  </tr> 
  <tr> 
   <th>year</th> 
   <th>fruit</th> 
   <th></th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>2018</th> 
   <th>apple</th> 
   <td>2345</td> 
   <td>111</td> 
  </tr> 
  <tr> 
   <th>banana</th> 
   <td>3214</td> 
   <td>222</td> 
  </tr> 
  <tr> 
   <th>apple</th> 
   <td>4444</td> 
   <td>333</td> 
  </tr> 
  <tr> 
   <th>2019</th> 
   <th>banana</th> 
   <td>5555</td> 
   <td>444</td> 
  </tr> 
  <tr> 
   <th>apple</th> 
   <td>2234</td> 
   <td>555</td> 
  </tr> 
 </tbody> 
</table>

df.loc[2018,'banana']

/usr/local/Cellar/ipython/7.8.0/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:1: PerformanceWarning: indexing past lexsort depth may impact performance.
      """Entry point for launching an IPython kernel.

## pandas：按照层次索引进行统计数据 ##

df.sum(level='year')

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>account</th> 
   <th>profit</th> 
  </tr> 
  <tr> 
   <th>year</th> 
   <th></th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>2018</th> 
   <td>10003</td> 
   <td>666</td> 
  </tr> 
  <tr> 
   <th>2019</th> 
   <td>7789</td> 
   <td>999</td> 
  </tr> 
 </tbody> 
</table>

df.mean(level='fruit')

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>account</th> 
   <th>profit</th> 
  </tr> 
  <tr> 
   <th>fruit</th> 
   <th></th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>apple</th> 
   <td>3007.666667</td> 
   <td>333.0</td> 
  </tr> 
  <tr> 
   <th>banana</th> 
   <td>4384.500000</td> 
   <td>333.0</td> 
  </tr> 
 </tbody> 
</table>

df.min(level=['year','fruit'])

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th></th> 
   <th>account</th> 
   <th>profit</th> 
  </tr> 
  <tr> 
   <th>year</th> 
   <th>fruit</th> 
   <th></th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>2018</th> 
   <th>apple</th> 
   <td>2345</td> 
   <td>111</td> 
  </tr> 
  <tr> 
   <th>banana</th> 
   <td>3214</td> 
   <td>222</td> 
  </tr> 
  <tr> 
   <th>2019</th> 
   <th>banana</th> 
   <td>5555</td> 
   <td>444</td> 
  </tr> 
  <tr> 
   <th>apple</th> 
   <td>2234</td> 
   <td>555</td> 
  </tr> 
 </tbody> 
</table>