pandas入门（上）

pandas含有使数据分析工作变得更快更简单的高级数据结构和操作工具。pandas是基于NumPy构建的，它使得以NumPy为中心的应用变得更加简单。pandas具有以下功能：

• 具备按轴自动或显示数据对齐功能的数据结构。这可以防止许多由于数据未对齐以及来自不同数据源（索引方式不同）的数据而导致的常见错误
• 集成时间序列功能
• 既能处理时间序列数据也能处理非时间序列数据的数据结构
• 数学运算和约减（比如对某个轴求和）可以分局不同的元数据（轴编号）进行
• 灵活处理缺失数据
• 合并及其他出现在常见数据库（例如基于SQL的)中的关系型运算

在后续部分中，我们使用下面这样的pandas引入约定，由于Series和DataFrame用的次数非常多，所以将其引入本地命名空间中会更方便：

from pandas import Series, DataFrameimport pandas as pdimport numpy as np

pandas的数据结构介绍

要使用pandas，我们首先要熟悉它的两个主要数据结构：Series和DataFrame。

Series

Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及与之相关的数据标签（即索引）组成。仅由一组数组即可产生最简单的Series：

obj1 = Series([4,5,7,-1])obj1

0    41    52    73   -1dtype: int64

Series的字符串表现形式为：索引在左边，值在右边。因为我们没有为数据指定索引，所以Series会自动创建一个从0到N-1（N为数组长度）的整数型索引。可以通过Series的values和index属性获取其数组表示形式和索引对象：

obj1.values

array([ 4,  5,  7, -1], dtype=int64)

obj1.index

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

通常，我们希望所创建的Series带有一个可以对各个数据点进行标记的索引：

obj2 = Series([4,7,-5,3],index=['d','a','c','b'])obj2

d    4a    7c   -5b    3dtype: int64

obj2.index

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

可以通过索引的方式选取Series中的单个或一组值：

obj2['a']

7

obj2[['a','b']]

a    7b    3dtype: int64

NumPy中的数组运算（如根据布尔型数组进行过滤、标量乘法、应用数学函数等）都会保留索引和值之间的连接：

obj2

d    4a    7c   -5b    3dtype: int64

obj2[obj2 > 2]

d    4a    7b    3dtype: int64

obj2 * 2

d     8a    14c   -10b     6dtype: int64

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

'b' in obj2

True

for k in obj2.keys():    print(k)

dacb

如果数据被存放在一个Python字典中，也可以直接通过这个字典来创建Series：

sdata = {'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}obj3 = Series(sdata)obj3

Ohio      35000Oregon    16000Texas     71000Utah       5000dtype: int64

如果只传入一个字典，则结果Series中的索引就是原字典的键（有序排列）：

states = ['California','Ohio','Oregon','Texas']obj4 = Series(sdata,index=states)obj4

California        NaNOhio          35000.0Oregon        16000.0Texas         71000.0dtype: float64

在上面的例子中，sdata中和states索引相匹配的那3个值会被找出来并放到相应的位置上，但是由于“California”所对应的sdata值找不到，所以其结果就是NaN（Not a Number）。pandas中的isnull和notnull函数可用于检测缺失数据：

pd.isnull(obj4)

California     TrueOhio          FalseOregon        FalseTexas         Falsedtype: bool

pd.notnull(obj4)

California    FalseOhio           TrueOregon         TrueTexas          Truedtype: bool

Series也有类似的实例方法：

obj4.isnull()

California     TrueOhio          FalseOregon        FalseTexas         Falsedtype: bool

对于许多应用，Series最重要的一个功能就是：他在算术运算中会自动对齐不同索引的数据：

obj3

Ohio      35000Oregon    16000Texas     71000Utah       5000dtype: int64

obj4

California        NaNOhio          35000.0Oregon        16000.0Texas         71000.0dtype: float64

obj3 + obj4

California         NaNOhio           70000.0Oregon         32000.0Texas         142000.0Utah               NaNdtype: float64

Series对象本身及其索引都有一个name属性，该属性跟pandas其他的关键功能非常密切：

obj4.name = 'population'obj4.index.name = 'state'obj4

stateCalifornia        NaNOhio          35000.0Oregon        16000.0Texas         71000.0Name: population, dtype: float64

Series的索引可以通过复制的方式就地修改：

obj1.index

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

obj1.index = ['Bob','Steve','Jeff','Ryan']obj1

Bob      4Steve    5Jeff     7Ryan    -1dtype: int64

DataFrame

DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame既有行索引，又有列索引，它可以被看成是一个由Series组成的字典（共用一个索引）。构建DataFrame的方法有很多，最常用的一种是直接传入一个由等长列表或ndarray组成的字典，DataFrame会自动加上索引，且全部列会被有序排列：

data = {'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],        'year':[2000,2001,2002,2001,2002],        'pop':[1.5,1.7,3.6,2.4,2.9]}frame1 = DataFrame(data)frame1

pop state year 0 1.5 Ohio 2000 1 1.7 Ohio 2001 2 3.6 Ohio 2002 3 2.4 Nevada 2001 4 2.9 Nevada 2002

如果指定了列序列，那么DataFrame的列就会按照指定顺序进行排列：

DataFrame(data,columns=['year','state','pop'])

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

和Series一样，如果传入的列在数据中找不到，就会产生NaN：

frame2 = DataFrame(data,columns=['year','state','pop','debt'],index=['one','two','three','four','five'])frame2

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

frame2.columns

Index(['year', 'state', 'pop', 'debt'], dtype='object')

通过类似字典标记的方式或属性的方式，可以将DataFrame的列获取为一个Series：

frame2['state']

one        Ohiotwo        Ohiothree      Ohiofour     Nevadafive     NevadaName: state, dtype: object

frame2.year

one      2000two      2001three    2002four     2001five     2002Name: year, dtype: int64

注意，返回的Series拥有与原DataFrame相同的索引，且其name属性也已经被相应地设置好了。行也可以通过位置或名称的方式进行获取，比如用索引字段loc：

frame2.loc['three']

year     2002state    Ohiopop       3.6debt      NaNName: three, dtype: object

列可以通过赋值的方式进行修改。例如，我们可以给那个空的“debt”列赋上一个标量值或一组值：

frame2['debt'] = 16.5frame2

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

frame2['debt'] = np.arange(5)frame2

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

将列表或数组赋值给某个列时，其长度必须与DataFrame的长度相匹配。如果赋值的是一个Series，则会精确匹配DataFrame的索引，所有的空位都会被填上缺失值：

val = Series([-1.2,-1.5,-1.7],index=['two','four','three'])frame2['debt'] = valframe2

year state pop debt one 2000 Ohio 1.5 NaN two 2001 Ohio 1.7 -1.2 three 2002 Ohio 3.6 -1.7 four 2001 Nevada 2.4 -1.5 five 2002 Nevada 2.9 NaN

为不存在的列赋值为创建一个新的列。关键字del用于删除列：

frame2['eastern'] = frame2.state == 'Ohio'frame2

year state pop debt eastern one 2000 Ohio 1.5 NaN True two 2001 Ohio 1.7 -1.2 True three 2002 Ohio 3.6 -1.7 True four 2001 Nevada 2.4 -1.5 False five 2002 Nevada 2.9 NaN False

del frame2['eastern']frame2.columns

Index(['year', 'state', 'pop', 'debt'], dtype='object')

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

另一种常见的数据形式是嵌套字典，如果将它传递给DataFrame，那么外层字典的键将被作为列，而内层字典的键将被作为行索引：

pop = {'Nevada':{2001:2.4,2002:2.9},'Ohio':{2000:1.5,2001:1.7,2002:3.6}}frame3 = DataFrame(pop)frame3

Nevada Ohio 2000 NaN 1.5 2001 2.4 1.7 2002 2.9 3.6

当然，我们也可以对结果进行转置：

frame3.T

2000 2001 2002 Nevada NaN 2.4 2.9 Ohio 1.5 1.7 3.6

内层字典的键会被合并、排序以形成最终的1索引。如果显式地指定了索引，则不会这样：

DataFrame(pop,index=[2001,2002,2003])

Nevada Ohio 2001 2.4 1.7 2002 2.9 3.6 2003 NaN NaN

由Series组成的字典也是差不多的用法：

pdata = {'Ohio':frame3['Ohio'][:-1],         'Nevada':frame3['Nevada'][:2]}DataFrame(pdata)

Nevada Ohio 2000 NaN 1.5 2001 2.4 1.7

下面列出了DataFrame构造函数所能接受的各种数据。

可以输入给DataFrame构造器的数据类型说明二维ndarray数据矩阵，还可以传入行标或列标由数组、列表或元组组成的字典每个序列会变成DataFrame的一列。所有序列的长度都必须相同NumPy的结构化/记录数组类似于“由数组组成的字典”由Series组成的字典每个Series会成为一列。如果没有显式指定索引，则各Series的索引会被合并成结果的行索引由字典组成的字典各内层字典会成为一列。键会被合并成结果的行索引，和“由Series组成的字典”情况一样字典或Series的列表各项将会成为DataFrame的一行。字典键或Series索引的并集会成为DataFrame的列标由列表或元组组成的列表类似于“二维ndarray”另一个DataFrame该DataFrame的索引将会被沿用，除非显式指定了其它索引NumPy的MaskedArray类似于“二维ndarray”的情况，只是掩码值在结果DataFrame中会变成缺失值

如果设置了DataFrame的index和columns的name属性，则这些信息也会被显示出来：

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

state Nevada Ohio year 2000 NaN 1.5 2001 2.4 1.7 2002 2.9 3.6

跟Series一样，values属性也会以二维ndarry的形式返回DataFrame中的数据：

frame3.values

array([[ nan,  1.5],       [ 2.4,  1.7],       [ 2.9,  3.6]])

如果DataFrame各列的数据类型不同，则值数组的数据类型就会选用能兼容素有列的数据类型：

frame2.values

array([[2000, 'Ohio', 1.5, nan],       [2001, 'Ohio', 1.7, -1.2],       [2002, 'Ohio', 3.6, -1.7],       [2001, 'Nevada', 2.4, -1.5],       [2002, 'Nevada', 2.9, nan]], dtype=object)

索引对象

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

obj = Series(range(3),index=['a','b','c'])index = obj.indexindex

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

index[1:]

Index(['b', 'c'], dtype='object')

Index对象是不可修改的（Immutable），因此用户不能对其进行修改：

index[1] = 'd'

---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)<ipython-input-46-676fdeb26a68> in <module>()----> 1 index[1] = 'd'E:\Anaconda3\lib\site-packages\pandas\core\indexes\base.py in __setitem__(self, key, value)   1618    1619     def __setitem__(self, key, value):-> 1620         raise TypeError("Index does not support mutable operations")   1621    1622     def __getitem__(self, key):TypeError: Index does not support mutable operations

不可修改性非常重要，因为这样才能使Index对象在多个数据结构之间安全共享：

index = pd.Index(np.arange(3))obj3 = Series([1.5,-2.5,0],index=index)obj3.index is index

True

下表给出了pandas库中内置的Index类。现在Index还可以被继承重而实现特别的轴索引功能。

pandas中主要的Index对象类说明Index最泛化的Index对象，将轴标签表示为一个由Python对象组成的NumPy数组Int64Index针对整数的特殊IndexMultiIndex“层次化”索引对象，表示单个轴上的多层索引。可以看作由元组组成的数组DatetimeIndex存储纳秒级时间戳（用NumPy的datatime64类型表示）PeriodIndex针对Period数据（时间间隔）的特殊Index

除了长的像数组，Index的功能也类似一个固定大小的集合：

frame3

state Nevada Ohio year 2000 NaN 1.5 2001 2.4 1.7 2002 2.9 3.6

'Ohio' in frame3.columns

True

2003 in frame3.index

False

每个索引都有一些方法和属性，他们可用于设置逻辑并回答有关该索引所包含的数据的常见问题。下面给出这些函数。

Index的方法和属性方法说明append连接另一个Index对象，产生一个新的Indexdiff计算差集intersection计算交集union计算并集isin计算一个指示各值是否都包含在参数集合中的布尔型数组delete删除索引i处的元素，并得到新的Indexdrop删除传入的值，并得到新的Indexinsert将元素插入到索引i处，并得到新的Indexis_monotomic当各元素均大于等于前一个元素时，返回Trueis_unique当Index没有重复值时，返回Trueunique计算Index中唯一值的数组

基本功能

重新索引

pandas对象有一个reindex方法，它可以创建一个适应新索引的对象：

obj1 = Series([4.5,7.2,-5.3,3.6],index=['d','a','b','c'])obj1

d    4.5a    7.2b   -5.3c    3.6dtype: float64

obj2 = obj.reindex(['a','b','c','d','e'])obj2

a    7.2b   -5.3c    3.6d    4.5e    NaNdtype: float64

obj1.reindex(['a','b','c','d','e'],fill_value=0)

a    7.2b   -5.3c    3.6d    4.5e    0.0dtype: float64

对于时间序列这样的有序数据，重新索引时可能需要做一些插值处理。method选项可以实现这种功能。例如，使用ffill可以实现前向填充：

obj3 = Series(['blue','purple','yellow'],index=[0,2,4])obj3

0      blue2    purple4    yellowdtype: object

obj3.reindex(range(6),method='ffill')

0      blue1      blue2    purple3    purple4    yellow5    yellowdtype: object

下面给出了可用的method选项。

reindex的（插值）method选项参数说明ffill或pad前向填充（或搬运）值bfill或backfill后向填充（或搬运）值

对于DataFrame，reindex可以修改行索引或列索引，也可以两个都修改。如果只传入一个序列，则会重新索引行：

frame1 = DataFrame(np.arange(9).reshape((3,3)),index=['a','c','d'],columns=['Ohio','Texas','California'])frame1

Ohio Texas California a 0 1 2 c 3 4 5 d 6 7 8

frame2 = frame1.reindex(['a','b','c','e'])frame2

Ohio Texas California a 0.0 1.0 2.0 b NaN NaN NaN c 3.0 4.0 5.0 e NaN NaN NaN

使用关键字columns可以重置列索引：

frame1.reindex(columns=['Texas','Uath','Ohio'])

Texas Uath Ohio a 1 NaN 0 c 4 NaN 3 d 7 NaN 6

可以同时对行和列使用reindex，但是插值只能按行（轴0）使用：

frame1.reindex(index=['a','b','c','d'],columns=['Ohio','Texas','California'],method='pad')

Ohio Texas California a 0 1 2 b 0 1 2 c 3 4 5 d 6 7 8

利用loc的标签索引功能，重新索引任务会更简洁：

frame1.loc[['a','b','c','d'],['Ohio','Texas','California']]

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

丢弃指定轴上的项

使用drop方法可以丢弃某条轴上的一个或多个项，该方法返回一个在指定轴上删除了指定值的新对象：

obj = Series(np.arange(5),index=['a','b','c','d','e'])obj

a    0b    1c    2d    3e    4dtype: int32

new_obj = obj.drop('c')new_obj

a    0b    1d    3e    4dtype: int32

obj.drop(['d','c'])

a    0b    1e    4dtype: int32

对于DataFrame，可以删除任意轴上的索引值：

df = DataFrame(np.arange(16).reshape((4,4)),               index=['Ohio','Colorado','Utah','New York'],               columns=['one','two','three','four'])df

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

df.drop(['Colorado','Ohio'])

one two three four Utah 8 9 10 11 New York 12 13 14 15

df.drop('two',axis=1)

one three four Ohio 0 2 3 Colorado 4 6 7 Utah 8 10 11 New York 12 14 15

索引、选取和过滤

Series索引类似于NumPy数组的索引，不过Series索引的值不只可以是整数。对于Series来说，利用标签的切片运算与普通的Python切片运算不同，它的末端是包含的（即闭区间）：

obj = Series(np.arange(4),index=['a','b','c','d'])obj

a    0b    1c    2d    3dtype: int32

obj['a':'c']

a    0b    1c    2dtype: int32

对DataFrame进行索引就是获取一个或多个列：

data = DataFrame(np.arange(16).reshape((4,4)),                 index=['Ohio','Colorado','Utah','New York'],                 columns=['one','two','three','four'])data

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

data['two']

Ohio         1Colorado     5Utah         9New York    13Name: two, dtype: int32

data['Ohio':'Utah']

one two three four Ohio 0 1 2 3 Colorado 4 5 6 7 Utah 8 9 10 11

另外，还可以通过布尔型DataFrame进行索引：

data < 5

one two three four Ohio True True True True Colorado True False False False Utah False False False False New York False False False False

data[data < 5] = 0data

one two three four Ohio 0 0 0 0 Colorado 0 5 6 7 Utah 8 9 10 11 New York 12 13 14 15

我们还可以使用索引字段loc进行行索引：

data.loc['Colorado',['two','three']]

two      5three    6Name: Colorado, dtype: int32

data.loc[['Colorado','Utah'],['four','two']]

four two Colorado 7 5 Utah 11 9

data.iloc[2]

one       8two       9three    10four     11Name: Utah, dtype: int32

data.loc[:'Utah','two']

Ohio        0Colorado    5Utah        9Name: two, dtype: int32

data.loc[data.three > 5, :]

one two three four Colorado 0 5 6 7 Utah 8 9 10 11 New York 12 13 14 15

对pandas对象中的数据的选取和重排方式有很多。下面简单总结一下：

DataFrame的索引选项类型说明df[x]选取DataFrame的单个列或一组列df.iloc[x]通过行号（位置）索引数据df.loc[x]通过行标签索引数据reindex方法将一个或多个轴匹配到新索引xs方法根据标签选取单列或单行，返回一个Seriesicol、irow方法根据行号（位置）选取单列或单行，返回一个Seriesget_value、set_value方法根据行标签和列标签选取或设置单个值

算术运算和数据对齐

pandas可以对具有不同索引的对象进行算数运算。在将对象相加时，如果存在不同的索引对，那么结果就是该索引对的并集：

s1 = Series([7.3,-2.5,3.4,1.5],index=['a','c','d','e'])s2 = Series([-2.1,3.6,-1.5,4,3.1],index=['a','c','e','f','g'])s1 + s2

a    5.2c    1.1d    NaNe    0.0f    NaNg    NaNdtype: float64

对于DataFrame，对齐操作会同时发生在行和列上：

df1 = DataFrame(np.arange(9).reshape((3,3)),columns=list('bcd'),index=['Ohio','Texas','Colorado'])df1

b c d Ohio 0 1 2 Texas 3 4 5 Colorado 6 7 8

df2 = DataFrame(np.arange(12).reshape((4,3)),columns=list('bde'),index=['Utah','Ohio','Texas','Oregon'])df2

b d e Utah 0 1 2 Ohio 3 4 5 Texas 6 7 8 Oregon 9 10 11

df1 + df2

b c d e Colorado NaN NaN NaN NaN Ohio 3.0 NaN 6.0 NaN Oregon NaN NaN NaN NaN Texas 9.0 NaN 12.0 NaN Utah NaN NaN NaN NaN

在对不同索引的对象进行算数运算时，有时我们希望当一个对象中某个轴标签在另一个对象中找不到时填充一个特殊值，使用算数方法可以解决我们的需求：

df1.add(df2,fill_value=0)

b c d e Colorado 6.0 7.0 8.0 NaN Ohio 3.0 1.0 6.0 5.0 Oregon 9.0 NaN 10.0 11.0 Texas 9.0 4.0 12.0 8.0 Utah 0.0 NaN 1.0 2.0

如果某个轴标签在在两个对象中都没有出现，那么结果中该轴标签对应位置的值仍然是NaN，就像上面的运行结果所表示的那样。

DataFrame和Series之间的运算类似于NumPy数组，默认情况下，DataFrame和Series之间的算数运算会将Series的索引匹配到DataFrame的列，然后沿着行向下进行广播：

frame = DataFrame(np.arange(12).reshape((4,3)),columns=list('bde'),index=['Utah','Ohio','Texas','Oregon'])frame

b d e Utah 0 1 2 Ohio 3 4 5 Texas 6 7 8 Oregon 9 10 11

series = frame.iloc[0]series

b    0d    1e    2Name: Utah, dtype: int32

frame - series

b d e Utah 0 0 0 Ohio 3 3 3 Texas 6 6 6 Oregon 9 9 9

如果某个索引值在DataFrame的列或Series的索引中找不到，则参与运算的两个对象就会被重新索引以形成并集：

series2 = Series(range(3),index=['b','e','f'])series2 + frame

b d e f Utah 0.0 NaN 3.0 NaN Ohio 3.0 NaN 6.0 NaN Texas 6.0 NaN 9.0 NaN Oregon 9.0 NaN 12.0 NaN

如果想要Series匹配其他轴（如匹配行），则必须使用算数方法，并将轴号作为参数传递：

series3 = frame['d']series3

Utah       1Ohio       4Texas      7Oregon    10Name: d, dtype: int32

frame

b d e Utah 0 1 2 Ohio 3 4 5 Texas 6 7 8 Oregon 9 10 11

frame.sub(series3,axis=0)

b d e Utah -1 0 1 Ohio -1 0 1 Texas -1 0 1 Oregon -1 0 1

函数应用和映射

NumPy的ufunc也可用于操作pandas对象：

frame = DataFrame(np.random.randn(4,3),columns=list('bde'),index=['Utah','Ohio','Texas','Oregon'])frame

b d e Utah 0.440197 0.354393 0.451931 Ohio -1.486743 0.094794 -0.799018 Texas 0.974240 0.155924 -0.500135 Oregon 0.234171 -1.571440 -2.229566

np.abs(frame)

b d e Utah 0.440197 0.354393 0.451931 Ohio 1.486743 0.094794 0.799018 Texas 0.974240 0.155924 0.500135 Oregon 0.234171 1.571440 2.229566

DataFrame的apply方法可以将函数应用到各行或者各列形成的一维数组上：

f = lambda x: x.max() - x.min()frame.apply(f)

b    2.460983d    1.925833e    2.681498dtype: float64

frame.apply(f,axis=1)

Utah      0.097538Ohio      1.581537Texas     1.474374Oregon    2.463738dtype: float64

另外，元素级的Python函数也是可以使用的，使用applymap方法即可：

frame.applymap(lambda x: '%.2f' % x)

b d e Utah 0.44 0.35 0.45 Ohio -1.49 0.09 -0.80 Texas 0.97 0.16 -0.50 Oregon 0.23 -1.57 -2.23

之所以叫applymap，是因为Series有一个用于应用元素级函数的map方法：

frame['e'].map(lambda x:'%.2f'%x)

Utah       0.45Ohio      -0.80Texas     -0.50Oregon    -2.23Name: e, dtype: object

排序

可以使用sort_index对Series和DataFrame的索引进行排序,它返回一个已排序的新对象：

obj = Series(range(4),index=list('dabc'))obj.sort_index()

a    1b    2c    3d    0dtype: int32

对于DataFrame，可以根据任意一轴上的索引进行排序：

frame = DataFrame(np.arange(8).reshape((2,4)),index=['three','one'],columns=list('dabc'))frame.sort_index()

d a b c one 4 5 6 7 three 0 1 2 3

frame.sort_index(axis=1)

a b c d three 1 2 3 0 one 5 6 7 4

默认按照升序排列，但是也可以降序排列：

frame.sort_index(axis=1,ascending=False)

d c b a three 0 3 2 1 one 4 7 6 5

可以使用sort_values方法按值对Series进行排序：

obj = Series([4,7,-3,2])obj.sort_values()

2   -33    20    41    7dtype: int64

对于DataFrame，我们可以在sort_values方法中设置by选项来实现按一个或多个列值的排序：

frame = DataFrame(np.random.randn(4,2),columns=[1,2],index=list('bdac'))frame

1 2 b 0.243187 -1.729129 d -0.136699 -1.140493 a -2.153898 0.467761 c -1.619538 0.049269

frame.sort_values(by=1)

1 2 a -2.153898 0.467761 c -1.619538 0.049269 d -0.136699 -1.140493 b 0.243187 -1.729129

frame.sort_values(by=[2,1])

1 2 b 0.243187 -1.729129 d -0.136699 -1.140493 c -1.619538 0.049269 a -2.153898 0.467761

带有重复值的轴索引

索引的is_unique属性可以告诉你它的值是否唯一：

obj = Series(range(5),index=list('aabbc'))obj

a    0a    1b    2b    3c    4dtype: int32

obj.index.is_unique

False

如果某个索引对应多个值，则返回一个Series；对应单个值的，返回一个标量值：

obj['a']

a    0a    1dtype: int32

obj['c']

4

对DataFrame进行索引时也是如此：

df = DataFrame(np.random.randn(4,3),index=list('aabc'),columns=[1,1,2])df

1 1 2 a 1.225549 -2.444507 -1.090840 a 1.030282 1.275122 -0.251795 b -0.943006 -2.288509 0.665299 c -0.529105 -0.346594 1.032035

df[1]

1 1 a 1.225549 -2.444507 a 1.030282 1.275122 b -0.943006 -2.288509 c -0.529105 -0.346594

df.loc['a']

1 1 2 a 1.225549 -2.444507 -1.090840 a 1.030282 1.275122 -0.251795