参考老师：http://www.cnblogs.com/wupeiqi
lambda表达式学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：
#普通条件语句if1 == 1:
name= ‘luotianshuai'else:
name='shuaige'#三元运算name ='luotianshuai'if1 == 1else'shuaige'#这个就是if else的一个简写。#if 条件成立的时候name为'luotianshuai' 不成立的时候为：'shuaige' ，语法糖！
那么函数有没有他的简写呢？也是有的lambda表达式！
lambda 和if else的三元运算一样，是为了简化函数，但是:
1、只能做简单的操作
2、自动return
看下面两个函数的对比：
'''正常函数'''deffunc(arg):returnarg + 1result= func(100)PRintresult'''lambda表达式'''func2=lambdaa: a + 1result= func2(10000)#这里调用函数的时候就是lambda表达式左边的等号就是他函数的调用！printresult#执行结果：#101#10001
内置函数 二一、map
遍历序列，对序列中每个元素进行操作，最终获取新的序列。
解释：
在Python中，最基本的数据结构是序列（sequence）。序列中的每个元素被分配一个序号——即元素的位置，也称为索引。第一个索引是 0，第二个则是 1，以此类推。序列中的最后一个元素标记为 -1，倒数第二个元素为 -2，一次类推。
Python包含 6 中内建的序列，包括列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。
'''例子1'''li= [11,22,33]deffunc1(arg):returnarg + 1#这里乘除都可以new_list= map(func1,li)#这里map调用函数，函数的规则你可以自己指定，你函数定义成什么他就做什么操作！printnew_list
输出结果：[12, 23, 34]'''例子2'''li= ['shuaige','nihao',]deffunc1(arg):return'%s test string'% arg#或者使用+进行拼接万恶的+能不用最好不用他会在内存中开辟新的空间！new_strlist=map(func1,li)printnew_strlist
输出结果：['shuaige test string','nihao test string']'''例子3'''li='abcdefg'deffunc1(arg):return'%s test string'%arg
new_list=map(func1,li)printnew_list#结果：['a test string', 'b test string', 'c test string', 'd test string', 'e test string', 'f test string', 'g test string']
map例子
使用lambda表达式：
li = [11,22,33,44,55]
new_li= map(lambdaa:a + 100,li)printnew_li#输出结果： [111, 122, 133, 144, 155]#多个列表操作：l1 = [11,22,33,44,55]
l2= [22,33,44,55,66]
l3= [33,44,55,66,77]printmap(lambdaa1,a2,a3:a1+a2+a3,l1,l2,l3)#输出结果： [66, 99, 132, 165, 198]#这里需要注意如果使用map函数列表中的元素必须是相同的才可以!否则就会报下面的错误！#TypeError: unsupportedOperand type(s) for +: 'int' and 'NoneType'，如果看下面l1 = [11,22,33,44,55]
l2= [22,33,44,55,66]
l3= [33,44,55,66,]#l3的数据少一个，如果元素里的元素为空那么他调用的时候这个元素就是None
lambda表达式
二、filter
对于序列中的元素进行筛选，最终获取符合条件的序列！
li = [11,22,33,44,55,66,77,88]printfilter(lambdaa:a>33,li)
输出结果：[44, 55, 66, 77, 88]
三、reduce
对于序列内所有元素进行累计操作
li = [1,2,3,4,5,6,7,8]
result= reduce(lambdaa1,a2:a1+a2,li)#累乘、除、加、减printresult#reduce的第一个参数，函数必须要有两个参数，因为他是两两进行操作#reduce的第二个参数，要循环的序列#reduce的第三个参数，初始值#初始值li = [1,2,3,4,5,6,7,8]
result= reduce(lambdaa1,a2:a1+a2,li,100000)#累乘、除、加、减printresult
默认参数：
yield生成器yield和return的区别：
yield跳出函数后会记录当前函数的状态当下次调用的时候，从记录的状态开始！
return后将直接跳出函数！
1、对比range 和 xrange 的区别
>>>printrange(10)
[0,1, 2, 3, 4, 5, 6, 7, 8, 9]>>>printxrange(10)
xrange(10)
如上代码所示，range会在内存中创建所有指定的数字，而xrange不会立即创建，只有在迭代循环时，才去创建每个数组。
看下下面的例子：（自定义生成器）
defmrange(arg):
seed=0whileTrue:
seed= seed +1ifseed >arg:returnelse:yieldseedforiinmrange(10):printi
冒泡算法
需求：请按照从小到大对列表 [13, 22, 6, 99, 11] 进行排序
思路：相邻两个值进行比较，将较大的值放在右侧，依次比较！
冒泡算法原理图：
冒泡算法实例：
列表中有5个元素两辆进行比较，然后用中间值进行循环替换！
既然这样，既然这样我们还可以用一个循环把上面的循环进行在次循环，用表达式构造出内部循环！
li = [13,22,6,99,11]forninrange(1,len(li)):forminrange(len(li)-n):
num1=li[m]
num2= li[m+1]ifnum1 >num2:
temp=li[m]
li[m]=num2
li[m+1] =tempprintli
让的原理和下面一样：
li = [13,22,6,99,11]forminrange(4):#等价于：for m in range(len(li)-1)num1 =li[m]
num2= li[m+1]ifnum1 >num2:
temp=li[m]
li[m]=num2
li[m+1] =tempprintliforminrange(3):#等价于：for m in range(len(li)-2)num1 =li[m]
num2= li[m+1]ifnum1 >num2:
temp=li[m]
li[m]=num2
li[m+1] =tempprintliforminrange(2):#等价于：for m in range(len(li)-3)num1 =li[m]
num2= li[m+1]ifnum1 >num2:
temp=li[m]
li[m]=num2
li[m+1] =tempprintliforminrange(1):#等价于：for m in range(len(li)-4)num1 =li[m]
num2= li[m+1]ifnum1 >num2:
temp=li[m]
li[m]=num2
li[m+1] =tempprintli
冒泡算法原理
装饰器装饰器是函数，只不过该函数可以具有特殊的含义，装饰器用来装饰函数或类，使用装饰器可以在函数执行前和执行后添加相应操作。
简单的来说在不修改原函数的情况下，在对原函数进行包装！
一、初创公司有N个业务部门，1个基础平台部门，基础平台负责提供底层的功能，如：数据库操作、redis调用、监控API等功能。业务部门使用基础功能时，只需调用基础平台提供的功能即可。如下：
############### 基础平台提供的功能如下 ###############
def f1():
print 'f1'
def f2():
print 'f2'
def f3():
print 'f3'
def f4():
print 'f4'
############### 业务部门A 调用基础平台提供的功能 ###############
f1()
f2()
f3()
f4()
############### 业务部门B 调用基础平台提供的功能 ###############
f1()
f2()
f3()
f4()
目前公司有条不紊的进行着，但是，以前基础平台的开发人员在写代码时候没有关注验证相关的问题，即：基础平台的提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构，为平台提供的所有功能添加验证机制，即：执行功能前，先进行验证。
老大把工作交给 Low B，他是这么做的：
跟每个业务部门交涉，每个业务部门自己写代码，调用基础平台的功能之前先验证。诶，这样一来基础平台就不需要做任何修改了。
当天Low B 被开除了...
老大把工作交给 Low BB，他是这么做的：
只对基础平台的代码进行重构，让N业务部门无需做任何修改
############### 基础平台提供的功能如下 ###############deff1():#验证1#验证2#验证3print'f1'deff2():#验证1#验证2#验证3print'f2'deff3():#验证1#验证2#验证3print'f3'deff4():#验证1#验证2#验证3print'f4'############### 业务部门不变 ################## 业务部门A 调用基础平台提供的功能###f1()
f2()
f3()
f4()### 业务部门B 调用基础平台提供的功能 ###f1()
f2()
f3()
f4()
修改原基础平台代码
过了一周 Low BB 被开除了...
老大把工作交给 Low BBB，他是这么做的：
只对基础平台的代码进行重构，其他业务部门无需做任何修改
############### 基础平台提供的功能如下 ###############defcheck_login():#验证1#验证2#验证3passdeff1():
check_login()print'f1'deff2():
check_login()print'f2'deff3():
check_login()print'f3'deff4():
check_login()print'f4'
新建立一个函数把函数应用到原基础函数上
老大看了下Low BBB 的实现，嘴角漏出了一丝的欣慰的笑，语重心长的跟Low BBB聊了个天：
老大说：
写代码要遵循开发封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：
封闭：已实现的功能代码块开放：对扩展开发如果将开放封闭原则应用在上述需求中，那么就不允许在函数 f1 、f2、f3、f4的内部进行修改代码，老板就给了Low BBB一个实现方案：
def w1(func):
def inner():
# 验证1
# 验证2
# 验证3
return func()
return inner
@w1
def f1():
print 'f1'
@w1
def f2():
print 'f2'
@w1
def f3():
print 'f3'
@w1
def f4():
print 'f4'
对于上述代码，也是仅仅对基础平台的代码进行修改，就可以实现在其他人调用函数 f1 f2 f3 f4 之前都进行【验证】操作，并且其他业务部门无需做任何操作。
Low BBB心惊胆战的问了下，这段代码的内部执行原理是什么呢？
老大正要生气，突然Low BBB的手机掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一紧一抖，喜笑颜开，交定了Low BBB这个朋友。详细的开始讲解了：
单独以f1为例：
def w1(func):
def inner():
print 'gongneng1'
func()
print 'gongneng2'
return inner
@w1
def f1():
print 'f1'
f1()
当执行的时候，python是由上到下执行的，首先执行到def w1(func):这里把def w1(func)加载到内存
当执行到@w1的时候@w1是python的语法糖！他会把他下面的函数进行封装。
把f1这个函数作为def w1(func)的参数传进去！就是：f1()=w1(f1)
然后def w1(func): == w1(f1)就会执行：
def inner():
print 'gongneng1'
func() #func() == f1()“原函数”
print 'gongneng2'
return inner #然后把封装后的函数输出给原函数
@w1就相当于做了一个替换
def f1() <==> def inner()
@w1
def f1(): # ==def inner() :
print 'f1' # print 'gongneng1'
# func()
# print 'gongneng2'
二、被装饰的函数如果有参数呢？
def w1(func):
def inner(arg):
# 验证1
# 验证2
# 验证3
return func(arg)
return inner
@w1
def f1(arg):
print 'f1'
一个参数
################################
def w1(func):
def inner(arg1,arg2):
# 验证1
# 验证2
# 验证3
return func(arg1,arg2)
return inner
@w1
def f1(arg1,arg2):
print 'f1'
两个参数
################################
def w1(func):
def inner(arg1,arg2,arg3):
# 验证1
# 验证2
# 验证3
return func(arg1,arg2,arg3)
return inner
@w1
def f1(arg1,arg2,arg3):
print 'f1'
三个参数
用动态参数搞定！
def w1(func):
def inner(*args,**kwargs):
# 验证1
# 验证2
# 验证3
return func(*args,**kwargs)
return inner
@w1
def f1(arg1,arg2,arg3):
print 'f1'
三、一个函数可以被多个装饰器装饰吗？
def w1(func):
def inner(*args,**kwargs):
print 'gongneng1'
func(*args,**kwargs)
print 'gongneng2'
return inner
def w2(func):
def inner(*args,**kwargs):
print 'gongneng3'
func(*args,**kwargs)
print 'gongneng4'
return inner
@w1
@w2
def f1(arg,arg2,arg3):
print arg,arg2,arg3
f1('nihao','tianshuai','shuaige')
输出结果：
gongneng1
gongneng3
nihao tianshuai shuaige
gongneng4
gongneng2
这个被多个装饰器装饰，其实就是套完一层在套一层！勿把自己绕进去！
四、还有什么更吊的装饰器吗？
def Filter(a1,a2):
def outer(main_func):
def wrapper(request,kargs):
print a1
main_result = main_func(request,kargs)
print a2
return main_result
return wrapper
return outer
@Filter(f5, f6)
def Index(request,kargs):
print 'index'
'''
1、第一步：把def Filter(a1,a2): 加载到内存
2、第二步：@Filter(f5, f6) == 调用了装饰器 == @outer 然后返回给函数
3、第散步：执行outer函数并返回给index函数 Index == wrapper
4、执行wrapper 函数，这样做的意义就是除了原函数给的参数外，装饰器也可以调用自己定义的参数
'''
这样做的意义就是除了原函数给的参数外，装饰器也可以调用自己定义的参数