python 评分卡建模记录---使用到的各种函数（1）

用python评分卡建模过程中使用到的numpy 和pandas中的方法

（一）python选取特定列——pandas的iloc和loc以及icol使用（列切片及行切片）

df是一个dataframe，列名为A B C D
具体值如下：
A    B    C     D
0    ss   小红  8
1    aa   小明  d
4    f          f
6    ak   小紫  7 

dataframe里的属性是不定的，空值默认为NA。
一、选取标签为A和C的列，并且选完类型还是dataframe
df = df.loc[:, ['A', 'C']]
df = df.iloc[:, [0, 2]]
二、选取标签为A/C并且只取前两行，选完类型还是dataframe
df = df.loc[0:2, ['A', 'C']]  
df = df.iloc[0:2, [0, 2]] 
聪明的朋友已经看出iloc和loc的不同了：loc是根据dataframe的具体标签选取列，而iloc是根据标签所在的位置

"，"前面的"："表示选取整列，第二个示例中的的0:2表示选取第0行到第二行，这里的0:2相当于[0,2）前闭后开，2是不在范围之内
的。
需要注意的是，如果是df = df.loc[0:2, ['A', 'C']]或者df = df.loc[0:2, ['A', 'C']]，切片之后类型依旧是dataframe，不能直接进行
加减乘除等操作的，比如dataframe的一列是数学成绩(shuxue)，另一列为语文成绩(yuwen)，现在需要求两门课程的总和。

可以使用df['shuxue'] + df['yuwen']（选取完之后类型为series）来获得总分，而不能使用df.iloc[:,[2]]+df.iloc[:,[1]]或
df.iloc[:,['shuxue']]+df.iloc[:,['yuwen']]，这会产生错误结果。
还有一种方式是使用df.icol(i)来选取列，选取完的也不是dataframe而是series，i为该列所在的位置，从0开始计数。
如果你想要选取某一行的数据，可以使用df.loc[[i]]或者df.iloc[[i]]。

三、条件选择子集（后进行计算）

1.如选择列‘feature’为‘key’的列‘woe’

feature_bin_woe[feature_bin_woe['feature']=='key']['WOE']

2. 对同一列满足不同条件行做不同计算

df['a1'] = np.where(df.a1 >0,df['a2']-df['a3'],0)

 

（二）merge  通过键拼接列

pandas提供了一个类似于关系数据库的连接(join)操作的方法merage,可以根据一个或多个键将不同DataFrame中的行连接起来
语法如下

[python] view plain copy

1. merge(left, right, how='inner', on=None, left_on=None, right_on=None,  
2.       left_index=False, right_index=False, sort=True,  
3.       suffixes=('_x', '_y'), copy=True, indicator=False)  

用于通过一个或多个键将两个数据集的行连接起来，类似于 SQL 中的 JOIN。该函数的典型应用场景是，针对同一个主键存在两张包含不同字段的表，现在我们想把他们整合到一张表里。在此典型情况下，结果集的行数并没有增加，列数则为两个元数据的列数和减去连接键的数量。
on=None 用于显示指定列名（键名），如果该列在两个对象上的列名不同，则可以通过 left_on=None, right_on=None 来分别指定。或者想直接使用行索引作为连接键的话，就将 left_index=False, right_index=False 设为 True。
how='inner' 参数指的是当左右两个对象中存在不重合的键时，取结果的方式：inner 代表交集；outer 代表并集；left 和 right 分别为取一边。
suffixes=('_x','_y') 指的是当左右对象中存在除连接键外的同名列时，结果集中的区分方式，可以各加一个小尾巴。
对于多对多连接，结果采用的是行的笛卡尔积。

参数说明：
left与right：两个不同的DataFrame
how：指的是合并(连接)的方式有inner(内连接),left(左外连接),right(右外连接),outer(全外连接);默认为inner
on : 指的是用于连接的列索引名称。必须存在右右两个DataFrame对象中，如果没有指定且其他参数也未指定则以两个DataFrame的列名交集做为连接键
left_on：左则DataFrame中用作连接键的列名;这个参数中左右列名不相同，但代表的含义相同时非常有用。
right_on：右则DataFrame中用作 连接键的列名
left_index：使用左则DataFrame中的行索引做为连接键
right_index：使用右则DataFrame中的行索引做为连接键
sort：默认为True，将合并的数据进行排序。在大多数情况下设置为False可以提高性能
suffixes：字符串值组成的元组，用于指定当左右DataFrame存在相同列名时在列名后面附加的后缀名称，默认为('_x','_y')
copy：默认为True,总是将数据复制到数据结构中；大多数情况下设置为False可以提高性能

indicator：在 0.17.0中还增加了一个显示合并数据中来源情况；如只来自己于左边(left_only)、两者(both)

（三）dataframe 分组求和和计数

根据temp列分组后组内对target变量内的列名所指的列计数、求和

total = df2.groupby(['temp'])[target].count() 

total = df2.groupby(['temp'])[target].sum()

map根据现有列映射产生新列

df2['temp'] = df2[feature].map(lambda x: AssignGroup(x, split_x))  

(四)python DataFrame的apply方法

 

[python] view plain copy

1. #函数应用和映射  
2. import numpy as np  
3. import pandas as pd  
4. df=pd.DataFrame(np.random.randn(4,3),columns=list('bde'),index=['utah','ohio','texas','oregon'])  
5. print(df)  

 

 b         d         e
utah   -0.451195 -0.183451 -0.297182
ohio    0.443792  0.925751 -1.320857
texas   1.039534 -0.927392  0.611482
oregon  0.938760  1.265244  0.313582

 

 

[python] view plain copy

1. #将函数应用到由各列或行形成的一维数组上。DataFrame的apply方法可以实现此功能  
2. f=lambda x:x.max()-x.min()  
3. #默认情况下会以列为单位，分别对列应用函数  
4. t1=df.apply(f)  
5. print(t1)  
6. t2=df.apply(f,axis=1)  
7. print(t2)  

b    1.490729
d    2.192636
e    1.932339
dtype: float64
utah      0.267744
ohio      2.246608
texas     1.966925
oregon    0.951662
dtype: float64

[python] view plain copy

1. #除标量外，传递给apply的函数还可以返回由多个值组成的Series  
2. def f(x):  
3.     return pd.Series([x.min(),x.max()],index=['min','max'])  
4. t3=df.apply(f)  
5. #从运行的结果可以看出，按列调用的顺序，调用函数运行的结果在右边依次追加  
6. print(t3)  

b         d         e
min -0.451195 -0.927392 -1.320857
max  1.039534  1.265244  0.611482

[python] view plain copy

1. #元素级的python函数，将函数应用到每一个元素  
2. #将DataFrame中的各个浮点值保留两位小数  
3. f=lambda x: '%.2f'%x  
4. t3=df.applymap(f)  
5. print(t3)  

 b      d      e
utah    -0.45  -0.18  -0.30
ohio     0.44   0.93  -1.32
texas    1.04  -0.93   0.61
oregon   0.94   1.27   0.31

[python] view plain copy

1. #注意，这里之所以叫applymap,是因为Series有一个永远元素级函数的map方法  
2. t4=df['e'].map(f)  
3. print(t4)  

utah      -0.30
ohio      -1.32
texas      0.61
oregon     0.31
Name: e, dtype: object

（五）dataframe的set_index和reset_index

 

1.set_index

DataFrame可以通过set_index方法，可以设置单索引和复合索引。 
DataFrame.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False) 
append添加新索引，drop为False，inplace为True时，索引将会还原为列

 

[python] view plain copy

1. In [307]: data  
2. Out[307]:   
3.      a    b  c    d  
4. 0  bar  one  z  1.0  
5. 1  bar  two  y  2.0  
6. 2  foo  one  x  3.0  
7. 3  foo  two  w  4.0  
8.   
9. In [308]: indexed1 = data.set_index('c')  
10.   
11. In [309]: indexed1  
12. Out[309]:   
13.      a    b    d  
14. c                 
15. z  bar  one  1.0  
16. y  bar  two  2.0  
17. x  foo  one  3.0  
18. w  foo  two  4.0  
19.   
20. In [310]: indexed2 = data.set_index(['a', 'b'])  
21.   
22. In [311]: indexed2  
23. Out[311]:   
24.          c    d  
25. a   b            
26. bar one  z  1.0  
27.     two  y  2.0  
28. foo one  x  3.0  
29.     two  w  4.0  

2.reset_index

 

reset_index可以还原索引，从新变为默认的整型索引 
DataFrame.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill=”) 
level控制了具体要还原的那个等级的索引 
drop为False则索引列会被还原为普通列，否则会丢失

[python] view plain copy

1. In [318]: data  
2. Out[318]:   
3.          c    d  
4. a   b            
5. bar one  z  1.0  
6.     two  y  2.0  
7. foo one  x  3.0  
8.     two  w  4.0  
9.   
10. In [319]: data.reset_index()  
11. Out[319]:   
12.      a    b  c    d  
13. 0  bar  one  z  1.0  
14. 1  bar  two  y  2.0  
15. 2  foo  one  x  3.0  
16. 3  foo  two  w  4.0  

 

pandas contact 之后，一定要记得用reset_index去处理index,不然容易出现莫名的逻辑错误

如下：

 

[python] view plain copy

1. # -*- coding: utf-8 -*-  
2. import pandas as pd  
3. import sys  
4.   
5. df1 = pd.DataFrame({ 'A': ['A0', 'A1', 'A2', 'A3'],  
6.                      'B': ['B0', 'B1', 'B2', 'B3'],  
7.                      'C': ['C0', 'C1', 'C2', 'C3'],  
8.                      'D': ['D0', 'D1', 'D2', 'D3']})  
9.                        
10. df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],  
11.                      'B': ['B4', 'B5', 'B6', 'B7'],  
12.                      'C': ['C4', 'C5', 'C6', 'C7'],  
13.                      'D': ['D4', 'D5', 'D6', 'D7']})  
14.                        
15. df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],  
16.                      'B': ['B8', 'B9', 'B10', 'B11'],  
17.                      'C': ['C8', 'C9', 'C10', 'C11'],  
18.                      'D': ['D8', 'D9', 'D10', 'D11']})  
19.   
20. frames = [df1, df2, df3]  
21. result = pd.concat(frames)  

说明：直接contact之后，index只是重复，而不是变成我们希望的那样，这样在后续的操作中，容易出现逻辑错误。

使用result = result.reset_index(drop=True)来改变index就可以了,

(关于reset_index各个参数的详细讲解https://yq.aliyun.com/articles/420254)

或者也可以将 result = pd.concat(frames) 

这句话改成 result = pd.concat(frames,ignore_index=True)，就可以解决了

 

 

（六）DataFrame.to_dict(orient='dict')

 

 

将DataFrame格式的数据转化成字典形式
参数：当然参数orient可以是字符串{'dict', 'list', 'series', 'split', 'records', 'index'}中的任意一种来决定字典中值的类型
字典dict（默认）：类似于{列：{索引：值}}这样格式的字典
列表list：类似于{列：[值]}这种形式的字典
序列series：类似于{列：序列（值）}这种形式的字典
分解split：类似于{索引：[索引]，列：[列]，数据：[值]}这种形式的字典
记录records：类似于[{列：值}，...，{列：值}]这种形式的列表
索引index：类似于{索引：{列：值}}这种形式的字典
在新版本0.17.0中，允许缩写，s表示序列，sp表示分裂

 

返回：结果：像{列：{索引：值}}这种形式的字典

比如当关键字orient=’index’ 时 

形成{index -> {column -> value}}的结构，调用格式正好和’dict’ 对应的反过来，

data_index=data.to_dict(orient='index')

data_index
Out[43]: 
{12: {'age': 31.19418104265403,
  'embarked': 'Cherbourg',
  'home.dest': 'Paris, France',
  'pclass': '1st',
  'sex': 'female'},
 437: {'age': 48.0,
  'embarked': 'Southampton',
  'home.dest': 'Somerset / Bernardsville, NJ',
  'pclass': '2nd',
  'sex': 'female'},
 507: {'age': 31.19418104265403,
  'embarked': 'Southampton',
  'home.dest': 'Petworth, Sussex',
  'pclass': '2nd',
  'sex': 'male'}}