索引、分组与多表组合

1. 索引的设置与逆操作

• set_index：给当前的数据集设置索引
• reset_index：将当前的索引设置成列

注意几个参数

append：boolean,default False；Whether to append columns to existing index

drop：boolean,default True；Delete columns to be used as the new index

inplace：boolean,default False；Modify the DataFrame in place (do not create a new object)

 

2. 多重索引：

• 多重索引既可以作用于行，也可以作用于列

level：是我们选取层次索引的参数

df.loc的用法与单层索引类似

df.xs允许我们通过Level制定索引

slice

Indexslice

• 范围选取使用slice；指定选取直接使用列表；多重索引使用之前必须对索引进行排序（slice）

df.sort_index(level)

 

3. 分组计算

• Group By : split – apply – combine

split:很具某些条件对数据进行分组

apply:对每一个group独立的应用函数

combine：将结果数据组合到某种数据结构中

• Split：

groupby columns

groupby index

• Apply:
  • aggregation: 对每一个小组做一些统计上的计算。一次应用多个函数/对不同的column应用不同的函数
  • transformation: 对group做一些特别的计算。
    • 会返回一个数据集，这个数据集与group具有同样的索引以及大小
    • 举例说明：对数据集进行标准化：

zscore= lambda s : (s –s.mean()) / s.td()

transformed= df.groupby(key).transform(zscore)

• filtration:对group进行某些条件的过滤；
  • 返回原始数据集的一个子集
  • 举个例子：

过滤group的size

过滤group里某个元素指的和或者长度

 

• 遍历：遍历每一个group；选择某个group；其它的一些group特征

• 例子：小精灵游戏数据集

pokemon.head()      

pokemon.columns         #看一共有哪些列

len(pokemon['type1'].value_counts())      #想根据typeone种类分类，看下有那些种类，多少个种类

grouped1 = pokemon.groupby('Type 1')     #根据Type1进行分组

grouped1是一个groupby对象

grouped1.sum()

grouped1.median()                        #分组后计算每一个种类的其他属性平均值，中位值

grouped2 =pokemon.groupby(['Type1','Type2'])#有两种类型，想看下在Type1里再做一次分组Type2

grouped2.mean()

import numpy as np                       #标准库，与数值分析相关的库；np.mean

grouped2.aggregate([np.mean, np.median])['HP'] #加入需要aggregate的统计量,放到list of funtion 里，即加[]                                                                                       #aggregate 聚合，把想要求的function放在一起，使用多个统计量的时候[list of functions]/也可以用字典，只选['HP']属性

grouped2.agg({"HP":np.mean,"Sp.Atk":[np.sum,np.median]})   #针对不同的列做不同的统计量（函数）；dict of columns使用字典

grouped2.size()                                                    #group变量的特征， 每个小组的大小（有多少个样本）

grouped2.groups                                                        #每个索引对应的样本的索引位是多少，验证group2.loc[237]

grouped2.get_group("Bug", "Poison")            #取出对应索引对类别的所有小组

print(name)

print(group.shape)                                                  #循环迭代取出每个小组的大小  

for name,group in group2:

print(name)

print(group.shape)

 

#在不同的组内进行标准化

for name, group in grouped2:

zscore = lambda s :（s-s.mean()/s.std()) #标准化，s为每一个小组别

grouped1.transform(zscore)                                #分组完之后，写入刚才定义好的函数，会自动把非数值型属性过滤掉，把数值型属性拿出来计算

 

#过滤filter,需要group2每个小组别个数小于10

cond1 = lambda s : len(s)<10

groued2.filter(cond1)

groued2.filter(cond1).shape                                #查看当前分组样本数

 

pok1 = pokemon.set_index(['Type1','Type2']) #Type1,Type2设置为索引，对索引进行分组

pok1.groupby(level = [0,1])                           #groupby会在列里面找分组，level在索引上面进行分组？

 

4. 多表组合

• 几个重要的函数
• Concat

• Append

增加一个数据集；增加一行；增加一列；简化版concat,后面只能附一个数据集

• Merge

joiningkey columns

joiningkey indexes

joiningkey columns on indexes

merge()能够取代join(),类似于append()于concat()

• Join

组合dataframe 的一种快捷方式，它默认的是在索引上进行Join；

join有一个参数on，可以指定一个或者多个columns，但是这只对最左边的数据集有效，右边的数据集的key还是索引

• 内置函数

Enumerate(iterable,start = 0)

Returnan enumerate object. iterable must be a sequence, an iterator, or some otherobject which supports iteration. The __next__() method of the iterator returnedby enumerate() returns a tuple containing a count (from start which defaults to0) and the values obtained from iterating over iterable

Zip()

Makean iterator that aggregates elements from each of the iterables.

Returnsan iterator of tuples, where the i-th tuple contains the i-th element from eachof the argument sequences or iterables. The iterator stops when the shortestinput iterable is exhausted. With a single iterable argument, it returns aniterator of 1-tuples

 

• 例子

• from pandas import DataFrame

df1 =DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],

'B':['B0', 'B1', 'B2', 'B3'],

'C':['C0', 'C1', 'C2', 'C3'],

'D':['D0', 'D1', 'D2', 'D3']},

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

df2 =DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],

'B':['B4', 'B5', 'B6', 'B7'],

'C':['C4', 'C5', 'C6', 'C7'],

'D':['D4', 'D5', 'D6', 'D7']},

index=[4,5, 6, 7])

df3 =DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],

'B':['B8', 'B9', 'B10', 'B11'],

'C':['C8', 'C9', 'C10', 'C11'],

'D':['D8', 'D9', 'D10', 'D11']},

index=[8,9, 10, 11])

pd.concat([df1,df2,df3])                     #上下组合df1,2,3，保留原来的索引值

pd.concat([df1,df2，df3],axis= 1)#左右组合df1,df2,通过相同的索引位进行组合,注意索引是否一致，否则按照索引添加Nan！

df1.append(df2) #方法二，append“悬挂”，append是concat一个简便形式后面只能附一个数据集

 

• left = DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],

'key2':['K0', 'K1', 'K0', 'K1'],

'A':['A0', 'A1', 'A2', 'A3'],

'B':['B0', 'B1', 'B2', 'B3']})

right= DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],

'key2':['K0', 'K0', 'K0', 'K0'],

'C':['C0', 'C1', 'C2', 'C3'],

'D':['D0', 'D1', 'D2', 'D3']})

#pandas里的函数merge()，每次只能对两个数据集（左右）进行操作，how=inner为默认,on左右两边的key

pd.merge(left,right, on = "key1", how= "inner")

#how=inner,两张表join时地位是需要平等的，主键on="key1"在两张表中都要出现，多对一和一对多没关系。how="left"以左边的表为主表，"right"，当主键左右两边的值都有的时候，那么没有区别。how = "outer"，不相等的值要设为missingvalue

pd.merge(left,right, on = ['key1','key2'],how = "left")#这里用两个主键，以左边的表为主表，右边表没有出现的值为missing value

right1 = right.rename(columns ={"key1":"key1_new","key2":"key2_new")#rename()      #重新命名

pd.merge(left,right1, left_on =['key1','key2'], right_on=["key1_new","key2_new"], how ="left") #两张表变量名称不一样如何操作?不一样的名字都会打印出来，left,right键的位置和数量一样

left_Index = left.set_index(["key1","key2"])     #左边表把列设置为索引

pd.merge(left_Index,right1, left_index =True,right_on=["key1_new","key2_new"], how = "left") #left_index设置成True，需要一一对应，左边数据集使用索引位，右边使用列名，进行merge组合

 

• 融360

user_info=pd.rea_csv("",header=Nnoe,names=["id","sex","job","education"，"marriage","hukou"])

id=User_info['id']

user_info.shape

len(id.unique())                     #id里面唯一的值有哪些

bank_detail=pd.read_csv("bank_detail_train.txt",header=None,names=["id","time","type0fTrans","incomeType")             #银行流水信息，并不是每一个用户都有流水信息，蛋都要进行分析，所以第一个表user_info始终作为主表

bank_detail.head()

user_bank=pd.merge(user_info,bank_detail,on=["id"],how="left") #保证的是用户的信息被完整保存下来，哪怕他没有银行的账单信息，所以用left

user_bank.shape                       #数据量很大

#信用卡记录

credit_detail=pd.read_csv("bill_detail_train.txt",header=None,names=[

"id","billTime","bankId","lastBillAmount",

"lastPaiedAmount","creditCardAmount","currentBillRemaining",

"currentBillMinPaied","consumeTimes","currentBillAmount",

"adjustAmount","recurrentInterest","aviliableRemaining",

"preCashAmount","payStatus"]

)

credit_detail

#银行记录

bank_detail.head()

#计算每一个ID的支出和收入差，对每个ID做分组，支出和收入做分组

grouped3=bank_detail.groupby(['id','typeOfTrans'])#typeOfTrans，0为支出，1为收入

grouped3["amountOfTrans"].sum()

a=Grouped3["amountOfTrans"].sum().unstack()    #把typeOfTrans的取值变为列，0，1为列

a.rename(columns={a.columns[0]:"shouru",a.columns[1]:"zhichu"},inplace=True)

a['diff']=a["zhichu"]-a["shouru"]

grouped4=bank_detaail.groupby("id")

grouped4.count()

credit_detail.head()

#上期借款是否还完

#不同银行卡，每个用户本期银行卡欠了多少钱

grouped_credit=credit_detaail.groupby("id")

grouped_credit["currentBillAmount"].sum()#本期欠款总额

#会逾期的用户会有哪些特征，想方设法造特征，算法和模型在整个项目中起到的作用微乎其微

 

zip()拉链

a=[1,2,3,4]

b=["a","b","c","d"]

for i in zip(a,b):

print(i)

#（迭代器）返回的对应的元祖，数量不对应则丢弃掉不完整的

for i ，j inenumerate（b）:

print(i,j)

#默认参数起始位为0

for i ，j inenumerate（b,10）:

print(i,j)

#设置起始位为10

 

#当有一列很长的数据时候，当不知道索引位时,可以使用这个看下索引是什么

id=user_info.id

for i,j in enumerate(id):

print(I,j)

a.stack().unstack()

 

5. 使用透视进行数据重组

• Stack and Unstack

stack: “pivot” a level of the (possibly hierarchical) column labels,returning a DataFrame with an index with a new inner-most level of row labels.

unstack: inverse operation from stack: “pivot” a level of the(possibly hierarchical) row index to the column axis, producing a reshapedDataFrame with a new inner-most level of column labels.

• 
  

 

• 例子：

pd.pivot_table?

pd.pivot_table(data=pokemon,index="Type1",columns='Type2',values=['HP','Total'],aggfunction=[np.sum,np.mean],margins=True)                                  #默认aggfunction为mean,margins汇总

pokemon.columns

 

6. 交互表

计算频数？两个分类变量的交叉二元表

pd.crosstab(index=pokemon['Type1'],columns=pokemon['Type2'],margins=True)

pd.get_dummies(data=pikemon,columns=['Type1','Type2'])

 

7. pandas常用函数