pandas入门

Pandas含有使数据分析工做变得更快更简单的高级数据结构和操做工具。pandas是基于NumPy构建的，让以Numpy为中心的应用变得更加简单。

 

Pandas的两个主要数据结构：Series和DataFrame。

Series：

• Series是一种相似于一维数组的对象，它由数据（各类NumPy数据类型)以及与之相关的数据标签（即索引）组成。

In [2]: from pandas import Series, DataFrame

In [3]: obj = Series([4, 7, -5, 3]) In [4]: obj Out[4]: 0 4 1 7 2 -5 3 3 dtype: int64

• 能够经过Series的values和index属性获取其数组表示形式和索引对象：

• In [5]: obj.values Out[5]: array([ 4, 7, -5, 3]) In [6]: obj.index Out[6]: RangeIndex(start=0, stop=4, step=1)

 

• 能够经过索引的方式选取Series中的单个或一组值
• NumPy数组运算（如根据布尔型数组进行过滤、标量乘法、应用数学函数等）都会保留索引和值之间的连接：

In [7]: obj[obj>2]
Out[7]: 0 4 1 7 3 3 dtype: int64 In [8]: obj*2 Out[8]: 0 8 1 14 2 -10 3 6 dtype: int64

 

• 还能够将Series当作是一个定长的有序字典，由于它是索引值到数据值的一个映射：

0 in obj
Out[9]: True

• Python字典中的数据也能够直接建立Series：

In [10]: sdata = {'Ohio':35000, 'Texas':71000, 'Oregon':16000, 'Utah':5000}

In [11]: obj3 = Series(sdata) In [12]: obj3 Out[12]: Ohio 35000 Oregon 16000 Texas 71000 Utah 5000 dtype: int64

• Pandas的isnull和notnull函数可用于检测缺失数据：

In [14]: import pandas as pd
In [16]: pd.isnull(obj3) Out[16]: Ohio False Oregon False Texas False Utah False dtype: bool

• Series对象自己及其索引都有一个name属性

In [17]: obj3.name = 'population'
In [18]: obj3.index.name = 'state' In [19]: obj3 Out[20]: state Ohio 35000 Oregon 16000 Texas 71000 Utah 5000 Name: population, dtype: int64

 

Series最重要的一个功能：它在算术运算中会自动对齐不一样索引的数据。

 

 DataFrame

• DataFrame是一个表格型数据，它含有一组有序的列，每列能够是不一样的值类型（数值、字符串、布尔值等）。DataFrame即有行索引也有列索引，它能够被看作由Series组成的字典（共用同一个索引）。

from pandas import Series, DataFrame
data = {'state':['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'], 'year':[2000, 2001, 2002, 2001, 2001], 'pop':[1.5, 1.7, 3.6, 2.4, 2.9]} frame = DataFrame(data);

print (frame)

 

• 结果DataFrame会自动加上索引，且所有列会被有序排列：

   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  2001

 

• 若是指定了列序列，则DataFrame的列就会按照指定的顺序进行排序：

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

 

• 传入的列在数据中找不到，就会产生NA值。
• 经过相似字典标记的方式或属性的方式，能够将DataFrame的列获取为一个Series：

print (frame2['state'])
print (frame2.year)

 

　　输出：

0      Ohio
1 Ohio 2 Ohio 3 Nevada 4 Nevada Name: state, dtype: object 0 2000 1 2001 2 2002 3 2001 4 2001 Name: year, dtype: int64

• 行也能够经过位置或名称的方式进行获取，好比用索引字段 ix
• 跟Series同样，若是传入的列在数据中找不到，就会产生NA值：

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

 

　　输出：

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

　　列能够经过赋值的方式修改：

frame3['debt'] = np.arange(5.0)
print (frame3)

　　输出：

   year   state  pop  debt
0  2000    Ohio  1.5   0.0
1  2001    Ohio  1.7   1.0
2  2002    Ohio  3.6   2.0
3  2001  Nevada  2.4   3.0
4  2001  Nevada  2.9   4.0

• 将列表或数组赋值给某个列时，其长度必须跟DataFrame的长度想匹配。若是赋值的是一个Series，就会精确匹配DataFrame的索引，全部的空位都将被填上缺失值：

val = Series([-1.2, -1.5, -1.7], index=[ 0, 2, 3])
frame3['debt'] = val print (frame3)

　　输出：

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

 

注意：经过索引方式返回的列只是相应数据的视图，并非副本

• 另外一种常见的数据形式是嵌套字典（字典的字典）：

 

pop = {'Nevada':{2001:2.4, 2002:2.9},
       'Ohio': {2000:2.5, 2001:1.7, 2002:3.6}} frame4 = DataFrame(pop) print (frame4)

 

　　输出：

      Nevada  Ohio
2000     NaN   2.5
2001     2.4   1.7
2002     2.9   3.6

 

　　转置：

frame4.T

• 由Series组成的字典用法相似
• 若是设置了DataFrame的index和columns的name属性，则这些信息也会被显示出来：

frame4 = DataFrame(pop)
frame4.index.name = 'year' frame4.columns.name = 'state' print (frame4)

　　输出：

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

 

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

print (frame4.values)
#输出
[[ nan  2.5] [ 2.4 1.7] [ 2.9 3.6]]

 

基本功能

从新索引

• 调用该Series的reindex将会根据数据索引进行重排。若是某个索引值当前不存在，就引入缺失值NaN：

obj = Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a' , 'c'])
obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e']) print (obj2) #输出 a -5.3 b 7.2 c 3.6 d 4.5 e NaN dtype: float64

 

• 使用 fill_value 可作插值处理

obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value=0)
print (obj2) #输出 a -5.3 b 7.2 c 3.6 d 4.5 e 0.0 dtype: float64

• method选项

obj3 = Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
print (obj3.reindex(range(6), method='ffill')) #输出 0 blue 1 blue 2 purple 3 purple 4 yellow 5 yellow dtype: object

参数	说明
ffill或pad	前向填充值
bfill或backfill	后向填充值

 

 

 

 

• 对于DataFrame，reindex能够修改（行）索引、列，或两个都修改。

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

frame2 = frame.reindex(['a', 'b', 'c', 'd']) states = ['Texas', 'Utah', 'California'] frame3 = frame.reindex(columns=states)

　　利用ix的标签索引功能，从新索引任务能够变的更简洁：

frame.ix[['a', 'b', 'c', 'd'], states]

 

 

丢弃指定轴上的项

• 丢掉某条轴上的一个或多个项，只要有一个索引数组或列表便可，使用 drop 方法 

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

 

 

索引、选取和过滤

• Series索引的几个例子：

obj = Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
obj['b'] obj[1] obj[2:4] obj['b', 'a', 'd'] obj[[1,3]] obj[obj<2] obj['b', 'c']

 

• DataFrame索引：

data = DataFrame(np.arange(16).reshape((4,4)), index=['Ohio', 'Colorado', 'Utah', 

data[['two', 'three']] #输出  two three Ohio 1 2 Colorado 5 6 Utah 9 10 New York 13 14 data[:2] #输出  one two three four Ohio 0 1 2 3 Colorado 4 5 6 7 data[data['three']>5] #输出  one two three four Colorado 4 5 6 7 Utah 8 9 10 11 New York 12 13 14 15

• 专门的索引字段ix

类型	说明
obj[val]	选取DataFrame的单个列或一组列
obj.ix[val]	选取DataFrame的单个行或一组行
obj.ix[:,val]	选取单个列或列子集
obj.ix[val1,val2]	同时选取行和列

 

 

 

 

 

 

 

 

算术运算和数据对齐

• pandas最重要的一个功能是，它能够对不一样的索引的对象进行算术运算。在将对象相加时，若是存在不一样的索引对，则结果的索引就是该索引对的并集。
• 使用df1的 add 方法，传入df2以及一个fill_value参数：

df1 = DataFrame(np.arange(12.).reshape((3,4)), columns= list('abcd'))
df2 = DataFrame(np.arange(20.).reshape((4,5)), columns= list('abcde')) print(df1+df2) print(df1.add(df2,fill_value=0)) #输出  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 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从新索引时，也能够指定一个填充值：

df1.reindex(columns=df2.columns, fill_value=0)
#输出
 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

• 默认状况下，DataFrame和Series之间的算术运算会将Series的索引匹配到DataFrame的列，而后沿着行一直向下广播。
• 若是某个索引值在DataFrame的列或Series的索引中找不到，则参与运算的两个对象就会被从新索引以造成并集。

 

函数应用和映射

• NumPy的ufuncs(元素级数组方法）也能够用于操做pandas对象：

#示例
np.abs(frame)

 

• 另外一种常见的操做是，将函数应用到各列或行所造成的一维数组上。使用DataFrame的 apply 方法。

frame = DataFrame(np.random.randn(4,3), columns=list('bde'), index=[1,2,3,4])
print (frame) f = lambda x:x.max() - x.min() print (frame.apply(f)) print (frame.apply(f, axis=1)) #输出  b d e 1 0.756197 2.094682 -2.139083 2 0.231391 -0.682302 0.908212 3 0.447181 -0.172543 0.221593 4 -0.500720 0.248337 -0.034403 b 1.256918 d 2.776984 e 3.047295 dtype: float64 1 4.233765 2 1.590513 3 0.619723 4 0.749058 dtype: float64

 

• 元素级的Python函数也是能够用的：

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

　　之因此叫applymap，是由于Series有一个敢于应用元素级函数的map方法：

print (frame['e'].map(format))

#输出
       b      d      e
1  -0.84   0.10   1.07
2   0.56  -0.49  -1.98
3  -0.60  -1.57  -1.42
4   0.53  -0.85  -0.01

1     1.07
2    -1.98
3    -1.42
4    -0.01 Name: e, dtype: object

 

排序和排名

• 要对行或列索引进行排序（按字典顺序），可以使用 sort_index 方法，它将返回一个已排序的心对象: 

obj = Series(range(4), index=['d', 'a', 'b', 'c'])
print (obj.sort_index())
#输出
a    1
b    2
c    3
d    0
dtype: int64

 

　　默认升序，降序以下：

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

• 按值对Series进行排序，可以使用其 order 方法：

 

• 在DataFrame上，将一个或多个列的名字传递给 by 选项便可根据一个或多个列中的值进行排序：

frame = DataFrame({'b':[4, 7, -3, 2], 'a':[0, 1, 0 , 1]})
print (frame.sort_values(by=['a','b']))
#输出
   a  b
2  0 -3
0  0  4
3  1  2
1  1  7

 

带有重复值的轴索引

• 许多pandas函数（如reindex）要求标签惟一，但这并非强制性的。

obj = Series(range(5),index=['a', 'a', 'b', 'b', 'c'])

　　索引的 is_unique 属性能够告诉你它的值是否惟一 

obj.index.is_unique

• 对于带有重复值的索引，若是某个索引对应多个值，则返回一个Series，而对应单个值的，则返回一个标量值。
• 对DataFrame的行进行索引时也是如此。

 

汇总和计算描述统计

• pandas对象拥有一组经常使用的数学和统计方法。它们大部分都属于约简和汇总统计，用于从Series中提取单个值（如sum或mean）或从DataFrame的行或列中提取一个Series。

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'])
print (df)
print (df.sum())
print (df.sum(axis=1)) #axis 约简的轴。DataFrame的行用0，列用1

#输出
    one  two
a  1.40  NaN
b  7.10 -4.5
c   NaN  NaN
d  0.75 -1.3
one    9.25
two   -5.80
dtype: float64
a    1.40
b    2.60
c     NaN
d   -0.55
dtype: float64

 

　　NA值会自动被排除，除非整个切片（这里指的是行或列）都是NA。经过 skipna 选项能够禁用该功能。

• 有些方法（如 idxmin 和 idxmax ）返回的是间接统计（好比达到最小值或最大值的索引）

 

相关系数和协方差

• Series的 corr 方法用于计算两个Series中重叠的、非NA的、按索引对齐的值的相关系数。与此相似，cov 用于计算协方差。
• DataFrame的 corr 和 cov 方法将以DataFrame的形式返回完整的相关系数或协方差矩阵。

 

惟一值、值计数以及成员资格

• unique 函数能够获得Series中的惟一值数组：

obj = Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
uniques = obj.unique()
print (uniques)
#输出
['c' 'a' 'd' 'b']

　　返回的惟一值是为排序的，可以使用 uniques.sort() 进行排序

• value_counts 用于计算一个Series中各值出现的频率：

print (obj.value_counts())
#输出
c    3
a    3
b    2
d    1
dtype: int64

　　结果是按值频率降序排列的。

pd.value_counts(obj.values, sort=False)

 

• isin 用于判断矢量化集合的成员资格，可用于选取Series中或DataFrame列中数据的子集：

mask = obj.isin(['b','c'])
print (mask)
#输出
0     True
1    False
2    False
3    False
4    False
5     True
6     True
7     True
8     True
dtype: bool

 

 

处理缺失数据

• pandas使用浮点值 NaN（Not a Number）表示浮点和非浮点数组中的缺失数据，它只是一个用于被检测出来的标记而已：

　

string_data = Series(['aa', 'bb', np.nan, 'cc'])
print (string_data.isnull())
#输出
0    False
1    False
2     True
3    False
dtype: bool

 

　　Python内置的 None 值也会被看成NA处理。

• NA处理方法

方法	说明
dropna	根据各标签的值中是否存在缺失数据对轴标签进行过滤，可经过阀值调节对缺失值的容忍度
fillna	用指定值或插值方法（如ffill或bfill）填充缺失数据
isnull	返回一个含有布尔值的对象，这些布尔值表示哪些值是缺失值／NA，该对象的类型与源类型同样
notnull	isnull的否认式

 

 

 

 

 

 

 

 

滤除缺失数据

• 对于一个Series，dropna 返回一个仅含非空数据和索引值的Series：

data = Series([1, np.nan, 3.5, np.nan, 7])
print (data.dropna())
#输出
0    1.0
2    3.5
4    7.0
dtype: float64

• 对于DataFrame对象，dropna 默认丢弃任何含有缺失值的行

　　传入 how='all' 将只丢弃全为 NA 的那些行：

data.dropna(how='all')

　　以这种方式丢弃列：

data.dropna(axis=1, how='all')

 

 

填充缺失数据

• 一般一个常数调用 fillna 就会将缺失值替换为那个常数：

df.fillna(0)

• 若经过一个字典调用 fillna ,就能够实现对不一样的 列 填充不一样的值：

df.fillna({1:0.5, 3:-1})

 

注：fillna 默认返回新对象，但也能够对现有对象进行修改：

#老是返回被填充对象的引用
_ = df.fillna(o, inplace=True)

• 对 reindex 有效的那些插值方法也能够用于fillna：

#df.fillna(method='ffill')
df.fillna(method='ffill', limit=2) #（对于前向和后向填充）能够连续填充的最大数量
#输出
          0         1         2
0 -2.512334  0.566809 -0.310823
1  1.480002  0.089615 -0.876138
2  1.446703  0.089615 -0.705835
3 -0.241433  0.089615  0.897966
4  0.028517       NaN  0.897966
5 -0.045509       NaN  0.897966

 

 

层次化索引

• 层次化索引能使你能在一个轴上拥有多个（两个以上）索引级别：

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,1,2]])
print (data)
print (data.index)
#输出
a  1   -0.041274
   2    1.288469
   3   -0.731776
b  1    1.411813
   2   -1.108839
   3   -0.689199
c  1   -0.185918
   2    0.803436
d  1    0.094525
   2    0.692778
dtype: float64

MultiIndex(levels=[[u'a', u'b', u'c', u'd'], [1, 2, 3]],
           labels=[[0, 0, 0, 1, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 1, 2, 0, 1, 0, 1]])

• 对于一个层次化索引的对象选取数据子集操做：

data['b']
data['b':'c']
data.ix[['b', 'd']]

　　在内层中选取：

data[:, 2]
#输出
a    0.780424
b    0.034343
c   -1.635875
d   -1.068981
dtype: float64

 

 

重排分级顺序

• 从新调整某条轴上各级别的顺序，swaplevel 接收两个级别编号或名称，并返回互换了级别的新对象（但数据不会发生变化）：

frame = DataFrame(np.arange(12).reshape(4,3),
                  index=[['a','a','b','b'], [1,2,1,2]],
                  columns=[['Ohio', 'Ohio', 'Colorado'],
                           ['Green', 'Red', 'Green']])
frame.index.names = ['key1', 'key2']
frame.columns.names = ['state', 'color']
#输出
state Ohio Colorado
color Green Red Green
key1 key2 
a 1 0 1 2
2 3 4 5
b 1 6 7 8
2 9 10 11


frame.swaplevel('key1', 'key2')

 

• sortlevel根据单个级别中的值对数据进行排序（稳定）：

frame.sort_index(level=1)
#输出
state      Ohio     Colorado
color     Green Red    Green
key1 key2                   
a    1        0   1        2
b    1        6   7        8
a    2        3   4        5
b    2        9  10       11

 

•  交换级别：

frame.swaplevel(0,1).sort_index(level=0)
#输出
state      Ohio     Colorado
color     Green Red    Green
key2 key1                   
1    a        0   1        2
     b        6   7        8
2    a        3   4        5
     b        9  10       11

 

 

根据级别汇总统计

• 许多对DataFrame和Series的描述和汇总统计都有一个level选项，它用于指定在某条轴上求和的级别。

#示例
frame.sum(level='key2')
#输出
state  Ohio     Colorado
color Green Red    Green
key2                    
1         6   8       10
2        12  14       16

frame.sum(level='color', axis=1)
#输出
color      Green  Red
key1 key2            
a    1         2    1
     2         8    4
b    1        14    7
     2        20   10

 

 

使用DataFrame的列

• 人们常常想要将DataFrame的一个或多个列看成索引来用，或者可能但愿将行索引变成DataFrame的列：

frame = DataFrame({'a':range(7), 'b':range(7,0,-1), 'c':['one','one','one','two','two','two','two'],
                   'd':[0,1,2,0,1,2,3]})
print frame
#输出
   a  b    c  d
0  0  7  one  0
1  1  6  one  1
2  2  5  one  2
3  3  4  two  0
4  4  3  two  1
5  5  2  two  2
6  6  1  two  3

• DataFrame的 set_index 函数会将其一个或多个列转换为行索引，并建立一个新的DataFrame：

frame2 = frame.set_index(['c','d'])
#输出
       a  b
c   d      
one 0  0  7
    1  1  6
    2  2  5
two 0  3  4
    1  4  3
    2  5  2
    3  6  1

 

• reset_index 的功能跟 set_index 恰好相反，层次化索引的级别会被转移到列里面：

frame2.reset_index()