熬掉了两根头发才整理出来的，python数据分析之pandas基础知识

逃离我推掉我的手 2023-02-13 14:44 6阅读 0赞

# 前言 #

本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjE0MTU0_size_16_color_FFFFFF_t_70_pic_center]

# 1.pandas的数据结构介绍 #

pandas的两个主要数据结构: Series和DataFrame

## 1.1 Series ##

##### 1 Series的基本概念和形式 #####

Series是一种类似于一维数组的对象, 它由一组数据 (各种NumPy数据类型) 以及一组与之相关的数据标签 (即索引) 组成

Series的字符串表现形式为: 索引在左边, 值在右边. 由于我们没有为数据指定索引, 于是会自动创建一个0到 N-1 (N为数据的长度) 的整数型索引

In [2]: import pandas as pd
    
    In [3]: obj = pd.Series([1,2,3,4])
    
    In [4]: obj
    Out[4]:
    0    1
    1    2
    2    3
    3    4
    dtype: int64

##### 2 Series的values, index和name属性 #####

可以通过Series 的values和index属性获取其数组表示形式和索引对象

In [5]: obj.values
    Out[5]: array([ 4,  7, -5,  3], dtype=int64)
    
    In [6]: obj.index
    Out[6]: RangeIndex(start=0, stop=4, step=1)
    Series对象本身及其索引都有一个name属性,  该属性跟pandas其他的关键功能关系非常密切
    
    In [32]: obj4
    Out[32]:
    California        NaN
    Ohio          35000.0
    Oregon        16000.0
    Texas         71000.0
    dtype: float64
    
    In [33]: obj4.name = 'population'
    
    In [34]: obj4.index.name = 'state'
    
    In [35]: obj4
    Out[35]:
    state
    California        NaN
    Ohio          35000.0
    Oregon        16000.0
    Texas         71000.0
    Name: population, dtype: float64

##### 3 Series的索引 #####

Series的字符串表现形式为: 索引在左边, 值在右边. 如果没有指定索引, 那么就会自动创建一个0到N-1的整数型索引. (比如上面的obj)

**(1) 自行创建索引**  
创建的Series带有一个可以对各个数据点进行标记的索引, 即可以自己创建索引的名字.

In [7]: obj2 = pd.Series([4,7,-5,3],index=['d','b','a','c'])
    
    In [8]: obj2
    Out[8]:
    d    4
    b    7
    a   -5
    c    3
    dtype: int64
    
    In [9]: obj2.index
    Out[9]: Index(['d', 'b', 'a', 'c'], dtype='object')
    
    In [10]: obj.values
    Out[10]: array([ 4,  7, -5,  3], dtype=int64)

**(2) Series索引的使用**  
可以通过索引的方式选取Series中的单个或一组值

可使用原索引名字, 也可以用数字索引 \# 如obj2\[‘a’\]或boj2\[2\], 结果都是-5

索引查找单个值 \# obj2\[‘a’\]

索引查找一组值 \# obj2\[\[‘c’,‘a’,‘d’\]\]

结果以\[‘c’,‘a’,‘d’\]排序

利用索引重新赋值 \# obj2\[‘d’\] = 6

In [13]: obj2['a']#索引查找单个值
    Out[13]: -5
    
    In [14]: obj2['d'] = 6#利用索引重新赋值
    
    In [16]: obj2[['c','a','d']]#索引查找一组值
    Out[16]:
    c    3
    a   -5
    d    6
    dtype: int64

其中, \[‘c’,‘a’,‘d’\] 是索引列表. 可以是字符串形式, 也可以是数字.

**(3) 索引本身的修改**  
Series的索引可以通过赋值的方式就地修改

In [10]: obj
    Out[10]:
    0    4
    1    7
    2   -5
    3    3
    dtype: int64
    
    In [11]: obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']
    
    In [12]: obj
    Out[12]:
    Bob      4
    Steve    7
    Jeff    -5
    Ryan     3
    dtype: int64

**(4) 运算会保留索引值的链接**  
使用NumPy函数或类似NumPy的运算 (如根据布尔型数组进行过滤、标量乘法、应用数学函数等) 都会保留索引值的链接.

In [17]: obj2[obj2>0]
    Out[17]:
    d    6
    b    7
    c    3
    dtype: int64
    
    In [18]: obj2 * 2
    Out[18]:
    d    12
    b    14
    a   -10
    c     6
    dtype: int64
    
    In [19]: np.exp(obj2)
    Out[19]:
    d     403.428793
    b    1096.633158
    a       0.006738
    c      20.085537
    dtype: float64

##### 4 Series与字典 #####

(1) 将Series看成一个定长的有序字典  
还可以将Series看成是一个定长的有序字典, 因为它是索引值到数据值的一个映射. 它可以用在许多原本需要字典参数的函数中.

In [20]: 'b' in obj2
    Out[20]: True
    
    In [21]: 'e' in obj2
    Out[21]: False

**(2) 通过字典创建Series**  
如果数据被存放在一个Python字典中, 也可以直接通过这个字典来创建Series.

如果只传入一个字典, 则结果Series中的索引就是原字典的键 (有序排列)

In [22]: sdata = { 'Ohio':35000, 'Texas':71000, 'Oregon': 16000,'Utah': 50000}
    
    In [23]: 'Ohio' in sdata
    Out[23]: True
    
    In [24]: obj3 = pd.Series(sdata)
    
    In [25]: obj3
    Out[25]:
    Ohio      35000
    Texas     71000
    Oregon    16000
    Utah      50000
    dtype: int64

**(3) 可以传入排好序的字典的键以改变顺序**

In [26]: states = ['California', 'Ohio', 'Oregon', 'Texas']
    
    In [27]: obj4 = pd.Series(sdata,index=states)
    
    In [28]: obj4
    Out[28]:
    California        NaN
    Ohio          35000.0
    Oregon        16000.0
    Texas         71000.0
    dtype: float64

sdata中跟states索引相匹配的那3个值会被找出来并放到相应的位置上, 但由于"California"所对应的sdata值找不到, 所以其结果就为NaN(即非数字, not a number)  
‘Utah’不在states中, 它被从结果中除去

##### 5 pandas中检测缺失数据 #####

pandas的isnull和notnull函数可用于检测缺失数据. isnull和notnull既是pandas的顶级函数, 也是方法.

In [29]: pd.isnull(obj4)
    Out[29]:
    California     True
    Ohio          False
    Oregon        False
    Texas         False
    dtype: bool
    
    In [30]: pd.notnull(obj4)
    Out[30]:
    California    False
    Ohio           True
    Oregon         True
    Texas          True
    dtype: bool
    
    In [31]: obj4.notnull()
    Out[31]:
    California    False
    Ohio           True
    Oregon         True
    Texas          True
    dtype: bool

##### 6 Series根据索引标签自动对齐数据 #####

Series最重要的一个功能是, 它会根据运算的索引标签自动对齐数据

In [36]: obj3
    Out[36]:
    Ohio      35000
    Texas     71000
    Oregon    16000
    Utah      50000
    dtype: int64
    
    In [37]: obj4
    Out[37]:
    state
    California        NaN
    Ohio          35000.0
    Oregon        16000.0
    Texas         71000.0
    Name: population, dtype: float64
    
    In [38]: obj3+obj4
    Out[38]:
    California         NaN
    Ohio           70000.0
    Oregon         32000.0
    Texas         142000.0
    Utah               NaN
    dtype: float64

## 1.2 DataFrame ##

##### 1 DataFrame的基本概念 #####

DataFrame是一个表格型的数据结构, 它含有一组有序的列, 每列可以是不同的值类型 (数值、字符串、布尔值等)

DataFrame既有行索引也有列索引, 它可以被看做由Series组成的字典 (共用同一个索引)  
DataFrame中的数据是以一个或多个二维块存放的 (而不是列表、字典或别的一维数据结构)

##### 2 创建DataFrame #####

**(1) 直接传入等长列表或numpy数组组成的字典**  
建DataFrame的办法有很多, 最常用的一种是直接传入一个由等长列表或NumPy数组组成的字典.

In [3]: data = { 'state': ['Ohio','Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
       ...: 'year': [2000, 2001, 2002, 2001, 2002, 2003],
       ...: 'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
    
    In [4]: frame = pd.DataFrame(data)
    
    In [5]: frame
    Out[5]:
        state  year  pop
    0    Ohio  2000  1.5
    1    Ohio  2001  1.7
    2    Ohio  2002  3.6
    3  Nevada  2001  2.4
    4  Nevada  2002  2.9
    5  Nevada  2003  3.2

和Series一样, 结果DataFrame会自动加上索引, 且全部列会被有序排列

选取前五行–head方法:

对于特别大的DataFrame, head方法会选取前五行显示:

In [7]: frame.head()
    Out[7]:
        state  year  pop
    0    Ohio  2000  1.5
    1    Ohio  2001  1.7
    2    Ohio  2002  3.6
    3  Nevada  2001  2.4
    4  Nevada  2002  2.9

**(2) 指定index和columns**  
也可以指定行索引和列索引

1.  指定列索引  
    如果指定了列索引, 则DataFrame的列就会按照指定顺序进行排列

In [13]: pd.DataFrame(data,columns=['year','state','pop'])
    Out[13]:
       year   state  pop
    0  2000    Ohio  1.5
    1  2001    Ohio  1.7
    2  2002    Ohio  3.6
    3  2001  Nevada  2.4
    4  2002  Nevada  2.9
    5  2003  Nevada  3.2

1.  指定列索引和行索引  
    也可以同时指定列索引和行索引

且如果传入的列索引在数据中找不到, 就会在结果中产生缺失值:

In [17]: frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'],index=['one', 'two', 'three', 'four',
        ...: 'five','six'])
    
    In [18]: frame2
    Out[18]:
           year   state  pop debt
    one    2000    Ohio  1.5  NaN
    two    2001    Ohio  1.7  NaN
    three  2002    Ohio  3.6  NaN
    four   2001  Nevada  2.4  NaN
    five   2002  Nevada  2.9  NaN
    six    2003  Nevada  3.2  NaN

注:

1 .从字典到DataFrame的过程中, 如果原来的数据中(即data)有列索引, 那么可以指定列索引, 且列索引数可以不严格和原数据列数目对应, 如果列索引不在原来的数据中, 就会在结果中产生缺失值;  
如果原来的数据中(即data)没有列索引, 即data中没有’stae’,‘year’, ‘pop’. 那么可以赋索引. 且数目必须与data中列的数目对应.  
2 .行索引同理. 在这个例子中, 原来数据中没有行索引, 如果不指定行索引,就会自动产生行索引(0,1,2,3,4,5). 如果指定行索引, 那么行索引数目必须与原数据行数目对应.

**(3) 用嵌套字典创建DataFrame**  
另一种常见的数据形式是嵌套字典,

1.  简单的嵌套字典  
    如果嵌套字典传给DataFrame, pandas就会被解释为: 外层字典的键作为列, 内层键则作为行索引, 而内层字典的键会被合并、排序以形成最终的索引.

In [31]: pop = pop = { 'Nevada': { 2001: 2.4, 2002: 2.9},
        ...: 'Ohio': { 2000: 1.5, 2001: 1.7, 2002: 3.6}}
    
    In [32]: pop
    Out[32]: { 'Nevada': { 2001: 2.4, 2002: 2.9}, 'Ohio': { 2000: 1.5, 2001: 1.7, 2002: 3.6}}
    
    In [33]: frame3 = pd.DataFrame(pop)
    
    In [34]: frame3
    Out[34]:
          Nevada  Ohio
    2001     2.4   1.7
    2002     2.9   3.6
    2000     NaN   1.5

也可以使用类似NumPy数组的方法, 对DataFrame进行转置 (交换行和列)

In [7]: frame3.T
    Out[7]:
            2001  2002  2000
    Nevada   2.4   2.9   NaN
    Ohio     1.7   3.6   1.5

1.  明确指定索引形式  
    如果明确指定了索引, 则情况不是如 1) 一样

In [8]: pd.DataFrame(pop, index=[2001,2002,2003])
    Out[8]:
          Nevada  Ohio
    2001     2.4   1.7
    2002     2.9   3.6
    2003     NaN   NaN
    
    In [9]: pd.DataFrame(pop, index=[2001,2002,2003,2004])
    Out[9]:
          Nevada  Ohio
    2001     2.4   1.7
    2002     2.9   3.6
    2003     NaN   NaN
    2004     NaN   NaN
    
    In [10]: pd.DataFrame(pop, index=[2001,2003,2004])
    Out[10]:
          Nevada  Ohio
    2001     2.4   1.7
    2003     NaN   NaN
    2004     NaN   NaN

**表5-1: 可以输入给 Data Frame构造器的数据**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjE0MTU0_size_16_color_FFFFFF_t_70_pic_center 1]

##### 3 DataFrame的属性 #####

**(1) index-行索引属性**

frame.index
    
    In [36]: frame.index
    Out[36]: RangeIndex(start=0, stop=6, step=1)
    
    In [37]: frame3.index
    Out[37]: Int64Index([2001, 2002, 2000], dtype='int64')
    
    In [38]: frame2.index
    Out[38]: Index(['one', 'two', 'three', 'four', 'five', 'six'], dtype='object')

**(2) columns-列索引属性**

frame.columns
    
    In [39]: frame.columns
    Out[39]: Index(['state', 'year', 'pop'], dtype='object')
    
    In [40]: frame3.columns
    Out[40]: Index(['Nevada', 'Ohio'], dtype='object')
    
    In [41]: frame2.columns
    Out[41]: Index(['year', 'state', 'pop', 'debt'], dtype='object')

**(3) DataFrame中index和columns的name属性**  
类比Series中的name属性, (Series对象本身及其索引(index)都有一个name属性)

对于DataFrame, 索引有两个, 即index和columns. 所以, 有index的name属性和columns的name属性.

frame3.index.name = 'year'
    
    frame3.colmuns.name = 'state'

注意: Series对象本身还有一个name属性.而DataFrame本身也有, 不过很少提到, 也很少用到, 就当成没有吧.

In [88]: frame3.index.name = 'year'
    
    In [89]: frame3.columns.name = 'state'
    
    In [90]: frame3
    Out[90]:
    state  Nevada  Ohio
    year
    2001      2.4   1.7
    2002      2.9   3.6
    2000      NaN   1.5
    
    In [92]: frame3.index.name
    Out[92]: 'year'
    In [93]: frame3.columns.name
    Out[93]: 'state'

**(4) values- 值属性**  
跟Series一样, values属性也会以二维ndarray的形式返回DataFrame中的数据

In [9]: frame3.values
    Out[9]:
    array([[2.4, 1.7],
           [2.9, 3.6],
           [nan, 1.5]])

##### 4 获取DataFrame的行或列的数据(结果都是Series) #####

**(1) 获取DataFrame的列**  
通过类似字典标记的方式或属性的方式, 可以将DataFrame的列获取为一个Series

字典标记: frame2\[‘state’\]\# 也就是索引方式  
属性访问: frame2.state  
以上返回的结果都是Series.

In [43]: frame2['state']
    Out[43]:
    one        Ohio
    two        Ohio
    three      Ohio
    four     Nevada
    five     Nevada
    six      Nevada
    Name: state, dtype: object
    
    In [44]: frame2.state
    Out[44]:
    one        Ohio
    two        Ohio
    three      Ohio
    four     Nevada
    five     Nevada
    six      Nevada
    Name: state, dtype: object

注: 返回的Series拥有原DataFrame相同的索引, 且其name属性也已经被相应地设置好了

延申: 类似于Series, 在使用字典标记的方式的时候, 可以传入\[‘state’, ‘year’\]选取一组Series, 结果还是DataFrame类型.

In [45]: frame2[['year','state']]
    Out[45]:
        year   state
    one    2000    Ohio
    two    2001    Ohio
    three  2002    Ohio
    four   2001  Nevada
    five   2002  Nevada
    six    2003  Nevada

注意: 通过索引方式返回的列只是相应数据的视图而已, 并不是副本. 因此, 对返回的Series所做的任何就地修改全都会反映到源DataFrame上. 通过Series的copy方法即可指定复制列.

**(2) 获取DataFrame的行-loc**  
行也可以通过位置或名称的方式进行获取, 此时需要用到loc属性

In [12]: frame2.loc['three']
    Out[12]:
    year     2002
    state    Ohio
    pop       3.6
    debt      NaN
    Name: three, dtype: object

##### 5 DataFrame列的重新赋值和删除 #####

**(1) DataFrame列的重新赋值**

1.  简单赋值  
    列可以通过赋值的方式进行修改

In [24]: frame2['debt'] = 16.5
    
    In [25]: frame2
    Out[25]:
           year   state  pop  debt
    one    2000    Ohio  1.5  16.5
    two    2001    Ohio  1.7  16.5
    three  2002    Ohio  3.6  16.5
    four   2001  Nevada  2.4  16.5
    five   2002  Nevada  2.9  16.5
    six    2003  Nevada  3.2  16.5
    
    In [26]: frame2['debt']=np.arange(6)
    
    In [27]: frame2
    Out[27]:
           year   state  pop  debt
    one    2000    Ohio  1.5     0
    two    2001    Ohio  1.7     1
    three  2002    Ohio  3.6     2
    four   2001  Nevada  2.4     3
    five   2002  Nevada  2.9     4
    six    2003  Nevada  3.2     5

1.  列表或数组赋值给某个列  
    将列表或数组赋值给某个列时, 其长度必须跟DataFrame的长度相匹配.

而如果赋值的是一个Series, 就会精确匹配DataFrame的索引, 所有的空位都将被填上缺失值.

为不存在的列赋值会创建一个新的列

In [28]: a = [0,0,0,0,0,0] # 列表赋值
    
    In [29]: frame2['debt']=a
    
    In [30]: frame2
    Out[30]:
           year   state  pop  debt
    one    2000    Ohio  1.5     0
    two    2001    Ohio  1.7     0
    three  2002    Ohio  3.6     0
    four   2001  Nevada  2.4     0
    five   2002  Nevada  2.9     0
    six    2003  Nevada  3.2     0
    
    In [31]: b = np.array([1,1,1,1,1,1])
    
    In [32]: frame2['debt'] = b #数组赋值
    
    In [33]: frame2
    Out[33]:
           year   state  pop  debt
    one    2000    Ohio  1.5     1
    two    2001    Ohio  1.7     1
    three  2002    Ohio  3.6     1
    four   2001  Nevada  2.4     1
    five   2002  Nevada  2.9     1
    six    2003  Nevada  3.2     1
    
    In [34]: val = pd.Series([-1.2, -1.5, -1.7], index=['two','four','five'])
    
    In [35]: frame2['debt'] = val # Series赋值
    
    In [36]: frame2
    Out[36]:
           year   state  pop  debt
    one    2000    Ohio  1.5   NaN
    two    2001    Ohio  1.7  -1.2
    three  2002    Ohio  3.6   NaN
    four   2001  Nevada  2.4  -1.5
    five   2002  Nevada  2.9  -1.7
    six    2003  Nevada  3.2   NaN
    
    In [37]: frame2['hello'] = np.arange(6) # 不存在的列赋值
    
    In [38]: frame2
    Out[38]:
           year   state  pop  debt  hello
    one    2000    Ohio  1.5   NaN      0
    two    2001    Ohio  1.7  -1.2      1
    three  2002    Ohio  3.6   NaN      2
    four   2001  Nevada  2.4  -1.5      3
    five   2002  Nevada  2.9  -1.7      4
    six    2003  Nevada  3.2   NaN      5

**(2) DataFrame列的删除 - del**

In [14]: frame2['eastern'] = frame2.state == 'Ohio'
    
    In [15]: frame2
    Out[15]:
           year   state  pop debt  eastern
    one    2000    Ohio  1.5  NaN     True
    two    2001    Ohio  1.7  NaN     True
    three  2002    Ohio  3.6  NaN     True
    four   2001  Nevada  2.4  NaN    False
    five   2002  Nevada  2.9  NaN    False
    six    2003  Nevada  3.2  NaN    False

注: “字典式”可查、可新建列、可删除列, 但“属性式”只能用于查询, 不能用于新建列、删除列

In [18]: del frame2['eastern']
    
    In [19]: frame2
    Out[19]:
           year   state  pop debt
    one    2000    Ohio  1.5  NaN
    two    2001    Ohio  1.7  NaN
    three  2002    Ohio  3.6  NaN
    four   2001  Nevada  2.4  NaN
    five   2002  Nevada  2.9  NaN
    six    2003  Nevada  3.2  NaN

## 1.3 索引对象 ##

##### 1 索引对象的基本概念 #####

pandas的索引对象负责管理轴标签和其他元数据 (比如轴名称等)  
构建Series或DataFrame时, 所用到的任何数组或其他序列的标签都会被转换成一个Index

In [3]: obj = pd.Series(range(3),index=['a','b','c'])
    
    In [4]: index = obj.index
    
    In [5]: index
    Out[5]: Index(['a', 'b', 'c'], dtype='object')
    
    In [6]: index[1:]
    Out[6]: Index(['b', 'c'], dtype='object')

2 建立索引对象

In [11]: labels = pd.Index(np.arange(3))
    In [12]: labels
    Out[12]: Int64Index([0, 1, 2], dtype='int64')
        
    In [9]: dup_labels = pd.Index(['foo','foo','bar','bar'])
    In [10]: dup_labels
    Out[10]: Index(['foo', 'foo', 'bar', 'bar'], dtype='object')

##### 3 index的不可变性 #####

**(1) index对象不可变的**  
Index对象是不可变的, 因此用户不能对其进行修改

In [8]: index[1]='j'
    ---------------------------------------------------------------------------
    TypeError: Index does not support mutable operations

**(2) Index对象可以共享**  
不可变可以使Index对象在多个数据结构之间安全共享

In [11]: labels = pd.Index(np.arange(3))
    
    In [12]: labels
    Out[12]: Int64Index([0, 1, 2], dtype='int64')
    
    In [13]: obj2 = pd.Series([1.5,-2.5,0],index=labels)
    
    In [14]: obj2
    Out[14]:
    0    1.5
    1   -2.5
    2    0.0
    dtype: float64
    
    In [15]: obj2.index is labels
    Out[15]: True

**(3)Index对象与集合**  
除了类似于数组, Index的功能也类似一个固定大小的集合

与python的集合不同, pandas的Index可以包含重复的标签

In [9]: dup_labels = pd.Index(['foo','foo','bar','bar'])
    In [10]: dup_labels
    Out[10]: Index(['foo', 'foo', 'bar', 'bar'], dtype='object')

**(4) Index的方法和属性**  
每个索引都有一些方法和属性, 它们可用于设置逻辑并回答有关该索引所包含的数据的常见问题. 表5-2列出了这些函数.

方法 说明  
append 连接另一个Index对象, 产生一个新的Index  
difference 计算差集, 并得到一个Index  
intersection 计算交集  
union 计算并集  
isin 计算一个指示各值是否都包含在参数集合中的布尔型数组  
delete 删除索引i处的元素, 并得到新的Index  
drop 删除传入的值, 并得到新的Index  
insert 将元素插入到索引i处, 并得到新的Index  
is\_monotonic 当各元素均大于等于前一个元素时, 返回True  
is\_unique 当Index没有重复值时, 返回True  
unique 计算Index中唯一值的数组

# 2 基本功能 #

## 2.1 重新索引–reindex ##

##### 1 重新索引的概念 #####

pandas对象的一个重要方法是reindex, 其作用是创建一个新的索引对象.

##### 2 Series的重新索引 #####

Series的reindex将会根据新索引进行重排. 如果某个索引值当前不存在, 就引入缺失值

In [4]: obj = pd.Series([4.5,7.2,-3,3.4],index=['d','b','a','c'])
    
    
    In [6]: obj2 = obj.reindex(['a','b','c','d','e'])
    
    In [7]: obj2
    Out[7]:
    a   -3.0
    b    7.2
    c    3.4
    d    4.5
    e    NaN
    dtype: float64

参数method可以进行插值处理

如使用ffill可以实现前向值填充:

In [8]: obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
    
    In [9]: obj3.reindex(range(6),method = 'ffill')
    Out[9]:
    0      blue
    1      blue
    2    purple
    3    purple
    4    yellow
    5    yellow
    dtype: object

##### 3 DataFrame的重新索引 #####

在DataFrame中, reindex可以修改行索引和列索引.

当只传递一个序列时, 默认重新索引结果的行  
列可以用columns关键字重新索引

In [11]: frame = pd.DataFrame(np.arange(9).reshape((3, 3)),^M
        ...: index=['a', 'c', 'd'],^M
        ...: columns=['Ohio', 'Texas', 'California'])
        
    In [12]: frame2 = frame.reindex(['a','b','c','d'])
    
    In [13]: frame2
    Out[13]:
       Ohio  Texas  California
    a   0.0    1.0         2.0
    b   NaN    NaN         NaN
    c   3.0    4.0         5.0
    d   6.0    7.0         8.0
    
    In [16]: frame.reindex(columns=states)
    Out[16]:
       Texas  Utah  California
    a      1   NaN           2
    c      4   NaN           5
    d      7   NaN           8

##### 4 reindex参数 #####

表5-3列出了reindex函数的各参数及说明

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjE0MTU0_size_16_color_FFFFFF_t_70_pic_center 2]

## 2.2 丢弃指定轴上的项–drop方法 ##

##### 1 基本概念 #####

丢弃某条轴上的一个或多个项, 可以使用传入一个索引数组或列表的drop方法,

drop方法返回的是一个在指定轴上删除了指定值的新对象, 但是原对象保持不变

##### 2 Series中drop方法的使用 #####

In [4]: obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
    
    In [6]: new_obj = obj.drop('c')# 丢弃一项
    
    In [7]: new_obj
    Out[7]:
    a    0.0
    b    1.0
    d    3.0
    e    4.0
    dtype: float64
    
    In [9]: obj.drop(['d', 'c'])# 丢弃几项
    Out[9]:
    a    0.0
    b    1.0
    e    4.0
    dtype: float64

##### 3 DataFrame中drop方法的使用 #####

默认删除行标签. 等价于参数axis=0或者axis=‘index’  
删除列标签, 传入参数axis=1或者axis=‘columns’

In [11]: data = pd.DataFrame(np.arange(16).reshape((4, 4)),
        ...: .....: index=['Ohio', 'Colorado', 'Utah', 'New York'],
        ...: .....: columns=['one', 'two', 'three', 'four'])
    
    In [12]: data
    Out[12]:
              one  two  three  four
    Ohio        0    1      2     3
    Colorado    4    5      6     7
    Utah        8    9     10    11
    New York   12   13     14    15
    
    In [13]: data.drop(['Colorado','Ohio'])#默认删除行标签
        								   #等价于参数axis=0或者axis='index'
    Out[13]:
              one  two  three  four
    Utah        8    9     10    11
    New York   12   13     14    15
    
    
    In [16]: data.drop('two',axis=1)
    Out[16]:
              one  three  four
    Ohio        0      2     3
    Colorado    4      6     7
    Utah        8     10    11
    New York   12     14    15
    
    
    In [18]: data.drop('two',axis='columns')
    Out[18]:
              one  three  four
    Ohio        0      2     3
    Colorado    4      6     7
    Utah        8     10    11
    New York   12     14    15

##### 4 参数inplace=True, 就地修改 #####

许多函数或方法, 如drop, 当传入参数inplace=True时, 可以就地修改, 不返回新对象

In [21]: data.drop('one',axis=1,inplace=True)
    
    In [22]: data
    Out[22]:
              two  three  four
    Ohio        1      2     3
    Colorado    5      6     7
    Utah        9     10    11
    New York   13     14    15
    
    In [23]: ctest = data.drop('Ohio',inplace=True)
    
    In [24]: ctest#可以看到ctest是空的,说明没有返回任何对象
    
    In [25]: data
    Out[25]:
              two  three  four
    Colorado    5      6     7
    Utah        9     10    11
    New York   13     14    15

使用inplace需小心. 可能会删除原数据.

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjE0MTU0_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200529185658549.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjE0MTU0,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjE0MTU0_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200529184155896.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjE0MTU0,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjE0MTU0_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200529185234206.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjE0MTU0,size_16,color_FFFFFF,t_70#pic_center