pandas

dataframe

    a   b   c
0   0   2   4
1   6   8  10
2  12  14  16
3  18  20  22
4  24  26  28
5  30  32  34
6  36  38  40
7  42  44  46
8  48  50  52
9  54  56  58

转换数据格式

df['ad_req_day']=(df['ad_req_day']).astype('int')

dataframe去除重复项

subset : column label or sequence of labels, optional 
用来指定特定的列，默认所有列
keep : {‘first’, ‘last’, False}, default ‘first’ 
删除重复项并保留第一次出现的项
inplace : boolean, default False 
是直接在原来数据上修改还是保留一个副本
totalExposureLog.drop_duplicates(['ad_req_time','ad_space_id','uid','aid'],keep='first',inplace=True)

检验空值

df.isnull().any()
true这一列有空值
False这一列无空值

groupby

• groupby之后如果不用Multindex，则as_index=False或者reset_index()

1.grouped = data.groupby(['x1', 'x2'], as_index=False).sum()
2.grouped = data.groupby(['x1', 'x2']).sum().reset_index()

• 分组后只选取某一个分组

In [16]: df3 = pd.DataFrame({'X' : ['A', 'B', 'A', 'B'], 'Y' : [1, 4, 3, 2]})

In [17]: df3.groupby(['X']).get_group('A')
Out[17]: 
   X  Y
0  A  1
2  A  3

• 统计D列的sum和mean做为新的特征（也可以通过groupby().sum().reset_index()来实现）

In [58]: grouped['D'].agg({'result1' : np.sum,
   ....:                   'result2' : np.mean})
   ....: 
Out[58]: 
      result2   result1
A                      
bar  0.306945  0.920834
foo -0.344944 -1.724719

train_df = pd.read_csv('train_transaction.csv',nrows =200)
#ProductCD字符类别特征，card4字符类别特征，card6字符类别特征，card2是数值型特征
tmp = pd.DataFrame(train_df.groupby(['ProductCD','card4']).size()).reset_index()#以['ProductCD','card4']进行分组之后，每组的大小是多少

tmp = pd.DataFrame(train_df.groupby(['ProductCD','card4'])['card6'].nunique()).reset_index()#以['ProductCD','card4']进行分组之后的不同的card6元素有几个

tmp_1 = pd.DataFrame(train_df.groupby(['ProductCD','card4'])['card2'].mean()).reset_index()#以['ProductCD','card4']进行分组之后的card2的均值是多少

print( pd.DataFrame(train_df.groupby('ProductCD').mean()).reset_index())#所有数值列都会被聚合,不是数值数据从结果中排除

apply

In [126]: grouped = df.groupby('A')['C']

In [127]: def f(group):
   .....:     return pd.DataFrame({'original' : group,
   .....:                          'demeaned' : group - group.mean()})
   .....: 

In [128]: grouped.apply(f)
Out[128]: 
   demeaned  original
0 -1.425665 -0.919854
1 -0.190202 -0.042379

统计列内的值以及出现次数

dic = dict(df["aid"].value_counts())#统计列元素的值的个数
aid_list=list(dic.keys())#aid
ad_exposure_num=list(dic.values())#次数

dataframe切片

• 选取特定行

df[1:4]选取了1,2,3行
df.loc[[1:4]]选取了1,2,3行
df.iloc[[1:4]]选取了1,2,3行
df.ix[[0,1]]

• 选取特定列

df[['a','c']]选取索引为a和c的两列
df.loc[:,['a',''c]]
df.iloc[:,[0,1]]
df.ix[:,[0,1]]

• 选取特定的行和列

df.loc[0,'c']
df.loc[1:4,['a','c']]
df.loc[[1,3,5],['a','c']]
iloc和loc的区别在于：iloc用列名的index来选取列，而loc用列名来选取列

df.iloc[1:4,[0,2]]
df.iloc[[1,3,5],[0,2]]

ix的功能更加强大，参数既可以是索引，也可以是名称
df.ix[1:3,['a','b']]
df.ix[[1,3,5],[0,2]]

• df.values返回的是numpy格式的数据，将dataframe转换为数组ndarray格式

df是一个二维数据
df.values返回的就是一个二维数组
df['某一列'].values返回的是一个一维list，shape=(n,)
df['某一列'].values.reshape(-1,1) 返回的二维数组，shape=(n,1)

• 取前n行

df.head(n)

dataframe筛选值

• 按属性条件筛选整行（一般用于筛选某些特定的行）

格式为df[选取的行或者列][约束]
1. df[df['a']>30]满足约束的所有数据都输出
2. df[['b','c']][df['a']>30]满足约束的数据的bc两列

筛选条件部分：ix iloc loc不要用，尽量只用df[]来表示筛选条件
3. 按照某属性的某些值进行筛选
df[['b','c']][df.a.isin([30, 54])]
4. 多条件筛选 &连接
df[(df['a'] > 30) & (df['b'] > 40)]

• df.groupby(5,sort=False)[5].mean()的意思是dataframe按照第5列的元素进行分组，分组后取第五列做各自的mean()处理然后输出
• df.groupby(5,sort=False)[5].size()统计各组的个数然后输出
• temp=df.sort_index(by=5,ascending=False) print(temp)dataframe按照第五列进行降序排列
• 转置df.T

dataframe删除行，列

• 按照索引删除dataframe的任意维度的值df=df.drop(一个或者一个list的索引值如'a',axis=0,1,2,3指定维度)

注意：newframe=frame.drop(…) frame本身不变，变的是newframe

dataframe与array的转换

• pandas转arrayarray=np.array(pd)或者dataframe.values
• array转pandaspd.DataFrame(array)只不过是默认索引

dataframe组合变换

• pd.merge(dataframe1,dataframe2)是合并数据

merge  通过键拼接列:

pandas找不到能够进行合并的列。如果进行合并，
其实有两个思路可以考虑。第一种是根据现在的数据重新创建列名一致的数据对象，
然后进行新的数据对象合并。
但是，这样在一定程度上来说就不是对最原始的数据进行处理了。不过，很多时候或许这也是一个值得考虑的手段。
另外一种方法就是利用pandas自带的功能，
在进行数据合并的时候直接指明需要合并的列的名称
 pd.merge(df1,df2,left_on='key1:',right_on='key2')

• join 拼接列，主要用于索引上的合并

1.默认按索引合并，可以合并相同或相似的索引，不管他们有没有重叠列。

2.可以连接多个DataFrame

3.可以连接除索引外的其他列

4.连接方式用参数how控制

5.通过lsuffix='', rsuffix='' 区分相同列名的列

• concat 可以沿着一条轴将多个对象堆叠到一起

轴向连接 pd.concat() 就是单纯地把两个表拼在一起，这个过程也被称作连接（concatenation）、绑定（binding）或堆叠（stacking）。因此可以想见，这个函数的关键参数应该是 axis，用于指定连接的轴向。
在默认的 axis=0 情况下，pd.concat([obj1,obj2]) 函数的效果与 obj1.append(obj2) 是相同的；
而在 axis=1 的情况下，pd.concat([df1,df2],axis=1) 的效果与 pd.merge(df1,df2,left_index=True,right_index=True,how='outer') 是相同的。
可以理解为 concat 函数使用索引作为“连接键”。

dataframe与series的拼接

• series->dataframe

list1=np.array(np.ones(5))
list2 = np.array(np.zeros(5))
#list转换成Series
bb=pd.Series(list2)
aa = pd.Series(list1)
#Series转换成dataframe
aa=aa.to_frame(name=None)
bb = bb.to_frame(name=None)
#Series转换成带有column的dataframe
aa=pd.DataFrame(aa,columns=['a'])
bb = pd.DataFrame(bb, columns=['b'])
#dataframe拼接
final=pd.concat([bb, aa], axis=1)
#index=false是不带索引的写入csv
final.to_csv("temp.csv", index=False, sep=',')

• dataframe->series

series=frame.ix[0]

datarframe算术运算与dataframe对齐

• add

1.已对齐
frame1.add(frame2)
2.未对齐
frame1.add(frame2,fill_value=0)
最终的行和列都按照max(frame1,frame2)取，缺失值可以自己设

• sub
• div
• mul 对应元素相乘，而不是矩阵相乘

series

创建series

通过传递一个list对象来创建Series，创建默认的0---N-1的整型索引；
a = Series([4, 7, -5, 3])


创建一个带有索引来确定每一个数据点的Series ;
b = Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
print u'创建带有索引的Series:'
print b

如果你有一些数据在一个Python字典中，你可以通过传递字典来创建一个Series；
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
c = Series(sdata)
print u'通过传递字典创建Series:'
print c
states = ['California', 'Ohio', 'Oregon', 'Texas']
d = Series(sdata, index=states)

直接传入一个字典创建series
obj=series(dict)

取出series的值

• 查看series的所有值或者所有索引
  obj.values ----- obj.index
• 通过索引查找一个或者一组值
  obj[一个索引或者一个索引list]
• 通过索引来判断某值在不在series中
  'b' in obj如果在返回True
• NAN值处理,检测缺失数据
  pd.isnull()判断是不是nan，pd.notnull()

series变换

• 两个series拼接
  obj1+obj2如果这两个series的有些元素是重复的，就自动舍弃重复的部分

series与list的转换

#list转换成Series
bb=pd.Series(list2)
#将Series转换成list
list=np.array(Series)