pandas是依照numpy包扩充而来的,5.2.1双重索引

pandas是依靠numpy包增添而来的,由此numpy的绝大大多方式在pandas中都能适用。

目录:

初始pandas

pandas 是八个能使数据深入分析变得更加快更简明的尖端数据结商谈操作工具。
pandas是在numpy的基本功上营造的,让以numpy为基本的接纳变得更简便。

pandas中大家要纯熟三个数据结构Series 和DataFrame

5.1 pandas 的数据结构介绍

安装

作者们能够透过pip来设置pandas
<code>sudo pip install pandas<code>

 

5.1.1 Series

引入包

<code>from pandas import Series,DataFrame
import pandas as pd<code>

Series是近乎于数组的靶子,它有一组数据和与之互为表里的标签组成。

5.1.2 DataFrame

pandas的数据结构

pandas 有多个基本点的数据结构:Series,DataFrame
Series
是一类别似于数组的靶子,由一组数据以及一组与之相关的数据标签(索引)组成:
<code>obj = Series([3,4,5,-4])<code>

import pandas as pd

object=pd.Series([2,5,8,9])

print(object)

5.1.3索引对象

Series

Series的字符串表现格局:索引在左侧,值在右侧。借使大家从没手动钦定索引,Series会默许创立从0到N-1的整数类型的目录。
可以由此.values和.index来赢得数组表现方式和目录对象
<code>obj.values
obj.index<code>

图片 1

image.png

内定索引:
<code> obj2 = Series([3,4,5,-4],index = [‘a’,’b’,’c’,’d’])
obj2
obj2.index<code>

图片 2

image.png

无论打字与印刷索引值为有个别值的值(有一些绕口哈)
<code>obj2[‘a’]
obj2[[‘a’,’c’,’d’]]
细心这里是双中括号<code>

图片 3

image.png

借使数额存在某python字典中,也足以透过字典创立Series:
<code>In [68]: sdata = {‘a’:100,’b’:200,’c’:300,’d’:400}
In [69]: obj2 = Series(sdata)
In [70]: obj2
Out[70]:
a 100
b 200
c 300
d 400
dtype: int64<code>

图片 4

image.png

只要只传入七个字典,且不钦赐索引:
<code>In [71]: states = [‘a’,’b’,’c’,’d’]
In [72]: obj4 = Series(states)
In [73]: obj4
Out[73]:
0 a
1 b
2 c
3 d
dtype: object<code>

设若只传入贰个字典,且钦命索引:
<code>In [74]: obj5 = Series(index = states)
In [75]: obj5
Out[75]:
a NaN
b NaN
c NaN
d NaN
dtype: float64<code>

假定只传入一个字典,钦命值,内定索引:
<code>In [76]: obj5 = Series(sdata,index = states)
In [77]: obj5
Out[77]:
a 100
b 200
c 300
d 400
dtype: int64<code>

图片 5

image.png

地点大家能够看到叁个缺失字段的代表:NA,pandas的isnull和notnull函数能够用于检查测量试验缺失的数据:

<code>In [79]: pd.isnull(obj5)
Out[79]:
a False
b False
c False
d False
dtype: bool
In [80]: pd.notnull(obj5)
Out[80]:
a True
b True
c True
d True
dtype: bool<code>

图片 6

image.png

Series也是有此类的用法:
<code>In [81]: obj4.isnull()
Out[81]:
0 False
1 False
2 False
3 False
dtype: bool<code>

图片 7

image.png

Series还会有多个name的属性,是百分之百塞里es的name,不是有些值。即便不钦点的话Series这几个name属性便是缺省的,尽管钦定的话,那一个name属性值就被填充:
<code>In [87]: obj5
Out[87]:
a 100
b 200
c 300
d 400
dtype: int64
In [88]: obj5.name = ‘Name’
In [89]: obj5
Out[89]:
a 100
b 200
c 300
d 400
Name: Name, dtype: int64<code>

图片 8

image.png

Series的目录还是能经过赋值的不二等秘书技举办修改:

<code>In [90]: obj5.index = [‘one’,’two’,’three’,’four’]
In [91]: obj5
Out[91]:
one 100
two 200
three 300
four 400
Name: Name, dtype: int64<code>

图片 9

image.png

结果为:

5.2基本功用

DateFrame

DataFrame是四个表格型的数据结构,你能够领略为“二维表”,它含有一组有序的列,每列可以是例外的数据类型(数值、字符串、布尔类型)DataFrame既有行索引,也可能有列索引,它也得以被看为是Series组成的字典(Series共用贰个索引)。

构建DataFrame
最广大的方法是传播四个等长列表也许Numpy数组组成的字典

<code>In [94]: data =
{‘states’:[‘a’,’a’,’a’,’b’,’b’],’year’:[2000,2001,2002,2003,2004
…: ],’pop’:[1,2,3,4,5]}
In [95]: frame = DataFrame(data)
In [96]: frame
Out[96]:
pop states year
0 1 a 2000
1 2 a 2001
2 3 a 2002
3 4 b 2003
4 5 b 2004<code>

图片 10

image.png

只要我们制定列的依次,那么DataFrame的列的次第就能够服从大家钦点的相继:

<code>In [97]: frame =
DataFrame(data,columns=[‘states’,’year’,’pop’])
In [98]: frame
Out[98]:
states year pop
0 a 2000 1
1 a 2001 2
2 a 2002 3
3 b 2003 4
4 b 2004 5<code>

图片 11

image.png

和Series同样,如若传入的列在数额中找到不到,就会生出NA:

<code>In [100]: frame2 =
DataFrame(data,columns=[‘states’,’year’,’pop’,’new’],index =
[‘one’,’two’
…: ,’three’,’four’,’five’])
In [101]: frame2
Out[101]:
states year pop new
one a 2000 1 NaN
two a 2001 2 NaN
three a 2002 3 NaN
four b 2003 4 NaN
five b 2004 5 NaN<code>

图片 12

image.png

透过类似字典标志或许性质的方法,能够把DataFrame的三个列获取成Series

<code>In [102]: frame2[‘states’]
Out[102]:
one a
two a
three a
four b
five b
Name: states, dtype: object
In [103]: frame2.year
Out[103]:
one 2000
two 2001
three 2002
four 2003
five 2004
Name: year, dtype: int64<code>

图片 13

image.png

这里必要小心,获取到的Series的目录依然原先DataFrame的目录,况兼连Name也早已设置好了。
大家试一下获取DataFrame中的一行:
<code>In [104]: frame2.ix[‘three’]
Out[104]:
states a
year 2002
pop 3
new NaN
Name: three, dtype: object<code>

此地Name棉被服装置成DataFrame这一行的目录。

图片 14

image.png

咱俩来看frame2的debt的列是值皆以NA,大家能够经过赋值的主意给这一列进行赋值。

<code>In [105]: frame2[‘debt’] = 13
In [106]: frame2
Out[106]:
states year pop new debt
one a 2000 1 NaN 13
two a 2001 2 NaN 13
three a 2002 3 NaN 13
four b 2003 4 NaN 13
five b 2004 5 NaN 13<code>

图片 15

image.png

再赋值二遍:

<code>In [107]: frame2[‘debt’] = np.arange(5.)
In [108]: frame2
Out[108]:
states year pop new debt
one a 2000 1 NaN 0.0
two a 2001 2 NaN 1.0
three a 2002 3 NaN 2.0
four b 2003 4 NaN 3.0
five b 2004 5 NaN 4.0<code>

图片 16

image.png

只要给列赋值,必须维持和DataFrame的长短是完全一样的,如若想要赋的值是一个Series,那么会准确的相称索引,未有值的职分会被填充上NA

<code>In [109]: val =
Series([‘1.2′,’1.3′,’1.4’],index=[‘two’,’three’,’four’])
In [110]: frame2[‘debt’]=val
In [111]: frame2
Out[111]:
states year pop new debt
one a 2000 1 NaN NaN
two a 2001 2 NaN 1.2
three a 2002 3 NaN 1.3
four b 2003 4 NaN 1.4
five b 2004 5 NaN NaN<code>

图片 17

image.png

什么删除DateFrame中的一列:

<code>In [112]: del frame2[‘new’]
In [113]: frame2
Out[113]:
states year pop debt
one a 2000 1 NaN
two a 2001 2 1.2
three a 2002 3 1.3
four b 2003 4 1.4
five b 2004 5 NaN<code>

图片 18

image.png

要求当心的是:通过索引的艺术赶回的列只是呼应数额的视图而已,由此,对回到的Series所做的其他操作都会反映到DataFrame上。通过Series的copy方法既可以够显式的复制列。

另一种分布的花样 叫做”字典的字典”,字典嵌套:

<code>In [10]: pop
={‘a’:{1:1000,2:2000},’b’:{3:3000,4:4000},’c’:{5:5000,6:6000}}
In [11]: pop
Out[11]: {‘a’: {1: 1000, 2: 2000}, ‘b’: {3: 3000, 4: 4000}, ‘c’: {5:
5000, 6: 6000}}<code>

把嵌套了字典的字典还给DataFrame的时候,会被解说成:外层的键作为列,内层的键作为行索引,

<code>frame3 = pd.DataFrame(pop)
In [12]: frame3 = pd.DataFrame(pop)
In [12]: frame3
Out[13]:
a b c
1 1000.0 NaN NaN
2 2000.0 NaN NaN
3 NaN 3000.0 NaN
4 NaN 4000.0 NaN
5 NaN NaN 5000.0
6 NaN NaN 6000.0<code>

图片 19

image.png

作者们能够对结果开始展览转置:

<code>In [15]: frame3.T
Out[15]:
1 2 3 4 5 6
a 1000.0 2000.0 NaN NaN NaN NaN
b NaN NaN 3000.0 4000.0 NaN NaN
c NaN NaN NaN NaN 5000.0 6000.0<code>

图片 20

image.png

塞里es的字典也以同等的点子来处理:
<code>In [16]: pdata = {‘a’:
frame3[‘a’][:-1],’b’:frame3[‘b’][:-2]}
In [17]: pdata
Out[17]:
{‘a’: 1 1000.0
2 2000.0
3 NaN
4 NaN
5 NaN
Name: a, dtype: float64, ‘b’: 1 NaN
2 NaN
3 3000.0
4 4000.0
Name: b, dtype: float64}
In [18]: frame4 = pd.DataFrame(pdata)
In [19]: frame4
Out[19]:
a b
1 1000.0 NaN
2 2000.0 NaN
3 NaN 3000.0
4 NaN 4000.0<code>

图片 21

image.png

能够输入给DataFrame构造器的数码如下:

<ol>
<li>二维ndarray</li>
<li>由数组、列表或然元祖组成的字典</li>
<li>Numpy的结构化/记录数组</li>
<li>由Series组成的字典</li>
<li>由字典组成的字典</li>
<li>字典恐怕塞里e的列表</li>
<li>由列表只怕元祖组成的列表</li>
<li>另一个DataFrame</li>
<li>Numpy的MaskedArray</li>
</ol>

0 2
1 5
2 8
3 9
dtype: int64

5.2.1再一次索引

结果中涵盖一列数据和一列标签
咱俩可以用values和index分别进行援用

5.2.2撇下钦点轴上的项

print(object.values)
print(object.index)

5.2.3索引、采取和过滤

结果为:

5.2.4算术运算和数量对齐

[2 5 8 9]  
RangeIndex(start=0, stop=4, step=1)

5.2.4.1在算术方法中填充钱

我们还是能够依据本人的心愿创设标签

5.2.4.2 DataFrame和Series之间的演算

object=pd.Series([2,5,8,9],index=['a','b','c','d'])

print(object)

5.2.5函数应用和照耀

结果为:

5.2.6排序和排行

a 2
b 5
c 8
d 9
dtype: int64

5.2.7分包重复的轴索引

咱俩还足以对队列进行演算

5.3聚齐和计算描述性总计

print(object[object>5])

5.3.1相关周详和协方差

结果为

5.3.2独一值、值计数以及成员身价

c 8
d 9
dtype: int64

5.4甩卖缺失数据

也得以把Series看成贰个字典,使用in进行推断

5.4.1滤除缺点和失误数据

print('a' in object)

5.4.2填充缺点和失误数据

结果为:

5.5档案的次序化索引

True

5.5.1重排分级顺序

其它,值是不能够直接被索引到的

5.5.2基于品级汇总计算

print(2 in object)

5.5.3使用DataFrame的列

结果为:

5.6另外有关pandas的话题

False

5.6.1整数目录

 

第5章 pandas入门

Series中的一些格局,

pandas 引进约定

isnull大概notnull能够用于决断数据中缺点和失误值情形

In [1]: from pandas import Series,DataFrame

name大概index.name可以对数码举办重命名

In [2]: import pandas as pd

DataFrame数据框,也是一种数据结构,和哈弗中的数据框类似

5.1 pandas 的数据结构介绍

图片 22

要动用pandas,首先要熟知他的七个第一的数据结构:Series和DataFrame。

data={'year':[2000,2001,2002,2003],
          'income':[3000,3500,4500,6000]}

data=pd.DataFrame(data)

print(data)

5.1.1 Series

结果为:

Series
是一连串似于一维数组的目的,由一组数据(种种numpy数据类型)以及一组与之相关的数据标签(即索引)组成。

   income year
0 3000 2000
1 3500 2001
2 4500 2002
3 6000 2003

仅由一组数据就能够爆发最简易的Series:

data1=pd.DataFrame(data,columns=['year','income','outcome'],
                          index=['a','b','c','d'])
print(data1)

In [3]: obj=Series([4,7,-5,3])

结果为:

In [4]: obj

   year income outcome
a 2000 3000 NaN
b 2001 3500 NaN
c 2002 4500 NaN
d 2003 6000 NaN

Out[4]:

新扩展列outcome在data中尚无,则用na值替代

0    4

目录的三种办法

1    7

print(data1['year'])
print(data1.year)

2  -5

二种索引是等价的,都以对列进行索引,结果为:

3    3

a 2000
b 2001
c 2002
d 2003
Name: year, dtype: int64

dtype: int64

对行实行索引,则是别的一种方式

serice 的字符串表现情势为:索引在右边,值在左手。

print(data1.ix['a'])

是因为大家从未为数量钦定索引,于是会自动创制八个0到N-1(N位数据的尺寸)的整数的目录。

结果为:

能够透过series的values和index属性获取其数组表现形式和目录对象。

year 2000
income 3000
outcome NaN
Name: a, dtype: object

In [6]: obj.values #表现方式

print(data1[1:3])

Out[6]: array([ 4,  7, -5,  3], dtype=int64)

大概也能够用切成丝的款式

In [7]: obj.index #目录对象

结果为:

Out[7]: RangeIndex(start=0, stop=4, step=1)

   year income outcome
b 2001 3500 NaN
c 2002 4500 NaN

经常大家盼望所成立的塞里es带有一个能够对一一数根据地实行标志的目录:

增删列

In [11]: obj2[‘a’]

data1['money']=np.arange(4)

Out[11]: -5

追加列为money

In [12]: obj2[‘d’]=6

  year income outcome money
a 2000 3000 NaN 0
b 2001 3500 NaN 1
c 2002 4500 NaN 2
d 2003 6000 NaN 3

In [13]: obj2[[‘c’,’a’,’d’]]

del data1['outcome']

Out[13]:

删去列结果为:

c    3

   year income money
a 2000 3000 0
b 2001 3500 1
c 2002 4500 2
d 2003 6000 3

a  -5

 

d    6

 pandas中的重要索引对象以及相对应的目录方法和品质

dtype: int64

图片 23

NumPy数组运算(若遵照布尔型数组进行过滤,标量乘法,应用数学函数等)都会保留索引和值时期的链接:

图片 24

In [14]: obj2

 

Out[14]:

 其余还会有三个reindex函数能够再度创设索引

d    6

data={'year':[2000,2001,2002,2003],
     'income':[3000,3500,4500,6000]}

data1=pd.DataFrame(data,columns=['year','income','outcome'],
index=['a','b','c','d'])

data2=data1.reindex(['a','b','c','d','e'])
print(data2)

b    7

 结果为:

a  -5

图片 25

c    3

图片 26

dtype: int64

data2=data1.reindex(['a','b','c','d','e'],method='ffill')
print(data2)

In [15]: obj2[obj2>0]

采取方法后的结果为: 

Out[15]:

 图片 27

d    6

 图片 28

b    7

 索引删除以及过滤等荣辱与共办法

c    3

 print(data1.drop(['a']))

dtype: int64

结果为: 

In [16]: obj2*2

图片 29

Out[16]:

print(data1[data1['year']>2001])

d    12

结果为:

b    14

图片 30

a  -10

 print(data1.ix[['a','b'],['year','income']])

c    6

结果为 :

dtype: int64

图片 31

In [19]: np.exp(obj2)

print(data1.ix[data1.year>2000,:2])

Out[19]:

结果为:

d    403.428793

图片 32

b    1096.633158

详细的目录过滤方法如下:

a      0.006738

图片 33

c      20.085537

 

dtype: float64

 dataframe的算法运算

小编们也足以将Serice看成一个定长的有序字典,因为它是索引值到数据值的一个辉映。能够用在数不尽原来须求字典参数的函数中:

data={'year':[2000,2001,2002,2003],
'income':[3000,3500,4500,6000]}

data1=pd.DataFrame(data,columns=['year','income','outcome'],
index=['a','b','c','d'])

data2=pd.DataFrame(data,columns=['year','income','outcome'],
index=['a','b','c','d'])

data1['outcome']=range(1,5)

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

print(data1.add(data2,fill_value=0))

In [20]: ‘b’ in obj2

结果为:

Out[20]: True

图片 34

In [21]: ‘e’ in obj2

 

Out[21]: False

图片 35

举例数额被寄放在一个python字典中,能够直接通过那个字典来创设塞里es

 

In [4]: sdata={‘Ohio’:35000,’Texas’:71000,’Oregon’:16000,’Utah’:5000}

 对dataframe实行排序

In [5]: obj3=Series(sdata)

data=pd.DataFrame(np.arange(10).reshape((2,5)),index=['c','a'],
            columns=['one','four','two','three','five'])

print(data)

In [6]: obj3

结果为:

Out[6]:

图片 36

Ohio      35000

print(data.sort_index())

Oregon    16000

结果为:

Texas    71000

图片 37

Utah      5000

print(data.sort_index(axis=1))

dtype: int64

结果为:

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

图片 38

In [7]: states=[‘California’,’Ohio’,’Oregon’,’Texas’]

 

In [8]: obj4=Series(sdata,index=states)

print(data.sort_values(by='one'))

In [9]: obj4

结果为:

Out[9]:

 图片 39

California        NaN    #“California ”的值找不到,结果用NaN来顶替。

print(data.sort_values(by='one',ascending=False))

Ohio          35000.0

结果为:

Oregon        16000.0

图片 40

Texas        71000.0

那边是对结果举行降序排列

dtype: float64

 

pandas的isnull和notnull函数能够用来检查测验缺点和失误数据:

汇总以及计算描述

In [10]: pd.isnull(obj4)

data=pd.DataFrame(np.arange(10).reshape((2,5)),index=['c','a'],
columns=['one','four','two','three','five'])

print(data.describe())

Out[10]:

结果为:

California    True

 图片 41

Ohio          False

print(data.sum())

Oregon        False

结果为:

Texas        False

 图片 42

dtype: bool

print(data.sum(axis=1))

In [11]: pd.notnull(obj4)

结果为:

Out[11]:

图片 43

California    False

 

Ohio          True

详见约简方法 

Oregon        True

 图片 44

Texas          True

连锁描述总括函数

dtype: bool

 图片 45

Series也会有周围的实例方法:

 

In [12]: obj4.isnull()

 相关周密与协方差

Out[12]:

 

California    True

data=pd.DataFrame(np.random.random(20).reshape((4,5)),index=['c','a','b','c'],
columns=['one','four','two','three','five'])

print(data)

Ohio          False

结果为:

Oregon        False

图片 46

Texas        False

print(data.one.corr(data.three))

dtype: bool

one和three的相关周全为:

Series首要的三个作用是:它在算术中会自动对齐分裂索引的数目。

0.706077105725

In [13]: obj3

print(data.one.cov(data.three))

Out[13]:

one和three的协方差为:

Ohio      35000

0.0677896135613

Oregon    16000

print(data.corrwith(data.one))

Texas    71000

one和装有列的相关周到: 

Utah      5000

图片 47

dtype: int64

 

In [14]: obj4

独一值,成员身价等措施

Out[14]:

data=pd.Series(['a','a','b','b','b','c','d','d'])

print(data.unique())

California        NaN

结果为:

Ohio          35000.0

[‘a’ ‘b’ ‘c’ ‘d’]

Oregon        16000.0

print(data.isin(['b']))

Texas        71000.0

结果为:

dtype: float64

0 False
1 False
2 True
3 True
4 True
5 False
6 False
7 False
dtype: bool

In [15]: obj3+obj4

 print(pd.value_counts(data.values,sort=False))

Out[15]:

结果为:

California        NaN

d 2
c 1
b 3
a 2
dtype: int64

Ohio          70000.0

图片 48

Oregon        32000.0

 

Texas        142000.0

缺点和失误值管理

Utah              NaN

data=pd.Series(['a','a','b',np.nan,'b','c',np.nan,'d'])

print(data.isnull())

dtype: float64

结果为:

Series对象自己及其索引都有二个name属性,该属性跟pandas别的关键功用关系十分稳重:

0 False
1 False
2 False
3 True
4 False
5 False
6 True
7 False
dtype: bool

In [16]: obj4.name=’population’

print(data.dropna())

In [17]: obj4.index.name=’state’

结果为:

In [18]: obj4

0 a
1 a
2 b
4 b
5 c
7 d
dtype: object

Out[18]:

 print(data.ffill())

state

 结果为:

California        NaN

0 a
1 a
2 b
3 b
4 b
5 c
6 c
7 d
dtype: object

Ohio          35000.0

 print(data.fillna(0))

Oregon        16000.0

结果为:

Texas        71000.0

0 a
1 a
2 b
3 0
4 b
5 c
6 0
7 d
dtype: object

Name: population, dtype: float64

 图片 49

Series 的目录能够通过赋值的点子就地修改:

图片 50

In [20]: obj=Series([4,7,-5,3])

 

In [21]: obj.index=[‘Bob’,’Steve’,’Jeff’,’Ryan’]

 档期的顺序化索引

In [22]: obj

可以对数码实行多维度的目录

Out[22]:

data = pd.Series(np.random.randn(10), index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd'], 
         [1, 2, 3, 1, 2, 3, 1, 2, 2, 3]])

print(data)

Bob      4

结果为:

Steve    7

 图片 51

Jeff    -5

print(data.index)

Ryan    3

结果为:

dtype: int64

MultiIndex(levels=[[‘a’, ‘b’, ‘c’, ‘d’], [1, 2, 3]],

5.1.2 DataFrame

labels=[[0, 0, 0, 1, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 1, 2, 0, 1, 1, 2]])

print(data['c'])

DataFrame是一个表格型的数据结构,含有一组有序的列,每列能够是例外的值类型(数值,字符串,布尔值等)

结果为:

DataFrame既有行索引也许有列索引,能够被用作是由Series组成的字典。

图片 52

跟另外的好像的数据结构相比较(如Rubicon的data.frame),DataFrame中面向行和列的操作基本是平衡的。

print(data[:,2])

DataFrame中的数据是以多个或几个二维块贮存的。

结果为: 

创设DataFrame的章程有那多少个,最常用的一种是一贯传入贰个由等长列表或numpy组成的数组组成的字典:

图片 53

In [5]: from pandas import Series,DataFrame

 print(data.unstack())

In [6]: import pandas as pd

结果为:

In [7]:
data={‘state’:[‘Ohio’,’Ohio’,’Ohio’,’Nevada’,’Nevada’],’year’:[2000,2001,2002,2001,2002],’pop’:[1.5,1.7,3.6,2.4,2.9]}

图片 54

In [8]: frame=DataFrame(data)

把数据调换来为五个dataframe

结果DataFrame’会自动抬高索引(跟Series同样),且凡事列会被有序排列:

print(data.unstack().stack())

In [10]: frame

图片 55

Out[10]:

unstack()的逆运算

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的列就能够依照钦点顺序实行排列:

In [11]: DataFrame(data,columns=[‘year’,’state’,’pop’])

Out[11]:

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一样,假若传入的列在数量中找不到,就能够发生NA值:

In [11]: 
frame2=DataFrame(data,columns=[‘year’,’state’,’pop’,’debt’]

…: ,index=[‘one’,’two’,’three’,’four’,’five’])

In [12]: frame2

Out[12]:

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

In [26]: frame2.columns

Out[26]: Index([u’years’, u’state’, u’pop’, u’debt’],
dtype=’object’)

透过类似于字典标识的艺术或性质的不二等秘书籍,能够将DataFrame的列获取为多个Series:

In [27]: frame2[‘state’]

Out[27]:

one        Ohio

two        Ohio

three      Ohio

four    Nevada

five    Nevada

Name: state, dtype: object

In [18]: frame2.year

Out[18]:

one      2000

two      2001

three    2002

four    2001

five    2002

Name: year, dtype: int64

留心,再次来到的Series具有原DataFrame一样的目录,且其name属性也一度被相应的装置好了。

行也足以通过岗位或称谓的方法来举办获取。

In [19]: frame2.ix[‘three’]

Out[19]:

year    2002

state    Ohio

pop      3.6

debt      NaN

Name: three, dtype: object

列能够经过赋值的法门张开修改。如下,大家得以给空的”debt“列赋值三个标量或一组值。

In [20]: frame2[‘debt’]=16.5

In [21]: frame2

Out[21]:

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

In [24]: frame2[‘debt’]=np.arange(5.)

In [25]: frame2

Out[25]:

year  state  pop  debt

one    2000    Ohio  1.5  0.0

two    2001    Ohio  1.7  1.0

three  2002    Ohio  3.6  2.0

four  2001  Nevada  2.4  3.0

five  2002  Nevada  2.9  4.0

将列表或数组赋值给有个别列的时候,其尺寸必须求跟DataFrame的长度向相称。借使赋值的是贰个个Series
,就可以标准的般配DataFrame的目录,全数的空位都将被填上的缺点和失误值。

In [26]: val=Series([-1.2,-1.5,-1.7],index=[‘two’,’four’,’five’])

In [27]: frame2[‘debt’]=val

In [28]: frame2

Out[28]:

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

为不设有的列赋值会成立八个新列。关键字del用于删除列:

In [29]: frame2[‘eastern’]=frame2.state==’Ohio’

In [30]: frame2

Out[30]:

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  NaN    True

four  2001  Nevada  2.4  -1.5  False

five  2002  Nevada  2.9  -1.7  False

In [31]: del frame2[‘eastern’]

In [32]: frame2.columns

Out[32]: Index([u’year’, u’state’, u’pop’, u’debt’], dtype=’object’)

另一种常见的多少格局是嵌套字典(也等于字典的字典):

In [33]: pop={‘Nevada’:{2001:2.4,2002:2.9},’Ohio’:{2000:1.5,2001:1.7,

…: 2002:3.6}}

将它传给DataFrame,就能够被批注为:外层字典的键作为列,内层键作为行索引。

In [34]: frame3=DataFrame(pop)

In [35]: frame3

Out[35]:

Nevada  Ohio

2000    NaN  1.5

2001    2.4  1.7

2002    2.9  3.6

也足以对结果举办转置:

In [36]: frame3.T

Out[36]:

2000  2001  2002

Nevada  NaN  2.4  2.9

Ohio    1.5  1.7  3.6

内层字典的键会被统一、排序以及变成最后的目录。若钦定了显式索引,则不会这么:

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

Out[37]:

Nevada  Ohio

2001    2.4  1.7

2002    2.9  3.6

2003    NaN  NaN

由塞里es组成的字典差不离也是均等的用法:

In [40]:
pdata={‘Ohio’:frame3[‘Ohio’][:-1],’Nevada’:frame3[‘Nevada’][:2]}

In [41]: DataFrame(pdata)

Out[41]:

Nevada  Ohio

2000    NaN  1.5

2001    2.4  1.7

一经设置了Data.Frame的index属性和columns的name属性,

In [42]: frame3.index.name=’year’;frame3.columns.name=’state’

In [43]: frame3

Out[43]:

state  Nevada  Ohio

year

2000      NaN  1.5

2001      2.4  1.7

2002      2.9  3.6

In [44]: frame3.values

Out[44]:

array([[ nan,  1.5],

[ 2.4,  1.7],

[ 2.9,  3.6]])

In [45]: frame3.values

Out[45]:

array([[ nan,  1.5],

[ 2.4,  1.7],

[ 2.9,  3.6]])

5.1.3索引对象

pandas的目录对象肩负管理标签和别的元数据(举个例子轴名称等)。营造Series或DataFrame时,所用到的其余数组或任何体系的竹签都会被转变来二个Index:

In [2]: import numpy as np

In [3]: import pandas as pd

In [5]: from pandas import Series,DataFrame

In [6]: obj=Series(range(3),index=[‘a’,’b’,’c’])

In [7]: index=obj.index

In [8]: index

Out[8]: Index([u’a’, u’b’, u’c’], dtype=’object’)

In [9]: index[1:]

Out[9]: Index([u’b’, u’c’], dtype=’object’)

Index对象是不足修改的,因而用户无法对其修改:

In [10]: index[1]=’d’


TypeError                                Traceback (most recent call
last)

in ()

—-> 1 index[1]=’d’

H:\Anaconda2-4.3.0.1\lib\site-packages\pandas\indexes\base.pyc in
__setitem__(self, key, value)

1402

1403    def __setitem__(self, key, value):

-> 1404        raise TypeError(“Index does not support mutable
operations”)

1405

1406    def __getitem__(self, key):

TypeError: Index does not support mutable operations

不得修改性非常首要,因为如此技艺使得index对象在多个数据结构之间安全分享:

In [12]: index=pd.Index(np.arange(3))

In [13]: obj2=Series([1.5,-2.5,0],index=index)

In [14]: obj2=Series([1.5,-2.5,0],index=index)

In [16]: obj2.index is index

Out[16]: True

除开长得像数组,index的效果与利益也仿佛两个确定地点大小的联谊:

In [43]: frame3

Out[43]:

state  Nevada  Ohio

year

2000      NaN  1.5

2001      2.4  1.7

2002      2.9  3.6

In [46]: ‘Ohio’ in frame3.columns

Out[46]: True

In [47]: 2003 in frame3.index

Out[47]: False

5.2基本功用

介绍操作塞里es和DataFrame中的数据的中坚花招。

5.2.1双重索引

pandas对象的二个最首要的格局就是reindex,成效是成立二个适应新索引的新目的。

In [33]:  import pandas as pd

from pandas import Series,DataFrame

In [34]: obj=Series([4.5,7.2,-5.3,3.6],index=[‘d’,’b’,’a’,’c’])

In [35]: obj

Out[35]:

d    4.5

b    7.2

a  -5.3

c    3.6

dtype: float64

调用该塞里es的reindex将会依据新索引举行重排。若是有些索引值当前不存,就引进缺点和失误值:

In [36]: obj2=obj.reindex([‘a’,’b’,’c’,’d’,’e’])

In [37]: obj2

Out[37]:

a  -5.3

b    7.2

c    3.6

d    4.5

e    NaN

dtype: float64

In [38]:  obj.reindex([‘a’,’b’,’c’,’d’,’e’],fill_value=0)

Out[38]:

a  -5.3

b    7.2

c    3.6

d    4.5

e    0.0

dtype: float64

对此时间种类那样的雷打不动数据,重新索引时只怕必要做一些插值管理。method选项就可以用达到此指标。举个例子:ffill能够兑现向前值填充:

In [39]: obj3=Series([‘blue’,’purple’,’yellow’],index=[0,2,4])

In [40]: obj3.reindex(range(6),method=’ffill’)

Out[40]:

0      blue

1      blue

2    purple

3    purple

4    yellow

5    yellow

dtype: object

下表中列出了可用的method选项。

参数 说明

fill或pad 前向填充(或搬运)值

bfill或backfill 后向填充(或搬运)值

对此DataFrame,reindex能够修改(行)索引,列,或七个都修改。假使仅传入八个行列,则会重新索引行:

In [41]:
frame=DataFrame(np.arange(9).reshape((3,3)),index=[‘a’,’c’,’d’],columns=[‘Ohio’,’Texas’,’California’,])

In [52]: frame

Out[53]:

Ohio  Texas  California

a    0      1          2

c    3      4          5

d    6      7          8

In [54]: frame2=frame.reindex([‘a’,’b’,’c’,’d’])

In [55]:frame2

Out[55]:

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

运用columns关键字即能够重新索引。

In [56]: states=[‘Texas’,’Utah’,’California’]

frame.reindex(columns=states)

Out[57]:

Texas  Utah  California

a      1  NaN          2

c      4  NaN          5

d      7  NaN          8

也得以并且对行和列进行重复索引,而插值则不得不按行应用(即轴0):

frame.reindex(index=[‘a’,’b’,’c’,’d’],method=’ffill’,columns=states)

Out[58]:

Texas  Utah  California

a      1  NaN          2

b      1  NaN          2

c      4  NaN          5

d      7  NaN          8

使用ix的竹签的=索引功能,重新索引职分能够变得简洁:

frame.ix[[‘a’,’b’,’c’,’d’],states]

Out[59]:

Texas  Utah  California

a    1.0  NaN        2.0

b    NaN  NaN        NaN

c    4.0  NaN        5.0

d    7.0  NaN        8.0

5.2.2舍弃钦点轴上的项

撇开某条轴上的贰个或八个项,只要有四个索引数组或列表就可以。

鉴于必要施行一些多少整理和聚众逻辑,所以drop方法重返的是多个在钦点轴上剔除了钦定值的新目的:

In [60]: obj=Series(np.arange(5.),index=[‘a’,’b’,’c’,’d’,’e’])

In [61]: new_obj=obj.drop(‘c’)

In [62]: new_obj

Out[62]:

a    0.0

b    1.0

d    3.0

e    4.0

dtype: float64

In[63]: obj.drop([‘d’,’c’])

Out[63]:

a    0.0

b    1.0

e    4.0

dtype: float64

对于DataFrame,能够去除大肆轴上的索引值:

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

In[67]: data.drop([‘Colorado’,’Ohio’])

Out[67]:

one  two  three  four

Utah        8    9    10    11

New York  12  13    14    15

In [68]: data.drop(‘two’,axis=1)

Out[68]:

one  three  four

Ohio        0      2    3

Colorado    4      6    7

Utah        8    10    11

New York  12    14    15

In [69]: data.drop([‘two’,’four’],axis=1)

Out[69]:

one  three

Ohio        0      2

Colorado    4      6

Utah        8    10

New York  12    14

5.2.3索引、选拔和过滤

Series索引
(obj[…])的办事办法临近于NumPy数组的目录,只不过Series的索引值不只是整数。例:

In [5]: obj=Series(np.arange(4.),index=[‘a’,’b’,’c’,’d’])

In [6]: obj[‘b’]

Out[6]: 1.0

In [7]: obj[1]

Out[7]: 1.0

In [8]: obj[2:4]

Out[8]:

c    2.0

d    3.0

dtype: float64

In [10]: obj[[‘b’,’a’,’d’]]

Out[10]:

b    1.0

a    0.0

d    3.0

dtype: float64

In [11]: obj[[1,3]]

Out[11]:

b    1.0

d    3.0

dtype: float64

In [12]: obj[obj<2]

Out[12]:

a    0.0

b    1.0

dtype: float64

利用标签的切丝运算与常见的python切条运算差别,其前边是包含的(inclusive)

In [19]: obj[‘b’:’c’]

Out[19]:

b    1.0

c    2.0

dtype: float64

安装方法如下:

In [20]: obj[‘b’:’c’]=5

In [21]: obj

Out[21]:

a    0.0

b    5.0

c    5.0

d    3.0

dtype: float64

如你所见,对DataFrame实行索引其实就是赢得贰个或三个列:

In [24]: data=DataFrame(np.arange(16).reshape((4,4)),

index=[‘Ohio’,’Colorado’,’Utah’,’New
York’],columns=[‘one’,’two’,’three’,’four’])

In [25]: data

Out[25]:

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 [26]: data[‘two’]

Out[26]:

Ohio        1

Colorado    5

Utah        9

New York    13

Name: two, dtype: int32

In [28]: data[[‘three’,’one’]]

Out[28]:

three  one

Ohio          2    0

Colorado      6    4

Utah        10    8

New York    14  12

In [30]: data[[‘three’,’one’]]

Out[30]:

three  one

Ohio          2    0

Colorado      6    4

Utah        10    8

New York    14  12

这种索引方式有多少个新鲜意况。首先通过切成片或布尔数组进行选用行:

In [29]: data[:2]

Out[29]:

one  two  three  four

Ohio        0    1      2    3

Colorado    4    5      6    7

In [31]: data[data[‘three’]>5]

Out[31]:

one  two  three  four

Colorado    4    5      6    7

Utah        8    9    10    11

New York  12  13    14    15

另一种用法使通过布尔型DataFrame实行索引:

In [32]: data<5

Out[32]:

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

In [33]: data[data<5]=0

In [34]: data

Out[34]:

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

这段代码使得DataFrame在语法上像ndarray

为了在DataFrame的行上进行标签索引,大家引进专门的索引字段ix。使得你通过numpy式的标识法以及轴标签的从DataFrame中选用行和列的子集。那是复出索引的简要花招:

In [35]: data.ix[‘Colorado’,[‘two’,’three’]]

Out[35]:

two      5

three    6

Name: Colorado, dtype: int32

In [36]: data.ix[[‘Colorado’,’Utah’],[3,0,1]]

Out[36]:

four  one  two

Colorado    7    0    5

Utah        11    8    9

In [37]: data.ix[2]

Out[37]:

one      8

two      9

three    10

four    11

Name: Utah, dtype: int32

In [38]: data.ix[:’Utah’,’two’]

Out[38]:

Ohio        0

Colorado    5

Utah        9

Name: two, dtype: int32

In [39]: data.ix[data.three>5,:3]

Out[39]:

one  two  three

Colorado    0    5      6

Utah        8    9    10

New York  12  13    14

5.2.4算术运算和数目对齐

In [5]: s1=Series([7.3,-2.5,3.4,1.5],index=[‘a’,’c’,’d’,’e’])

In [6]:
s2=Series([-2.1,3.6,-1.5,4,3.1],index=[‘a’,’c’,’e’,’f’,’g’])

In [7]: s1

Out[7]:

a 7.3

c -2.5

d 3.4

e 1.5

dtype: float64

In [8]: s2

Out[8]:

a -2.1

c 3.6

e -1.5

f 4.0

g 3.1

dtype: float64

把她们相加:

In [9]: s1+s2

Out[9]:

a 5.2

c 1.1

d NaN

e 0.0

f NaN

g NaN

dtype: float64

自行的数码对其操作在不重叠的索引处引进了NA值。缺点和失误值会在算术运算进程中传出。

对于DataFrame,对齐操作会同期产生在行和列上:

In [6]:
df1=DataFrame(np.arange(9.).reshape((3,3)),columns=list(‘bcd’),index=[‘Ohio’,’Texas’,’Colorado’])

In [7]:
df2=DataFrame(np.arange(12.).reshape((4,3)),columns=list(‘bde’),index=[‘Utah’,’Ohio’,’Texas’,’Oregon’])

In [8]: df1

Out[8]:

b c d

Ohio 0.0 1.0 2.0

Texas 3.0 4.0 5.0

Colorado 6.0 7.0 8.0

In [9]: df2

Out[9]:

b d e

Utah 0.0 1.0 2.0

Ohio 3.0 4.0 5.0

Texas 6.0 7.0 8.0

Oregon 9.0 10.0 11.0

将她们相加后,会回来二个新的DataFrame,其索引和列为原本的那多少个DataFrame的并集:

In [10]: df1+df2

Out[10]:

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

5.2.4.1在算术方法中填充钱

在分化索引的指标开始展览算术运算时,你也许希望当三个目的中有个别轴标签在另二个对象张找不到时填充三个极度值:

In [20]:
df1=DataFrame(np.arange(12.).reshape((3,4)),columns=list(‘abcd’))

In [21]:
df2=DataFrame(np.arange(20.).reshape((4,5)),columns=list(‘abcde’))

In [22]: df1

Out[22]:

a b c d

0 0.0 1.0 2.0 3.0

1 4.0 5.0 6.0 7.0

2 8.0 9.0 10.0 11.0

In [23]: df2

Out[23]:

a b c d e

0 0.0 1.0 2.0 3.0 4.0

1 5.0 6.0 7.0 8.0 9.0

2 10.0 11.0 12.0 13.0 14.0

3 15.0 16.0 17.0 18.0 19.0

将他们相加时,未有重叠的职分就能生出NA值:

In [24]: df1+df2

Out[24]:

a b c d e

0 0.0 2.0 4.0 6.0 NaN

1 9.0 11.0 13.0 15.0 NaN

2 18.0 20.0 22.0 24.0 NaN

3 NaN NaN NaN NaN NaN

选取df1的add方法,传入df2以及一个fill_value参数:

In [26]: df1.add(df2,fill_value=0)

Out[26]:

a b c d e

0 0.0 2.0 4.0 6.0 4.0

1 9.0 11.0 13.0 15.0 9.0

2 18.0 20.0 22.0 24.0 14.0

3 15.0 16.0 17.0 18.0 19.0

对Series或DataFrame重新索引时,也能够钦命贰个填充值:

In [28]: df1.reindex(columns=df2.columns,fill_value=0)

Out[28]:

a b c d e

0 0.0 1.0 2.0 3.0 0

1 4.0 5.0 6.0 7.0 0

2 8.0 9.0 10.0 11.0 0

表5-7 灵活的算术方法

方法 说明

add 用于加法(+)的措施

sub 用于减法(-)的不二等秘书技

div 用于乘法(*)的方法

mul 用于除法(/)的办法

5.2.4.2 DataFrame和Series之间的运算

跟NumPy数组一样,DataFrame和Series的=之间的算术运算也有鲜明规定的。

上面来计量二个二维数组与其某行之间的差:

In [29]: arr=np.arange(12.).reshape((3,4))

In [30]: arr

Out[30]:

array([[ 0., 1., 2., 3.],

[ 4., 5., 6., 7.],

[ 8., 9., 10., 11.]])

In [31]: arr[0]

Out[31]: array([ 0., 1., 2., 3.])

In [32]: arr-arr[0]

Out[32]:

array([[ 0., 0., 0., 0.],

[ 4., 4., 4., 4.],

[ 8., 8., 8., 8.]])

地方的演算就称为,广播。

DataFrame和Series之间的运算差不离也是如此:

In [33]:
frame=DataFrame(np.arange(12.).reshape((4,3)),columns=list(‘bde’),index=[‘Utah’,’Ohio’,’Texas’,’Oregon’])

In [34]: series=frame.ix[0]

In [35]: frame

Out[35]:

b d e

Utah 0.0 1.0 2.0

Ohio 3.0 4.0 5.0

Texas 6.0 7.0 8.0

Oregon 9.0 10.0 11.0

In [36]: series

Out[36]:

b 0.0

d 1.0

e 2.0

Name: Utah, dtype: float64

默许情状下,DataFrame和Series之间的算术运算符将Series的目录相称到DataFrame的列,然后沿着行平素向下播放:

In [37]: frame – series

Out[37]:

b d e

Utah 0.0 0.0 0.0

Ohio 3.0 3.0 3.0

Texas 6.0 6.0 6.0

Oregon 9.0 9.0 9.0

如若有个别索引值在DataFrame的列或塞里es的目录中找不到,则参预运算的四个对象就能够被另行索引以产生并集:

In [38]: series2=Series(range(3),index=[‘b’,’e’,’f’])

In [39]: frame+series2

Out[39]:

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

若果你希望相称行且在列上海人民广播广播台播,则必须运用算术运算方法:

In [40]: series3=frame[‘d’]

In [41]: frame

Out[41]:

b d e

Utah 0.0 1.0 2.0

Ohio 3.0 4.0 5.0

Texas 6.0 7.0 8.0

Oregon 9.0 10.0 11.0

In [42]: series3

Out[42]:

Utah 1.0

Ohio 4.0

Texas 7.0

Oregon 10.0

Name: d, dtype: float64

In [43]: frame.sub(series3,axis=0)

Out[43]:

b d e

Utah -1.0 0.0 1.0

Ohio -1.0 0.0 1.0

Texas -1.0 0.0 1.0

Oregon -1.0 0.0 1.0

传播的轴号就是梦想相称的轴。

5.2.5函数应用和照耀

Numpy的ufuncs(成分级数组方法)也能够用来操作pandas对象:

In [44]:
frame=DataFrame(np.random.randn(4,3),columns=list(‘bde’),index=[‘Utah’,’Ohio’,’Texas’,’Oregon’])

In [45]: frame

Out[45]:

b d e

Utah -0.172344 1.823441 -0.067380

Ohio -0.338604 -0.189082 -0.145676

Texas 1.310289 -0.518146 -0.231740

Oregon -1.880954 -0.400772 0.228320

In [46]: np.abs(frame)

Out[46]:

b d e

Utah 0.172344 1.823441 0.067380

Ohio 0.338604 0.189082 0.145676

Texas 1.310289 0.518146 0.231740

Oregon 1.880954 0.400772 0.228320

另一个普及的操作,将函数应用到由各列或行所产生的一维数组上。DataFrame的apply方法就可以兑现此意义:

In [47]: f=lambda x:x.max() – x.min()

In [48]: frame.apply(f)

Out[48]:

b 3.191243

d 2.341587

e 0.460059

dtype: float64

In [49]: frame.apply(f,axis=1)

Out[49]:

Utah 1.995785

Ohio 0.192928

Texas 1.828435

Oregon 2.109274

dtype: float64

除标量外,传递给apply的函数仍是能够回到由五个值组成的Series:

In [52]: def f(x):

…: return Series([x.min(),x.max()],index=[‘min’,’max’])

…:

In [53]: frame.apply(f)

Out[53]:

b d e

min -1.880954 -0.518146 -0.23174

max 1.310289 1.823441 0.22832

其余,成分级的python函数也是能够用的。

若是想博得frame中逐条浮点数的格式化字符串,使用applymap即可:

In [54]: format=lambda x:’%.2f’ %x

In [55]: frame.applymap(format)

Out[55]:

b d e

Utah -0.17 1.82 -0.07

Ohio -0.34 -0.19 -0.15

Texas 1.31 -0.52 -0.23

Oregon -1.88 -0.40 0.23

故此叫做applymap,是因为Series有三个用以选用成分级函数的map的诀要:

In [56]: frame[‘e’].map(format)

Out[56]:

Utah -0.07

Ohio -0.15

Texas -0.23

Oregon 0.23

Name: e, dtype: object

5.2.6排序和排名

基于准则对数据集排序也是一种重大的放到运算。要对行或列索引实行排序(按字典顺序),能够行使sort_index方法,它将重返贰个早已排序的新对象:

In [57]: obj=Series(range(4),index=[‘d’,’a’,’b’,’c’])

In [58]: obj.sort_index()

Out[58]:

a 1

b 2

c 3

d 0

dtype: int64

而对此DataFrame,则足以依赖随意贰个轴上的目录实行排序:

In [59]:
frame=DataFrame(np.arange(8).reshape((2,4)),index=[‘three’,’one’],columns=[‘d’,’a’,’b’,’c’])

In [60]: frame.sort_index()

Out[60]:

d a b c

one 4 5 6 7

three 0 1 2 3

In [61]: frame.sort_index(axis=1)

Out[61]:

a b c d

three 1 2 3 0

one 5 6 7 4

多少暗许是按升序排列的,但也足以降序排序:

In [64]: frame.sort_index(axis=1,ascending=False)

Out[64]:

d c b a

three 0 3 2 1

one 4 7 6 5

若要按值对Series实行排序,可以利用order方法:

In [65]: obj=Series([4,7,-3,2])

In [66]: obj.order()

Out[66]:

2 -3

3 2

0 4

1 7

dtype: int64

在排序的时候,缺点和失误值暗中同意都会被放在了Series的最后:

In [67]: obj=Series([4,np.nan,7,np.nan,-3,2])

In [68]: obj.order()

Out[68]:

4 -3.0

5 2.0

0 4.0

2 7.0

1 NaN

3 NaN

dtype: float64

在DataFrame上,你或然希望依据二个或七个列中的值进行排序。将二个或七个列的名字传递给by选项就能够直达该指标:

In [69]: frame=DataFrame({‘b’:[4,7,-3,2],’a’:[0,1,0,1]})

In [70]: frame

Out[70]:

a b

0 0 4

1 1 7

2 0 -3

3 1 2

In [71]: frame.sort_index(by=’b’)

Out[71]:

a b

2 0 -3

3 1 2

0 0 4

1 1 7

要基于八个列进行排序,传入名称的列表就可以:

In [73]: frame.sort_index(by=[‘a’,’b’])

Out[73]:

a b

2 0 -3

0 0 4

3 1 2

1 1 7

排行(ranking)跟排序关系密切,且会增设三个排名值(从1始发,一向到数组中央银立竿见影数据的数目),跟numpy.argsort爆发的间接排序索引差不离,只可是它能够依据某种准绳破坏平级关系。

下边介绍Series和DataFrame的rank方法。暗许下:rank是通过“为各组分配贰个等分排行”的艺术来破坏平级关系。

In [75]: obj=Series([7,-5,7,4,2,0,4])

In [76]: obj.rank()

Out[76]:

0 6.5

1 1.0

2 6.5

3 4.5

4 3.0

5 2.0

6 4.5

dtype: float64

也足以依照值在原数据中冒出的次第给出排行:

In [77]: obj.rank(method=’first’)

Out[77]:

0 6.0

1 1.0

2 7.0

3 4.0

4 3.0

5 2.0

6 5.0

dtype: float64

也足以按降序实行排名:

In [78]: obj.rank(ascending=False,method=’max’)

Out[78]:

0 2.0

1 7.0

2 2.0

3 4.0

4 5.0

5 6.0

6 4.0

dtype: float64

表5-8
列出了富有用于破坏平级关系的method选项。DataFrame能够在行或列上计算排名:

In [79]:
frame=DataFrame({‘b’:[4.3,7,-3,2],’a’:[0,1,0,1],’c’:[-2,5,8,-2.5]})

In [80]: frame

Out[80]:

a b c

0 0 4.3 -2.0

1 1 7.0 5.0

2 0 -3.0 8.0

3 1 2.0 -2.5

In [81]: frame.rank(axis=1)

Out[81]:

a b c

0 2.0 3.0 1.0

1 1.0 3.0 2.0

2 2.0 1.0 3.0

3 2.0 3.0 1.0

表5-8 :排行时用来破坏平级关系的method选项

method 说明

‘average’ 暗许:在极度分组中,为各类值分配平均排‘’

‘min’ 使用成套分组的微小排行

‘max’ 使用一切分组的最大排名

‘first’ 按值在原本数据中的出现顺序分配排名

5.2.7满含重复的轴索引

大家看看上边那么些差非常少的涵盖重复索引值的Series:

In [82]: obj=Series(range(5),index=[‘a’,’a’,’b’,’b’,’c’])

In [83]: obj

Out[83]:

a 0

a 1

b 2

b 3

c 4

dtype: int64

索引的is_unique属性能够告诉你他的值是不是是独一的:

In [84]: obj.index.is_unique

Out[84]: False

对于再一次的目录,数据选用的展现将会有一些分化。若是有些索引对应的四个值,则赶回贰个Series,而对应单个值,则赶回一个标量:

In [85]: obj[‘a’]

Out[85]:

a 0

a 1

dtype: int64

In [86]: obj[‘c’]

Out[86]: 4

对DataFrame的行动行索引时候也是如此:

In [87]: df=DataFrame(np.random.randn(4,3),index=[‘a’,’a’,’b’,’b’])

In [88]: df

Out[88]:

0 1 2

a 0.056598 1.592208 -0.576368

a 0.842511 -0.085418 0.818032

b 1.347421 -0.239196 -0.543597

b -0.598395 0.966395 0.285722

In [89]: df.ix[‘b’]

Out[89]:

0 1 2

b 1.347421 -0.239196 -0.543597

b -0.598395 0.966395 0.285722

相关文章