原文地址：http://www.huaxiaozhuan.com/%E5%B7%A5%E5%85%B7/pandas/chapters/pandas.html

 

 

pandas 0.19

 

一、基本数据结构

1. Pandas的两个主要数据结构： Series和DateFrame

1. Series

1. 创建： class pandas.Series(data=None, index=None, dtype=None, name=None, copy=False,fastpath=False):

   参数：

   • data：它可以是一个字典、array-like、标量。表示Series包含的数据，如果是序列/数组，则它必须是一维的
   • 如果是字典，则字典的键指定了label。如果你同时使用了index，则以index为准。
   • 如果是标量，则结果为：该标量扩充为index长度相同的列表。
   • index：一个array-like或者一个Index对象。它指定了label。其值必须唯一而且hashable，且长度与data一致。如果data是一个字典，则index将会使用该字典的key（此时index不起作用）。如果未提供，则使用np.arange(n)。
   • name：一个字符串，为Series的名字。
   • dtype：指定数据类型。如果为None，则数据类型被自动推断
   • copy：一个布尔值。如果为True，则拷贝输入数据data

   

2. 还可以通过类方法创建Series：Series.from_array(arr, index=None, name=None, dtype=None,copy=False, fastpath=False)：其中arr可以是一个字典、array-like、标量。其他参数见1.

3. 我们可以将Series转换成其他数据类型：

   • .to_dict()：转换成字典，格式为{label->value}
   • .to_frame([name])：转换成DataFrame。name为Index的名字
   • .tolist()：转换成列表

   

4. 可以将Series转换成字符串：

    

     .to_string(buf=None, na_rep='NaN', float_format=None, header=True, index=True, 

     length=False, dtype=False, name=False, max_rows=None)

   • buf：一个StringIO-like对象，是写入的buffer
   • na_rep：一个字符串，代表数值NaN
   • float_format：浮点数的格式化函数。应用于浮点列
   • header：一个布尔值。如果为True，则添加头部信息（index name）
   • index：一个布尔值。如果为True，则添加index labels
   • length：一个布尔值。如果为True，则添加Series的长度信息
   • dtype：一个布尔值。如果为True，则添加dtype信息
   • name：一个布尔值。如果为True，则添加Series name
   • max_rows：一个整数值，给出了最大转换的行数。如果为None，则转换全部。

   返回转换后的字符串。

2. Index

1. class pandas.Index(data=None, dtype=None, copy=False, name=None, fastpath=False, tupleize_cols=True)：创建Index对象。

   参数：

   • data：一个array-like，必须是一维的
   • name：一个字符串，为Index的名字。
   • dtype：指定数据类型。如果为None，则默认为object
   • copy：一个布尔值。如果为True，则拷贝输入数据data
   • tupleize_cols：一个布尔值，如果可能则尽量创建MultiIndex对象

   

2. Index对象负责管理轴label和其他元数据（比如轴name）。构建Series/DataFrame时，传给index/columns关键字的任何数组或者序列都将被转化成一个Index。Index 对象是immutable，因此用户无法对其进行修改。这样才能够使得Index对象在多个数据结构之间安全共享 

3. 存在多种索引类型。

   • Index：最泛化的Index对象，将轴label表示为一个Python对象组成的Numpy数组
   • Int64Index：针对整数的特殊Index
   • MultiIndex：层次化索引对象，表示单个轴上的多层索引。可以看做由元组组成的数组
   • DatatimeIndex：存储纳秒级时间戳，用numpy的datatime64类型表示
   • PeriodIndex：针对Period数据（时间间隔）的特殊Index

4. Index的功能类似一个固定大小的集合。其类似于集合的方法有（因为Index不可变，因此返回的都是新的Index对象）：

   • .copy([name,deep,dtype])：返回一份Index的拷贝。
   • .append(other)：连接另一个Index对象，产生一个新的Index对象。注意重复的label并不会合并
   • .difference(other)：计算差集，返回一个Index对象
   • .intersection(other)：计算交集，返回一个Index对象
   • .union(other)：计算并集，返回一个新的Index对象
   • .isin(values[, level])：计算Index中各label是否在values中
   • .delete(loc)：删除下标loc处的元素，得到新的Index
   • .drop(labels[, errors])：删除传入的labels，得到新的Index
   • .insert(loc, item)：在指定下标位置插入值，得到新的Index
   • .unique()：返回Index中唯一值的数组，得到新的Index

   

5. 我们可以将Index转换成其他数据类型：

   • .astype(dtype,[,copy])：转换成另一个数据类型的Index，其label的dtype被转换成指定的值
   • .tolist()：转换成列表
   • .to_series(**kwargs)：转换成Series，Series的数据和label相同

   

6. Index提供的选取方法有：

   • .get_indexer(target[, method, limit, ...]) ：获取target（一个Index对象）对应的下标列表。

     • target：一个Index对象。我们要考察的就是Index中的每个label在self中的下标序列。

     • method：指定label的匹配方法。可以为None，表示严格匹配（如果不存在则下标为 -1）。如果为'pad'/'ffill'，则：若未找到匹配的，则使用前向匹配。如果为'backfill'/'bfill'，则：若未找到匹配的，则使用后向匹配。如果为'nearest'，则：若未找到匹配的，则使用最近邻匹配。

       匹配时，假设你的Index的label是有序排列的（要么是升序，要么是降序）

     • limit：一个整数，指定前向/后向/最近填充时：如果有连续的k个NaN，则只填充其中limit个。

     • tolerance：一个整数，用于给出在不匹配时，连续采用前向/后向/最近邻匹配的跨度的最大值。

   • .get_level_values(level)：返回指定level的Index，用于MultiIndex。

   • .get_loc(key[, method, tolerance])：返回指定label处的下标，由key指定。其中method和tolerance参数见上述。如果method=None，且key指定的label找不到，则抛出异常。

   • .get_value(series, key)：寻找Series指定label处的值。若key指定的label找不到，则抛出异常。

   • .slice_locs([start, end, step, kind])：计算给定start label和end label之间的下标序列，返回代表该下标序列的切片或者数组。其中不包括end。 

3. MultiIndex

1. MultiIndex代表的是多级索引对象。它继承自Index，其中的多级label采用元组对象来表示。在MultiIndex内部，并不直接保存元组对象，而是使用多个Index对象保存索引中每级的label。

2. class pandas.MultiIndex(levels=None, labels=None, sortorder=None, names=None, copy=False, verify_integrity=True, _set_identity=True, name=None, **kwargs)

   参数：

   • levels：一个数组的列表，给出了每一级的level。

   • labels：一个数组的列表，给出了每一级level的下标。第i级label是这样产生的：

     • 首先获取labels[i]，它是一个下标序列，代表第 级。
     • 假设第 k位置为整数 3，在第 级第 位的label就是levels[i][3]。

   • sortorder：一个整数，给出了已经排序好了的level级别。

   • names：一个字符串序列，给出了每个Index的name。其中每个级别对应一个Index

   • copy：一个布尔值。如果为True，则拷贝基础数据

   • verify_integrity：一个布尔值。如果为True，则检测各级别的label/level都是连续的且有效的

   • name：指定了本MultiIndex的名字

   你也可以通过下面的类方法来创建MultiIndex：

   • MultiIndex.from_arrays(arrays[, sortorder, ...])：将二维序列转换为MultiIndex。其中arrays为array-like的序列，每个array-like按顺序的给出了一列label（一个级别）
   • MultiIndex.from_tuples(tuples[, sortorder, ...]) ：将元组序列转换为MultiIndex。其中tuples为tuple-like的序列，每个array-like按顺序的给出了一行label对（不同级别的一对）
   • MultiIndex.from_product(iterables[, ...])：根据多个可迭代对象生成一个MultiIndex，其中使用笛卡尔积的算法。其中iterables为可迭代对象的序列

   你也可以通过传递一个元组列表给Index()，并且将tupleize_cols设置为True来创建MultiIndex

   

4. DataFrame

1. DataFrame 是一个表格型的数据结构，它含有一组有序的列，每一列都可以是不同的值类型（数值、日期、object类型）。其中object类型可以保存任何python对象，比如字符串。同一列必须是相同的值类型。

   • DataFrame 既有行索引，又有列索引。他可以被看作为Series组成的字典（共用同一个行索引）
   • DataFrame中面向行和面向列的操作基本上是平衡的。其实DataFrame中的数据是以一个或者多个二维块存放的

   

2. class pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)：

   • data：可以是一个二维数组、字典、或者DataFrame。
   • index：一个Index或者array-like对象（必须为一维的），它指定了行标签。如果未提供，则使用np.arange(n)。
   • columns：一个Index或者array-like对象（必须为一维的），它指定了列标签。如果未提供，则使用np.arange(n)。
   • dtype：指定数据类型。如果为None，则数据类型被自动推断
   • copy：一个布尔值。如果为True，则拷贝输入数据data

   常见的构造DataFrame有以下情况：

   • 二维ndarray：data就是数据，此时可以传入index/columns参数
   • 一个字典，其中字典的值为一维数组、一维列表、一维元组：此时每个键就是列索引，对应的值就是列数据。要求所有序列的长度相同
   • numpy的结构化数组：类似于由数组组成的字典
   • Series组成的字典：此时每个键就是列索引，对应的Series就是列数据。如果没有显式的指定行索引，那么各个Series的索引将会被合并成DataFrame的行索引。
   • 字典的字典：各个内层字典会成为一列，键会被合并成结果的行索引。跟Series 组成的字典情况一致
   • 字典或者Series的列表：每一项将会成为DataFrame的一行。字典的键、Series索引的并集将会成为DataFrame的列索引
   • 列表、元组组成的列表：类似于二维ndarray
   • 另一个DataFrame：该DataFrame的索引将会被沿用，除非显式指定其他索引
   • numpy的MaskedArray：类似于二维ndarray，只是掩码值在结果DataFrame中会变成NA/缺失值

   columns/index有两种作用：如果构造的DataFrame没有索引，则它们分别给索引赋值；如果构造的DataFrame已有索引，则它们按照指定顺序排列指定的索引。

3. 可以通过下面的类方法从其他数据结构中创建DataFrame：

   • DataFrame.from_dict(data, orient='columns', dtype=None)：从字典中创建DataFrame。

     • data：是个字典，其格式为： {key:array-like}或者{key:dict}。
     • orient：指定了key为行还是列。参数的值为'columns'（key为列的label，默认行为）；或者'index'（key为行的label）
     • dtype：数据类型。如果为None，则自动推断。

   

   • DataFrame.from_items(items, columns=None, orient='columns')：从元组序列中创建DataFrame。

     • items：为元组序列，元组格式为：(key,value)，其中value为表示一维数据的序列或者Series对象。

     • columns：一个序列，给出列的labels。

       • 当orient='index'时必须传入（此时key 指定的是行的label），且长度不能大于DataFrame的列数。
       • 当orient='columns时，key就是列的label，此时columns关键字参数指定的列label必须等于某个key；否则抛出异常。

   • orient：参见.from_dict的解释。

   

4. 你可以将DataFrame转换为其他数据类型。

   • .to_dict(*args, **kwargs)方法：转换成字典。参数orient决定了转换方式。

     • orient ='dict'：字典的形式为： {col_label:{index_label:value}}（默认行为）
     • orient ='list'：字典的形式为： {col_label:[values]}
     • orient ='series'：字典的形式为： {col_label:Series(values)}
     • orient ='split'：字典的形式为： {'index':[index_labels],'columns':[col_labels],'data':[values]}
     • orient ='records'：字典的形式为： [{col_label:value},...,{col_label:value}]
     • orient ='index'：字典的形式为： {index_label:{col_label:value}}
     • 你可以使用简化字符串，如's'代表'series'，'sp'代表'split'

   • .to_records(index=True, convert_datetime64=True)方法：转换成结构数组。

     • index：一个布尔值。如果为True，则结果中包含index
     • convert_datetime64：一个布尔值，如果为True，则转换DatetimeIndex为datetime.datetime

    

5. 可以将DateFrame转换成字符串：

    

   to_string(buf=None, columns=None, col_space=None, header=True, index=True,

     na_rep='NaN', formatters=None, float_format=None, sparsify=None, 

     index_names=True, justify=None, line_width=None, max_rows=None,

     max_cols=None, show_dimensions=False)

   • buf：一个StringIO-like对象，是写入的buffer

   • columns：一个序列，指定了列标签的一个子集，该子集的数据被输出

   • col_space：一个整数，指定了每一列的最小宽度

   • header：一个布尔值。如果为True，则添加头部信息（column labels）

   • index：一个布尔值。如果为True，则添加index labels

   • na_rep：一个字符串，代表数值NaN

   • float_format：浮点数的格式化函数（单参数）。应用于浮点列

   • formatters：一个单参数函数的列表（列表长度等于列数）或者一个单参数函数的字典。

     • 如果是列表，则根据列号，对应使用格式化函数
     • 如果是字典，则根据列label，对应使用格式化函数

   • sparsify：一个布尔值。Set to False for a DataFrame with a hierarchical index to print every multiindex key at each row, default True

   • index_names：一个布尔值。如果为True，则添加index names

   • justify：指定column label的对齐方式。可以为'left'（左对齐），或者'right'（右对齐）。默认为None

   返回转换后的字符串。

   

二、 内部数据结构

1. Index的结构如图所示（实线为普通属性，虚线为property属性或者getset_descriptor）： 

   • .name为普通属性，返回Index的名字
   • .values/._values为property属性，返回Index的内部数据的视图
   • ._data为普通属性，返回Index的内部数据
   • .shape为property属性，返回内部数据的形状
   • ._engine为标签映射管理器，它负责管理label和下标之间的映射
   • ObjectEngine对象使用一个哈希表对象PyObjectHashTable对象（由ObjectEngine对象的.mmaping属性给出，该属性是一个getset_descriptor）将标签映射到其对应的整数下标的。

2. MultiIndex的结构如图所示 

   • .name为普通属性，返回MultiIndex的名字。同Index

   • .values/._values为property属性，返回MultiIndex的内部数据的视图。同Index

     ._data为None，这里是与Index不同。

    

   • .shape为property属性，返回内部属性的形状 。同Index
   • ._engine为标签映射管理器，它负责管理label和下标之间的映射。同Index
   • .labels为property属性，它返回一个FrozenList（不可变列表），列表中存储每一级的label对应的下标（也就是创建MultiIndex时传入的labels参数），以FrozenNDArray的数据类型。
   • .levels为property属性，它返回一个FrozenList（不可变列表），列表中存储每一级的label（也就是创建MultiIndex时传入的levels参数），以Index的数据类型。

3. Seris的结构如图所示（实线为普通属性，虚线为property属性或者getset_descriptor）：

   • ._name为普通属性，返回Seris的名字；.name为property属性，返回的也是Seris名字
   • .dtype/.dtypes为property属性，返回Series的数据类型。
   • .ftype/ftypes为property属性，返回一个字符串，说明Series是否稀疏数据。（二者返回的字符串的值相同，但不是同一个字符串对象）
   • .values/._values为property属性，返回Series的内部数据的视图
   • .index为普通属性，返回Series的索引
   • .shape为property属性，返回Series的数据的形状
   • ._data为普通属性，它返回的是一个SingleBlockManager对象，该对象负责管理内部数据。
   • SingleBlockManager的.shape属性为property属性，返回内部数据的形状
   • SingleBlockManager的.blocks属性为普通属性，返回一个列表，该列表只有一个元素，该元素为一个IntBlock对象（或者其他的xxxBlock对象），代表了内部数据。
   • IntBlock的.values属性为普通属性，它返回内部数据：一个ndarray。
   • IntBlock的.shape属性为property属性，它返回内部数据的形状

4. DataFrame的结构如图所示（实线为普通属性，虚线为property属性或者getset_descriptor）：
   

   • .index/columns属性都为普通属性，它们返回的都是一个Index对象，参考Series。 

   • .dtypes属性为property属性，给出了每列的数值类型。它返回的是一个Series。并且没有.dtype属性，这一点与Series不同。 

   • .ftypes属性为property属性，给出了每列是否为sparse/dense的。它返回的是一个Series。并且没有.ftype属性，这一点与Series不同。 

   • .values/._values/.shape属性都为property属性，参考Series。

   • ._data属性为普通属性，它返回的是一个BlockManager对象，该对象负责管理内部数据。该对象的.block属性（普通属性）返回一个列表，该列表里面有多个元素。 DataFrame尽量用一个数组保存类型相同的列。

   • 每个元素都为一个xxBlock对象。如IntBlock/FloatBlock...

     • 一个xxBlock 可能存储多个列的数据（这些列的数据都是同一个类型）

   • xxBlock对象的.values属性（普通属性）就是存储的某个列（或者某些类型相同的列）的内部数据，一个ndarray

   • xxBlock对象的.shape属性（property属性）就是存储的某个列（或者某些类型相同的列）的内部数据的形状 

   • .blocks属性为property属性。该属性返回一个字典，该字典的键为不同的数值类型，该字典的值为该数值类型的数值组成的DataFrame 

三、 下标存取

1. [ ] 操作符

1. 对于Index对象，可以通过[]来选取数据，它类似于一维ndarray的索引。下标可以为下列几种下标对象：

   • 一个整数下标。此时返回对应的label

   • 一个整数slice。此时返回对应的Index（根据一维labels先切片，再组装成Index）

   • 一个array-like对象（元素可以为下标或者布尔值）。此时返回对应的Index。（根据一维labels先索引，再组装成Index）

   • 由None组成的二元组，其中None相当于新建一个轴。

     • 如果None为第一个元素，则新建的轴为 0 轴；
     • 如果None为第二个元素，则新建的轴为 1 轴。
     • 另外idx[None]等价于idx[None,:]，但是idx[None]返回的是ndarray。
     • 它并没有将Index 转换成MultiIndex，只是将Index内部的数据数组扩充了一个轴

   Index 的索引只支持整数/整数slice/整数序列/布尔序列/整数数组/布尔数组/None 等。

   

2. 对于Series对象，可以通过[]来选取数据，它类似于一维ndarray的索引。下标可以为下列几种下标对象：

   • 一个整数下标/一个属性（属性名为某个label）/字典索引（键为label）：返回对应的数值

   • 一个整数切片/一个label切片：返回对应的Series。（根据一维Series先切片，再组装成Series）。注意：label切片同时包含了起始label和终止label

   • 一个整数array-like/一个label array-like/一个布尔ndarray：返回对应的Series。（根据一维Series先索引，再组装成Series）

   • 一个二维整数array-like/二维label array-like：返回对应值组成的二维ndarray

     注意：Series必须使用布尔数组来索引，不支持布尔序列来索引(抛出KeyError异常)。

    

3. 对于DataFrame对象，可以通过[]来选取数据。下标可以为下列几种下标对象：

   • 一个属性（属性名为某个column label）/字典索引（键为column label）：返回对应的列对应的Series

     不可以使用单个整数来索引

   • 一个整数切片/一个row label切片：返回对应的行组成的DataFrame。注意：label切片同时包含了起始label和终止label

   • 一个一维label array-like:返回对应的列组成的DataFrame

   • 一个布尔数组：返回数组中True对应的行组成的DataFrame。

   • 一个布尔DataFrame：将该布尔DataFrame中的False对应的元素设置为NaN（布尔DataFrame中没有出现的值为False）

    

4. Series对象除了支持使用位置作为下标存取元素之外，还可以使用索引标签来存取元素。这个功能与字典类似，因此它也支持字典的一些方法，如Series.iteritems()。

5. 对于Series/DataFrame切片方式的索引，返回的结果与原始对象共享基础数据。对于采用其他方式的索引，返回的结果并不与元素对象共享基础数据。 

6. 对于DataFrame的赋值与列删除：

   • 将列表或者数组赋值给某个列时，其长度必须跟DataFrame的行数匹配。
   • 将标量赋值给某个列时，会将标量扩充
   • 将Series赋值给某个列时，会精确匹配DataFrame的索引。如果DataFrame中某个label在Series中找不到，则赋值NaN（空位都将被填上缺失值）
   • 为不存在的列赋值会创建出一个新列（必须用字典的形式，不能用属性赋值的形式）
   • 关键字del用于删除列（必须用字典的形式，不能用属性赋值的形式）

    

7. 对于Series的赋值与删除：

   • 对于单个索引或者切片索引，要求右侧数值的长度与左侧相等
   • 为不存在的label赋值会创建出一个新行（必须用字典的形式，不能用属性赋值的形式）
   • 关键字del用于删除行（必须用字典的形式，不能用属性赋值的形式）

8. 如果Series/DataFrame的索引有重复label，则数据的选取行为将有所不同：

   • 如果索引对应多个label，则Series返回一个Sereis，DataFrame返回一个DataFrame
   • 如果索引对应单个label，则Series返回一个标量值，DataFrame返回一个Series

   你可以通过Index.is_unique属性得知索引是否有重复的。

   • 对于[]、字典索引、属性索引或者.loc/.ix存取器，结论如上所述
   • 对于.at存取器：如果索引对应单个label，索引结果正常。如果索引对应多个label，则Series返回一个一维ndarray；DataFrame则抛出异常。

9. 对于Series/DataFrame，它们可以使用ndarray的接口。因此可以通过ndarray 的索引规则来索引它们。

    

   df=pd.DataFrame(...)

   df[:,0] #使用了 ndarray 的索引方式

   ​

2. loc/iloc/ix 存取器

1. 对于Series， .loc[]的下标对象可以为：

   • 单个label，此时返回对应的值
   • label的array-like、label slice以及布尔array-like：返回对应值组成的Series

   

2. 对于DataFrame，.loc[]的下标对象是一个元组，其中两个元素分别与DataFrame的两个轴对应。如果下标不是元组，则该下标对应的是第0轴，第一轴为默认值:。

   • 每个轴的下标都支持单个label、label array-like、label slice、布尔array-like。
   • 若获取的是某一列或者某一行，则返回的是Series；若返回的是多行或者多列，则返回的是DataFrame；如果返回的是某个值，则是普通的标量。

    

3. .iloc[]和.loc[]类似，但是.iloc[]使用整数下标，而不是使用label。

   • 注意整数切片不包括最后一个值。

    

4. .ix[]存取器综合了.iloc/.loc：它可以混合使用label和位置下标

   • 注意：如果有整数索引，则应该使用.loc/.iloc从而避免混淆

    

5. Index对象不能使用loc/iloc/ix存取器

6. 对于.loc/.iloc/.ix：如果某轴的索引为array-like或者布尔array-like，则返回的结果与原来的对象不再共享基础数据。如果轴的索引全部都是slice或者单个整数、单个label，则返回的结果与原来的对象共享基础数据。 

3. at/iat 存取器

1. .at和.iat分别使用label和整数下标获取单个值。它类似于.loc/.iloc，但是.at/.iat的速度更快

   • 每个索引只能是单个label或者单个整数

   

2. 对于DataFrame，.lookup(row_labels, col_labels)类似于：.loc[row_labels, col_labels]，但是.lookup返回的是一维ndarray。

   • 要求row_labels和col_labels长度相同。(row_labels[0],col_labels[0]决定了结果中第一个元素的位置，...(row_labels[i],col_labels[i]决定了结果中第 i+1个元素的位置，

3. DataFrame.get_value(index, col, takeable=False)等价于.loc[index, col]，它返回单个值。而Series.get_value(label, takeable=False)等价于.loc[label]，它也返回单个值 

4. .get(key[, default])方法与字典的get()方法的用法相同。对于DataFrame，key为col_label 

5. .head([n=5])和.tail([n=5])返回头部/尾部n行数据 

4. query 方法

1. 对于DataFrame，当需要根据一定的条件对行进行过滤时，通常可以先创建一个布尔数组，然后使用该数组获取True对应的行。另一个方案就是采用query(expr, inplace=False, **kwargs)方法：

   • expr是个运算表达式字符串，如'label1 >3 and label2<5'
   • 表达式中的变量名表示对应的列，可以使用not/and/or等关键字进行向量布尔运算。该方法会筛选出那些满足条件的行。
   • 如果希望在表达式中使用Python变量，则在变量名之前使用@
   • inplace是个布尔值，如果为True，则原地修改。否则返回一份拷贝。

5. 多级索引

1. 对于.loc/.ix/[]，其下标可以指定多级索引中，每级索引上的标签。

   • 多级索引轴对应的下标是一个下标元组，该元组中每个元素与索引中每级索引对应
   • 如果下标不是元组，则将其转换成长度为 1 的元组
   • 如果元组的长度比索引的层数少，则在其后面补充slice(None)

6. 整数 label

1. label不一定是字符串，也有可能是整数（如RangeIndex/Int64Index等）。尤其是当label是自动生成的时候。

   • 当你的label是整数时，面向整数的下标索引总是面向label的，而不是面向position的。因此推荐使用.loc来基于label索引，使用.iloc来基于position索引。

    

四、 运算

1. 数值运算

1. 当进行数值运算时，pandas会按照标签对齐元素：运算符会对标签相同的两个元素进行计算。对于DataFrame，对齐会同时发生在行和列上。

   • 当某一方的标签不存在时，默认以NaN填充。缺失值会在运算过程中传播。

   由于NaN是浮点数中的一个特殊值，因此结果的元素类型被转换为float64

   • 结果的索引是双方索引的并集。

2. 除了支持加减乘除等运算符之外，pandas还提供了对应的函数： add/sub/mul/div/mod(other, axis='columns', level=None, fill_value=None):

   • other：一个DataFrame/Series或者一个array-like，或者一个标量值
   • axis：指定操作的轴。可以为0/1/'index'/'columns' 。其意义是：操作发生在哪个轴上。
   • fill_value：指定替换掉NaN的值。可以为None（不替换），或者一个浮点值。注意：如果发现两个NaN相加，则结果仍然还是NaN，而并不会是两个fill_value相加。
   • level：一个整数或者label，用于多级索引的运算。

   全部运算操作函数为：

    

     add,sub,mul,div,truediv,floordiv,mod,pow,radd,rsub,rmul,rdiv,rtruediv,

     rfloordiv,rmod,rpow # 这些的参数为 other,axis,level,fill_value

     lt,gt,le,ge,ne,eq# 这些的参数为 ohter,axis,level  

   对于DataFrame和Series的运算，默认会用DataFrame的每一行与Series运算。如果你希望使用DataFrame的每一列与Series运算，则必须使用二元操作函数，并且指定axis=0（表示操作匹配的轴）。

     

2. 排序

1. .sort_index()方法的作用是根据label排序（而不是对存放的数据排序）。

    

     DataFrame/Series.sort_index(axis=0, level=None, ascending=True, inplace=False, 

     kind='quicksort', na_position='last', sort_remaining=True)

   • axis：指定沿着那个轴排序。如果为0/'index'，则对沿着0轴，对行label排序；如果为1/'columns'，则沿着 1轴对列label排序。
   • level：一个整数、label、整数列表、label list或者None。对于多级索引，它指定在哪一级上排序。
   • ascending：一个布尔值，如果为True，则升序排序；如果是False，则降序排序。
   • inplace：一个布尔值，如果为True，则原地修改。如果为False，则返回排好序的新对象
   • kind:一个字符串，指定排序算法。可以为'quicksort'/'mergesort'/'heapsort'。注意只有归并排序是稳定排序的
   • na_position：一个字符串，值为'first'/'last'，指示：将NaN排在最开始还是最末尾。
   • sort_remaining：一个布尔值。如果为True，则当多级索引排序中，指定level的索引排序完毕后，对剩下level的索引也排序。

2. .sort_values()方法的作用是根据元素值进行排序。

    

     DataFrame/Series.sort_values(by, axis=0, ascending=True, inplace=False, 

     kind='quicksort', na_position='last')

     Series.sort_values(axis=0, ascending=True, inplace=False, 

     kind='quicksort', na_position='last')

   • by：一个字符串或者字符串的列表，指定希望对那些label对应的列或者行的元素进行排序。对于DataFrame，必须指定该参数。而Series不能指定该参数。

     • 如果是一个字符串列表，则排在前面的label的优先级较高。

       它指定了用于比较的字段

   • axis：指定沿着那个轴排序。如果为0/'index'，则沿着0轴排序（此时by指定列label，根据该列的各元素大小，重排列各行）；如果为1/'columns'，则沿着 1轴排序（此时by指定行label，根据该行的各元素大小，重排列各列）。

   • ascending：一个布尔值，如果为True，则升序排序；如果是False，则降序排序。

   • inplace：一个布尔值，如果为True，则原地修改。如果为False，则返回排好序的新对象

   • kind:一个字符串，指定排序算法。可以为'quicksort'/'mergesort'/'heapsort'。注意只有归并排序是稳定排序的

   • na_position：一个字符串，值为'first'/'last'，指示：将NaN排在最开始还是最末尾。

    

3. DataFrame/Series.sortlevel(level=0, axis=0, ascending=True, inplace=False, sort_remaining=True)：根据单个level中的label对数据进行排列（稳定的）

   • axis：指定沿着那个轴排序。如果为0/'index'，则沿着0轴排序 ；如果为1/'columns'，则沿着 1轴排序
   • level：一个整数，指定多级索引的level
   • ascending：一个布尔值，如果为True，则升序排序；如果是False，则降序排序。
   • inplace：一个布尔值，如果为True，则原地修改。如果为False，则返回排好序的新对象
   • sort_remaining：一个布尔值。如果为True，则当多级索引排序中，指定level的索引排序完毕后，对剩下level的索引也排序。

    

4. .rank()方法的作用是在指定轴上计算各数值的排，其中相同数值的排名是相同的。

    

     DataFrame/Series.rank(axis=0, method='average', numeric_only=None,

     na_option='keep', ascending=True, pct=False)

   • axis：指定沿着那个轴排名。如果为0/'index'，则沿着行排名（对列排名）；如果为1/'columns'，则沿着列排名（对行排名）。

   • method：一个字符串，指定相同的一组数值的排名。假设数值 v一共有N个。现在轮到对v排序，设当前可用的排名为k。

     • 'average'：为各个等值平均分配排名，这N个数的排名都是

       ​

     • 'min'：使用可用的最小的排名，这N个数的排名都是 k

     • 'max'：使用可用的最大的排名，这N各数的排名都是 k+N-1

     • 'first：根据元素数据中出现的顺序依次分配排名，即按照它们出现的顺序，其排名分别为 k,k+1,...k+N-1

     • 'dense：类似于 'min'，但是排名并不会跳跃。即比v大的下一个数值排名为k+1，而不是k+N

   • numeric_only :一个布尔值。如果为True，则只对float/int/bool数据排名。仅对DataFrame有效

   • na_option：一个字符串，指定对NaN的处理。可以为：

     • 'keep'：保留NaN在原位置
     • 'top':如果升序，则NaN安排最大的排名
     • 'bottom':如果升序，则NaN安排最小的排名

   • ascending：一个布尔值，如果为True，则升序排名；如果是False，则降序排名。

   • pct：一个布尔值。如果为True，则计算数据的百分位数，而不是排名。

     

3. 统计

1. Series和DataFrame对象都支持Numpy的数组接口，因此可以直接使用Numpy提供的ufunc函数对它们进行运算。这些函数通常都有三个常用参数：

   • axis：指定运算沿着哪个轴进行
   • level：如果轴是多级索引MultiIndex，则根据level分组计算
   • skipna：运算是否自动跳过NaN

   下面的方法使用如下的两个Series和DataFrame: 

2. 数值运算类方法：（下面的DataFrame方法对于Series也适用）

   • DataFrame.abs()：计算绝对值（只对数值元素进行计算）

   • DataFrame.all([axis, bool_only, skipna, level])：返回指定轴上：是否所有元素都为True或者非零。bool_only为True则仅考虑布尔型的数据。

   • DataFrame.any([axis, bool_only, skipna, level]) ：返回指定轴上：是否存在某个元素都为True或者非零。bool_only为True则仅考虑布尔型的数据。

   • DataFrame.clip([lower, upper, axis]) ：将指定轴上的数据裁剪到[lower,upper]这个闭区间之内。超过upper的值裁剪成upper；小于lower的值裁剪成lower。

   • DataFrame.clip_lower(threshold[, axis])：返回一份拷贝，该拷贝是在指定轴上：向下裁剪到threshold

   • DataFrame.clip_upper(threshold[, axis])：返回一份拷贝，该拷贝是在指定轴上：向上裁剪到threshold

   • DataFrame.prod([axis, skipna, level, ...]) ：计算指定轴上的乘积

   • DataFrame.sum([axis, skipna, level, ...])：沿着指定轴，计算样本的和

   • DataFrame.cumsum([axis, skipna]) ：计算沿着axis轴的累积和。

   • DataFrame.cumprod([axis, skipna]) ：计算沿着axis轴的累积乘积。

   • DataFrame.count([axis, level, numeric_only])：计算沿着axis轴，level级索引的非NaN值的数量。如果numeric_only为True，则只考虑数值和布尔类型。

     对于Series，只有level一个参数。

   • DataFrame.round([decimals]) ：对元素指定小数点位数。decimals可以为一个整数（所有的元素都按照该小数点位数）、一个字典（根据列label指定）   

3. 最大最小：（下面的DataFrame方法对于Series也适用）

   • DataFrame.max([axis, skipna, level, ...])： 沿着指定轴，计算最大值

   • DataFrame.min([axis, skipna, level, ...])： 沿着指定轴，计算最小值

   • Series.argmax([axis, skipna, ...])： 计算最大值的索引位置（一个整数值）

     pandas 0.20 以后，它返回的不再是索引位置，而是索引 label，等价于 idxmax

   • Series.argmin([axis, skipna, ...])： 计算最小值的索引位置（一个整数值）

     pandas 0.20 以后，它返回的不再是索引位置，而是索引 label，等价于 idxmin

   • Series.idxmax([axis, skipna, ...])： 计算最大值的索引label

   • Series.idxmin([axis, skipna, ...])： 计算最小值的索引label

   • DataFrame.cummax([axis, skipna]) ：计算沿着axis轴的累积最大值。

   • DataFrame.cummin([axis, skipna]) ：计算沿着axis轴的累积最最小值。

   • DataFrame.quantile([q, axis, numeric_only, ...])：计算指定轴上样本的百分位数。q为一个浮点数或者一个array-like。每个元素都是 0~1之间。如 0.5代表 50%分位

   • DataFrame.rank([axis, method, numeric_only, ...])：计算指定轴上的排名。

   • DataFrame.pct_change([periods, fill_method, ...])：计算百分比变化。periods为相隔多少个周期。它计算的是：(s[i+periods]-s[i])/s[i]，注意结果并没有乘以 100。

   • Series.nlargest( *args,**kwargs)：计算最大的N个数。参数为：

     • n：最大的多少个数
     • keep：遇到重复值时怎么处理。可以为：'first'/'last'。

   • Series.nsmallest( *args,**kwargs)：计算最小的N个数。参数同上。

    

4. 统计类方法：（下面的DataFrame方法对于Series也适用）

   • DataFrame.mean([axis, skipna, level, ...])：沿着指定轴，计算平均值

   • DataFrame.median([axis, skipna, level, ...])：沿着指定轴，计算位于中间大小的数

   • DataFrame.var([axis, skipna, level, ddof, ...])：沿着指定轴，计算样本的方差

   • DataFrame.std([axis, skipna, level, ddof, ...])：沿着指定轴，计算样本的标准差

   • DataFrame.mad([axis, skipna, level])：沿着指定轴，根据平均值计算平均绝对离差

   • DataFrame.diff([periods, axis])：沿着指定轴的一阶差分。periods为间隔。

   • DataFrame.skew([axis, skipna, level, ...])：沿着指定轴计算样本的偏度（二阶矩）

   • DataFrame.kurt([axis, skipna, level, ...])：沿着指定轴，计算样本的峰度（四阶矩）

     • 对随机变量 ， 若存在，则称它为 的 阶原点矩，简称 阶矩。若 存在，则称它为 的 阶中心矩。

   • DataFrame.describe([percentiles, include, ...])：获取顺序统计量以及其他的统计结果。

     • percentiles：一个array-like。每个元素都是 0~1之间。如 0.5代表 50%分位
     • include,exclude：指定包含/不包含哪些列（通过dtype来指定）。可以为None/'all'，或者一个dtype列表

   • DataFrame.corr([method, min_periods])：计算任意两个列之间的非NAN的、按照索引对齐的值的相关系数。method为相关系数的类型，可以为：

     • 'pearson'：标准的相关系数
     • 'kendall'：Kendall Tau相关系数
     • 'spearman'：Spearman rank相关系数

     而min_periods：一个整数。它指定为了生成一个有效的相关系数，每一对列数据的最短长度。

   • DataFrame.corrwith(other[, axis, drop]) ：计算两个DataFrame的行-行、列-列的相关系数。

     • axis：如果为0/'index'则沿着0轴，则计算列-列之间的相关系数。如果为1/'columns'，则沿着1轴，计算行-行之间的相关系数
     • drop：一个布尔值。如果为True，则如果某行/列都是NaN，则抛弃该行/列。如果为False，则返回全部。

   • DataFrame.cov([min_periods])：计算任意两列之间的协方差。min_periods指定为了生成一个有效的协方差，每一对列数据的最短长度。

     • 对于Series，其调用为：Series.cov(other,[min_periods])

     

5. 对于Series：唯一值、值计数、成员资格：

   • Series.unique()：返回Series中唯一值组成的一维ndarray

   • Series.value_counts(normalize=False, sort=True, ascending=False, bins=None, dropna=True)：对Series中的数进行计数。如果normalize为True，则返回频率而不是频数。sort为True则结果根据出现的值排序，排序方式由ascending指定。

     • bins是一个整数或者None。如果它为整数，则使用半开半闭区间来统计，它给出了该区间的数量。

   • Series.isin(values)：返回一个布尔数组，给出Series中各值是否位于values中。

     DataFrame也有此方法。

   

6. 对于多级索引，可以通过level参数来指定在某个轴上的操作索引级别。如果level=None，则不考虑索引的多级。 

五、变换

1. 索引和轴的变换

1. 重新索引：Series/DataFrame.reindex(index=None, **kwargs)：

   • index：一个array-like对象，给出了新的index的label

   • method：当新的label的值缺失时，如何处理。参数值可以为：

     • None：不做任何处理，缺失地方填充NaN
     • 'backfill'/'bfill'：用下一个可用的值填充该空缺（后向填充）
     • 'pad'/'ffill'：用上一个可用的值填充该空缺（前向填充）
     • 'nearest'：用最近的可用值填充该空缺

   • copy：一个布尔值，如果为True，则返回一个新的Series对象（即使传入的index与原来的index相同）

   • level：一个整数或者name，在MultiIndex的指定级别上匹配简单索引

   • fill_value：一个标量。指定缺失值的填充数据，默认为NaN（如果该参数与method同时出现，则以method为主）

   • limit：一个整数，指定前向/后向填充时：如果有连续的k个NaN，则只填充其中limit个。它与method配合

   • tolerance：一个整数，用于给出在不匹配时，连续采用前向/后向/最近邻匹配的跨度的最大值。它与method配合

   对于DataFrame，多了关键字参数：

   • columns：一个array-like对象，给出了新的columns的label

   对于DataFrame，如果.reindex()只传入一个序列，则默认会重索引行label。如果同时重索引行label和列label，则method插值只能按照行来进行（即 0 轴）

     

2. 将列数据变成行索引（只对DataFrame有效，因为Series没有列索引），其中：col label变成index name，列数据变成行label：

    

     DataFrame.set_index(keys, drop=True, append=False, inplace=False, 

     verify_integrity=False)

   • keys： 指定了一个或者一列的column label。这些列将会转换为行index
   • drop：一个布尔值。如果为True，则keys对应的列会被删除；否则这些列仍然被保留
   • append：一个布尔值。如果为True，则原有的行索引将保留（此时一定是个多级索引）；否则抛弃原来的行索引。
   • inplace：一个布尔值。如果为True，则原地修改并且返回None
   • verify_integrity：一个布尔值。如果为True，则检查新的index是否有重复值。否则会推迟到检测过程到必须检测的时候。

    

3. reset_index会将层次化的行index转移到列中，成为新的一列。同时index 变成一个整数型的，从0开始编号：

    

     DataFrame.reset_index(level=None, drop=False, inplace=False, 

     col_level=0, col_fill='')

     Series.reset_index(level=None, drop=False, name=None, inplace=False)

   • level：一个整数、str、元组或者列表。它指定了将从层次化的index中移除的level。如果为None，则移除所有的level
   • drop：一个布尔值。如果为True，则并不会插入新的列。如果为False，则插入新的列（由index，组成，其列名为'index'）。
   • inplace：一个布尔值。如果为True，则原地修改并且返回None
   • col_level：如果列索引也是多层次的，则决定插入到列索引的哪个level。
   • col_fill：如果列索引也是多层次的，则决定插入之后其他level的索引如何命名的。默认情况下就是重复该index name

   对于Series，name就是插入后，对应的列label

4. 丢弃某条轴上的一个或者多个label：Series/DataFrame.drop(labels[, axis, level, inplace, errors]):

   • labels：单个label或者一个label序列，代表要被丢弃的label
   • axis：一个整数，或者轴的名字。默认为 0 轴
   • level：一个整数或者level名字，用于MultiIndex。因为可能在多个level上都有同名的label。
   • inplace：一个布尔值。如果为True，则原地修改并且返回None
   • errors：可以为'ignore'/'raise'

   

5. DataFrame的.T方法会对DataFrame进行转置，使得行与列互换（行索引与列索引也互换） 

6. 交换两个轴： DataFrame/Series.swapaxes(axis1, axis2, copy=True) 

7. 交换多级索引的两个level：DataFrame/Series.swaplevel(i=-2, j=-1, axis=0, copy=True) 

   • i/j为两个level的整数position，也可以是name字符串。

8. 想修改轴label有两种方案：

   • 可以采用Index.map(mapper)方法。其中mapper是个可调用对象，它对每个label进行调用然后返回新的label。该函数返回一个新的Index对象。然后将其赋值给pandas对象的.index/.columns属性。

   • 调用.rename方法：

      

       Series.rename(index=None, **kwargs)

       DataFrame.rename(index=None, columns=None, **kwargs)

     • index/columns：一个标量、dict-like、或者一个函数。

       • 标量：修改了Series.name属性。但是对于DataFrame会抛出异常
       • dict-like或者函数：应用于对应轴的label上

     • copy：如果为True，则拷贝底层数据（此时inplace=False）

     • inplace：一个布尔值。如果为True，则原地修改，此时忽略copy参数。否则新创建对象。

    

2. 合并数据

1. 对于DataFrame，merge()方法可以根据一个或者多个键将不同DataFrame的行连接接起来。它实现的就是数据库的连接操作。

    

     DataFrame.merge(right, how='inner', on=None, left_on=None, right_on=None, 

     left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'),

     copy=True, indicator=False)

   • right：另一个DataFrame对象

   • how：指定连接类型。可以为：

     • 'left'：左连接。只使用左边DataFrame的连接键
     • 'right'：右连接。只使用右边DataFrame的连接键
     • 'outer'：外连接。使用两个DataFrame的连接键的并集
     • 'inner'：内连接。使用两个DataFrame的连接键的交集

   • on：一个label或者label list。它指定用作连接键的列的label。并且必须在两个DataFrame中这些label都存在。如果它为None，则默认使用两个DataFrame的列label的交集。你可以通过left_on/right_on分别指定两侧DataFrame对齐的连接键。

   • left_on：一个label或者label list。指定左边DataFrame用作连接键的列，参考on

   • right_on：一个label或者label list。指定右边DataFrame用作连接键的列，参考on

   • left_index：一个布尔值。如果为True，则使用左边的DataFrame的行的index value来作为连接键来合并

   • right_index：一个布尔值。如果为True，则使用右边的DataFrame的行的index value来作为连接键来合并

   • sort：一个布尔值。如果为True，则在结果中，对合并采用的连接键进行排序

   • suffixes：一个二元序列。对于结果中同名的列，它会添加前缀来指示它们来自哪个DataFrame

   • copy：一个布尔值。如果为True，则拷贝基础数据。否则不拷贝数据

   • indicator：一个字符串或者布尔值。

     • 如果为True，则结果中多了一列称作_merge，该列给出了每一行来自于那个DataFrame
     • 如果为字符串，则结果中多了一列（该列名字由indicator字符串给出），该列给出了每一行来自于那个DataFrame

   说明：

   • 如果合并的序列来自于行的index value，则使用left_index或者right_index参数。如果是使用了left_index=True，则必须使用right_index=True，或者指定right_on。此时right_on为第二个DataFrame的行label。此时所有对键的操作都针对index label，而不再是column label。
   • 如果不显示指定连接的键，则默认使用两个DataFrame的column label的交集中的第一个label。
   • 如果根据列来连接，则结果的index label是RangeIndex（连续整数）。如果根据行label value连接，则结果的index label/column label来自两个DataFrame
   • 对于层次化索引的数据，你必须以列表的形式指明用作合并键的多个列。

     

2. 函数pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None,left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True,indicator=False)作用与left.merge(right)相同。

3. 如果所有的连接键来自于某列值，则可以使用DataFrame.join()函数。它是.merge()的简化版。

    

     DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)

   • other：一个DataFrame，或者一个Series（要求它的name非空），或者一个DataFrame序列。Series的name作用等同DataFrame的column label
   • on：指定以调用者的那个column对应的列为键。
   • how：参考merge的how
   • lsuffic/rsuffix：参考merge的suffixes。如果结果中有重名的列，则必须指定它们之一。
   • sort：一个布尔值。如果为True，则在结果中，对合并采用的连接键进行排序

   如果是Series，则连接键为Series的index value。此外，DataFrame默认使用 index value（这与merge()不同）。

    

4. pandas.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True)函数：它将多个DataFrame/Series对象拼接起来。

   • objs：一个序列，序列元素为Series/DataFrame/Panel等。你也可以传入一个字典，此时字典的键将作为keys参数。

   • axis：指定拼接沿着哪个轴。可以为0/'index'/，表示沿着 0 轴拼接。可以为1/'columns'，表示沿着 1轴拼接。

   • join：可以为'inner'/'outer'，指定如何处理其他轴上的索引。

     即：其他轴上的 col 如何拼接

   • join_axes：一个Index对象的列表。你可以指定拼接结果中，其他轴上的索引而不是交集或者并集（join参数使用时，其他轴的索引是计算得出的）。

   • verify_integrity：一个布尔值。如果为True，则检查新连接的轴上是否有重复索引，如果有则抛出异常。

   • keys：一个序列。它用于区分拼接结果中，这些行/列来分别来自哪里。在必要的时候将建立多级索引，keys作为最外层的索引。如果objs是个字典，则使用字典的键作为keys。

     它用于建立拼接结果的 index

   • levels：一个序列。与keys配合使用，指定多级索引各级别上的索引。如果为空，则从keys参数中推断。（推荐为空）

   • names：一个序列。与keys配合使用，用于建立多级索引的names。

   • ignore_index：一个布尔值。如果为True，则不使用拼接轴上的index value，代替以RangeIndex，取值为0,1,...

   • copy：一个布尔值。如果为True，则拷贝数据。

    

5. Series/DataFrame.combine_first()也是一种合并方式。它用参数对象中的数据给调用者打补丁。

    

     Series.combine_first(other)

     DataFrame.combine_first(other)

   • other：Series中必须为另一个Series，DataFrame中必须为另一个DataFrame

   结果的index/columns是两个的并集。结果中每个元素值这样产生：

   • 如果调用者不是NaN，则选择调用者的值
   • 如果调用者是NaN，则选择参数的值（此时无论参数的值是否NaN）

    

6. Series/DataFrame.combine()也是一种合并。

    

     Series.combine(other, func, fill_value=nan)

     DataFrame.combine(other, func, fill_value=None, overwrite=True)

   • other：Series中必须为另一个Series，DataFrame中必须为另一个DataFrame

   • func：一个函数，该函数拥有两个位置参数。第一个参数来自于调用者，第二个参数来自于other。

     • 对于Series，两个参数都是标量值，对应它们对齐后的元素值。返回值就是结果对应位置处的值。
     • 对于DataFrame，这两个参数都是Series，即对应的列。

   • fill_value：一个标量 。在合并之前先用它来填充 NaN。

   • overwrite：如果为True，则原地修改调用者。如果为False，则返回一个新建的对象。

   对于Series，结果的index是两个的并集。结果中每个元素值这样产生：

   • 将两个Series在同一个index的两个标量值分别传给func
   • func的返回值就是结果Series在该index处的值

   对于DataFrame，结果的index/columns是两个的并集。结果中每列这样产生：

   • 将两个DataFrame在同一个column label的两列值分别传给func
   • func的返回值就是结果DataFrame在该column label列的值

    

3. 索引旋转

1. DataFrame.stack()方法将数据的列索引旋转为行索引。注意：它跟转置不同，转置会同时旋转数据。

    

     DataFrame.stack(level=-1, dropna=True)

   • level：一个整数、字符串或者整数字符串的列表。如果列索引为多级索引，它指定了将哪个级别的索引旋转为行索引
   • dropna：一个布尔值。如果为True，则如果结果中某行全为NaN，则抛弃该行。

   与DataFrame.stack()对应的就是DataFrame.unstack()方法。它将数据的行索引转换为列索引。注意：它跟转置不同，转置会同时旋转数据。

    

   DataFrame.unstack(level=-1, fill_value=None)

   • level：一个整数、字符串或者整数字符串的列表。如果行索引为多级索引，它指定了将哪个级别的索引旋转为列索引
   • fill_value：一个标量。如果结果中有NaN，则使用fill_value替换。

   旋转时，比如列索引旋转为行索引，则新的行索引是个多级索引，最内层的一级就是原来的列索引。

    

2. DataFrame.pivot()方法重排数据。它是一个快捷方式，它使用set_index将列数据变成行索引，然后使用unstack将行索引转为列索引。

    

     DataFrame.pivot(index=None, columns=None, values=None)

   • index：一个字符串。指定了一个column name，用该列数据来set_index（将该列数据变成行索引，删除了原来的旧的行索引）。如果为None，则不执行set_index

   • columns：一个字符串，指定了哪个列数据作为结果的columns labels。

     实际上对 index,clumns 指定的列数据均 set_index，然后仅对 columns 对应的列数据 unstack

   • values：一个字符串，指定了哪个列数据作为结果的数据。如果未提供，则剩余的所有列都将作为结果的数据。

   

1.