pandas是依照numpy包扩展而来的,5.3集中和计量描述性总计

print(data.corrwith(data.one))

Out[28]:

6  two  3  6  1

print(data1.ix['a'])

dtype: float64

In [168]:
MultiIndex.from_arrays([[‘Ohio’,’Ohio’,’Colorado’],[‘Green’,’Red’,’Green’]],names=[‘state’,’color’])

刺探这个,应该可以举行局部健康的数码处理了。

three  2002    Ohio  3.6  NaN

3  6  1

结果为

a  -10

state      Ohio    Colorado

 

a 0

In [162]:
frame=DataFrame(np.arange(12).reshape((4,3)),index=[[‘a’,’a’,’b’,’b’],[1,2,1,2]],columns=[[‘Ohio’,’Ohio’,’Colorado’],[‘Green’,’Red’,’Green’]])

集中以及总计描述

b    1.0

5 b

结果为:

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

2    9  10      11

import pandas as pd

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

print(object)

Texas 9.0 NaN 12.0 NaN

In [26]: ser

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

Out[27]:

Out[163]:

 

5.2.6排序和排名

dtype: bool

结果为: 

Out[35]:

a  1    0.024162

二种索引是等价的,都是对列举办索引,结果为:

California        NaN

1        2        3

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

4 3.0

b 2

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

5 6.0

0    False

结果为:

3    3

Out[139]:

图片 1

four  one  two

对于一个层次化索引的靶子,选择数据子集的操作很简单:

 

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

2  2  5

图片 2

Utah 0.0 1.0 2.0

Out[111]:

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

遵照标准对数码集排序也是一种关键的放到运算。要对行或列索引举行排序(按字典顺序),可以运用sort_index方法,它将回到一个一度排序的新目的:

比如,你或许以为上面的代码不会报错。

 图片 3

New York  12  13    14

key2 key1

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

Ohio 3.0 4.0 5.0

4 7.000000

del data1['outcome']

In [14]: obj2

2 -0.451567 1.441581 -0.150315

结果为:

除标量外,传递给apply的函数还是可以够再次来到由五个值组成的Series:

d 1

结果为:

2000    NaN  1.5

In [95]: df.idxmax()

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

In [32]: frame2.columns

1  4  3  two  1

结果为:

year  state  pop  debt

0 0.501394 -1.735750 0.197643

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

In [32]: arr-arr[0]

b  1    1.136933

 图片 4

列可以由此赋值的章程开展改动。如下,大家可以给空的”debt“列赋值一个标量或一组值。

对reindex有效的那一个插值方法也足以用来fillna:

结果为:

2  2002    Ohio  3.6

dtype: float64

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)

three  one

2 False

图片 5

Out[43]:

color Green Red

图片 6

Out[89]:

1 1.0 NaN NaN NaN

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

Out[78]:

b  1.136933 -0.158487  0.482377

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

In [7]: s1

5 0.738134 -1.505505 -0.052306

 相关周到与协方差

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

In [173]: frame.sum(level=’color’,axis=1)

结果为:

one    2000    Ohio  1.5  16.5

key1 key2

 

4 5.0

2  2  5  one  2

删去列结果为:

Out[31]:

2 NaN NaN NaN

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

print(data.isnull())

Oregon 9.0 10.0 11.0

state      Ohio    Colorado

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

普普通通我们目的在于所创造的Series带有一个足以对一一数据点举行标记的目录:

5.3汇集和测算描述性总计

one和颇具列的相关全面: 

5.3汇聚和测算描述性总结

In [14]: frame=DataFrame({‘a’:range(7),’b’:range(7,0,-1),

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

In [37]: obj2

2  one  2  2  5

print(data.dropna())

c    2.0

one 0  0  7  one  0

结果为:

Out[80]:

2 NaN NaN NaN

Series是近似于数组的目的,它有一组数据和与之休戚相关的竹签组成。

serice 的字符串表现模式为:索引在左手,值在左侧。

2  5  2  two  2

图片 7

Out[25]:

Out[31]: 2.0

 结果为:

two    2001    Ohio  1.7  1.0

2        9  10

结果为:

five  2002  Nevada  2.9  NaN

a  0.024162  0.969526 -0.215712

   year income outcome
b 2001 3500 NaN
c 2002 4500 NaN

Ohio -0.15

1 6 8 10

 print(data.unstack())

TypeError: Index does not support mutable operations

In [164]: frame.index.names=[‘key1′,’key2’]

图片 8

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

可以单独的创办MultiIndex
然后复用,上面非凡DataFrame中的(分级)列可以如此创制:

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)

瞩目,再次来到的Series拥有原DataFrame相同的目录,且其name属性也早就被相应的安装好了。

key1 key2

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

New York    14  12

6 -1.712077 0.386785 0.436945

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

Out[13]:

In [146]: df.ix[2:,1]=NA;df.ix[4:,2]=NA

另外,值是不可能一向被索引到的

也可以对结果开展转置:

Out[121]:

结果为:

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

4 4 3 4

True

In [11]: pd.notnull(obj4)

Out[166]:

结果中涵盖一列数据和一列标签
我们得以用values和index分别开展引用

Name: two, dtype: int32

fillna默认会重返新目的,不过也可以对现有的目标举办修改:

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

print(data)

one 5 6 7 4

In [32]: ser.ix[:1]

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

print(object)

Utah -1.0 0.0 1.0

4 False

充实列为money

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

state      Ohio    Colorado

d 2
c 1
b 3
a 2
dtype: int64

0    4

one b

False

b 2

2  -0.158487

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

1 9.0 11.0 13.0 15.0 NaN

Out[116]:

图片 9

dtype: int64

2    a        3  4        5

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

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

In [126]: data.dropna()

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

Out[19]:

In [113]: mask

0.706077105725

d    6

In [161]: data.unstack().stack()

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

dtype: float64

Out[160]:

 

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

3  6  1  two  3

唯一值,成员身份等办法

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

dtype: float64

 图片 10

0 4

color      Green  Red

one和three的相关周到为:

0 2.0 3.0 1.0

5 0.738134 -1.505505 -0.052306

把数据转换成为一个dataframe

Utah        8    9    10    11

末段isin,它用于判断矢量化最集合的积极分子身份,可用于选拔Series中或DataFrame列中的数据的子集:

 图片 11

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

4 -1.038639 NaN -0.756553

结果为:

假若某个索引值在DataFrame的列或Series的目录中找不到,则参预运算的五个对象就会被重复索引以形成并集:

2  -0.158487

 

In [4]: obj

Out[151]:

新扩大列outcome在data中从不,则用na值代替

Steve    7

In [116]: data

a 2
b 5
c 8
d 9
dtype: int64

d NaN

稍许汇总总括(如先关周到和协方差)是透过参数总结出来的。

 

Ohio -1.0 0.0 1.0

1 2.099104 1.441581 0.743717

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

将她们相加时,没有重叠的职位就会发生NA值:

one 9.25

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

Out[43]:

In [166]: frame

 

one  two  three  four

In [17]: frame2

俺们还是可以对队列举行演算

Texas  Utah  California

a    1        0  1        2

日增和删除列

d    4.5

表5-10列出了有着与描述总计相关的主意。

 

c    3

Out[127]:

结果为:

Ohio        0      2

In [143]: _=df.fillna(0,inplace=True)

图片 12

Ohio 3.0 3.0 3.0

4 -1.038639 0.000000 -0.756553

print(data.sum(axis=1))

four  2001  Nevada  2.4  -1.5

one two

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

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

3 -0.032894 NaN 0.418310

 图片 13

In [19]: np.exp(obj2)

Out[99]:

 对dataframe进行排序

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

3 0.010116 0.500000 0.064880

图片 14

Oregon 0.23

In [142]: df.fillna({1:0.5,3:-1})

结果为:

为了在DataFrame的行上举办标签索引,大家引入专门的索引字段ix。使得你通过numpy式的标记法以及轴标签的从DataFrame中选拔行和列的子集。这是复出索引的简易手段:

8 c

咱俩还足以按照自己的希望构建标签

one  three

1  1  6  one  1

抑或也能够用切片的花样

dtype: object

1  one  1  1  6

详尽约简方法 

Out[73]:

data[‘b’]

print(object[object>5])

Colorado    7    0    5

1 False

结果为:

In [45]: frame3.values

4 -1.038639 0.000000 -0.756553

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

print(data)

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

Out[38]:

结果为:

dtype: int64

5.5.2依照级别汇总统计

name或者index.name可以对数码进行重命名

2 6.5

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

0.0677896135613

2 7.0

Out[156]:

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

Out[11]: -5

In [90]:
df=DataFrame([[1.4,np.nan],[7.1,-4.5],[np.nan,np.nan],[0.75,-1.3]],index=[‘a’,’b’,’c’,’d’],columns=[‘one’,’two’])

图片 15

Out[68]:

a NaN

结果为 :

Oregon        16000.0

各层都得以出名字(可以是字符串,也足以是python对象)。假如指定了名称,他们就会来得在支配台出口中:

 图片 16

dtype: float64

In [148]: df.fillna(method=’ffill’)

结果为:

New York    13

a    1        0    1

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

print(data['c'])

Out[6]:

0 0.452896 NaN NaN

one和three的协方差为:

a b c

0 1 2

结果为:

d c b a

2  -1.090750

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

print(data.describe())

Out[26]:

In [149]: df.fillna(method=’ffill’,limit=2)

print(data1[1:3])

将它传给DataFrame,就会被诠释为:外层字典的键作为列,内层键作为行索引。

a    0.969526

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

e 2.0

one 0  0  7

print('a' in object)

In [18]: frame2.year

In [159]: data[:,2]

unstack()的逆运算

Out[11]:

dtype: float64

 另外还有一个reindex函数能够重复构建索引

Ohio      35000

Qu1 Qu2 Qu3

目录的三种方法

2    purple

0 0.501394 -1.735750 0.197643

结果为:

In [45]: frame

4  4  3  two  1

此地是对结果开展降序排列

Out[24]:

2    a        3  4        5

连带描述总结函数

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

c  1  -0.551888

结果为:

Out[88]:

In [115]:
data=DataFrame({‘Qu1′:[1,3,4,3,4],’Qu2′:[2,3,1,2,3],’Qu3’:[1,5,2,4,4]})

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

data=pd.DataFrame(data)

print(data)

four    Nevada

In [91]: df

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

dtype: float64

Out[154]:

结果为:

a  -5

通过一个常数来fillna就会将缺失值替换为特别常数值:

 

对此时间类别那样的不变数据,重新索引时可能需要做一些插值处理。method选项即可用达到此目标。例如:ffill可以兑现向前值填充:

2    b        9  10      11

可以对数码开展多维度的目录

2 0 -3

pandas对象拥有一组常用的数学和总括方法。他们多数都属于约简和集中总括,用于从Series中领到单个值(如mean或sum)或从DataFrame的行或列中领取一个Series。跟对应的NumPy数组方法相比较,他们都是遵照没有缺失数据的比方而构建的。

 

Texas          True

0 1 2

 dataframe的算法运算

地点的演算就叫做,广播。

0    0

 print(data.fillna(0))

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

比如,传入Series的平均值或中位数:

print(data.sort_index())

two      9

5.4拍卖缺失数据

图片 17

5.5.2基于级别汇总总括

In [35]: ser3.iget_value(2)

图片 18

5.5层次化索引

Out[147]:

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

In [34]: frame3=DataFrame(pop)

dtype: float64

结果为:

one  two  three  four

操作由整数索引的pandas对象日常会让新手抓狂,因为他们跟内置的python数据结构(如列表和元组)在索引语义上稍微不同。

图片 19

year  state  pop debt

a  b    c  d

图片 20

Ohio -0.34 -0.19 -0.15

dtype: float64

图片 21

2001      2.4  1.7

3 3.833333

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 [80]: frame

freq     8

图片 22

pandas的目录对象负责管理标签和另外元数据(比如轴名称等)。构建Series或DataFrame时,所用到的此外数组或任何体系的竹签都会被转换成一个Index:

Out[142]:

图片 23

In [21]: frame2

重重对DataFrame
和Series的描述和集中总括都有一个leve选项,用于指定在某条轴上对求和的级别,再也上边的老大DataFrame为例子,我们按照行或列上的级别举办求和:

结果为:

In [7]: obj[1]

1 2.099104 1.441581 0.743717

 

Ohio          False

3    0.482377

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

而外长得像数组,index的功用也相近一个永恒大小的聚合:

75%  4.250000 -2.100000

图片 24

pandas 引入约定

dtype: float64

0 2
1 5
2 8
3 9
dtype: int64

5.4.2填充缺失数据

In [99]: obj.describe()

 print(data.ffill())

2002      2.9  3.6

3    0.482377

结果为:

Ohio        0

5  5  2  two  2

 图片 25

In [68]: obj.order()

In [136]: data.dropna(axis=1,how=’all’)

图片 26

Out[57]:

b  1    1.136933

pandas是遵照numpy包扩充而来的,因此numpy的大部分艺术在pandas中都能适用。

state

unstack的逆运算是stack:

print(data.sort_index(axis=1))

Out[21]:

2    2.0

结果为:

b 0.0

0 1 2

 层次化索引

Out[36]:

6 -1.712077 0.386785 0.436945

结果为: 

Out[15]:

d  2  -0.073204

结果为:

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

5.4.1滤除缺失数据

图片 27

Out[55]:

b  1    1.136933

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

Utah              NaN

unique  3

结果为:

Ohio 0.192928

color    Green Red    Green

 图片 28

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

min    0.750000 -4.500000

图片 29

In [41]: DataFrame(pdata)

再有局部措施,既不是约简型也不是累计型。

print(2 in object)

In [26]: frame2.columns

In [130]: cleaned=data.dropna()

 索引删除以及过滤等息息相关措施

d 1.0

c  d

图片 30

New York  12  13    14    15

In [132]: cleaned

运用办法后的结果为: 

Out[21]: False

3 NaN 6.5 3.0

也得以把Series看成一个字典,使用in举办判定

b    14

0 0.501394 -1.735750 0.197643

对行举办索引,则是此外一种样式

In [32]: data<5

2 3.5

pandas中我们要熟悉六个数据结构Series 和DataFrame

a b c d e

In [93]: df.sum(axis=1)

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

four  2001  Nevada  2.4  3.0

In [135]: data

isnull或者notnull能够用于判断数据中缺失值意况

Ohio          2    0

In [172]: frame.swaplevel(0,1).sortlevel(0)

c 8
d 9
dtype: int64

[ 2.9,  3.6]])

5  two  2  5  2

print(data[:,2])

a    0.0

—-> 1 ser[-1]

结果为:

5.6其他关于pandas的话题

25%  1.075000 -3.700000

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

Name: population, dtype: float64

重临值的唯一未排序的,即便需要的话,可以对结果再度展开排序(unique.sort())

结果为:

而对此DataFrame,则足以按照随便一个轴上的目录实行排序:

0 1 2 4

图片 31

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

two -5.80

 

one    2000    Ohio  1.5  NaN

Out[96]:

Series中的一些措施,

Out[12]:

In [124]: from numpy import nan as NA

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

In [12]: obj[obj<2]

In [125]: data=Series([1,NA,3.5,NA,7])

 

2 18.0 20.0 22.0 24.0 NaN

std    3.493685 2.262742

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

Ohio          35000.0

0 1 2

结果为:

Out[12]:

max  7.100000 -1.300000

 

3 1 2.0 -2.5

0 1 2

结果为:

Out[16]: True

In [114]: obj[mask]

print(data.index)

f 4.0

c 0.00

 

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

dtype: object

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

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

In [18]: frame.set_index([‘c’,’d’],drop=False)

print(data.sum())

b    1.0

In [145]: df=DataFrame(np.random.randn(6,3))

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

对此DataFrame,reindex可以修改(行)索引,列,或多少个都修改。假设仅传入一个系列,则会重新索引行:

1 1.0 NaN NaN

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

print(data.unique())

2 10.0 11.0 12.0 13.0 14.0

In [20]: frame2.reset_index()

缺失值处理

出于需要执行一些数额整理和聚集逻辑,所以drop方法重返的是一个在指定轴上删除了指定值的新目的:

3  -0.215712

图片 32

2001      2.4  1.7

1 1.071009 0.000000 0.000000

 图片 33

Out[10]:

2 NaN NaN NaN NaN

 结果为:

b d e

3    0.482377

结果为:

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

1    1.0

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

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

Out[20]:

图片 34

Out[45]:

In [170]: frame.sortlevel(1)

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

3 3 2 4

In [9]: obj4

2 -0.135804 0.000000 0.000000

b d e

率先个函数是unique,可以得到Sseries中的唯一数组:

Texas 1.310289 0.518146 0.231740

3  -1.217613

5.2.7包含重复的轴索引

1    a        0  1        2

Utah -0.07

5.6.1平头索引

max 1.310289 1.823441 0.22832

只要需要调动某条轴上各级其它一一,或基于指定界级别上的值对数码举办排序。swaplevel接受六个级别编号或名称,并回到一个对调级此外新目的(但数据不会发生变化):

b    1.0

c  1  -0.551888

0 0 4.3 -2.0

a 1.40

1      blue

Out[149]:

Utah      False  False  False  False

pandas\src\hashtable_class_helper.pxi in
pandas.hashtable.Int64HashTable.get_item (pandas\hashtable.c:85

c 3

In [96]: df.cumsum()

one 4 5 6 7

6 -1.712077 0.386785 0.436945

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

c NaN

d    3.0

3 NaN 6.5 3.0

2 -3

d  2  -0.073204

e    0.0

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

c    3

b 7.10 -4.5

Name: two, dtype: int32

3 -0.032894 1.441581 0.418310

b    7.2

0 1.0 6.5 3.0

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

Out[173]:

Utah 0.172344 1.823441 0.067380

color    Green Red    Green

In [12]: frame2

1 1.0 NaN NaN

0 4.0

2 4 1 2

In [5]: obj3=Series(sdata)

d -0.55

b d e f

In [33]: ser3=Series(range(3),index=[-5,1,3])

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

5 -0.058611 1.441581 0.418310

dtype: float64

a 1    0  1        2

array([[ nan,  1.5],

c 3

Out[8]:

c  d  a  b

Out[44]:

2    True

2002      2.9  3.6

8 True

four    11

Out[120]:

Oregon        False

dtype: float64

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

DataFrame的set_index函数会将一个或四个列转换为行索引,并创设一个新的DataFrame:

1405

6 True

Out[70]:

python内置的None值也会被看做NA处理:

DataFrame中的数据是以一个或四个二维块存放的。

reset_index的功用跟set_index刚好相反,层次化索引的级别会被更换到列里面:

4    yellow

0  0  7  one  0

Utah        8    9    10    11

2  2  5  one  2

Out[37]:

5.6别样关于pandas的话题

Colorado      6    4

data.ix[[‘b’,’d’]]

3 15.0 16.0 17.0 18.0 19.0

俺们来创制一个Series,并用一个由列表或数组组成的列表作为目录:

…:

2  -1.090750

…: 2002:3.6}}

a 1.40 NaN

不可修改性非凡紧要,因为如此才能使得index对象在六个数据结构之间安全共享:

0 1 2

debt      NaN

In [109]: uniques

three  2002    Ohio  3.6  2.0

Out[15]:

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

即使pandas会“求助于”整数索引,可是没有哪个种类方法可以既不引入bug,又能迎刃而解问题的。

c    3.6

dtype: float64

2 0 -3.0 8.0

one two

a 5.2

In [139]: df

3  2.4  Nevada  2001

In [97]: df.describe()

In [60]: frame.sort_index()

data[‘b’:’c’]

Out[77]:

将DataFrame的一个或五个列当做行索引来用,或者可能希望将行索引变成DataFrame要的列。

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

a 3

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

0    0.0

d    3.0

为了有利于查看,结果Series是按值频率降序排列的。

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

5 True

Oregon        False

2    0.969526

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

In [112]: mask=obj.isin([‘b’,’c’])

dtype: int64

0 1 2 1

3 4.5

另一个滤出DataFrame行的问题事关时间系列数据。

b c d

Out[109]: array([‘c’, ‘a’, ‘d’, ‘b’], dtype=object)

b    7

In [123]: string_data.isnull()

1 5.0 6.0 7.0 8.0 9.0

2 -0.451567 NaN -0.150315

In [43]: frame3

Out[144]:

5.1 pandas 的数据结构介绍

Out[94]:

Utah      5000

3    0.482377

5.2基本功用

color    Green Red    Green

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

1    1.136933

Out[12]:

‘c’:[‘one’,’one’,’one’,’two’,’two’,’two’,’two’],’d’:[0,1,2,0,1,2,3]})

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

In [30]: ser2=Series(np.arange(3.),index=[‘a’,’b’,’c’])

Utah        9

对于DataFrame对象,假如期待抛弃全NA或NA的行货列,dropna默认放弃任何带有缺失值的行:

Ohio 4.0

6 -1.712077 0.386785 0.436945

In [6]: obj[‘b’]

1 False

2003    NaN  NaN

稍加措施(如idxmin和idxmax)再次回到的是直接总括(比如达到最大值或最小值的目录):

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

key1 key2

Out[40]:

one two

Out[19]:

竟然仍可以够在“内层”中进行选取:

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

In [31]: ser2[-1]

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

大家有一个含有0,1,2的目录,可是很难揣度出用户想要什么:

Utah 1.995785

0 0.452896 0.000000 0.000000

Out[58]:

2 -0.451567 1.441581 -0.150315

Out[21]:

对此非数值型的数目,describe会暴发另一种汇总总括:

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

2 -0.135804 0.500000 NaN

two    2001    Ohio  1.7  NaN

层次化索引,是您能在一个轴上拥有多少个(多少个以上)索引级别。

Utah        10    8

color Green Red Green

d a b c

2  -0.158487

Series首要的一个功用是:它在算术中会自动对齐不同索引的数据。

d  -0.073204

In [35]: frame3

In [107]: obj=Series([‘c’,’a’,’d’,’a’,’a’,’b’,’b’,’c’,’c’])

2  -5

Out[148]:

f NaN

传入axis=1 将会按行进行求和测算:

Nevada  Ohio

有了分部的列索引,因而得以选拔列分组:

In [34]: data

调用DataFrame的sum方法将会回来一个带有列的小计的Series:

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

4 2.0 0.0 2.0

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

In [117]: result=data.apply(pd.value_counts).fillna(0)

Ohio          True

Out[135]:

如你所见,对DataFrame举行索引其实就是得到一个或两个列:

a  b    c  d

2001    2.4  1.7

若果你只想留住一部分寓目数据,可以用thresh参数实现此目的:

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

Out[172]:

b 1.347421 -0.239196 -0.543597

Out[118]:

Texas 6.0 NaN 9.0 NaN

In [98]: obj=Series([‘a’,’a’,’b’,’c’]*4)

a  -5.3

0 1 2

In [11]: obj2[‘a’]

3      avocado

b    7

从一维Series的值中抽取音信。以下这些Series为例:

c    5.0

key2

2 0 -3

7 True

In [35]: frame

d 0.75 -1.3

5.2.3索引、采取和过滤

Out[97]:

Out[9]:

In [118]: result

d 3.4

2        3  4        5

表5-8
列出了所有用于破坏平级关系的method选项。DataFrame能够在行或列上总括名次:

b 2.60

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

dtype: object

Out[38]:

2    3  4        5

3 2.0 3.0 1.0

6 b

Jeff    -5

有些方法则是累计型的:

In [6]: import pandas as pd

默认情状下,这些列会从DataFrame中移除,不过也足以将其保存:

Out[10]:

4 1.285966 1.441581 0.418310

a      0.006738

color    Green Red    Green

5.1.3索引对象

b  1    1.136933

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

5 0.738134 -1.505505 -0.052306

a      1  NaN          2

Out[153]:

Out[16]:

b 1.300

c    3.6

value_counts 依然一个一等的pandas方法,可用于其他数组的或体系:

Out[23]:

Out[170]:

表5-8 :名次时用于破坏平级关系的method选项

b 2

Ohio          2    0

Green Red    Green

对此再一次的目录,数据接纳的表现将会稍为不同。固然某个索引对应的两个值,则赶回一个Series,而对应单个值,则赶回一个标量:

0    aardvark

Oregon 2.109274

2    0.969526

Out[14]:

5.5.1重排分级顺序

Numpy的ufuncs(元素级数组方法)也得以用来操作pandas对象:

即能以低纬度形式处理高纬度数据。

1403    def __setitem__(self, key, value):

dtype: float64

c    4.0  NaN        5.0

Out[113]:

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

b    1        6    7

three  2002    Ohio  3.6  NaN

c NaN NaN

Out[7]:

c  d

one    two  three  four

two 0  3  4

1 1.0

层次化索引的在数量重塑和依据分组的操作(如透视表生成)中饰演重要角色。比如说,这段数据足以经过unstack方法被重新安排到一个DataFrame中:

b 3.191243

n [160]: data.unstack()

dtype: bool

2        3    4

2001    2.4  1.7

Out[136]:

four  2001  Nevada  2.4  -1.5  False

dtype:    object

仅由一组数据即可发生最简便易行的Series:

state Ohio Colorado

Out[68]:

In [37]: frame=DataFrame(np.arange(6).reshape(3,2),index=[2,0,1])

Out[41]:

1 1.071009 0.000000 0.000000

New York  12  13    14    15

0 c

Texas    71000

In [108]: uniques=obj.unique()

dtype: float64

5 -0.058611 NaN 0.418310

b    1.0

2 20 10

也得以按降序举办名次:

a 3

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

Out[93]:

5.2.4.2 DataFrame和Series之间的运算

In [174]: frame.sum(level=’key2′)

对于DataFrame,可以去除任意轴上的索引值:

流传how=‘all’ 将只遗弃全为NA的这一个行:

Series 的目录可以经过赋值的法子就地修改:

In [129]:
data=DataFrame([[1.,6.5,3.],[1.,NA,NA],[NA,NA,NA],[NA,6.5,3.]])

five  2002  Nevada  2.9  -1.7  False

0 1.0

另一个普遍的操作,将函数应用到由各列或行所形成的一维数组上。DataFrame的apply方法即可实现此效能:

In [153]: data

In [15]: obj3+obj4

1    a        0  1        2

3 4.0

dtype: int64

In [36]: frame3.T

b 8.50 -4.5

In [18]: obj4

Out[92]:

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

4 -1.038639 0.500000 -0.756553

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

dtype: bool

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

2  -0.158487

Out[14]:

0 0.452896 0.000000 0.000000

对Series或DataFrame重新索引时,也可以指定一个填充值:

08)()

one 4 7 6 5

1 1.0 1.0 1.0

Ohio 3.0 NaN 6.0 NaN

5.3.1相关周到和协方差

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

In [134]: data[4]=NA

行也足以通过岗位或名称的不二法门来拓展获取。

top        a

Out[49]:

In [167]: frame[‘Ohio’]

Series
是一系列似于一维数组的目的,由一组数据(各个numpy数据类型)以及一组与之相关的数码标签(即索引)组成。

dtype: float64

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

要用这种办法丢弃列,只需传入axis=1即可:

In [85]: obj[‘a’]

而sortleval则按照单个级别中的值对数码开展排序(稳定的)。互换级别时,日常也会用到sortlevel,这样结尾的结果就是有序的了:

此外,元素级的python函数也是可以用的。

2 3.500000

Ohio 3.0 NaN 6.0 NaN

3  two  0  3  4

In [24]: df1+df2

two d

two        Ohio

3 False

下面来测算一个二维数组与其某行之间的差:

3 0.010116 0.000000 0.064880

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

设若不想滤除数据,而是希望填充数据。

e    NaN

Qu1 Qu2 Qu3

Ohio -0.338604 -0.189082 -0.145676

2  -0.158487

two    2001    Ohio  1.7  -1.2    True

表5-9交付了约简方法常用选项

由于我们从来不为多少指定索引,于是会自动创制一个0到N-1(N位数据的长度)的平头的目录。

这就是富含MultiIndex 索引的Series
的格式输出格式。索引之间的“间隔”表示“直接拔取方面的竹签”:

5.1.2 DataFrame

In [110]: obj.value_counts()

d    6      7          8

Out[126]:

Out[22]:

5 0.738134 -1.505505 -0.052306

In [86]: obj[‘c’]

2 0.0 2.0 1.0

a    0.0

b 1    6  7        8

Out[9]:

Out[32]:

2 7.0

state      Ohio    Colorado

In [29]: data[:2]

1  1  6  one  1

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

In [92]: df.sum()

Out[30]:

1  1  6

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

Out[18]:

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

Name: 2, dtype: int32

In [1]: from pandas import Series,DataFrame

two 0  3  4  two  0

5 2.0

1  4  3

In [66]: obj.order()

2 12 14 16

Texas 7.0

b        6  7        8

d    12

5.5.3使用DataFrame的列

a b

in ()

Ohio        0    1      2    3

dtype: float64

6 4.0

Out[132]:

dtype: float64

如若稍微动脑子,就足以接纳fillna的=实现广大的此外功能。

pandas对象的一个要害的点子就是reindex,效率是成立一个适应新索引的新目的。

Out[133]:

method 说明

Out[26]:

Utah        8    10

a    2        3  4        5

d    4.5

key1 key2

利用ix的标签的=索引效能,重新索引任务可以变得简洁:

3  3  4  two  0

3 1 2

0 1.0 6.5 3.0

five    Nevada

a  b

In [21]: ‘e’ in obj2

In [154]: data.index

Out[4]:

Out[159]:

In [8]: index

d -0.275

c -2.5

In [141]: df.fillna(0)

New York  12  13    14    15

1 1.071009 NaN NaN

In [31]: arr[0]

0  one  0  0  7

Colorado    4    5      6    7

In [147]: df

three  2002    Ohio  3.6  NaN    True

3 False

Out[26]:

Out[131]:

one      8

In [131]: data

In [26]: data[‘two’]

对此一个Series,dropna重临一个仅包含非空数据的和索引值的Series:

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

count 3.000000 2.000000

Colorado    0    5      6    7

count  16

5.2.4.1在算术方法中填充值

c NaN NaN

点名列系列,DataFrame的列就会按照指定顺序举办排列:

5.5层次化索引

Ryan    3

In [121]: string_data.isnull()

In [6]: obj3

Out[35]: 2

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

5.4.2填充缺失数据

a b c d e

0 1 2

Out[30]:

4  two  1  4  3

e    4.0

5 -0.058611 NaN NaN

In [36]: series

0 1.0 6.5 3.0 NaN

one  two  three  four

value_counts 用于总计一个Series中各值现身的效能:

Out[35]:

In [127]: data[data.notnull()]

c    2.0

dtype: float64

min -1.880954 -0.518146 -0.23174

1 1.071009 0.500000 NaN

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

0 1 2

b 1.347421 -0.239196 -0.543597

In [152]:
data=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]])

2000      NaN  1.5

b        9  10      11

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

Out[169]:

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

Out[174]:

California    True

2 3.5

2 18.0 20.0 22.0 24.0 14.0

In [144]: df

Out[11]:

1    False

2 2.0 1.0 3.0

5 0.0 0.0 1.0

设置方法如下:

3 0.010116 NaN 0.064880

a b c d

In [169]: frame.swaplevel(‘key1′,’key2’)

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

有时候,你恐怕需要得到DataFrame中六个相关的一张柱状图。

dtype: int64

mean 3.083333 -2.900000

b d e

c  -1.090750

e 1.5

dtype: int64

1 7

1 2.099104 1.441581 0.743717

[ 2.9,  3.6]])

d      NaN -0.073204 -1.21761

b d e

dtype: float64

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

Out[161]:

‘min’ 使用一切分组的小小名次

3 NaN 6.5 3.0

New York  12    14

由此一个字典调用fillna,就可以实现对两样的列填充不同的值:

0 0 4

Out[17]:

In [88]: df

a  1    0.024162

Utah 0.0 1.0 2.0

3 NaN 6.5 3.0 NaN

dtype: float64

In [140]: df.dropna(thresh=3)

dtype: float64

1    arrichoke

Out[28]:

In [38]: frame.irow(0)

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

In [119]:
string_data=Series([‘aardvark’,’arrichoke’,np.nan,’avocado’])

5.1 pandas 的数据结构介绍

2 True

Out[85]:

0 1.000000

pandas的isnull和notnull函数可以用来检测缺失数据:

In [163]: frame

In [8]: frame=DataFrame(data)

pandas使用浮点数NaN(Not a
Number)表示浮点和非浮点数组中的缺失数据。只是一个有利于检测出来的符号而已:

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

Out[114]:

Utah -0.172344 1.823441 -0.067380

3    0.482377

Texas        71000.0

0 True

Out[10]:

In [133]: data.dropna(how=’all’)

Out[28]:

对此一个DataFrame,每条轴都得以分段索引:

c      20.085537

0 1.0

将她们相加后,会回去一个新的DataFrame,其索引和列为原来的这六个DataFrame的并集:

4 1.285966 NaN 0.418310

1 1 7

In [111]: pd.value_counts(obj.values,sort=False)

Utah      5000

d 9.25 -5.8

Utah        8    9    10    11

KeyError: -1L

2002    2.9  3.6

b  -0.158487

Ohio          35000.0

In [137]: df=DataFrame(np.random.randn(7,3))

要是想获取frame中相继浮点数的格式化字符串,使用applymap即可:


Out[11]:

In [151]: data.fillna(data.mean())

Out[34]:

1    1.0

In [10]: df1+df2

c -0.551888 -1.090750      NaN

Texas 1.31 -0.52 -0.23

In [94]: df.mean(axis=1,skipna=False)

In [22]: df1

0 1.0 6.5 3.0

Oregon        16000.0

4 7.0

参数 说明

1 3.833333

1    7

1    1

California        NaN

Out[155]:

In [3]: import pandas as pd

上边是一个简便的DataFrame:

Out[86]: 4

反而,对于一个非整数索引,就从不如此的歧义:

Texas        142000.0

2          NaN

In [53]: frame.apply(f)

3  -1.217613

three  one

还足以由此布尔型索引达到这多少个目标:

构建DataFrame的办法有无数,最常用的一种是一贯传入一个由等长列表或numpy组成的数组组成的字典:

Out[158]:

Out[18]:

2        9  10      11

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]}

In [15]: frame

Utah NaN NaN NaN NaN

key2 key1

DataFrame和Series之间的运算差不多也是这般:

Ohio    Colorado

Utah 0.0 1.0 2.0

2 -0.135804 0.000000 0.000000

2 2.0

为了保持出色的一致性,假使你的轴索引含有索引器,那么依据整数举办数量接纳的操作蒋总是面向标签的。那也席卷用ix举办切开:

自动的数量对其操作在不重叠的索引处引入了NA值。缺失值会在算术运算过程中传唱。

3    False

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

0    0.0

0 6.0

0 0.452896 0.500000 NaN

In [15]: obj2[obj2>0]

3 0.010116 0.000000 0.064880

four  2001  Nevada  2.4  16.5

0 1 2

0  2000    Ohio  1.5

b    2        9  10      11

1406    def __getitem__(self, key):

3 2.0 2.0 0.0

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

d  2  -0.073204

Nevada  Ohio

2 -0.135804 NaN NaN

传扬的轴号就是可望匹配的轴。

一旦需要可靠的,不考虑索引类型的,基于地方的目录,可以行使Series 的
iget_value 方法和DataFrame的irow和icol方法:

5.6.1平头目录

7 c

Out[53]:

In [150]: data=Series([1.,NA,3.5,NA,7])

5.2.2放弃指定轴上的项

1    b        6  7        8

a    1.0  NaN        2.0

1 3 3 5

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

In [165]: frame.columns.names=[‘state’,’color’]

5.2.6排序和名次

2  -1.090750

In [5]: from pandas import Series,DataFrame

Out[95]:

Out[8]:

2 8 4

New York  12    14    15

b    1        6  7        8

Out[32]:

拍卖缺失数据(missing
data)在大部分的多寡解析应用中很宽泛。pandas的计划性目标之一就是让缺失数据的拍卖任务尽量轻松。

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

b 1 14 7

Ohio          35000.0

0 1 2

下边介绍Series和DataFrame的rank方法。默认下:rank是由此“为各组分配一个平分名次”的点子来破坏平级关系。

3 -0.032894 1.441581 0.418310

In [9]: df2

0 True

Colorado    4    5      6    7

a 1.40 NaN

a  -5.3

3  -0.215712

sub 用于减法(-)的艺术

In [25]: ser[-1]

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

1 1.0 NaN NaN

a b

6 -1.712077 0.386785 0.436945

Out[37]:

dtype: bool

Texas    71000

5 0.738134 -1.505505 -0.052306

e -1.5

50%  1.400000 -2.900000

0 0.0 1.0 2.0 3.0 0

c  1  -0.551888

3 15.0 16.0 17.0 18.0 19.0

4 1.285966 NaN NaN

d  6.0    7.0        8.0

0 1.0 6.5 3.0

a  0.0    1.0        2.0

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

c    3      4          5

d 1

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

Out[167]:

Colorado    0    5      6

6  6  1  two  3

three 0 1 2 3

In [138]: df.ix[:4,1]=NA;df.ix[:2,2]=NA

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

a 1 2 1

a -2.1

KeyError                                  Traceback (most recent call
last)

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

Out[141]:

d    3.0

0 1 2

5.2.7饱含重复的轴索引

NA值将会被电动删除,除非整套切片都是NA。通过skipna选项可以禁用该效能:

Out[36]:

dtype: float64

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

2  5  2

three  2002    Ohio  3.6  16.5

dtype: object

Out[64]:

b    1        6  7        8

Out[71]:

Out[140]:

Oregon -1.88 -0.40 0.23

3  -1.217613

dtype: float64

Out[123]:

In [8]: obj[2:4]

c 3

in ()

In [24]: ser=Series(np.arange(3.))

Texas        71000.0

Out[110]:


In [120]: string_data

In [25]: data

Out[91]:

Out[13]:

4 7.0

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

a    1        0  1        2

Out[10]:

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

Out[48]:

state    Ohio

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

1 NaN

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

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

5.4.1滤除缺失数据

b    1.0

Ohio    1.5  1.7  3.6

调用该Series的reindex将会基于新索引举办重排。假诺某个索引值当前不存,就引入缺失值:

Out[22]:

第5章 pandas入门

Series也有类似的实例方法:

Nevada  Ohio

[ 2.4,  1.7],

Texas  Utah  California

Texas 6.0 7.0 8.0

5.2.4.2 DataFrame和Series之间的运算

one      2000

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

Utah        9

In [9]: index[1:]

Texas 1.828435

b    5.0

Texas        71000.0

one        Ohio

Utah 0.0 NaN 3.0 NaN

Oregon    16000

c  3.0    4.0        5.0

这种索引情势有几个奇特意况。首先通过切片或布尔数组举办采纳行:

Colorado      6    4

dtype: int64

five  2002  Nevada  2.9  -1.7

Out[58]:

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

1 1.0 3.0 2.0

1  1.7    Ohio  2001

2 8.0 9.0 10.0 11.0 0

dtype: float64

一旦您愿意匹配行且在列上广播,则必须利用算术运算方法:

2002    2.9  3.6

Out[38]:

div 用于乘法(*)的方法

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

dtype: float64

Series对象自我及其索引都有一个name属性,该属性跟pandas其他关键效能关系非常细致:

d      7  NaN          8

Out[25]:

d      7  NaN          8

1 1 7.0 5.0

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

Ohio      True  True  True  True

Texas        False

In [70]: frame

Out[35]:

要按照四个列举办排序,传入名称的列表即可:

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

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

b -0.598395 0.966395 0.285722

one  three  four

d    3.0

Out[6]: 1.0

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

DataFrame既有行索引也有列索引,可以被视作是由Series组成的字典。

b c d e

Out[29]:

California    False

Oregon -1.880954 -0.400772 0.228320

Ohio        0    0      0    0

介绍操作Series和DataFrame中的数据的主干手法。

[ 2.4,  1.7],

Out[41]:

动用标签的切片运算与平时的python切片运算不同,其背后是带有的(inclusive)

Nevada  NaN  2.4  2.9

Name: Utah, dtype: float64

five    2002

Ohio  Texas  California

2 0 -3

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

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

Out[63]:

New York    14  12

Colorado    4    5      6    7

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

a  -5.3

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

two      2001

1 4.0 5.0 6.0 7.0 0

b d e

c 3.6

0 6.5

5.2.5函数应用和照耀

Ohio        0      2    3

透过类似于字典标记的章程或性能的措施,可以将DataFrame的列获取为一个Series:

4 -3.0

0 0 4

Ohio        1

a 0.056598 1.592208 -0.576368

Out[81]:

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

dtype: float64

跟Series一样,假设传入的列在数据中找不到,就会发生NA值:

Ohio 3.0 4.0 5.0

表5-7 灵活的算术方法

Series索引
(obj[…])的行事章程接近于NumPy数组的目录,只可是Series的索引值不只是整数。例:

dtype: float64

4 3.0

Out[47]: False

Out[46]:

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

Out[67]:

In [30]: frame2

5.2基本效率

dtype: int64

c 1.1

1  2001    Ohio  1.7

a 0

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

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

a b c d

Utah        11    8    9

Out[60]:

pop      3.6

Utah        8    9    10

Ohio        0    1      2    3

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

Oregon 9.0 NaN 12.0 NaN

dtype: float64

Out[83]:

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

pop  state  year

e    4.0

In [84]: obj.index.is_unique

d 0

year

a b c d e

Oregon        16000.0

dtype: float64

Colorado 6.0 7.0 8.0

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

0 1 2

b d e

b  NaN    NaN        NaN

4  2002  Nevada  2.9

In [62]: new_obj

add 用于加法(+)的法门

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

假若数量被寄存在一个python字典中,可以直接通过这么些字典来创造Series

g 3.1

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

Out[7]: 1.0

b    7.2

3 2

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

3 1 2

dtype: float64

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

In [39]: frame+series2

2  3.6    Ohio  2002

我们看看下边那一个大概的盈盈重复索引值的Series:

e 0.0

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

Oregon 9.0 10.0 11.0

dtype: float64

5.4拍卖缺失数据

Out[9]:

In [25]: frame2

0 0.0 1.0 2.0 3.0 4.0

3    purple

Out[32]:

In [55]:frame2

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

In [20]: ‘b’ in obj2

Texas  Utah  California

1 4.0 5.0 6.0 7.0

In [52]: def f(x):

California    True

In [47]: 2003 in frame3.index

d    6

5    yellow

1 1 7

d    4.5

year  state  pop

Out[36]:

In [8]: s2

g NaN

state  Nevada  Ohio

New York  12  13    14    15

from pandas import Series,DataFrame

state  Nevada  Ohio

a b c

In [58]: obj.sort_index()

方法 说明

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

Out[30]:

b 2

6 5.0

Out[19]:

Texas        False

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

4  2.9  Nevada  2002

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

故此叫做applymap,是因为Series有一个用来采用元素级函数的map的法门:

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

0 0 4

five  2002  Nevada  2.9  4.0

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

5.5.1重排分级顺序

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

In [5]: from pandas import Series,DataFrame

New York  False  False  False  False

In [21]: obj

Utah        8    9    10    11

可以因而series的values和index属性获取其数组表现形式和目录对象。

Out[55]:

e 0.460059

Name: three, dtype: object

c      4  NaN          5

one  two  three  four

丢掉某条轴上的一个或五个项,只要有一个索引数组或列表即可。

对DataFrame的行走行索引时候也是这么:

Ohio  Texas  California

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

5.1.1 Series

5.1.1 Series

0 0.0 2.0 4.0 6.0 4.0

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

Out[59]:

Name: e, dtype: object

3 NaN

1402

c    3.6

array([[ nan,  1.5],

In [35]: obj

Colorado    4      6    7

b 3

b    1096.633158

Texas 6.0 6.0 6.0

three 0 3 2 1

a 1

four  2001  Nevada  2.4  NaN

In [8]: df1

索引的is_unique属性可以告知您他的值是否是唯一的:

d    6

5.5.3使用DataFrame的列

d    403.428793

In [48]: frame.apply(f)

1 1.0

dtype: bool

1 9.0 11.0 13.0 15.0 9.0

5.2.4算术运算和数目对齐

dtype: int64

在排序的时候,缺失值默认都会被放在了Series的最终:

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

Texas 3.0 4.0 5.0

one  two  three  four

Texas 6.0 7.0 8.0

Out[20]: True

In [52]: frame

In [9]: s1+s2

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

Bob      4

Ohio 3.0 4.0 5.0

‘average’ 默认:在至极分组中,为各个值分配平均排‘’

Colorado  True  False  False  False

In [23]: df2

b    1.0

d 2.341587

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

在DataFrame上,你或许希望按照一个或多个列中的值举办排序。将一个或四个列的名字传递给by选项即可达到该目标:

Ohio      35000

Utah 1.0

Colorado    5

Utah        8    10    11

Oregon        32000.0

year

In [76]: obj.rank()

a 0.842511 -0.085418 0.818032

Oregon -1.0 0.0 1.0

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

In [43]: frame3

In [42]: series3

2000      NaN  1.5

four    2001

1 1 7

2 8.0 9.0 10.0 11.0

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

在不同索引的对象开展算术运算时,你恐怕希望当一个对象中某个轴标签在另一个对象张找不到时填充一个新鲜值:

Texas 6.0 7.0 8.0

Out[8]:

Out[84]: False

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

Colorado NaN NaN NaN NaN

year  state  pop  debt

Out[61]:

2000    NaN  1.5

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

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

a    0.0

Oregon NaN NaN NaN NaN

Utah 0.0 0.0 0.0

In [83]: obj

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

Out[37]:

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

In [12]: obj4.isnull()

Ohio          False

b    NaN  NaN        NaN

3 NaN NaN NaN NaN NaN

In [41]: frame

dtype: int64

0 1 2

three    6

5.1.2 DataFrame

In [7]: index=obj.index

Out[15]:

b      1  NaN          2

one    2000    Ohio  1.5  NaN    True

5 2.0

2000  2001  2002

要利用pandas,首先要熟练她的两个第一的数据结构:Series和DataFrame。

Texas 1.310289 -0.518146 -0.231740

Name: Utah, dtype: int32

dtype: int64

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

c    6

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

mul 用于除法(/)的模式

In [27]: frame2[‘state’]

dtype: float64

Ohio 0.338604 0.189082 0.145676

内层字典的键会被合并、排序以及形成最后的目录。若指定了显式索引,则不会如此:

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

0  1.5    Ohio  2000

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

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

c      4  NaN          5

Out[53]:

5 2.0

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

In [37]: frame – series

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

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

c    3

Texas -0.23

Out[18]:

three      Ohio

a    0.0

In [37]: data.ix[2]

dtype: float64

5.2.4算术运算和数码对齐

Ohio          70000.0

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

In [2]: import pandas as pd

year    2002

In [16]: obj2*2

Out[56]:

Out[35]:

a b c d e

数据默认是按升序排列的,但也得以降序排序:

dtype: float64

In [13]: obj3

Out[66]:

In [10]: pd.isnull(obj4)

Name: state, dtype: object

b    7.2

In [44]: frame3.values

默认意况下,DataFrame和Series之间的算术运算符将Series的目录匹配到DataFrame的列,然后沿着行一向向下播放:

5.3.1相关周到和协方差

a    0.0

c 4

In [46]: np.abs(frame)

Out[62]:

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

one    2000    Ohio  1.5  NaN

拔取columns关键字即可以再一次索引。

frame.reindex(columns=states)

Oregon 10.0

另一种普遍的数额情势是嵌套字典(也就是字典的字典):

Utah -0.17 1.82 -0.07

5.1.3索引对象

two    2001    Ohio  1.7  16.5

Oregon        True

Out[43]:

three    2002

b d e

Oregon 9.0 9.0 9.0

5.2.2丢弃指定轴上的项

California        NaN

Texas -1.0 0.0 1.0

two    2001    Ohio  1.7  -1.2

Oregon 1.880954 0.400772 0.228320

Name: d, dtype: float64

6 4.5

Out[42]:

a b

Utah        10    8

TypeError                                Traceback (most recent call
last)

Out[37]:

3  2001  Nevada  2.4

three 1 2 3 0

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

dtype: float64

5.2.4.1在算术方法中填充值

Name: year, dtype: int64

0 2.0

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

由Series组成的字典差不多也是同样的用法:

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

Out[69]:

In [2]: import numpy as np

d    7.0  NaN        8.0

5.2.5函数应用和照耀

Oregon 9.0 10.0 11.0

Out[46]: True

two      5

In [22]: obj

名次(ranking)跟排序关系密切,且会增设一个排行值(从1开始,一直到数组中有效数据的数额),跟numpy.argsort爆发的间接排序索引差不多,只可是它可以按照某种规则破坏平级关系。

In [30]: arr

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

把他们相加:

5.2.3索引、选用和过滤

0      blue

In [14]: obj4

Out[39]:

咱俩也得以将Serice看成一个定长的稳步字典,因为它是索引值到数据值的一个辉映。可以用在许多原本需要字典参数的函数中:

In [16]: obj2.index is index

5.2.1再次索引

Out[76]:

3 1 2

In [10]: frame

Ohio 0.0 1.0 2.0

In [33]:  import pandas as pd

将列表或数组赋值给某个列的时候,其长度必须要跟DataFrame的长度向匹配。假使赋值的是一个个Series
,就会规范的匹配DataFrame的目录,所有的空位都将被填上的缺失值。

dtype: int64

1 7.0

In [28]: frame2

‘max’ 使用所有分组的最大名次

Out[45]:

5.2.1再次索引

也足以而且对行和列进行再一次索引,而插值则不得不按行应用(即轴0):

a    0      1          2

0 0.0 1.0 2.0 3.0

b -0.598395 0.966395 0.285722

In [55]: frame.applymap(format)

dtype: bool

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

b d e

0 0.0 2.0 4.0 6.0 NaN

a 7.3

目录:

b d e

year  state  pop  debt

dtype: int64

a      1  NaN          2

one  two  three

a 1

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

dtype: int64

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

Colorado    5

one    2000    Ohio  1.5  0.0

a 1

2001    2.4  1.7

year  state  pop  debt eastern

3 4.0

Oregon    16000

d    3.0

Name: Colorado, dtype: int32

a  -5

three    10

dtype: float64

Out[39]:

dtype: float64

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

Colorado    4      6

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

five  2002  Nevada  2.9  16.5

相关文章