pandas基础这一篇足以,看完即成初级数据分析师

太过爱你忘了你带给我的痛 2021-07-24 15:27 522阅读 0赞

本文是基于上一篇pandas的补充,为了不影响知识整体的结构,写在一起,方便客官们查阅.后期的博客还会有pandas的高级内容

### 小弟的目录 ###

*  1.1Pandas概述:
 *  1.2Pandas的数据结构分析
 *   *  Series
     *   *  Series的介绍
         *  Series对象的创建
     *  DataFrame
     *   *  DataFrame的介绍:
         *  DataFrame对象的创建:
         *  重置索引
         *   *  reindex参数说明
 *  1.3索引操作
 *   *  Series类型的索引操作
     *  DataFrame的索引操作
     *  pandas库中提供了操作索引的方法来访问数据
 *  
 *  1.4pandas的算术运算和数据对齐
 *   *  算术运算
     *  数据排序:
     *   *  按索引排序
         *  按值排序
 *  1.5统计计算与描述
 *   *  常用的统计计算
 *  1.6Pandas的索引对象:
 *   *  索引对象的创建
     *  索引对象的分类
     *  索引对象的获取:
     *  索引对象的特点:
     *  索引对象的方法和属性
     *   *  方法:
         *  属性:
     *  索引对象的重命名(轴索引)
 *  1.7索引的整数索引:
 *   *  程序:
     *  解析:
     *  整数索引的规则:
     *   *  非整数索引:
     *  整数标签基于位置的使用方法:

# 1.1Pandas概述: #

Pandas是一个基于Numpy的数据分析包，它是为了解决数据分析任务而创建的。Pandas中纳入了大量库和标准的数据模型，提供了高效地操作大型数据集所需的函数和方法，使用户能够快速便捷地处理数据。

**Pandas特点：**

*  一个快速高效的DataFrame对象，具有默认和自定义的索引  
    \*用于在数据结构和不同文件格式中读取和写入数据，比如文本文件  
    \*智能数据对齐和缺失数据的集成处理  
    \*基于标签切片和花式索引获取数据集的子集  
    \*可以删除或插入来自数据结构的列  
    \*按数据分组进行聚合和转换  
    \*高性能的数据合并和连接  
    \*时间序列功能

# 1.2Pandas的数据结构分析 #

Pandas中有两个主要的数据结构：`Series`和`DataFrame`。其中`Series`是一维的、`DataFrame`是二维的。

## Series ##

### Series的介绍 ###

Series是一个类似于一维数组的对象，它能够保存任何类型的数据，主要由一组数据和与之相关的索引两部分构成。  
Series

<table> 
 <thead> 
  <tr> 
   <th align="right">index</th> 
   <th align="right">element</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="right">0</td> 
   <td align="right">1</td> 
  </tr> 
  <tr> 
   <td align="right">1</td> 
   <td align="right">2</td> 
  </tr> 
  <tr> 
   <td align="right">2</td> 
   <td align="right">3</td> 
  </tr> 
  <tr> 
   <td align="right">3</td> 
   <td align="right">4</td> 
  </tr> 
  <tr> 
   <td align="right">4</td> 
   <td align="right">5</td> 
  </tr> 
 </tbody> 
</table>

**索引在左，数据在右**

### Series对象的创建 ###

Pandas的Series类对象可以使用以下构造方法创建：  
class pandas.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)

**构造方法中常用参数含义如下：**

1.data：传入的数据，可以是ndarray、list等。  
2.index：索引，必须是唯一的，且与数据的长度相同。如果没有传入索引参数，默认会自动创建一个从0~N的整数索引。  
3.dtype：数据的类型  
4.copy：是否复制数据，默认为False

import pandas as pd
    ser_obj = pd.Series([1,2,3,4,5])
    ser_obj

可以在创建的时候，为数据指定索引：

import pandas as pd
    ser_obj = pd.Series([1,2,3,4,5],index=['a','b','c','d','e'])
    ser_obj

使用列表构建Series外，可以使用dict进行构建，具体如下：

year_data = { 2001:17.8, 2002:20.1, 2003:16.5}
    ser_obj2 = pd.Series(year_data)
    ser_obj2

为了方便的操作Series对象中的索引和数据，所以该对象提供两个属性index和values分别进行获取。

## DataFrame ##

### DataFrame的介绍: ###

DataFrame是一个类似于二维数组或表格的对象，它每列数据可以是不同的数据类型。由索引和数据组成，有行索引、还有列索引。  
默认索引也是自动创建，默认是从0-N的整数类型索引。

### DataFrame对象的创建: ###

Pandas的DataFrame类对象可以使用以下构造方法创建：  
pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=None)  
**常用参数如下：**

*  `index`：行标签。如果没有传入索引参数，默认会自动创建一个从0-N的整数类型索引  
    \*`columns`：列标签，如果没有传入索引参数，默认会自动创建一个从0-N的整数类型索引

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类对象时，指定了索引，则DataFrame的列会按照指定的索引顺序进行排列：

df_obj =pandas.DataFrame(demo_arr,)columns=['No1','No2','No3']
    df_obj

为了便于获取每列数据，可以使用列索引方式，也可以通过访问属性方式来获取，返回一个结果是Series对象，该对象拥有与原DataFrame对象相同的行索引。

element = df_obj['No2']
    element

**注意：在获取DataFrame的一列数据时，推荐使用列索引方式**

要想为DataFrame增加一列数据，则可以通过给列索引或者列名称赋值的方式实现，类似于给字典增加键值对的操作。

df_obj['No4'] = ['g','h']
    df_obj

删除一列数据:

del df_obj['No3']
    
    print(df_obj)

### 重置索引 ###

Pandas中提供一个重要方法是reindex()，该方法的作用是对原有索引和新索引进行匹配，新索引含有原索引的数据，而原索引数据按照新索引排序。如果新索引中没有原索引数据，那么程序不仅不会报错，而且会添加新的索引，并将值填充为NaN或者使用fill\_values填充其他值。

**reindex()方法的语法格式:**

*  DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill\_value=nan, limit=None, tolerance=None)

#### reindex参数说明 ####

*  index：用作索引的新序列
 *  method：插值填充方式
 *  fill\_value: 引入缺失值时使用的替代值
 *  limit：前向或者后向填充时的最大填充量

import pandas as pd
    ser_obj = pd.Series([1,2,3,4,5], index=['c','d','a','b','e'])
    print(ser_obj)
    
    
    >>>[out]
    c  1
    d  2
    a  3
    b  4
    e  5

import pandas as pd
    ser_obj2 = ser_obj.reindex(['a','b','c','d','e','f'])
    ser_obj2
    print(ser_obj2)
    
    
    >>>[out]
    c  1.0
    d  2.0
    a  3.0
    b  4.0
    e  5.0
    f  NaN

默认填充的是NaN,如果不想填充NaN,那么可以通过参数`method`来进行设置

import pandas as pd
    ser_obj2 = ser_obj.reindex(['a','b','c','d','e','f'], fill_value=6)
    print(ser_obj2)
    
    
    >>>[out]
    c  1
    d  2
    a  3
    b  4
    e  5
    f  6

**注意:fill\_value参数会让所有的缺失数据都填充为同一个值。**

如果期望使用相邻的元素值（前边或者后边元素的值）进行填充，则可以使用method参数。method参数对应的值有多个

**method参数说明**

<table> 
 <thead> 
  <tr> 
   <th align="center">参数</th> 
   <th align="center">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">fifill或pad</td> 
   <td align="center">前向填充值</td> 
  </tr> 
  <tr> 
   <td align="center"></td> 
   <td align="center">后向填充值</td> 
  </tr> 
  <tr> 
   <td align="center"></td> 
   <td align="center">从最近的索引值填充</td> 
  </tr> 
 </tbody> 
</table>

import pandas as pd
    ser_obj3 = pd.Series([1,3,5,7], index=[0,2,4,6])
    print(ser_obj3)
    
    >>>[out]
    0 1
    2 3
    4 5
    6 7
    ser_obj3.reindex(range(6),method='ffill')  #重新索引，前向填充值
    
    >>>[out]
    0 1 
    1 1
    2 3
    3 3
    4 5
    5 5
    ser_obj3.reindex(range(6),method='bfill')   #重新索引，后向填充值
    
    >>>[out]
    0 1
    1 3
    2 3
    3 5
    4 5
    5 7

# 1.3索引操作 #

## Series类型的索引操作 ##

Series类对象属于一维结构，它只有行索引。而DataFrame类对象属于二维结构，它同时拥有行索引和列索引。

import pandas as pd
    ser_obj = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
    print(ser_obj[2])#使用索引位置
    
    >>[out]
            3
    ser_obj['c']     #使用索引名称获取数据
    >>[out]
            3

**Series也可以使用切片来获取数据。**

**注意：如果使用位置索引切片，与list相似，包含起始位置但不包含结束位置**

**如果使用索引名称进行切片，则切片结果是包含结束位置的**

如果希望获取的是不连续的数据，则可以通过不连续索引来实现

import pandas as pd
    ser_obj = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
    print(ser_obj[2:4])    #使用位置索引进行切片
    
    >>[out]
    c 3
    d 4
    e 5
    print(ser_obj[[0,2,4]])#使用不连续位置索引
    >>[out]
    a  1
    c  3
    e  5
    print(ser_obj[['a','c','d']])#使用不连续名称索引
    >>[out]
    a  1
    c  3
    d  4

布尔型索引具体用法跟数组的用法一样，将布尔型的数组索引作为模板筛选数据，返回与模板中True位置对应的元素

import pandas as pd
    ser_obj = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
    ser_bool = ser_obj>2
    print(ser_bool)
    
    >>[out]
    a  False
    b  False
    c  True
    d  True
    e  True

同时布尔索引也能作为索引值,默认只输出True的值

print(ser_obj[ser_bool])
    
    >>[out]
    c  3
    d  4
    e  5

## DataFrame的索引操作 ##

DataFrame结构既包含行索引，也包含列索引。其中，行索引是通过index属性进行获取的。列索引是通过columns属性进行获取的.

DataFrame中每列的数据都是一个Series对象，可以使用列索引进行获取。

import numpy as np
    arr = np.arange(12).reshape(3,4)
    df_obj = pd.DataFrame(arr, columns=['a','b','c','d'])
    print(df_obj)
    
    >>[out]   a  b  c  d
           0  0  1  2  3
           1  4  5  6  7
           2  8  9 10  11
    print(df_obj['b'])
    
    >>[out]
    0  1
    1  5
    2  9
    print(type(df_obj['b']))
    
    >>[out]
    pandas.core.series.Series

## pandas库中提供了操作索引的方法来访问数据 ##

loc：基于标签索引（索引名称，如a,b），用于按标签选取数据。当执行切片操作时，既包含起始索引，也包含结束索引

iloc：基于位置索引（整数索引，从0到length-1），用于按位置选取数据。当执行切片操作时，只包含起始索引，不包含结束索引。

iloc方法主要使用整数来索引数据，而不能使用字符标签来索引数据。而loc方法恰恰相反，它只能使用字符标签来索引数据，而不能使用整数来索引数据。

arr = np.arange(16).reshape(4,4)
    dataframe_obj = pd.DataFrame(arr, columns=['a','b','c','d'])
    print(dataframe_obj)
    
    
    >>[out]   a   b   c   d
           0  0   1   2   3
           1  4   5   6   7
           2  8   9   10  11
           3  12  13  14  15
    #下面这两个分别用位置和标签索引的方式操作列(结果是一样的,我只写一个输出)
    print(dataframe_obj.iloc[:,[2,0]])
    print(dataframe_obj.iloc[:,['c','a']])
    
    >>[out]  c   a
          0  2   0
          1  6   4
          2  10  8
          3  14  12

#  #

# 1.4pandas的算术运算和数据对齐 #

**Pandas执行算术运算时，会先按照索引进行对齐，对齐以后再进行相应的运算，没有对齐的位置会用NaN进行补齐。其中，Series是按行索引对齐的，DataFrame是按行索引、列索引对齐的。**

## 算术运算 ##

import pandas as pd
    obj_one = pd.Series(range(10,13), index=range(3))
    obj_two = pd.Series(range(20,25), index=range(5))
    print(obj_one)
    
    >>[out]
    0	10
    1	11
    2	12
    
    print(obj_two)
    
    >>[out]
    0	20
    1	21
    2	22
    3	23
    4	24
    
    print(obj_one+obj-two)
    
    >>[out]
    0	30.0
    1	32.0
    2	34.0
    3	NaN
    4	NaN
    
    print(obj_one.add(obj_two, fill_value=0))#这里零填补空缺,也可以其他值,只是举一个例子
    
    >>[out]
    0	30.0
    1	32.0
    2	34.0
    3	23.0
    4	24.0

## 数据排序: ##

**Pandas中存放的是索引和数据的组合，既可以按索引进行排序，又可以按数据进行排序。**

### 按索引排序 ###

Pandas中按索引排序使用的是sort\_index()方法，该方法可以用行索引或者列索引进行排序。

语法:

*  sort\_index(axis=0, level=None, ascending=True, inplace=False, kind=’quicksort’, na\_position=’last’, sort\_remaining=True)

参数说明:

<table> 
 <thead> 
  <tr> 
   <th align="center">参数</th> 
   <th align="center">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">axis</td> 
   <td align="center">轴索引(排序方向),0表示index(按行),1表示按列</td> 
  </tr> 
  <tr> 
   <td align="center">level</td> 
   <td align="center">若不为None，则对指定索引级别的值进行排序</td> 
  </tr> 
  <tr> 
   <td align="center">ascending</td> 
   <td align="center">是否升序排列，默认为True，表示升序</td> 
  </tr> 
  <tr> 
   <td align="center">inplace</td> 
   <td align="center">默认为False，表示对数据表进行排序，不创建新的实例</td> 
  </tr> 
  <tr> 
   <td align="center">kind</td> 
   <td align="center">选择排序算法</td> 
  </tr> 
 </tbody> 
</table>

**默认情况下，Pandas对象是按照升序排列，可以通过参数ascending=False改为降序排列**,使用的是科学排序法,并列会占位,比如有两个第一名,那么下一个就直接是第三名,而不是第二名.

import pandas as pd
    ser_obj = pd.Series(range(10,15), index=[5,3,1,3,2])
    print(ser_obj)
    
    >>[out]
    5	10
    3	11
    1	12
    3	13
    2	14
    
    print(ser_obj.sort_index())
    
    >>[out]
    1	12
    2	14
    3	11
    3	13
    5	10

**对DataFrame的索引进行排序**

import numpy as np
    import pandas as pd
    df_obj = pd.DataFrame(np.arange(9).reshape(3,3), index=[4,3,5])
    print(df_obj)
    
    >>[out]
    		0	1	2
        4	0	1	2
        3	3 	4	5
        5	6	7	8
        
        
    print(df_obj.sort_index())
    
    >>[out]
    		0	1	2
        3	3	4	5
        4	0	1	2
        5	6	7	8

### 按值排序 ###

**Pandas中用来按值排序的方法为sort\_values()**

语法格式:

*  sort\_values(by, axis=0, ascending=True, inplace=False, kind=’quicksort’, na\_position=’last’)

**参数说明:**

by 参数表示排序的列，na\_position参数只有两个值：first和last， 若设为first，则会将NaN值放在开头；若设为False，则会将NaN值放在最后.

ser_obj = pd.Series([4, np.nan, 6, np.nan, -3, 2])
    print(ser_obj)
    
    
    >>[out]
    0	4.0
    1	NaN
    2	6.0
    3	NaN
    4	-3.0
    5	2.0
    
    
    print(ser_obj.sort_values())
    
    >>[out]
    4	-3.0
    5	2.0
    0	4.0
    2	6.0
    1	NaN
    3	NaN

**在DataFrame中，sort\_values()方法可以根据一个或多个列中的值进行排序，但是需要在排序时将一个或多个列的索引传递给by参数才行**

df_obj = pd.DataFrame([[0.4, -0.1, -0.3, 0.0],
                          [0.2, 0.6, -0.1, -0.7],
                          [0.8, 0.6, -0.5, 0.1]])
    print(df_obj)
    
    >>[out]
    		0		1		2		3
        0	0.4		-0.1	-0.3	0.0
        1	0.2		0.6		-0.1	-0.7
        2	0.8		0.6		-0.5	0.1
    print(df_obj.sort_values(by=2))
    
    
    >>[out]
    		0		1		2		3
        2	0.8		0.6		-0.5	0.1
        0	0.4		-0.1	-0.3	0.0
        1	0.2		0.6		-0.1	-0.7

# 1.5统计计算与描述 #

## 常用的统计计算 ##

常用描述性统计方法及说明

<table> 
 <thead> 
  <tr> 
   <th>函数名称</th> 
   <th>说明</th> 
   <th>函数名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>sum</td> 
   <td>计算和</td> 
   <td>std</td> 
   <td>样本值的标准差</td> 
  </tr> 
  <tr> 
   <td>mean</td> 
   <td>计算平均值</td> 
   <td>skew</td> 
   <td>样本值的偏度（三阶矩）</td> 
  </tr> 
  <tr> 
   <td>median</td> 
   <td>获取中位数</td> 
   <td>kurt</td> 
   <td>样本值的峰度（四阶矩）</td> 
  </tr> 
  <tr> 
   <td>max、min</td> 
   <td>获取最大值和最小值</td> 
   <td>cumsum</td> 
   <td>样本值的累积和</td> 
  </tr> 
  <tr> 
   <td>idxmax、idxmin</td> 
   <td>获取最大和最小索引值</td> 
   <td>cummin、cummax</td> 
   <td>样本值的累积最小值和累积最大值</td> 
  </tr> 
  <tr> 
   <td>count</td> 
   <td>计算非NaN值的个数</td> 
   <td>cumprod</td> 
   <td>样本值的累计积</td> 
  </tr> 
  <tr> 
   <td>head</td> 
   <td>获取前N个值</td> 
   <td>describe</td> 
   <td>对Series和DataFrame列计算汇总统计</td> 
  </tr> 
  <tr> 
   <td>var</td> 
   <td>样本值的方差</td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

df_obj = pd.DataFrame(np.arange(12).reshape(3,4), columns=['a','b','c','d'])
    print(df_obj)
    
    >>[out]
    			a	b	c	d
        	0	0	1	2	3
            1	4	5	6	7
            2	8	9	10	11
            
    print(df_obj.sum())
    
    >>[out]
    	a	12
        b	15	
        c	18
        d	21

**统计描述**

如果希望一次性输出多个统计指标，比如平均值、最大值、最小值、求和等，调用describe()方法实现，而不用再单独地逐个调用相应的统计方法。

describe()方法的语法格式

*  describe(percentiles=None, include=None, exclude=None)

参数说明:

*  percentiles：输出中包含的百分数，位于\[0,1\]之间。如果不设置该参数，则默认为\[0.25,0.5,0.75\]，返回25%， 50%， 75%分位数。
 *  include，exclude：指定返回结果的形式

# 1.6Pandas的索引对象: #

## 索引对象的创建 ##

*  pd.X(array-like)
    
        index = pd.Index(np.arange(3))

> ## 索引对象的分类 ##

<table> 
 <thead> 
  <tr> 
   <th align="center">分类</th> 
   <th align="center">介绍</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">Index</td> 
   <td align="center">最泛化的对象</td> 
   <td align="center">轴标签—&gt;数组</td> 
  </tr> 
  <tr> 
   <td align="center">Int64Index</td> 
   <td align="center">用于整数的特殊对象</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">MultiIndex</td> 
   <td align="center">层次化索引对象(单个轴上的多层索引)</td> 
   <td align="center">可看作是元组的数组</td> 
  </tr> 
  <tr> 
   <td align="center">DatetimeIndex</td> 
   <td align="center">用于纳米级索引对象</td> 
   <td align="center"></td> 
  </tr> 
 </tbody> 
</table>

## 索引对象的获取: ##

<table> 
 <thead> 
  <tr> 
   <th align="center">分类</th> 
   <th align="center">获取方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">Series</td> 
   <td align="center">.index</td> 
  </tr> 
  <tr> 
   <td align="center">DataFrame</td> 
   <td align="center">① .index ② .columns</td> 
  </tr> 
 </tbody> 
</table>

## 索引对象的特点: ##

索引对象是不可修改的,这样能够保证Index对象在不同的数据结构之间安全的共享

obj = Series(data,index=index)
    print(obj.index is index)

结果为True

## 索引对象的方法和属性 ##

### 方法: ###

<table> 
 <thead> 
  <tr> 
   <th align="center">方法表达式</th> 
   <th align="center">描述</th> 
   <th align="center">特征</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">append()</td> 
   <td align="center">连接另一个索引对象</td> 
   <td align="center">数组</td> 
  </tr> 
  <tr> 
   <td align="center">diff/intersection/union()</td> 
   <td align="center">Index–&gt;差集/交集/并集</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">isin()</td> 
   <td align="center">各值是否在参数集合中</td> 
   <td align="center">布尔数组</td> 
  </tr> 
  <tr> 
   <td align="center">delete/insert()</td> 
   <td align="center">删除/插入索引出的元素</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">drop()</td> 
   <td align="center">删除传入的值</td> 
   <td align="center">会生成新的Index</td> 
  </tr> 
  <tr> 
   <td align="center">unique()</td> 
   <td align="center">计算唯一值数组</td> 
   <td align="center"></td> 
  </tr> 
 </tbody> 
</table>

### 属性: ###

<table> 
 <thead> 
  <tr> 
   <th align="center">属性</th> 
   <th align="center">返回值</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">is_monotonic</td> 
   <td align="center">True</td> 
   <td align="center">各元素均大于前一个元素</td> 
  </tr> 
  <tr> 
   <td align="center">is_unique</td> 
   <td align="center">True</td> 
   <td align="center">当前Index无重复值</td> 
  </tr> 
 </tbody> 
</table>

## 索引对象的重命名(轴索引) ##

有两种方式:

*  直接赋值
 *  obj.rename()
    
    <table> 
     <thead> 
      <tr> 
       <th align="center">方法</th> 
       <th align="center">操作</th> 
       <th align="center">特征</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="center">直接赋值</td> 
       <td align="center">obj.index/columbs = …</td> 
       <td align="center">就地修改</td> 
      </tr> 
      <tr> 
       <td align="center">obj.rename()</td> 
       <td align="center">index/columns = 函数/字典(传入部分轴)</td> 
       <td align="center"></td> 
      </tr> 
      <tr> 
       <td align="center">obj.rename()</td> 
       <td align="center">inplace=默认(保留原始数据)/True(就地修改)</td> 
       <td align="center"></td> 
      </tr> 
     </tbody> 
    </table>
    
        data.index = data.index.map(str.upper)
        data.rename(index={ old:new},columns = { old;new})
        data.rename(index=str.title,columns = str.upper)

# 1.7索引的整数索引: #

## 程序: ##

客官们,先来看一个整数索引的示例:

import numpy as np
    import pandas as pd
    from pandas import Series
    ser = Series(np.arange(3))
    print(ser.index)

这个程序的输出结果是:

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

import numpy as np
    import pandas as pd
    from pandas import Series
    ser = Series(np.arange(3))
    print(ser[-1])

**这个程序会发生错误.**

## 解析: ##

第一个程序能够正确的运行,并返回.

索引器:自动递增的数字索引(RangeIndex)

而第二个程序无法正常运行时因为索引是基于`标签`或者`位置`的

这样我们得出了整数索引的规则.

## 整数索引的规则: ##

当含有索引器时:

*  根据整数进行数据选取
 *  总是面向标签的--------整数->标签名 包括ix切片
    
    ### 非整数索引: ###
    
    **示例:**
    
        import numpy as np
        import pandas as pd
        from pandas import Series
        ser2 = Series(np.arange(3),index = ['a','b','c'])
        print(ser['a':'b'])#即是把str类型作为一个切片的索引是基于标签的
    
    使用任意类型的索引
    
    还是基于标签或者位置的.

## 整数标签基于位置的使用方法: ##

<table> 
 <thead> 
  <tr> 
   <th align="center">数据结构</th> 
   <th align="center">方法</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">Series</td> 
   <td align="center">series.iloc[i]/.iat[i]</td> 
   <td align="center">i为整数</td> 
  </tr> 
  <tr> 
   <td align="center">DataFrame</td> 
   <td align="center">DF.iloc[*]</td> 
   <td align="center">①[i]第i+1行②[:j]第j+1列</td> 
  </tr> 
 </tbody> 
</table>