Python基本学习—函数

Filter，Map，Reduce

1. Filter
   对字符串给或者列表进行过滤，返回为TRUE的结果,第一个参数为返回true或者false的函数

s = '1    46$ I a932874756like45651927_(&%$#$^&python'
print(filter(str.isalpha,s))   ++++++ Ilikepython

1. Map
   每个元素都通过map处理一下
   map（函数，list）-list的每个元素都会在函数里处理一下，结果输出成list

l = [random.randint(0,100) for i in range(10)]
def sub50(a):
    return a-50
map(sub50,l)

1. Reduce
   注意其插入的函数必须有两个参数，要是超过两个参数，可以考虑看官方文档，改变原函数

def f_add(a,b):
    return a+b

reduce(f_add,range(1,100))  #返回1到100的累计和

lambda

lower = (lambda x,y: x if x<y else y )   # lower是一个函数， lower(2,3) -2

回调 callback

函数作为参数,调用完之后仍然回到主函数

def test(callback):
    print("test func begin")
    callback()
    print("test func end")
def cb1():
    print("callback 1")
test(cb1)

闭包Closure

1. 定义
   闭包是绑定外部变量的函数

2. 例子

#通过传入外部变量返回新函数inner
def pow_x(x):
    #x = 2,对x进行任何修改只是对局部变量的修改
    #x = [1,2]，对x[1]=x[1]*2进行修改，可改变外部变量
    def inner(value):
        return value**x
    return inner

lst = [pow_x(2),pow_x(3)]  #lst为函数列表
for p in lst:
        print(p(2)) 

装饰器Decorator

函数作为参数并作为返回值
1. 粒子

def decorator(f):
    print ("before f() called")
    return f
def myfunc1():
    print("myfunc1() called")
@decorator
def myfunc2():
    print("myfunc2() called")

if __name__ == "__main__":
    pass
    decorator(myfunc1)()   #==  myfunc2()
    myfunc2()

1. 无嵌套结构装饰器的问题

   • @装饰器会提前执行
   • 目标函数无法带入参数
   • 目标函数调用后无法插入代码

2. 装饰器——2层嵌套

# 直接换函数
def time_cost(f):
    def _f(*arg,**kwarg):
        start = time.clock()
        f(*arg,**kwarg)
        end = time.clock()
        print(end - start)
    return _f
@time_cost
def list_comp(length):
    return [(x,y) for x in range(length) for y in range(length) if x*y >25]

list_comp(1000)

• 问题：装饰器无法带参数,可以通过3层嵌套结构解决

装饰器——3层嵌套

def time_cost(timef):
    def decorator(f):
        def _f(*arg,**kwarg):
            start = timef()
            a = f(*arg,**kwarg)
            end = timef()
            print（end - start）
            return a
        return _f
    return decorator

装饰器-装饰模式

def wearTrouser(f):
    def _f(*arg, **kwarg):
        printInfo("裤子")    
        return f(*arg, **kwarg)
    return _f

def wearSuit(f):
    def _f(*arg, **kwarg):
        printInfo("西服")    
        return f(*arg, **kwarg)
    return _f

def wearTShirt(f):
    def _f(*arg, **kwarg):
        printInfo("T恤")    
        return f(*arg, **kwarg)
    return _f

def wearCap(f):
    def _f(*arg, **kwarg):
        printInfo("帽子")    
        return f(*arg, **kwarg)
    return _f

def wearSportShoes(f):
    def _f(*arg, **kwarg):
        printInfo("运动鞋")    
        return f(*arg, **kwarg)
    return _f    

def wearLeatherShoes(f):
    def _f(*arg, **kwarg):
        printInfo("皮鞋")    
        return f(*arg, **kwarg)
    return _f    

def wearedPerson(person,cloths):
    w = person
    for f in cloths:
        w=f(w)
    return w



#@wearTrouser    
#@wearTShirt    
def person(name):
    printInfo("装扮好的%s" % name)

if __name__ == '__main__':

    person("晓明")
    print "-----------------------"

    business_wear=[wearLeatherShoes,wearSuit,wearTrouser]
    sports_wear = [wearSportShoes,wearCap,wearTShirt,wearTrouser]

    weared_business_person = wearedPerson(person,business_wear)
    weared_sports_person = wearedPerson(person,sports_wear)

    weared_business_person("晓明")
    print "-----------------------"
    weared_sports_person("晓红")

递归 recursion

函数调用自己

#例1
def fib(n):
    if n <=2:
        return 1
    else:
        return fib(n-1)＋fib(n-２)
# fib = lambda n:1 if n<=2 else fib(n-1)+fib(n-2) 

#例2
def reverse_s(s):
    if len(s)<=1:
        return s
    else:
        return reverse_s(s[1:])+s[0]
s = 'ilikepython'
print(reverse_s(s))

生成器和yield

1. Iterable, Iterator, Generator(函数或者表达式)

def fib_opt(n):
    a,b,i  = 0,1,0
    while i < n:
        a,b = b, a+b
        i += 1
    else:
        return b
#[fib_opt(i) for i in range(100)]  计算比递归快，但是会重复计算

#next函数
def fib_iter():
    a,b = 0,1
    while True:
        yiled b  # yiled相当于 return，但是下次调用时用上次的
        a,b = b,a+b
#A = fib_iter()
#[A.next() for i in range(1000)]
#yield生成器面向的需求是顺序的算n个值

#send用法
def func():
    input = []
    while True:
        a = (yeild )
        Your statement
        input.append(a)
#itertools
horses = [1,2,3,4]
races = itertools.permutations(horses)  #穷举horses的所有排列
a = itertools.product([1,2],[3,4]) #(1,3),(1,4) (2,3),(2,4)
b = itertools.repeat([1,2],4)
C = itertools.chain(races,a,b) #将生成的迭代器链接到一起

内容来源