高级特性与函数式编程

生成器：
*读取生成器元素的两种方式
1.g.next()
列表生成式，当生成元素即打印，会占用内存；
g = [i for i in range(100000000)]
g.next()
g.next()
g.next()

2.for 循环读取（生成器实质上是可迭代对象）
from collections import Iterable
g = (i**2 for i in range(3))    ##从0开始往后的3个自然数
print isinstance(g,Iterable)
for i in g:
    print i

True
0
1
4

Fibonacci数列：
1，1，2，3，5，8，13，21....
生成fib数列的函数，m代表最终生成的数列元素个数；
def fib(m):
    n,a,b = 0,0,1
    while n < m:
        print b
        a,b = b,a+b
        n += 1
fib(5)

yield关键字：
1.生成fib数列的函数，m代表最终生成的数列元素个数；
  def fib(m):
    n,a,b = 0,0,1
    while n < m:
        yield b
        a,b = b,a+b
        n += 1
  g = fib(5)
  for i in g:
    print i


2.def g_yield():
    print "first"
    yield 1
    print "second"
    yield 2

  g = g_yield()
  print g.next()
  print g.next()


#在pycharm里，选中，shift+tab 消除空格

例：（厂<-->中间商<-->买家）
#!/usr/bin/env python
#coding:utf-8


product_agency = []
def consumer(name):
    print "%s 准备制作产品..." %(name)
    while 1:
        kind = yield
        product_agency.remove(kind)
        print "[%s]买了[%s]类型的产品" %(name,kind)

import time
def producer(name,*kind):

    print "准备制作产品..."
    for i in kind:
        time.sleep(1)
        print "[%s]制作了[%s]类新的产品，准备提供给客户..." %(name,i)
        product_agency.append(i)
producer('小名','产品1','产品2','产品3','产品4')

c1 = consumer('工厂')
c1.next()
c1.send('产品1')

print "目前产品类型有:",
for i in product_agency:
    print i,


例：（简型机器人对话系统）
#函数中yield，代表调用函数，返回值为生成器
def chat_robet():
    res = ''
    while 1:
        #遇到yield停止
        received = yield res
        if 'hello' in received or 'hi' in received:
            res = 'hello,I am sari!'
        elif 'name' in received:
            res = 'secret!I am saucer man!'
        elif 'price' in received:
            res = 'only 998!'
        elif 'bey' in received:
            res = 'bey'
        else:
            res = 'I dont no what you said[%s]!' %(received)


Chat = chat_robet()  #Chat是生成器
next(Chat)  #Chat.next和next(Chat)效果相同

while 1:
    r_input = raw_input("beauty>>:")
    if not r_input:
        continue
    elif r_input.lower() == 'q':
        print "Robot is going..."
        break
    else:
        response = Chat.send(r_input)
        print response

内置高阶函数：
*****map
map(function, sequence[, sequence, ...]) -> list
对sequence序列中的每一个元素item依次执行function(item)函数操作，最终返回一个列表；

def aaa(x):
    return x**2
print map(aaa,[1,2,3,4])

##str==>int
a = raw_input("num:")   
a_list = a.split()
print map(int, a_list)

****reduce
reduce(function, sequence[, initial]) -> value
对于序列中的每个元素迭代调用function函数；
reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])===>((((1+2)+3)+4)+5).
注意的点：function必须要用两个参数；
#阶乘
def mypower(x,y):
    return x*y
print reduce(mypower,range(1,8))


*****filter
filter(function or None, sequence) -> list, tuple, or string
注意：function返回为bool值
def odd(x):
    return x%2 == 0
print filter(odd,[12,34,32,45,53])

******sorted函数排序
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
cmp=用于比较的函数，返回值一定和cmp函数的返回值对应（1，-1，0）

#li.sort()作用于列表本身，只能用于列表排序
li = [1,23,45,65,2,43]
li.sort()
print li

#sorted返回一个新的对象，可以对任意一个可迭代的对象进行排序
li = [1,23,45,65,2,43]
print sorted(li)
print li

#sorted逆序排序
t = (1,23,45,65,2,43)
print sorted(t,reverse=True)

#忽略大小写进行排序
name = ['alice','Jerry','Amy','Bob','jack']
def ignore_case(s1,s2):
    s1 = s1.lower()
    s2 = s2.lower()
    return cmp(s1,s2)
print sorted(name,ignore_case)

#找出货物中数量最多的
good = [
    ["apple",2.00,10],
    ["computer",4000.00,5],
    ["banana",1.00,40]
]
print sorted(good,reverse=True,key=lambda x:x[2])[0][0]  #[0][0]列表中的第一个索引中的第一个索引

函数作为返回值：
def fun(x,y):
return xx
例：
def cacl_sum(*args):
    all_sum = 0
    for i in args:
        all_sum +=i
    return all_sum
print cacl_sum(1,2,3,4,5)

闭口
def lay_sum(*args):
    def cacl_sum():
        all_sum = 0
        for i in args:
            all_sum +=i
        return all_sum
    return cacl_sum()
f = lay_sum(1,2,3,4,5)
print f

装饰器：
器，可以理解为函数；装饰器实际上是用来装饰函数的；
就是在原来的功能基础上加一些其他功能，即在程序执行前或者执行后加上需要的操作；
功能：权限的验证，日至记录，函数运行时间统计，执行函数前预备处理，执行函数后清例功能等。


#!/usr/bin/env python
#coding:utf-8
import time
def addinfo(fun):
    def wrpper(*args,**kwargs):  ##多个参数 
        begin_time = time.time()
        fun(*args,**kwargs)
        end_time = time.time()
        Time = end_time - begin_time
        print "%s's going time is %s" %(fun.__name__,Time)
    return wrpper

@addinfo  #调用这个函数，也就是添加的内容
def add(*a):
    print min(a)
    #print [i**2 for i in a]
add(33,4,6,23)


#!/usr/bin/env python
#coding:utf-8
import time
def addinfo(fun):
    def wrpper(a,b):    ##两个参数的
        begin_time = time.time()
        fun(a,b)
        end_time = time.time()
        Time = end_time - begin_time    
        print "%s's going time is %s" %(fun.__name__,Time)   ##程序执行时间，函数名
    return wrpper

@addinfo
def add(x,y):
    print x+y

add(33,4)


例：
#!/usr/bin/env python
#coding:utf-8
def addinfo(a):
    def addinfo1(fun):
        def wrpper():
            print "welcom to %s " %(a)
            fun()
        return wrpper
    return addinfo1


@addinfo('index')
def index():
    print "index...."

@addinfo('login')
#login = addinfo(login)
def login():
    print "login....."

index()
login()