lambda表达式

这个表达式其实和三院运算一样，就是为了提高python的处理速度和简化代码用的。

但是lamda函数只能处理简单的逻辑

例如以下函数

def s(x):
    return x+1
print s(1)
2

如果用lambda表达式写就可以简化为

s=lambda x:x+1
print s(1)
2

同理，如果有多个参数可以写成

s=lambda x,y:x+y
print s(1,2)
3


map()函数

map函数的作用是对序列中每个元素都进行操作，并生成新的序列

python培训day4 随便_day4

map()括号里第一个参数要求是个函数，第二个参数要求是个序列。

如下面的例子，对序列li中的每个元素都添加100

li=[1,2,3,4,5]
s=lambda x:x+100
new_list=map(s,li)
print new_list
[101, 102, 103, 104, 105]

如果有两个序列，注意序列里元素的个数要一致，不然就会报错。

li=[1,2,3,4,5]
xi=[10,20,30,40,50]
s=lambda x,y:x+y
new_list=map(s,li,xi)
print new_list
[11, 22, 33, 44, 55]


filter()函数

filter函数的作用是按照一定的规则过滤序列中的元素容，并生成新的序列

python培训day4 随便_day4_02

filter()中有两个参数。第一个参数要求是个函数，第二个参数是个序列。对序列中元素的过滤条件就要通过函数来定义

例如要将序列中大于22的数字取出来

li=[1,5,11,22,81,100]
s=lambda x:x>22
new_list=filter(s,li)
print new_list
[81, 100]

或者这样写

li=[1,5,11,22,81,100]
def s(x):
    if x > 22:
        return x
new_list=filter(s,li)
print new_list
[81, 100]

如果过滤条件写入None，则打印原序列。但是回将序列中的空值去掉

li=[1,5,11,22,81,100,'',' ','\n']
def s(x):
    if x > 22:
        return x
new_list=filter(None,li)
print new_list
[1, 5, 11, 22, 81, 100, ' ', '\n']


reduce()函数

reduce()函数的作用是将元素中所有的元素进行累计操作

python培训day4 随便_day4_03

reduce()函数要求输入三个参数，第一个参数要求是函数，第二个参数要求是个序列。第三个是选填的参数表示基数

例如要对一个序列进行累加操作

li=[1,2,3,4,5]
def s(x,y):
    return x+y
new_list=reduce(s,li)
print new_list
15

如果加入基数这个参数相当于在计算结果的基础上附加一个基数

li=[1,2,3,4,5]
def s(x,y):
    return x+y
new_list=reduce(s,li,1000)
print new_list
1015

如果第一个参数内部是将后面序列中的元素相乘，那么第三个基数的作用就相当于在计算机过最后乘以

基数

li=[1,2,3,4,5]
def s(x,y):
    return x*y
new_list=reduce(s,li,10)
print new_list
1200


yield生成器

当我们定义函数的时候，如果遇到return 那么return后面的代码就不再执行了。

def a():
    return 1
    return 2
print a()
1

但是如果我们生成器yield的话，每次执行函数都会记录上一次执行到的位置并下一行的内容。但是返回的内容必须调用for才能看到。

def a():
    yield 1
    yield 2
for i in a():
    print i
1
2

参考range(10)和xrange(10)，这两个函数都可以产生0-9的数字序列。range()工作的时候是先在内存中把这是个数字创建好再打印出来。而利用了生成器的xrange()需要打印需要打印哪个数字了才创建哪个数字并打印，这样就不会占用太多的系统内存。生成器在编写数据库连接池的时候应用比较广泛。


装饰器

装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

例如如下函数：

def a():
return '123'
print a()
123

如果要在该函数输出的时候前面加上字符串'hello'的话

可以通过修改函数a()实现，但是如果有很多个类似a()的函数都有这个功能需求的话。每个函数都去代码里面修改是不现实的。

这时候就可以通过装饰器来实现

#第一个装饰器函数的名称，函数的参数就是需要添加新功能的函数名
def add_str(func):
    #再定义一个函数，该函数里面放入要添加的内容和调用要被包含的函数
    def wrapper():
        #这里要添加的str内容
        str= 'hello'
        #这里调用需要被包含的函数，本例就是相当于s=a()
        s=func()
        #对字符串进行拼接
        return '%s %s'%(str,s)
    #这里一定要加入返回wrapper的内存地址给装饰器，注意不能是return wrapper()。
    return wrapper
#通过@+装饰器名称的格式，放在在指定函数前面。表示这个函数运行的时候要加装饰器
@add_str
def a():
    return '123'
x = a()
print x
hello 123


如果被添加装饰器的函数本身就需要传递参数

例如

def a(m，n):
    return '123'+m+n
x = a('321','ABC')
print x
123321ABC

那么只需要在装饰器内嵌函数中设置两个形参，这样装饰器就可以把原函数的需要的参数传递进装饰器内部

def add_str(func):
    #再定义一个函数，该函数里面放入要添加的内容和调用要被包含的函数和函数需要的形参
    def wrapper(m,n):
        str= 'hello'
        #这里调用需要被包含的函数，本例就是相当于s=a(m,n)
        s=func(m,n)
        return '%s %s'%(str,s)
    #这里一定要加入返回wrapper的内存地址给装饰器，注意不能是return wrapper()。
    return wrapper
@add_str
def a(m,n):
    return '123' + m + n
x = a('321','ABC')
print x
hello 123321ABC