python函数进阶和Sklearn机器学习学习笔记

本次主要针对lambda匿名函数，map函数，filter函数，
zip函数，enumerate函数的使用方法还有数据挖掘的一些代码笔记整理，以及一些零碎的知识点。

lambda匿名函数
定义一个简单函数，如果你的函数非常简单，只有一个表达式，不包含命令，可以考虑lambda函数。
否则，你还是定义函数才对，毕竟函数没有这么多限制。不能使用复杂语句。
不能包含分支或循环（但允许条件表达式），也不能包含return（或yield）函数。如果为元组，则应用圆括号将其包含起来。

f = lambda x: x+5
f(5)
>>
10

map函数
会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

def square(x) :
    return x ** 2
map(square, [1,2,3,4,5]) #生成迭代器
>><map at 0x1b2a8b52978>
list(map(square, [1,2,3,4,5]) )
>>
[1, 4, 9, 16, 25]

def add(x,y,z):
    return x+y+z
list1 = [1,2,3]
list2 = [1,2,3,4]
list3 = [1,2,3,4,5]
rs = map(add,list1,list2,list3)#把add函数作用到后面所有的列表上
print(list(rs))
>>
[3, 6, 9]

filter函数
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判， 然后返回 True 或 False，最后将返回 True 的元素放到新列表中。 filter(function, iterable)
function – 判断函数。
iterable – 可迭代对象

def is_odd(n):
    return n % 2 == 1
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
>>
[1, 3, 5, 7, 9]

zip函数
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
zip作用的键可以转为列表、字典，如c = dict(zip(a,b))， c=list(zip(a,b))
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
list(zip(a,b))     # 打包为元组的列表
>>
[(1, 4), (2, 5), (3, 6)]
list(zip(*zip(a,b)))  # 与 zip 相反，*zip 可理解为解压，返回二维矩阵式
>>
[(1, 2, 3), (4, 5, 6)]
c = dict(zip([1,2],[3,4]))
print(c)
>>
{1: 3, 2: 4}

enumerate函数
python中的enumerate()函数用于将一个可便利的数据对象（如列表、元组合字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中。

seasons = ['spring','summer','fall','winter']
list(enumerate(seasons))
>>
[(0, 'spring'), (1, 'summer'), (2, 'fall'), (3, 'winter')]
list(enumerate(seasons,start=1))#下标从1开始
>>
[(1, 'spring'), (2, 'summer'), (3, 'fall'), (4, 'winter')]

易错笔记：

def test_fun(a,b = 6,*c,**d):
    print("a =",a,",b =",b,"c =",c,",d =",d)#一个星号是元组，两个星号是字典
test_fun(1)
>>
>a = 1 ,b = 6 c = () ,d = {}

test_fun(a=1,b=2,c=3)
>>
a = 1 ,b = 2 c = () ,d = {'c': 3}

test_fun(a=1,b=2,c=3,d=4)
>>
a = 1 ,b = 2 c = () ,d = {'c': 3, 'd': 4}

test_fun(1,2,3,4,b=8)#报错，不能用之前的b，又赋值2，又赋值8

Sklearn机器学习笔记代码部分：

import numpy as np
import matplotlib.pyplot as plt

#波士顿数据集
from sklearn import datasets
boston = datasets.load_boston()#加载波士顿房价数据
boston.data###要输入

import pandas as pd
boston_df = pd.DataFrame(boston.data,columns = boston.feature_names)
boston_df.head(20)
#转化为数据框并使用
from sklearn import datasets
boston = datasets.load_boston()
bostondf = pd.DataFrame(boston.data,columns = boston.feature_names)
bostondf.head(20)###要输入

from sklearn import preprocessing
std = preprocessing.StandardScaler()
std.fit(boston_df)
std.mean_, std.scale_#fit之后求出了原始数据每列的均值和标准差
std.transform(boston_df)
std.transform(boston_df[:3])

boston_df.head()
boston_df.describe()

boston_scaled = preprocessing.scale(boston_df)
boston_scaled
boston_scaled.mean(axis = 0)
boston_scaled.std(axis = 0)
boston_scaled_all = preprocessing.scale(boston_df,axis=1)
boston_scaled_all.mean(axis = 0)
boston_scaled_all.std(axis = 0)
boston_scaled_all = preprocessing.scale(boston_df,axis=1)#即标准化用到的均值与标准差取整个矩阵所有元素的均值与标准差
boston_scaled_all.mean(),boston_scaled_all.std()
preprocessing.scale(boston.target)#scale函数还可以对单独某一列进行标准化

scaler = preprocessing.MinMaxScaler((1,10))
scaler.fit_transform(boston_df)
scaler_1 = preprocessing.MaxAbsScaler()
scaler_1.fit_transform(boston_df)
 
x = [[-1,-1,2]]
x_normalized = preprocessing.normalize(x,norm='l2',return_norm = True)#是l2，不是十二
x_normalized
 
#数据集导出
#digits = datasets.load_digits()
#digits.images[100]
#plt.matshow(digits.images[999])

#6实例化
from sklearn import preprocessing
std = preprocessing.StandardScaler()
std.get_params()###要输入
std.fit(boston.data)
std.mean_###要输入
std.var_###要输入
ZX = std.transform(boston.data)
ZX[:2]###要输入
std.fit_transform(boston.data)[:2]###要输入

from sklearn import linear_model
reg = linear_model.LinearRegression()
reg.fit(boston.data,boston.target)
reg.coef_###要输入
pred = reg.predict(boston.data)
pred[:10]###要输入
reg.score(boston.data,boston.target)###要输入
preprocessing.scale(boston.data)[:2]###要输入

#模型的保存
#from sklearn.externals import joblib
#joblib.dump(std,'f:\std.pkl')
#joblib.dump(reg,'f:\reg.pkl')
#reg2 = joblib.load('f:\reg.pkl')
#reg2.coef_

#缺失值处理
imp = preprocessing.Imputer()
imp.fit([[1,2],[np.nan,3],[7,6]])
imp.statistics_
imp.transform([[np.nan,2],[6,np.nan]])

#生成多项式特征
poly = preprocessing.PolynomialFeatures(interaction_only=True)
poly_res = poly.fit_transform(boston_df.iloc[:,[0,1,2,3]])
poly_res[:1]
poly = preprocessing.PolynomialFeatures(interaction_only=True)
poly_res = poly.fit_transform(boston_df)
poly_res[:1]

#自定义转换器
trans = preprocessing.FunctionTransformer(np.sqrt)
x = np.array([[1,2],[3,4]])
trans.transform(x)

#基于单变量检验进行筛选
from sklearn import feature_selection
sele = feature_selection.SelectKBest(feature_selection.f_regression,k = 2)
sele.fit_transform(boston.data,boston.target)