这篇博客介绍了pandas的基础操作，包括Series和DataFrame的数据结构，重置索引，选择与过滤数据，使用loc和iloc，算术运算，缺失数据处理，排序和排名，统计汇总，协方差和相关系数计算等关键概念。
pandas
- series
- dataframe
##Series
3. 由一组数据和一组与之相关的数据标签（即索引）组成
obj = Series([4, 5, -5, 3])
obj
0 4
1 7
2 -5
3 3
#表现形式极为索引在左，值在右边
#如果需要表现获取数组表现形式和索引对象
#用values获取数值
obj.values
orray([4, 7, -5, 3])
#用index获取索引对象
obj.index
Int64Index([0, 1, 2, 3])
#series对每一个数据点标记索引
obj = Series([4, 7, -5, 3], index['a', 'b', 'c', 'd'])
obj
a 4
b 7
c -5
d 3
#通过索引方式选取series中的单个或一组值
obj['a']
4
obj['d'] = 6
obj['a', 'b', 'c', 'd']
a 4
b 7
c -5
d 6
#通过a索引到值4， 通过d 更改数值为 6
#布尔型数组进行过滤，标量乘法，应用数学函数不改变其索引和值之间的连接
#过滤
obj[obj > 0]
a 4
b 7
d 6
#标量乘法
obj*2
a 8
b 14
c -10
d 12
#函数
np.exp(obj) # a 4 b 7 c -5
a 403.428793
b 1096.633158
d 0.006738
#可以用做判断,将series是为定长的有序字典
'b' in obj
true
#数据存放在字典里
sdata = {'ohio': 3500, 'texas': 71000, 'oregon': 16000, 'utah': 5000}
obj = Series(sdata)
obj
ohio 3500
texas 71000
oregon 16000
utah 5000
#若只传入一个字典，则结果series中的索引就是原字典的键（有序排列）
states = ['california', 'ohio', 'oregon', 'texas']
obj = Series(sdata, index=states)
obj
california NaN#not a number 表示缺失值 针对缺失值，可以使用isnull和 notnull 来检测
ohio 35000
oregon 16000
texas 71000
#pandas-isnull
pd.isnull(obj)
california true
ohio false
oregon false
texas false
#pandas-notnull
pd.notnull(obj)
california false
ohio true
oregon true
texas true
#series-isnull
obj.isnull()
california true
ohio false
oregon false
texas false
#series 最重要的功能，在算数运算时会自动对齐
#之前用abcd对应的数字 4 7 -5 3 现在使用index原地替换
obj.index = ['bob', 'steven', 'jeff', 'ryan']
obj
bob 4
steven 7
jeff -5
ryan 3
##dataframe是表格型的数据结构
import pandas as pd
data = {'state': ['ohio', 'ohio', 'ohio', 'nevada', 'nevada'], 'year': [2000, 2001, 2002, 2001, 2002],
'pop' [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = pd.DataFrame(data)
frame
#这个命名错了好几次了，注意前后统一，少了个pd死活过不去啊
state year pop
0 ohio 2000 1.5
1 ohio 2001 1.7
2 ohio 2002 3.6
3 nevada 2001 2.4
4 nevada 2002 2.9
#如果指定了顺序
pd.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
#若出现数据找不到，则表现NA
frame2 = pd.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
#类字典标记，获取一个series
frame2['state']
one ohio
two ohio
three ohio
four nevada
five nevada
Name: state, dtype: object
#通过赋值的方式进行修改
frame2['debt']=16.5
frame2
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
#精准赋值
val = pd.Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])
frame2['debt']=val
frame2
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
#为不存在的列赋值会创建出新的列
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 NaN True
four 2001 nevada 2.4 -1.5 False
five 2002 nevada 2.9 -1.7 False
#关键字用del删除即可
del frame2['eastern']
frame2.columns
Index(['year', 'state', 'pop', 'debt'], dtype='object')
#嵌套字典-外层字典的键作为列，内层键作为行
pop = {'nevada': {2001: 2.4, 2002: 2.9}, 'ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
frame3 = pd.DataFrame(pop)
frame3
nevada ohio
2001 2.4 1.7
2002 2.9 3.6
2000 NaN 1.5
#转置-横纵坐标对调
2001 2002 2000
nevada 2.4 2.9 NaN
ohio 1.7 3.6 1.5
#内层字典的键会被合并，排序以形成最终的索引
pd.DataFrame(pop, index=[2001, 2002, 2003])
nevada ohio
2001 2.4 1.7
2002 2.9 3.6
2003 NaN NaN
#还可以给行和列设置属性
frame3.index.name = 'year'; frame3.columns.name = 'state'
frame3
state nevada ohio
year
2001 2.4 1.7
2002 2.9 3.6
2000 NaN 1.5
#values 属性也会以ndarray的形式返回
frame3.values
array([[2.4, 1.7],
[2.9, 3.6],
[nan, 1.5]])
#各列的数据类型不同，则值数组的数据类型就会选用能兼容所有列的数据类型
frame2.values
array([[2000, 'ohio', 1.5, nan],
[2001, 'ohio', 1.7, -1.2],
[2002, 'ohio', 3.6, nan],
[2001, 'nevada', 2.4, -1.5],
[2002, 'nevada', 2.9, -1.7]], dtype=object)
重新索引
#reindex---传建一个适应新索引的对象
obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])
obj
d 4.5
b 7.2
a -5.3
c 3.6
dtype: float64
#reindex将会根据新索引进行重排
obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
obj2
a -5.3
b 7.2
c 3.6
d 4.5
e NaN
dtype: float64
#因为存在空值，令它等于0
obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value=0)
a -5.3
b 7.2
c 3.6
d 4.5
e 0.0
dtype: float64
#对于有序数据，索引时需要插值处理
obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
obj3
0 blue
2 purple
4 yellow
dtype: object
obj3.reindex(range(6), method='ffill')#前补后
0 blue
1 blue
2 purple
3 purple
4 yellow
5 yellow
dtype: object
obj3.reindex(range(6), method='bfill')#后补前
0 blue
1 purple
2 purple
3 yellow
4 yellow
5 NaN
dtype: object
#reindex可以修改行或列索引，只传递一个序列时，会重新索引结果的行
import numpy as np
frame = pd.DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'], columns=['ohio', 'texas', 'california'])
frame
ohio texas california
a 0 1 2
c 3 4 5
d 6 7 8
frame2 = frame.reindex(['a', 'b', 'c', 'd'])
frame2
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重新索引
states = ['texas', 'utah', 'california']
frame.reindex(columns=states)
texas utah california
a 1 NaN 2
c 4 NaN 5
d 7 NaN 8
#丢弃指定值上面的项
obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
obj
a 0.0
b 1.0
c 2.0
d 3.0
e 4.0
dtype: float64
#drop返回的是一个在指定轴上删除了指定值的新对象
#arange返回的是一个数据
obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
new_obj = obj.drop('c')
new_obj
a 0.0
b 1.0
d 3.0
e 4.0
dtype: float64
#用drop会从行标签axis 0删除
data.drop(['colorado', 'ohio'])
one two three four
utah 8 9 10 11
newyork 12 13 14 15
#axis=1 或axis= 'columns'可以删除列的值
data.drop('two', axis=1)
one three four
ohio 0 2 3
colorado 4 6 7
utah 8 10 11
newyork 12 14 15
data.drop('four', axis='columns')
one two three
ohio 0 1 2
colorado 4 5 6
utah 8 9 10
newyork 12 13 14
索引、选取和过滤
data = [1,2,3,4,5]
res = pd.Series(data,index=["a","b","c","d","e"])
print(res[0:3],"---") # 这里跟python的切片一样，数字说的是行数
print(res[3],"---")
print(res[-3:],"---")
a 1
b 2
c 3
dtype: int64 ---
4 ---
c 3
d 4
e 5
dtype: int64 ---
#布尔数组选取数据
data[data['three']> 5]
one two three four
colorado 4 5 6 7
utah 8 9 10 11
newyork 12 13 14 15
#做判断
data < 5
one two three four
ohio True True True True
colorado True False False False
utah False False False False
newyork False False False False
#做判断还能赋值
data[data < 5]=0
data
one two three four
ohio 0 0 0 0
colorado 0 5 6 7
utah 8 9 10 11
newyork 12 13 14 15
用loc和iloc进行选取
#loc选的轴标签
data.loc['colorado', ['two', 'three']]
two 5
three 6
Name: colorado, dtype: int32
#iloc选的整数索引
data.iloc[2, [3, 0, 1]]
four 11
one 8
two 9
Name: utah, dtype: int32
data.iloc[[1, 2], [3, 0, 1]]
four one two
colorado 7 0 5
utah 11 8 9
#多个标签切片
data.iloc[:, :3][data.three > 5]
one two three
colorado 0 5 6
utah 8 9 10
newyork 12 13 14
ser = pd.Series(np.arange(3.))
ser
0 0.0
1 1.0
2 2.0
dtype: float64
ser[:1]
0 0.0
dtype: float64
#loc左右都闭区间，可以选到1
ser.loc[:1]
0 0.0
1 1.0
dtype: float64
#iloc左闭右开，不可以选到1
ser.iloc[:1]
0 0.0
dtype: float64
算术运算和数据对齐
s1 = pd.Series([7.3, -2.5, 3.4, 1.5], index=['a', 'c', 'd', 'e'])
s2 = pd.Series([-2.1, 3.6, -1.5, 4, 3.1], index=['a', 'c', 'e', 'f', 'g'])
s1
a 7.3
c -2.5
d 3.4
e 1.5
dtype: float64
s2
a -2.1
c 3.6
e -1.5
f 4.0
g 3.1
dtype: float64
s1+s2
a 5.2
c 1.1
d NaN
e 0.0
f NaN
g NaN
dtype: float64
df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'), index=['ohio', 'texas', 'colorado'])
df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'), index=['utah', 'ohio', 'texas', 'oregon'])
df1
b c d
ohio 0.0 1.0 2.0
texas 3.0 4.0 5.0
colorado 6.0 7.0 8.0
df2
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
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 = pd.DataFrame(np.arange(12.).reshape((3, 4)), columns=list('abcd'))
df2 = pd.DataFrame(np.arange(20.).reshape((4, 5)), columns=list('abcde'))
df2.loc[1, 'b'] = np.nan
df1
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
df2
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
df1+df2
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
#1/df1 和 df1.rdiv（1）功能一样 都是求导
a b c d
0 inf 1.000000 0.500000 0.333333
1 0.250 0.200000 0.166667 0.142857
2 0.125 0.111111 0.100000 0.090909
DataFrame和Series之间的运算
#每一行都会执行这个操作，称之为broadcasting
arr = np.arange(12.).reshape((3, 4))
arr
array([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
arr[0]
array([0., 1., 2., 3.])
arr - arr[0]
array([[0., 0., 0., 0.],
[4., 4., 4., 4.],
[8., 8., 8., 8.]])
frame = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'), index=['utah', 'ohio', 'texas', 'oregon'])
series = frame.iloc[0]
frame
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
series
b 0.0
d 1.0
e 2.0
Name: utah, dtype: float64
#dataframe 和 series之间的算术运算会将series的索引匹配到 dataframe的列
frame - series
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
#如果某个索引值在索引中找不到，则参与运算的两个对象就会被重新索引以形成并集
series2 = pd.Series(range(3), index=['b', 'e', 'f'])
series
b 0.0
d 1.0
e 2.0
Name: utah, dtype: float64
frame + series2#frame-bde， series--bef，所以结合并集中，df没有值
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
#若希望匹配行且在列上广播，则必须使用算术运算方法
series3 = frame['d']
frame
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
series3
utah 1.0
ohio 4.0
texas 7.0
oregon 10.0
Name: d, dtype: float64
frame.sub(series3, axis='index')
#传入的轴号就是希望匹配到的轴，axis='index' or axis=0并进行广播
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
#函数应用和映射
# 取绝对值
frame=DataFrame(np.random.randn(4,3),
columns=list('bde'),
index=['Utah','Ohio','Texas','Oregon'])
frame
b d e
Utah 1.274993 1.356555 0.040055
Ohio 0.689279 -0.517478 1.557812
Texas -1.245693 -1.096686 0.290030
Oregon -1.857370 -0.135838 -0.083429
# 取绝对值
np.abs(frame)
b d e
Utah 1.274993 1.356555 0.040055
Ohio 0.689279 0.517478 1.557812
Texas 1.245693 1.096686 0.290030
Oregon 1.857370 0.135838 0.083429
#将函数应用到由各列或行所形成的一维数组上。
#DataFrame的apply方法即可实现此功能,f函数计算了一个series的max和min的差，在每列都执行了一次，每一列执行用f函数
f=lambda x:x.max() - x.min()
frame.apply(f)
b 3.132363
d 2.453241
e 1.641241
dtype: float64
#每一行执行f函数，axis='columns'到apply
frame.apply(f, axis='columns')
Utah 1.316500
Ohio 2.075290
Texas 1.535723
Oregon 1.773941
dtype: float64
# 除标量外，传递给apply的函数还可以返回由多个值组成的Series：
def f(x):
return pd.Series([x.min(),x.max()],index=['min','max'])
frame.apply(f)
b d e
min -1.857370 -1.096686 -0.083429
max 1.274993 1.356555 1.557812
print("---------------------")
# 此外，元素级的python函数也是可以用的。
# 假如想得到frame中各个浮点数的格式化字符串，使用applymap即可：
format=lambda x:'%.2f' %x
frame.applymap(format))
b d e
Utah 1.27 1.36 0.04
Ohio 0.69 -0.52 1.56
Texas -1.25 -1.10 0.29
Oregon -1.86 -0.14 -0.08
# 之所以叫做applymap，
# 是因为Series有一个用于应用元素级函数的map的方法
# 取某一列时，即为Series
print(frame['e'].map(format))
Utah 0.04
Ohio 1.56
Texas 0.29
Oregon -0.08
Name: e, dtype: object
# 也可以是 自建 的Series
series=Series(range(3),index=['b','e','f'])
print(series.map(format))
map，apply，applymap
- apply()
apply()是pandas里DataFrame的函数，可以针对DataFrame中的行数据或列数据应用操作。
import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.rand(4, 3), columns = list('abc'), index = ['Utah', 'Ohio', 'Texas', 'Oregon'])
print(frame)
# 输出如下:
# a b c
# Utah 0.443188 0.919623 0.550259
# Ohio 0.013923 0.557696 0.723975
# Texas 0.865469 0.720604 0.081306
# Oregon 0.506174 0.212421 0.061561
func = lambda x: x.max() - x.min()
print(frame.apply(func))
# 输出如下:
# a 0.851545
# b 0.707202
# c 0.662415
# dtype: float64
#注意：这里的apply是应用到每一行或者每一列操作，有专门的axis可以指定，默认是axis=0.
- applymap()
apply()是pandas里DataFrame的函数，但是它对DataFrame中所有的元素应用操作。
import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.rand(4, 3), columns = list('abc'), index = ['Utah', 'Ohio', 'Texas', 'Oregon'])
print(frame)
# 输出如下:
# a b c
# Utah 0.443188 0.919623 0.550259
# Ohio 0.013923 0.557696 0.723975
# Texas 0.865469 0.720604 0.081306
# Oregon 0.506174 0.212421 0.061561
func = lambda x: f'{x:.2f}%'
print(frame.applymap(func))
# 输出如下:
# a b c
# Utah 0.34% 0.43% 0.67%
# Ohio 0.75% 0.50% 0.14%
# Texas 0.68% 0.28% 0.90%
# Oregon 0.05% 0.86% 0.78%
- map()
map() 是python自带的函数，也就是我们常说的高阶函数，但它在DataFrame中可以直接使用**.map()**后缀的方式调用，由于只能直接对序列元素的操作，所以必须对DataFrame的某列 (只针对于列) 应用操作。
import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.rand(4, 3), columns = list('abc'), index = ['Utah', 'Ohio', 'Texas', 'Oregon'])
print(frame)
# 输出如下:
# a b c
# Utah 0.443188 0.919623 0.550259
# Ohio 0.013923 0.557696 0.723975
# Texas 0.865469 0.720604 0.081306
# Oregon 0.506174 0.212421 0.061561
func = lambda x: f'{x:.2f}%'
print(frame['a'].map(func))
# 输出如下:
# Utah 0.65%
# Ohio 0.90%
# Texas 0.09%
# Oregon 0.72%
# Name: a, dtype: object
排序和排名
根据条件对Series对象或DataFrame对象的值排序（sorting）和排名(ranking)是一种重要的内置运算。
使用pandas对象的：sort_index() / sort_values() / rank() 方法。
In [201]: obj = pd.Series(range(4), index=['d', 'a', 'b', 'c'])
In [202]: obj.sort_index()
Out[202]:
a 1
b 2
c 3
d 0
dtype: int64
#对于DataFrame，则可以根据任意一个轴上的索引进行排序：
In [203]: frame = pd.DataFrame(np.arange(8).reshape((2, 4)),
.....: index=['three', 'one'],
.....: columns=['d', 'a', 'b', 'c'])
In [204]: frame.sort_index() #默认axis=0 对行索引进行排序
Out[204]:
d a b c
one 4 5 6 7
three 0 1 2 3
In [205]: frame.sort_index(axis=1) # 对列索引进行排序
Out[205]:
a b c d
three 1 2 3 0
one 5 6 7 4
#数据默认是按升序排序的，但也可以降序排序：
In [206]: frame.sort_index(axis=1, ascending=False)
Out[206]:
d c b a
three 0 3 2 1
one 4 7 6 5
#若要按值对Series进行排序，可使用其sort_values方法：
In [207]: obj = pd.Series([4, 7, -3, 2])
In [208]: obj.sort_values()
Out[208]:
2 -3
3 2
0 4
1 7
dtype: int64
#在排序时，任何缺失值默认都会被放到Series的末尾：
In [209]: obj = pd.Series([4, np.nan, 7, np.nan, -3, 2])
In [210]: obj.sort_values()
Out[210]:
4 -3.0
5 2.0
0 4.0
2 7.0
1 NaN
3 NaN
dtype: float64
#当排序一个DataFrame时，可能希望根据一个或多个列中的值进行排序。将一个或多个列的名字传递给sort_values的by选项即可达到该目的：
In [211]: frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
In [212]: frame
Out[212]:
a b
0 0 4
1 1 7
2 0 -3
3 1 2
In [213]: frame.sort_values(by='b')
Out[213]:
a b
2 0 -3
3 1 2
0 0 4
1 1 7
#要根据多个列进行排序，传入名称的列表即可：
In [214]: frame.sort_values(by=['a', 'b'])
Out[214]:
a b
2 0 -3
0 0 4
3 1 2
1 1 7
#排名
#排名会从1开始一直到数组中有效数据的数量。接下来介绍Series和DataFrame的rank方法。默认情况下，rank是通过“为各组分配一个平均排名”的方式破坏平级关系的：
In [215]: obj = pd.Series([7, -5, 7, 4, 2, 0, 4])
In [216]: obj.rank()
Out[216]:
0 6.5
1 1.0
2 6.5
3 4.5
4 3.0
5 2.0
6 4.5
dtype: float64
#也可以根据值在原数据中出现的顺序给出排名：
In [217]: obj.rank(method='first')
Out[217]:
0 6.0
1 1.0
2 7.0
3 4.0
4 3.0
5 2.0
6 5.0
dtype: float64
#条目0和2没有使用平均排名6.5，它们被设成了6和7，因为数据中标签0位于标签2的前面。
#可以按降序进行排名：
# Assign tie values the maximum rank in the group
In [218]: obj.rank(ascending=False, method='max')
Out[218]:
0 2.0
1 7.0
2 2.0
3 4.0
4 5.0
5 6.0
6 4.0
dtype: float64
#表5-6列出了所有用于破坏平级关系的method选项。DataFrame可以在行或列上计算排名
In [219]: frame = pd.DataFrame({'b': [4.3, 7, -3, 2], 'a': [0, 1, 0, 1],
.....: 'c': [-2, 5, 8, -2.5]})
In [220]: frame
Out[220]:
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 [221]: frame.rank(axis='columns')
Out[221]:
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
带有重复值索引
#对series和dataframe一样
obj = pd.Series(range(5), index=['a', 'a', 'b', 'b', 'c'])
obj
a 0
a 1
b 2
b 3
c 4
dtype: int64
obj.index.is_unique
False
汇总和计算描述统计
pd.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'])
df
one two
a 1.40 NaN
b 7.10 -4.5
c NaN NaN
d 0.75 -1.3
#列求和
df.sum()
#行求和
df.sum(axis=1)
#NA值会被自动排除，除非整个切片都是NA
df.mean(axis='columns', skipna=False)
a NaN
b 1.300
c NaN
d -0.275
dtype: float64
#间接统计最大值 最小值
df.idmin
df.idmax
#累计最大
df.cumsum
#一次性统计多种数据
df.describe()
协方差
协方差（Covariance）
反映两个样本/变量之间的相互关系以及之间的相关程度。
期望值分别为E[X]与E[Y]的两个实随机变量X与Y之间的协方差Cov(X,Y)定义为：
如果有 X，Y 两个变量，每个时刻的 “X值与其均值之差” 乘以 “Y值与其均值之差” 得到一个乘积，再对这每时刻的乘积求和并求出均值。
如果协方差为正，说明 X，Y 是同向变化，协方差越大说明同向程度越高；如果协方差为负，说明 X ，Y 反向运动，协方差越小说明反向程度越高。
相关系数（Correlation coefficient）
反映两个样本/样本之间的相互关系以及之间的相关程度。在COV 的基础上进行了无量纲化操作，也就是进行了标准化操作。
其中，Cov(X,Y)为X与Y的协方差，Var[X]为X的方差，Var[Y]为Y的方差
用 X，Y 的协方差除以 X 的标准差和 Y 的标准差。所以，相关系数也可以看成协方差：一种踢除了两个变量量纲影响、标准化后的特殊协方差。
(1) 也可以反映两个变量变化时是同向还是反向，如果同向变化为正，反向变化为负；
(2) 由于它是标准化后的协方差，因此更重的特性是，它消除了两个变量变化幅度的影响，而只是单纯反映两个变量单位变化的相似程度。
注意：
相关系数不像协方差一样可以在 +\infty 到 -\infty 间变化，它只能在 +1 到 -1 之间变化；
当相关系数为 1 的时候两者相似度最大，同向正相关；
当相关系数为 0 的时候两者没有相似度，两个变量无关；
当相关系数为 -1 的时候两者变化的反向相似度最大，完全反向负相关。
>>> import pandas_datareader.data as web
>>> web
<module 'pandas_datareader.data' from 'D:\python\lib\site-packages\pandas_datareader\data.pyc'>
>>> all_data={}
>>> for ticker in {'AAPL','IBM','MSFT','GOOG'}:
... all_data[ticker] = web.get_data_yahoo(ticker,'1/1/2000','1/1/2010')
...
>>> price = DataFrame({tic:data['Adj Close'] for tic,data in all_data.iteritems()})
>>> volume = DataFrame({tic:data['Volume'] for tic,data in all_data.iteritems()})
>>> returns = price.pct_change()
>>> returns.tail()
AAPL GOOG IBM MSFT
Date
2009-12-24 0.034340 0.011117 0.004385 0.002587
2009-12-28 0.012294 0.007098 0.013326 0.005484
2009-12-29 -0.011861 -0.005571 -0.003477 0.007058
2009-12-30 0.012147 0.005376 0.005461 -0.013698
2009-12-31 -0.004300 -0.004416 -0.012597 -0.015504
#series
returns.MSFT.corr(returns.IBM)
0.49253706924390167
returns.MSFT.cov(returns.IBM)
0.00021557776646297303
#dataframe
returns.corr()
AAPL GOOG IBM MSFT
AAPL 1.000000 0.470676 0.412392 0.422852
GOOG 0.470676 1.000000 0.390689 0.438313
IBM 0.412392 0.390689 1.000000 0.492537
MSFT 0.422852 0.438313 0.492537 1.000000
returns.cov()
AAPL GOOG IBM MSFT
AAPL 0.001030 0.000303 0.000254 0.000309
GOOG 0.000303 0.000580 0.000142 0.000204
IBM 0.000254 0.000142 0.000369 0.000216
MSFT 0.000309 0.000204 0.000216 0.000519
#利用DataFrame的corrwith方法，你可以计算其列或行跟另一个Series或DataFrame之间的相关系数。传入一个Series将返回一个Series，在计算相关系数之前，所有数据都会按标签对齐
returns.corrwith(returns.IBM)
AAPL 0.412392
GOOG 0.390689
IBM 1.000000
MSFT 0.492537
dtype: float64
returns.corrwith(volume)
AAPL -0.057665
GOOG 0.062647
IBM -0.006592
MSFT -0.016101
dtype: float64
唯一值、值计数以及成员资格
从一维Series中抽取信息
-
Unique代表Series中的唯一值数组，返回的唯一值是未排序的，
-
value_counts()用于计算在Series中个值出现的频率，
-
isin()用于判断矢量化成员资格，可用于选取Series中或DataFrame列中数据的子集：
>>> from pandas import DataFrame,Series
Backend TkAgg is interactive backend. Turning interactive mode on.
>>> import numpy as np
>>> import pandas as pd
>>> obj = Series(['c','a','d','a','a','b','b','c','c'])
>>> uniques = obj.unique()
>>> uniques
array(['c', 'a', 'd', 'b'], dtype=object)
>>> obj.value_counts()
c 3
a 3
b 2
d 1
dtype: int64
>>> pd.value_counts(obj.values,sort=False)
a 3
c 3
b 2
d 1
dtype: int64
>>> mask = obj.isin(['b','c'])
>>> mask
0 True
1 False
2 False
3 False
4 False
5 True
6 True
7 True
8 True
dtype: bool
>>> obj[mask]
0 c
5 b
6 b
7 c
8 c
dtype: object
#如果希望得到DataFrame中多个相关列的柱状图。将pandas.value_count传给DataFrame的apply函数，就会变成元素次数统计。
data = DataFrame({'Qu1':[1,3,4,3,4],'Qu2':[2,3,1,2,3],'Qu3':[1,5,2,4,4]})
data
Qu1 Qu2 Qu3
0 1 2 1
1 3 3 5
2 4 1 2
3 3 2 4
4 4 3 4
result = data.apply(pd.value_counts).fillna(0)
result
Qu1 Qu2 Qu3
1 1.0 1.0 1.0
2 0.0 2.0 1.0
3 2.0 2.0 0.0
4 2.0 0.0 2.0
5 0.0 0.0 1.0
处理缺失数据
pandas的设计目标之一就是让缺失数据的处理任务更轻松，pandas使用浮点值NaN表示浮点数组和非浮点数组中的缺失数据，是一个便于被检测的标记
python内置的None也会被当作NA处理
from pandas import Series
>>> string_data = Series(['aardvark','artichoke',np.nan,'avocado'])
>>> string_data
0 aardvark
1 artichoke
2 NaN
3 avocado
dtype: object
>>> string_data.isnull()
0 False
1 False
2 True
3 False
dtype: bool
>>> string_data[0] = None
>>> string_data.isnull()
0 True
1 False
2 True
3 False
滤除缺失数据
dropna返回一个仅含非空数据和索引值的Series.
>>> from numpy import nan as NA
>>> data = Series([1,NA,3.5,NA,7])
>>> data.dropna()
0 1.0
2 3.5
4 7.0
dtype: float64
>>> data = data[data.notnull()]
>>> data
0 1.0
2 3.5
4 7.0
dtype: float64
#对于DataFrame对象，dropna默认丢弃含有缺失值的行
#传入how=‘all’即可只丢弃值全为NA的那些行
#再次传入axis= 1即可丢弃列
>>> data = DataFrame([[1.,6.5,3.],[1.,NA,NA],[NA,NA,NA],[NA,6.5,3.]])
>>> cleaned = data.dropna()
>>> data
0 1 2
0 1.0 6.5 3.0
1 1.0 NaN NaN
2 NaN NaN NaN
3 NaN 6.5 3.0
>>> cleaned
0 1 2
0 1.0 6.5 3.0
>>> data.dropna(how='all')
0 1 2
0 1.0 6.5 3.0
1 1.0 NaN NaN
3 NaN 6.5 3.0
>>> data[4] = NA
>>> data.dropna(axis = 1,how='all')
0 1 2
0 1.0 6.5 3.0
1 1.0 NaN NaN
2 NaN NaN NaN
3 NaN 6.5 3.0
#对于过滤时间序列数据，假如只需要与部分观测数据，可以用thresh参数实现目的
>>> df = DataFrame(np.random.randn(7,3))
>>> df.ix[:4,1] = NA;df.ix[:2,2] = NA
>>> df
0 1 2
0 -0.470646 NaN NaN
1 0.650343 NaN NaN
2 0.616738 NaN NaN
3 -0.244354 NaN 0.863931
4 -0.063218 NaN 0.978948
5 0.145755 0.630745 1.120421
6 -0.111001 0.322309 -0.860522
>>> df.dropna(thresh = 3)
0 1 2
5 0.145755 0.630745 1.120421
6 -0.111001 0.322309 -0.860522
>>> df.dropna(thresh = 2)
0 1 2
3 -0.244354 NaN 0.863931
4 -0.063218 NaN 0.978948
5 0.145755 0.630745 1.120421
6 -0.111001 0.322309 -0.860522
>>> df.dropna(thresh = 1)
0 1 2
0 -0.470646 NaN NaN
1 0.650343 NaN NaN
2 0.616738 NaN NaN
3 -0.244354 NaN 0.863931
4 -0.063218 NaN 0.978948
5 0.145755 0.630745 1.120421
6 -0.111001 0.322309 -0.860522
>>> df.dropna(thresh = 0)
0 1 2
0 -0.470646 NaN NaN
1 0.650343 NaN NaN
2 0.616738 NaN NaN
3 -0.244354 NaN 0.863931
4 -0.063218 NaN 0.978948
5 0.145755 0.630745 1.120421
6 -0.111001 0.322309 -0.860522
填补缺失数据
通常·使用fillna函数将缺失值替换为常数值
>>> df.fillna(0)
0 1 2
0 -0.470646 0.000000 0.000000
1 0.650343 0.000000 0.000000
2 0.616738 0.000000 0.000000
3 -0.244354 0.000000 0.863931
4 -0.063218 0.000000 0.978948
5 0.145755 0.630745 1.120421
6 -0.111001 0.322309 -0.860522
>>> df.fillna({1:0.5,2:-1})
0 1 2
0 -0.470646 0.500000 -1.000000
1 0.650343 0.500000 -1.000000
2 0.616738 0.500000 -1.000000
3 -0.244354 0.500000 0.863931
4 -0.063218 0.500000 0.978948
5 0.145755 0.630745 1.120421
6 -0.111001 0.322309 -0.860522
#fillna会默认返回新对象，但也可以通过设置修改现有对象
>>> _ = df.fillna(0,inplace=True)
>>> df
0 1 2
0 -0.470646 0.000000 0.000000
1 0.650343 0.000000 0.000000
2 0.616738 0.000000 0.000000
3 -0.244354 0.000000 0.863931
4 -0.063218 0.000000 0.978948
5 0.145755 0.630745 1.120421
6 -0.111001 0.322309 -0.860522
#对reindex有效的那些方法也可以用于fillna:
>>> df = DataFrame(np.random.randn(6,3))
>>> df.ix[2:,1] = NA;df.ix[4:,2] = NA
>>> df
0 1 2
0 -0.829840 -2.290885 0.258595
1 0.774171 -2.287114 0.873521
2 0.601178 NaN -0.660464
3 0.775981 NaN -1.640218
4 -1.792551 NaN NaN
5 0.411994 NaN NaN
>>> df.fillna(method = 'ffill')
0 1 2
0 -0.829840 -2.290885 0.258595
1 0.774171 -2.287114 0.873521
2 0.601178 -2.287114 -0.660464
3 0.775981 -2.287114 -1.640218
4 -1.792551 -2.287114 -1.640218
5 0.411994 -2.287114 -1.640218
>>> df.fillna(method = 'ffill',limit = 2)
0 1 2
0 -0.829840 -2.290885 0.258595
1 0.774171 -2.287114 0.873521
2 0.601178 -2.287114 -0.660464
3 0.775981 -2.287114 -1.640218
4 -1.792551 NaN -1.640218
5 0.411994 NaN -1.640218
>>> df.fillna(method = 'ffill',limit = 1)
0 1 2
0 -0.829840 -2.290885 0.258595
1 0.774171 -2.287114 0.873521
2 0.601178 -2.287114 -0.660464
3 0.775981 NaN -1.640218
4 -1.792551 NaN -1.640218
5 0.411994 NaN NaN
#用每一列平均数填补
>>> df.fillna(df.mean())
0 1 2
0 -0.829840 -2.290885 0.258595
1 0.774171 -2.287114 0.873521
2 0.601178 -2.288999 -0.660464
3 0.775981 -2.288999 -1.640218
4 -1.792551 -2.288999 -0.292142
5 0.411994 -2.288999 -0.292142
层次化索引
层次化索引是pandas的一项重要功能，它使你在一个轴上拥有多个索引级别，可以是你以低维度的形式处理高维度的数据。
levels是索引集合和它的空间结构
labels是索引在levels中索引的集合
> from pandas import DataFrame,Series
Backend TkAgg is interactive backend. Turning interactive mode on.
>>> import pandas as pd
>>> import numpy as np
>>> 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]])
>>> data
a 1 -0.070153
2 0.017225
3 0.905866
b 1 -0.156584
2 0.213097
3 0.263765
c 1 -0.141315
2 1.175804
d 2 0.812828
3 -0.820116
dtype: float64
>>> data.index
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, 1, 2]])
#对于层次化索引，选取数据子集操作很简单，也可以通过索引在内层进行选取
>>> data['b']
1 -0.156584
2 0.213097
3 0.263765
dtype: float64
>>> data['b':'c']
b 1 -0.156584
2 0.213097
3 0.263765
c 1 -0.141315
2 1.175804
dtype: float64
>>> data.ix[['b','d']]
b 1 -0.156584
2 0.213097
3 0.263765
d 2 0.812828
3 -0.820116
dtype: float64
>>> data[:,2]
a 0.017225
b 0.213097
c 1.175804
d 0.812828
dtype: float64
#数据可以通过unstack方法被安排到新的DataFrame中。也可过逆运算变回。
>>> data.unstack()
1 2 3
a -0.070153 0.017225 0.905866
b -0.156584 0.213097 0.263765
c -0.141315 1.175804 NaN
d NaN 0.812828 -0.820116
>>> data.unstack().stack()
a 1 -0.070153
2 0.017225
3 0.905866
b 1 -0.156584
2 0.213097
3 0.263765
c 1 -0.141315
2 1.175804
d 2 0.812828
3 -0.820116
dtype: float64
#每层索引可以设置名字
>>> frame = DataFrame(np.arange(12).reshape((4,3)),index=[['a','a','b','b'],[1,2,1,2]],columns=[['Onio','Onio','Colorado'],['Green','Red','Green']])
>>> frame
Onio Colorado
Green Red Green
a 1 0 1 2
2 3 4 5
b 1 6 7 8
2 9 10 11
>>> frame.stack()
Colorado Onio
a 1 Green 2.0 0
Red NaN 1
2 Green 5.0 3
Red NaN 4
b 1 Green 8.0 6
Red NaN 7
2 Green 11.0 9
Red NaN 10
>>> frame.index.names=['key1','key2']
>>> frame.columns.names = ['state','color']
>>> frame
state Onio 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['Onio']
Green Red
a 1 0 1
2 3 4
b 1 6 7
2 9 10
>>> frame.swaplevel('key1','key2')
state Onio Colorado
color Green Red Green
key2 key1
1 a 0 1 2
2 a 3 4 5
1 b 6 7 8
2 b 9 10 11
根据级别汇总统计
>>> frame.sum(level='key2')
state Onio 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的set_index函数会将一个或多个列转换为行索引，并创建一个新的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]})
>>> 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
>>> frame2= frame.set_index(['c','d'])
>>> frame2
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
>>> frame.set_index(['c','d'],drop=False)
a b c d
c d
one 0 0 7 one 0
1 1 6 one 1
2 2 5 one 2
two 0 3 4 two 0
1 4 3 two 1
2 5 2 two 2
3 6 1 two 3
>>> frame2.reset_index()
c d a b
0 one 0 0 7
1 one 1 1 6
2 one 2 2 5
3 two 0 3 4
4 two 1 4 3
5 two 2 5 2
6 two 3 6 1
扫一扫
1032
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
