a ,b= 100,100
id(a) == id(b)
# True

# 共享
a = "hello"
b = "hello"
# 不共享
a = "hello world"
b = "hello world"

import gc
class ClassA():
    def __init__(self):
        print('object born,id:%s'%str(hex(id(self))))
# 引用计数 解决不了 变量的循环引用或互相引用
# 才有分代收集机制才会减一来辅助完成回收
def f2():
    while True:
        c1 = ClassA()
        c2 = ClassA()
        c1.t = c2
        c2.t = c1
        del c1
        del c2
        # 如果没有下面一行代码,则内存使用快速上升
        gc.collect() # 手动启动垃圾回收
gc.disable()
# 隔(零)代回收:promote
f2()

def func(functionName):
    print("---func---1---")
    def func_in():
        print("---func_in---1---")
        ret = functionName()
        print("---func_in---2---")
        return ret
    print("---func---2---")
    return func_in
@func
def test():
    print("----test----")
    return "haha"
ret = test()
print("test return value is %s"%ret)

def decorator(func):
    # 装饰函数
    print('hello')
    return func
@decorator
def foo():
    # 被装饰函数 回调函数 闭包函数(当有自由变量)
    print('foo end')
    # 其解释器将此方法解释为
    # foo = decorator(foo)
    # 把一个函数当参数传到另一个函数中,然后再回调
if __name__ == '__main__':
    foo 
    # hello
    foo()
    # hello
    # foo end
    
    foo_text = decorator(foo)
    print(type(foo_text))
    # hello
    # hello
    # <class 'function'>
    foo_text()
    # foo end

def hello(fn):
    def wrapper():
        print("hello, %s" % fn.__name__)
        fn()
        print("goodby, %s" % fn.__name__)
    return wrapper
@hello
def foo(): 
    print("i am foo")
    # foo = hello(foo)
if __name__ == '__main__':
    foo()
    # hello, foo
    # i am foo
    # goodby, foo

# 多个decorator
@decorator_one
@decorator_two
def func():
    pass
    # func = decorator_one(decorator_two(func))
# 带参数的decorator
@decorator(arg1, arg2)
def func():
    pass
    # func = decorator(arg1,arg2)(func)
    # 这意味着decorator(arg1, arg2)这个函数需要返回一个"真正的decorator"

def decorator_func_args(func):
    def handle_args(*args, **kwargs):
        print("handle args start")
        func(*args, **kwargs)
        print("handle args end")
    return handle_args
@decorator_func_args
def foo2(a, b=2):
    print(a,b)
if __name__ == '__main__':
    foo2(1)
    # handle args start
    # 1 2
    # handle args end
    # 先传递函数名,再传递参数
    foo2_text = decorator_func_args(foo2)
    print('--')
    foo2_text(1)
    # --
    # handle args start
    # handle args start
    # 1 2
    # handle args end
    # handle args end

def decorator_with_params(arg_of_decorator):
    print(arg_of_decorator)
    def newDecorator(func):
        print(func)
        return func
    return newDecorator
@decorator_with_params("deco_args")
def foo3():
    pass
if __name__ == '__main__':
    foo3()
    # deco_args
    # <function foo3 at 0x7fba7bfcf7b8>
    
    # 先传递参数,再传递函数名
    foo3_text = decorator_with_params("deco_args")
    print('--')
    foo3 = foo3_text(foo3)
    # deco_args
    # <function foo3 at 0x7fba7bfcf7b8>
    # deco_args
    # --
    # <function foo3 at 0x7fba7bfcf7b8>
    
    func = decorator_with_params('1')(foo3)
    # deco_args
    # <function foo3 at 0x7ff913a6f730>
    # 1
    # <function foo3 at 0x7ff913a6f730>

def decorator_with_params_and_func_args(arg_of_decorator):
    def handle_func(func):
        def handle_args(*args, **kwargs):
            print("begin")
            func(*args, **kwargs)
            print("end")
            print(arg_of_decorator, func, args, kwargs)
        return handle_args
    return handle_func
@decorator_with_params_and_func_args("123")
def foo4(a, b=2):
    print("content")
if __name__ == '__main__':
    foo4(1, b=3)
    # begin
    # content
    # end
    # 123 <function foo4 at 0x7f4f0f056730> (1,) {'b': 3}
    foo4_dec = decorator_with_params_and_func_args("123")
    print('**')
    foo4_func = foo4_dec(foo4)
    print('@@')
    foo4_text = foo4_func(1, b=3)
    # **
    # @@
    # begin
    # begin
    # content
    # end
    # 123 <function foo4 at 0x7f663fd82730> (1,) {'b': 3}
    # end
    # 123 <function decorator_with_params_and_func_args.<locals>.handle_func.
        # <locals>.handle_args at 0x7f663fd827b8> (1,) {'b': 3}

def makeHtmlTag(tag, *args, **kwds):
    def real_decorator(fn):
        css_class = " class='{0}'".format(kwds["css_class"]) \
            if "css_class" in kwds else ""
        def wrapped(*args, **kwds):
            return "<" + tag + css_class + ">" + fn(*args,**kwds) + "</" + tag + ">"
        return wrapped
    return real_decorator
@makeHtmlTag(tag="b", css_class="bold_css")
@makeHtmlTag(tag="i", css_class="italic_css")
def hello(name):
    return "hello world {0}".format(name)
if __name__ == '__main__':
    print(hello('femn'))
    # <b class='bold_css'><i class='italic_css'>hello world femn</i></b>

Hi, f returns:
function name: function_wrapper
docstring: function_wrapper of greeting
module name:__main__

from functools import wraps
def greeting(func):
    @wraps(func)
    def function_wrapper(x):
        """function_wrapper of greeting"""
        print("Hi, " + func.__name__ + " returns:")
        return func(x)
    return function_wrapper
@greeting
def f(x):
    """just some silly function"""
    return x + 4
if __name__ == '__main__':
    f(10)
    print("function name: " + f.__name__)
    print("docstring: " + f.__doc__)
    print("module name:" + f.__module__) ")

Hi, f returns:
function name: f
docstring: just some silly function
module name:__main__

class Test():
    def __call__(self, *args, **kwargs):
        print('类对象的直接调用时,必须要重写的方法')
def fun():
    print('方法的引用之后的直接调用')
t = Test()
t()
f = fun
f()

class myDecorator(object):
    def __init__(self, fn):
        print( "inside myDecorator.__init__()")
        # 在我们给某个函数decorator时被调用,所以
        # 需要有一个fn的参数,也就是被decorator的函数
        self.fn = fn
    # 调用被decorator函数时被调用的
    # 也可以在这个传入fn __call__(self.fn)
    def __call__(self):
        self.fn()
        print( "inside myDecorator.__call__()")
@myDecorator
def aFunction():
    print( "inside aFunction()")
print( "Finished decorating aFunction()")
if __name__ == '__main__':
    aFunction()
    # inside myDecorator.__init__()
    # Finished decorating aFunction()
    # inside aFunction()
    # inside myDecorator.__call__()

class MyApp():
    def __init__(self):
        self.func_map = {}
    # decorator类中没有__call__(),但是wrapper返回了原函数
    def register(self, name):
        def func_wrapper(func):
            self.func_map[name] = func
            return func
        return func_wrapper
    def call_method(self, name=None):
        func = self.func_map.get(name, None)
        if func is None:
            raise Exception("No function registered against - " + str(name))
        return func()
app = MyApp()
@app.register('/')
def main_page_func():
    return "This is the main page."
@app.register('/next_page')
def next_page_func():
    return "This is the next page."
print(app.call_method('/'))
print(app.call_method('/next_page'))
# This is the main page.
# This is the next page.

1+2 # 3
'fe'+'mn' # femn
'abc'.count('a') # 1
[1,2,'a'].count('a') # 1

class A(object):
    def __init__(self):
        print( "A.__init__" )
class B(A):
    def __init__(self):
        super().__init__()
        print("B.__init__" )
class C(B):
    def __init__(self):
        super().__init__()
        print("C.__init__" )
class D(A):
    def __init__(self):
        super().__init__()
        print("D.__init__" )
class E(D):
    def __init__(self):
        super().__init__()
        print("E.__init__" )
class F(C,E):# C,E 相当于是子 父关系
    def __init__(self):
        super().__init__()
        print("F.__init__" )
if __name__ == '__main__':
    f = F()
    # A.__init__
    # D.__init__
    # E.__init__
    # B.__init__
    # C.__init__
    # F.__init__

>>> F.__mro__
(class'__main__.F'>,<class'__main__.C'>,<class'__main__.B'>,
<class'__main__.E'>,<class'__main__.D'>,<class'__main__.A'>,
<class'object'>)

class Person(dict):
    def __init__(self,name):
        super(Person,self).__init__()
        self.name = name
    def get_name(self):
        return self.name
if __name__ == '__main__':
    p = Person('femn')
    print(p) # {}  self本身为空 {} ,但其属性不为空
    print(p.get_name()) # femn
# 如果知道p是Person类的实例的话,
# 就可以把p.get_name()看作是Person.get_name(p)的简写.

class Rectangle:
    def __init__(self):
        self.width = 0
        self.height = 0
    def setSize(self, size):
        """访问器方法,把所有的属性都放到访问器方法中"""
        self.width, self.height = size
    def getSize(self):
        return self.width, self.height
    size = property(getSize, setSize)
    # 类属性,其中的访问器方法被用作参数(先取值,然后是赋值)
r = Rectangle()
r.width = 10
r.height = 5
r.size #  (10, 5)
r.size = 150, 100
r.width # 150

class Person(object):
    def __init__(self,name,age):
        """Constructor"""
        self.name = ''
        self.age = 0
    # 修改属性的值 一
    def getName(self):
        print('property()')
        return self._name
    def setName(self,name):
        """ 要使用_name 将实例属性name标记成protected变量
        不然就将name类属性,改个名字,
        只要满足类属性和实例属性不同名,否则会进入无限的递归"""
        self._name = name # protected实例变量:_name
    name = property(getName,setName) # publie类变量:name
    __aim = 'become stronger' # private 类变量:__aim
    # @property装饰器:
# 将方法变成了属性,我们可以使用正常的点符号访问它,但无法对属性值直接修改
    @property
    def info(self):
        """ Return my info """
        return "my name is %s, age is %s" % (self.name, self.age)
    # 修改属性的值 二
#一个property其实是 getter、setter 和 deleter 方法的集合,而不是单个方法
# 访问它的时候会自动触发 getter 、setter 和 deleter 方法
    @property
    def age(self):
        print('@property装饰器')
        return self._age
    @age.setter
    def age(self,age):
        self._age = age
    @age.deleter
    def age(self):
        raise AttributeError("Can't delete attribute")
if __name__ == '__main__':
    p = Person('leipengkai',25)
    # 方法一
    p.set_name = 'femn1'
    p.name = 'femn1.1'
    print(p.name)
    # 方法二
    p.age = 18
    print(p.age) 
# 输出如下
# property()
# femn1.1
# @property生成器
# 18

def print_params(x, y, z=3, *pospar, **keypar): #**代表命名参数
    print(x,y,z)
    print(pospar)
    print(keypar)
print_params(1,2,3,5,6,7,foo=1, bar=2)
1 2 3
(5, 6, 7)
{'foo': 1, 'bar': 2}
print_params(1,2,foo=1, bar=2)
1 2 3
()
{'foo': 1, 'bar': 2}

def scope_test():
    def do_local():
        spam = "local spam"
    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"
    def do_global():
        global spam
        spam = "global spam"
    spam = "test spam"
    do_local()
    print("After local assignment:", spam)
    # test spam
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    # nonlocal spam
    do_global()
    print("After global assignment:", spam)
    # nonlocal spam
if __name__ == '__main__':
    scope_test()
    print("In global scope:", spam)
    # global spam

def test():
    def do_nonlocal():
        nonlocal spam
        print("asssignment:", spam)  
        def do_nonlocal2():
            nonlocal spam
            spam = "nonlocal2 spam"  #修改了test()中spam的绑定
        do_nonlocal2()
    spam = "test spam"
    do_nonlocal()
    print("after nonlocal2 asssignment:", spam)  
if __name__ == '__main__':
    test()
    # asssignment: test spam
    # after nonlocal2 asssignment: nonlocal2 spam
    # do_nonlocal2()中的spam引用的是其外面的二层,也就是test()函数域中的spam

    import threading
    from time import ctime,sleep
    def music(func):
        for i in range(2):
            print( "I was listening to %s. %s" %(func,ctime()))
            sleep(1)
    def move(func):
        for i in range(2):
            print( "I was at the %s! %s" %(func,ctime()))
            sleep(5)
    # 主线程中 加两个子线程
    threads = [] # 装载多个线程的数组 看着像是同时进行的
    t1 = threading.Thread(target=music,args=(u'爱情买卖',))
    threads.append(t1)
    t2 = threading.Thread(target=move,args=(u'阿凡达',))
    threads.append(t2)
    if __name__ == '__main__':
        for t in threads:# 子线程
            t.setDaemon(True)
            """ 线程声明为守护线程,必须在start() 方法调用之前设置
            如果不设置为守护线程程序会被无限挂起.
            子线程启动后,父线程也继续执行下去,当父线程执行完最后一条语句print "all over %s" %ctime()后
没有等待子线程,直接就退出了,同时子线程也一同结束"""
            t.start()#开始线程活动
        t.join()
""" 在子线程完成运行之前,这个子线程的父线程将一直被阻塞.join()实际上意味着等到队列为空,再执行别的操作
join()方法的位置是在for循环外的,也就是说必须等待for循环里的两个进程都结束后,才去执行主进程 """
        print( "all over %s" %ctime()) #主线程

import _thread
import threading
import time
exitFlag = 0
class myThread (threading.Thread):   
    #继承父类threading.Thread
    def __init__(self, delay):
        threading.Thread.__init__(self)
        self.delay = delay
    def run(self):        
       #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数
        print( "Starting " + self.name)
        # name属性中保存的是当前线程的名字
        print_time(threadName=self.name,delay=self.delay,counter=5)
        print( "Exiting " + self.name)
def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            _thread.exit()
        time.sleep(delay)
        print( "%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1
thread1 = myThread( delay=1)
thread2 = myThread( delay=2)
# 开启线程
thread1.start()
thread2.start()
print( "Exiting Main Thread")

from threading import Thread, Lock
import time
# 参数
l = [22,33]
#线程之间共享全局变量
g_num = 0
def test1(l):
    global g_num
    #这个线程和test2线程都在抢着对这个锁进行上锁,如果有１方成功的上锁,那么导致另外
    #一方会堵塞(一直等待)到这个锁被解开为止
    mutex.acquire()
    for i in range(1000000):
        g_num += 1
    mutex.release()#用来对mutex指向的这个锁　进行解锁,,,只要开了锁,那么接下来会让所有因为
                    #这个锁　被上了锁　而堵塞的线程　进行抢着上锁
    print("---test1---g_num=%d"%g_num)
    l.append(11)
    print(l)
def test2(l):
    global g_num
    mutex.acquire()
    for i in range(1000000):
        g_num += 1
    mutex.release()
    print("---test2---g_num=%d"%g_num)
    l.append(44)
    print(l)
#创建一把互斥锁,这个锁默认是没有上锁的
mutex = Lock()
p1 = Thread(target=test1,args=(l,))
p1.start()
#延时一会,保证p1线程中的事情做完
#time.sleep(3) #取消屏蔽之后 再次运行程序,结果会不一样
p2 = Thread(target=test2,args=(l,))
p2.start()
print("---g_num=%d---"%g_num)

    import threading
    from datetime import datetime
    import time
    import _thread
    exitFlag = 0
    class myThread (threading.Thread):
        def __init__(self, delay):
            threading.Thread.__init__(self)
            # self.threadID = threadID
            self.delay = delay
        def run(self):
            print( "Starting " + self.name)
# 如果多个线程共同对某个数据修改,则可能出现不可预料的结果,
# 为了保证数据的正确性,需要对多个线程进行同步.
# 线程同步(为了确保数据的完整没有被其它的线程修改,必须要得锁和解锁
# 所以也导致了要一个线程全部结束之后,才能执行下一个的线程)
# 这会导致同步阻塞,也就是只有一个线程工作完之后,才能进行下一个线程
            # 获得锁,成功获得锁定后返回True
            # 可选的timeout参数不填时将一直阻塞直到获得锁定
            # 否则超时后将返回False
            threadLock.acquire()
            print_time(threadName=self.name, delay=self.delay, counter=5)
            # 释放锁
            threadLock.release()
            print( "Exiting " + self.name)
    def print_time(threadName, delay, counter):
        while counter:
            if exitFlag:
                _thread.exit()
            time.sleep(delay)
            print( "%s: %s" % (threadName, time.ctime(time.time())))
            counter -= 1
    # 线程同步
    threadLock = threading.Lock() 
    threads = []
    thread1 = myThread( delay=1)
    thread2 = myThread(delay=2)
    # 开启线程
    n = datetime.now()
    thread1.start()
    thread1.join()#因为没有queue可继续执行下面的线程
    thread2.start() #
    # 添加线程到线程列表
    threads.append(thread1)
    threads.append(thread2)
    # 等待所有线程完成
    for t in threads:
        t.join()
    print("Exiting Main Thread")
    print(datetime.now()-n)

    import queue, time, threading, datetime
    class Job:
        def __init__(self, name):
            self.name = name
        def do(self):
            time.sleep(2)
            print("\t[Info] Job({0}) is done!".format(self.name))
    que = queue.Queue()
#FIFO即First in First Out,先进先出 a[len(a):1]=[queue] 加在后面的
# lifoqueue = queue.LifoQueue()#LIFO即Last in First Out
# 后进先出 a[0:0]=[queue] 加在最前面的 入栈 出栈
    for i in range(20):
        # 保存要去工作的信息 在queue中
        que.put(Job(str(i + 1)))
#调用队列对象的put()方法在队尾插入一个项目
# put()有两个参数,第一个item为必需的,为插入项目的值;第二个block为可选参数,默认为1
# 如果队列当前满且block为1,put()方法就使调用线程暂停,直到空出一个数据单元.
# 如果block为0,put方法将引发Queue.Full异常
    print("\t[Info] Queue size={0}...".format(que.qsize()))#返回队列的大小
    # # Start activity to digest queue.
    st = datetime.datetime.now()
    #需要40秒
    while que.qsize() > 0:
        job = que.get()
        job.do()
    td = datetime.datetime.now() - st
    print("\t[Info] Spending time={0}!".format(td))
#q.qsize() 返回队列的大小
# q.empty() 如果队列为空,返回True,反之False
# q.full() 如果队列满了,返回True,反之False
# q.full 与 maxsize 大小对应
# q.get([block[, timeout]]) 获取队列,timeout等待时间
# q.get_nowait() 相当q.get(False)
# 非阻塞 q.put(item) 写入队列,timeout等待时间
# q.put_nowait(item) 相当q.put(item, False)
# q.task_done() 在完成一项工作之后,q.task_done()函数向任务已经完成的队列发送一个信号
# q.join() 实际上意味着等到队列为空,再执行别的操作

import queue, time, threading, datetime
class Job:
    def __init__(self, name):
        self.name = name
    def do(self):
        time.sleep(2)
        print("\t[Info] Job({0}) is done!".format(self.name))
que = queue.Queue()
for i in range(20):
    que.put(Job(str(i + 1)))
print("\t[Info] Queue size={0}...".format(que.qsize()))
def doJob(*args):
    queue = args[0]
    while queue.qsize() > 0:
        job = queue.get()
#调用队列对象的get()方法从队头删除并返回一个项目.可选参数为block,默认为True.
# 如果队列为空且block为True,get()就使调用线程暂停,直至有项目可用.
# 如果队列为空且block为False,队列将引发Queue.Empty异常
        job.do()
    # Open three threads
thd1 = threading.Thread(target=doJob, name='Thd1', args=(que,))
thd2 = threading.Thread(target=doJob, name='Thd2', args=(que,))
thd3 = threading.Thread(target=doJob, name='Thd3', args=(que,))
# thd4 = threading.Thread(target=doJob, name='Thd3', args=(que,))
# thd5 = threading.Thread(target=doJob, name='Thd3', args=(que,))
# # Start activity to digest queue.
st = datetime.datetime.now()
thd1.start()
thd2.start()
thd3.start()
# thd1.join()
#在子线程完成运行之前,这个子线程的父线程将一直被阻塞.
# join() 实际上意味着等到队列为空,再执行别的操作
#這會讓呼叫 join() 方法的線程被 blocked, 一直到被呼叫 join() 的線程結束為止
#不会再进行下面的线程了
# thd4.start()
# thd5.start()
#首先當 Thread 類別被實例化, 你可以呼叫物件上面的方法 start() 來啟動該線程,
#  一旦線程啟動, 它的狀態會變成 "alive" ;
# Wait for all threads to terminate.
while thd1.is_alive() or thd2.is_alive() or thd3.is_alive():
    time.sleep(1)
# 當執行完畢 run() 後狀態便不在是 "alive".
td = datetime.datetime.now() - st
print("\t[Info] Spending time={0}!".format(td))

import queue
import threading
from datetime import datetime
SHARE_Q = queue.Queue()  # 构造一个不限制大小的的队列
_WORKER_THREAD_NUM = 4  # 设置线程的个数
def worker():
    global SHARE_Q
    while not SHARE_Q.empty():
        one_dict = SHARE_Q.get()  # 获得任务
        # to worker ...
        SHARE_Q.task_done()
def main():
    a= datetime.now()
    threads = []
    global SHARE_Q
    library_list =['9787550215184','9787550206267']
    for i in library_list:
        SHARE_Q.put(i)
    for i in range(_WORKER_THREAD_NUM):
        thr = threading.Thread(target=worker)
        # 必须要有 target去指定函数
        thr.start()
        threads.append(thr)
    for thread in threads:
        thread.join()
    SHARE_Q.join()
    print(datetime.now() -a)#0:00:00.376745
    print('success')
if __name__ == '__main__':
    main()

举个通俗的例子: 你打电话问书店老板有没有《分布式系统》这本书
如果是同步通信机制,书店老板会说,你稍等,"我查一下",
然后开始查啊查,等查好了(可能是5秒,也可能是一天)告诉你结果(返回结果).
而异步通信机制,书店老板直接告诉你我查一下啊,
查好了打电话给你,然后直接挂电话了(不返回结果).
然后查好了,他会主动打电话给你.在这里老板通过"回电"这种方式来回调.

import time
import threading
def long_io(callback):
    """将耗时的操作交给另一线程来处理"""
    def fun(cb): # 回调函数作为参数
        """耗时操作"""
        print( "开始执行IO操作")
        time.sleep(5)
        print("完成IO操作,并执行回调函数")
        cb("io result")  # 执行回调函数
    threading._start_new_thread(fun, (callback,))  # 开启线程执行耗时操作
def on_finish(ret):
    """回调函数"""
    print( "开始执行回调函数on_finish")
    print( "ret: %s" % ret)
    print( "完成执行回调函数on_finish")
# 可读性差,要结合多个函数
def req_a():
    print( "开始处理请求req_a" )
    long_io(on_finish)
    print( "离开处理请求req_a")
def req_b():
    print( "开始处理请求req_b")
    time.sleep(2) # 添加此句来突出显示程序执行的过程
    print( "完成处理请求req_b")
def main():
    req_a()
    req_b()
    while 1: # 添加此句防止程序退出,保证线程可以执行完
        pass
if __name__ == '__main__':
    main()

你打电话问书店老板有没有《分布式系统》这本书,你如果是阻塞式调用,你会一直把自己"挂起"
直到得到这本书有没有的结果,如果是非阻塞式调用
你不管老板有没有告诉你,你自己先一边去玩了
当然你也要偶尔过几分钟check一下老板有没有返回结果

老张爱喝茶,废话不说,煮开水. 出场人物:
老张,水壶两把(普通水壶,简称水壶;会响的水壶,简称响水壶).
1 老张把水壶放到火上,立等水开.(同步阻塞) 老张觉得自己有点傻 
2 老张把水壶放到火上,去客厅看电视,时不时去厨房看看水开没有.(同步非阻塞)
老张还是觉得自己有点傻,于是买了把会响笛的那种水壶.水开之后,能大声发出嘀~~~~的噪音.
3 老张把响水壶放到火上,立等水开.(异步阻塞)  
老张觉得这样傻等意义不大
4 老张把响水壶放到火上,去客厅看电视,水壶响之前不再去看它了,响了再去拿壶.(异步非阻塞)

d=(x*x for x in range(10))
sum(d)
# 285
d.next() # StopIteration sum(d)已经迭代完了

def fab(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b #
        # yield 的作用就是把一个函数变成一个 generator
        # 调用 fab(5)不会执行fab函数,而是返回一个iterable对象
        a, b = b, a + b
        n = n + 1
        # 如果没有return,则默认执行至函数完毕,如果在执行过程中return
        #则直接抛出StopIteration终止迭代

for n in fab(5): print n

f = fab(5)
print(f.next())

f1 = fab(5)
print(f1.next())

def test_yield():
    yield 1
    yield 2
    yield (1,2)
g = test_yield()
print(next(g))
print(next(g))
# print(next(g))

def gen():
    i = 0
    while i < 5:
        temp = yield i
        # temp 并不是i的值
        print( temp )
        i+=1
f = gen() # 不是调用了函数,而是返回了生成器 生成器的值就是返回值
print(next(f)) # 0
print(next(f)) # None 1
print(f.send('femn')) # femn 2
# c.next()等价c.send(None)

import time
import threading
gen = None # 全局生成器,供long_io使用
def long_io():
    def fun():
        print("开始执行IO操作")
        global gen
        time.sleep(5)
        try:
            print("完成IO操作,并send结果唤醒挂起程序继续执行")
            gen.send("io result")  # 使用send返回结果并唤醒程序继续执行
        except StopIteration: # 捕获生成器完成迭代,防止程序退出
            pass
    threading._start_new_thread(fun, ())
def req_a():
    print("开始处理请求req_a")
    ret = yield long_io()
    print("ret: %s" % ret)
    print("完成处理请求req_a")
def req_b():
    print("开始处理请求req_b")
    time.sleep(2)
    print( "完成处理请求req_b")
def main():
    global gen
    gen = req_a() # 得到生成器,不能像同步一样去输写
    next(gen) # 开启生成器req_a的执行
    req_b()
    while 1:
        pass
if __name__ == '__main__':
    main()

def test1():
    while True:
        print("---1---")
        yield None
def test2():
    while True:
        print("---2---")
        yield None
t1 = test1()
t2 = test2()
while True:
    next(t1)
    next(t2)
# 暂停和启动之间的快速切换

import gevent
deff(n):
    fori in range(n):
        print(gevent.getcurrent(),i)
        #用来模拟一个耗时操作,注意不是time模块中的sleep
        gevent.sleep(1)
g1=gevent.spawn(f,5)
g2=gevent.spawn(f,5)
g3=gevent.spawn(f,5)
g1.join()
g2.join()
g3.join()

# 传统的生产者-消费者模型是一个线程写消息,一个线程取消息,
# 通过锁机制控制队列和等待,但一不小心就可能死锁.
# 如果改用协程,生产者生产消息后,直接通过yield跳转到消费者开始执行
# 待消费者执行完毕后,切换回生产者继续生产,效率极高
import time
def consumer():
    r = ''
    while True:
        n = yield r 
        # 3.consumer通过yield拿到消息,处理完又通过yield把结果传回
        if not n: return print('[CONSUMER] Consuming %s...' % n)
        print(n)
        time.sleep(1)
        r = '200 OK'
def produce(c):
    next(c) # 不是值 1. 启用生成器
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n) 
        # 这里才是迭代器中的值 2. 一旦生产了东西,通过c.send(n)切换到consumer执行
        print('[PRODUCER] Consumer return: %s' % r)
        # 4. produce拿到consumer处理的结果,继续生产下一条消息
    c.close() 
    # 5. produce决定不生产了,通过c.close()关闭consumer,整个过程结束
if __name__ == '__main__':
    c = consumer()
    produce(c)

for i in range(1000): pass

for i in xrange(1000): pass

from collections import	Iterable
isinstance([],	Iterable) # True
isinstance((x for x in range(10)),Iterable) # True

class Fab(object):
def __init__(self, max):
    self.max = max
    self.n, self.a, self.b = 0, 0, 1
def __iter__(self):
    return self
def __next__(self): # python2使用next()
    if self.n < self.max:
        r = self.b
        self.a, self.b = self.b, self.a + self.b
        self.n = self.n + 1
        return r
    raise StopIteration()
>>> for n in Fab(5): print(n)

it=iter([1,2,3])  iterkeys({1:"1",2:"2"}) iteritems({}) # 可迭代对象
it.next() # python3.0之前 迭代器
next(it)   #       之后
# itertools函数返回的都是迭代器对象
from itertools import cycle , islice
colors = cycle(['red', 'white', 'blue'])
next(colors)
limited = islice(colors, 0, 4)
for x in limited:print x