#! /usr/bin/env python  # -*- coding: utf-8 -*-  import time    def timer(func):      start_time = time.time()      func()      print '函數執行時間為', time.time() - start_time    def test():      print '開始執行test'      time.sleep(3)      print 'test執行結束'      timer(test)  '''  開始執行test  test執行結束  函數執行時間為 3.00332999229  '''

import time  def bar():      time.sleep(3)      print("in the bar")  def test2(func):      print(func)      return func  bar = test2(bar)  bar()

def foo():      print("in the foo")      def bar():          print("in the bar")      bar()  foo()

import time  def timer(func):   #timer(test1)  func=test1      def deco(*args,**kwargs):          start_time = time.time()          func(*args,**kwargs)      #run test1          stop_time = time.time()          print("running time is %s"%(stop_time-start_time))      return deco  @timer     # test1=timer(test1)  def test1():      time.sleep(3)      print("in the test1")  @timer  def test2(name):      print("in the test2",name)  test1()  test2("tom")

import time  user,passwd = 'aaa','123'  def auth(func):      def wrapper(*args,**kwargs):          username = input("Username:").strip()          password = input("Password:").strip()          if user == username and password == passwd:              print("User has passed authentication")              res = func(*args,**kwargs)   #這裡執行func()相當於執行調用的函數如home()              return res          #為了獲得home()函數返回值，可以將執行結果賦值給res然後返回print(home())結果是"from home"而不是"None"了          else:              exit("Invalid username or password")      return wrapper  def index():      print("welcome to index page")  @auth  def home():      print("welcome to home page")      return "from home"  @auth  def bbs():      print("welcome to bbs page")  index()  print(home())   #在這裡調用home()相當於調用wrapper()  bbs()

import time  user,passwd = 'aaa','123'  def auth(auth_type):      print("auth func:",auth_type)      def outer_wrapper(func):          def wrapper(*args, **kwargs):              print("wrapper func args:", *args, **kwargs)              if auth_type == "local":                  username = input("Username:").strip()                  password = input("Password:").strip()                  if user == username and passwd == password:                      print("33[32;1mUser has passed authentication33[0m")                      res = func(*args, **kwargs)  # from home                      print("---after authenticaion ")                      return res                  else:                      exit("33[31;1mInvalid username or password33[0m")              elif auth_type == "ldap":                  print("搞毛線ldap,不會。。。。")            return wrapper      return outer_wrapper    def index():      print("welcome to index page")  @auth(auth_type="local") # home = wrapper()  def home():      print("welcome to home  page")      return "from home"    @auth(auth_type="ldap")  def bbs():      print("welcome to bbs  page")    index()  print(home()) #wrapper()  bbs()

#! /usr/bin/env python  # -*- coding: utf-8 -*-  import time  def auth(auth_type):      print("auth func:",auth_type)      def outer_wrapper(func):          def wrapper(*args, **kwargs):              print("wrapper func args:", *args, **kwargs)              print('運行前')              func(*args, **kwargs)              print('運行後')          return wrapper      return outer_wrapper    @auth(auth_type="local") # home = wrapper()  def home():      print("welcome to home  page")      return "from home"  home()

#! /usr/bin/env python  # -*- coding: utf-8 -*-  import time    def timer(func):                    #timer(test1)  func=test1      def deco(*args,**kwargs):       # # 函數嵌套          start_time = time.time()          func(*args,**kwargs)        # 跨域訪問，引用了外部變數func   (func實質是函數記憶體地址)          stop_time = time.time()          print "running time is %s"%(stop_time-start_time)      return deco                    # 內層函數作為外層函數返回值    def test(name):      print "in the test2",name      time.sleep(2)    test = timer(test)   # 等價於 ==》 @timer語法糖  test("tom")  '''  運行結果：  in the test2 tom  running time is 2.00302696228  '''

def fib(max_num):      a,b = 1,1      while a < max_num:          yield b          a,b=b,a+b    g = fib(10)               #生成一個生成器：[1，2, 3, 5, 8, 13]  print(g.__next__())       #第一次調用返回：1  print(list(g))            #把剩下元素變成列表：[2, 3, 5, 8, 13]

def consumer(name):      print("%s 準備吃包子啦!" %name)      while True:         baozi = yield         print("包子[%s]來了,被[%s]吃了!" %(baozi,name))  c = consumer("Tom")  c.__next__()  b1 = "韭菜餡包子"  c.send(b1)    # c.send(b1)作用：  # c.send()的作用是給yied的傳遞一個值，並且每次調用c.send()的同時自動調用一次__next__  '''運行結果：  Tom 準備吃包子啦!  包子[韭菜餡包子]來了,被[Tom]吃了!  '''

import time  def consumer(name):      print("%s 準備吃包子啦!" %name)      while True:         baozi = yield         print("包子[%s]來了,被[%s]吃了!" %(baozi,name))  def producer(name):      c = consumer('A')      c2 = consumer('B')      c.__next__()      c2.__next__()      print("老子開始準備做包子啦!")      for i in range(10):          time.sleep(1)          print("做了2個包子!")          c.send(i)          c2.send(i)  producer("alex")    '''運行結果：  A 準備吃包子啦!  B 準備吃包子啦!  老子開始準備做包子啦!  做了2個包子!  包子[0]來了,被[A]吃了!  包子[0]來了,被[B]吃了!  做了2個包子!  包子[1]來了,被[A]吃了!  包子[1]來了,被[B]吃了!  做了2個包子!  包子[2]來了,被[A]吃了!  包子[2]來了,被[B]吃了!  做了2個包子!  包子[3]來了,被[A]吃了!  包子[3]來了,被[B]吃了!  做了2個包子!  包子[4]來了,被[A]吃了!  包子[4]來了,被[B]吃了!  做了2個包子!  包子[5]來了,被[A]吃了!  包子[5]來了,被[B]吃了!  '''

from collections import Iterable  print(isinstance([],Iterable))                               #True  print(isinstance({},Iterable))                               #True  print(isinstance((),Iterable))                               #True  print(isinstance("aaa",Iterable))                           #True  print(isinstance((x for x in range(10)),Iterable))          #True

from collections import Iterator  t = [1,2,3,4]  print(isinstance(t,Iterator))           #False  t1 = iter(t)  print(isinstance(t1,Iterator))          #True

#! /usr/bin/env python  # -*- coding: utf-8 -*-  class MyRange(object):      def __init__(self, n):          self.idx = 0          self.n = n        def __iter__(self):          return self        def next(self):          if self.idx < self.n:              val = self.idx              self.idx += 1              return self.n[val]          else:              raise StopIteration()      l = [4,5,6,7,8]  obj = MyRange(l)  print obj.next()      # 4  print obj.next()      # 5  print obj.next()      # 6

#! /usr/bin/env python  # -*- coding: utf-8 -*  l = [1,2,3,4,5]                  # 列表是一個可迭代對象，不是一個迭代器  print dir(l)                     # 所以 l 中有 __iter__() 方法，沒有 __next__()方法  iter_obj = l.__iter__()          # __iter__()方法返回迭代器對象本身(這個迭代器對象就會有 next 方法了)    print '###################################n'  print iter_obj.next()     # 1  print iter_obj.next()     # 2  print iter_obj.next()     # 3

import threading  import time    def sayhi(num):                                   # 定義每個執行緒要運行的函數      print("running on number:%s" % num)      time.sleep(3)    #1、target=sayhi ：sayhi是定義的一個函數的名字  #2、args=(1,)    ： 括弧內寫的是函數的參數  t1 = threading.Thread(target=sayhi, args=(1,))    # 生成一個執行緒實例  t2 = threading.Thread(target=sayhi, args=(2,))    # 生成另一個執行緒實例    t1.start()                                        # 啟動執行緒  t2.start()                                        # 啟動另一個執行緒    print(t1.getName())                               # 獲取執行緒名  print(t2.getName())

import threading  import time    class MyThread(threading.Thread):      def __init__(self,num):          threading.Thread.__init__(self)          self.num = num        def run(self):#定義每個執行緒要運行的函數          print("running on number:%s" %self.num)          time.sleep(3)    if __name__ == '__main__':      t1 = MyThread(1)      t2 = MyThread(2)      t1.start()      t2.start()

import threading  import time    def sayhi(num): #定義每個執行緒要運行的函數      print("running on number:%s" %num)      time.sleep(3)  for i in range(50):      t = threading.Thread(target=sayhi,args=('t-%s'%i,))      t.start()

import threading  import time  start_time = time.time()    def sayhi(num): #定義每個執行緒要運行的函數      print("running on number:%s" %num)      time.sleep(3)    t_objs = []    #將進程實例對象存儲在這個列表中  for i in range(50):      t = threading.Thread(target=sayhi,args=('t-%s'%i,))      t.start()          #啟動一個執行緒，程式不會阻塞      t_objs.append(t)  print(threading.active_count())    #列印當前活躍進程數量  for t in t_objs: #利用for循環等待上面50個進程全部結束      t.join()     #阻塞某個程式  print(threading.current_thread())    #列印執行這個命令進程    print("----------------all threads has finished.....")  print(threading.active_count())  print('cost time:',time.time() - start_time)

import threading  import time  start_time = time.time()    def sayhi(num): #定義每個執行緒要運行的函數      print("running on number:%s" %num)      time.sleep(3)  for i in range(50):      t = threading.Thread(target=sayhi,args=('t-%s'%i,))      t.setDaemon(True)  #把當前執行緒變成守護執行緒，必須在t.start()前設置      t.start()          #啟動一個執行緒，程式不會阻塞  print('cost time:',time.time() - start_time)

import time  import threading  lock = threading.Lock()          #1 生成全局鎖  def addNum():      global num                  #2 在每個執行緒中都獲取這個全局變數      print('--get num:',num )      time.sleep(1)      lock.acquire()              #3 修改數據前加鎖      num  -= 1                   #4 對此公共變數進行-1操作      lock.release()              #5 修改後釋放

# 1）第一步：count = 0   count初始值為0          # 2）第二步：執行緒1要執行對count加1的操作首先申請GIL全局解釋器鎖          # 3）第三步：調用作業系統原生執行緒在作業系統中執行          # 4）第四步：count加1還未執行完畢，時間到了被要求釋放GIL          # 5）第五步：執行緒1釋放了GIL後執行緒2此時也要對count進行操作，此時執行緒1還未執行完，所以count還是0          # 6）第六步：執行緒2此時拿到count = 0後也要對count進行加1操作，假如執行緒2執行很快，一次就完成了          #    count加1的操作，那麼count此時就從0變成了1          # 7）第七步：執行緒2執行完加1後就賦值count=1並釋放GIL          # 8）第八步：執行緒2執行完後cpu又交給了執行緒1，執行緒1根據上下文繼續執行count加1操作，先拿到GIL          #    鎖，完成加1操作，由於執行緒1先拿到的數據count=0，執行完加1後結果還是1          # 9）第九步：執行緒1將count=1在次賦值給count並釋放GIL鎖，此時連個執行緒都對數據加1，但是值最終是1

from threading import Thread,Lock  import time  mutexA=Lock()  mutexB=Lock()    class MyThread(Thread):      def run(self):          self.func1()          self.func2()      def func1(self):          mutexA.acquire()          print('33[41m%s 拿到A鎖33[0m' %self.name)            mutexB.acquire()          print('33[42m%s 拿到B鎖33[0m' %self.name)          mutexB.release()            mutexA.release()        def func2(self):          mutexB.acquire()          print('33[43m%s 拿到B鎖33[0m' %self.name)          time.sleep(2)            mutexA.acquire()          print('33[44m%s 拿到A鎖33[0m' %self.name)          mutexA.release()            mutexB.release()    if __name__ == '__main__':      for i in range(2):          t=MyThread()          t.start()    # 運行結果：輸出下面結果後程式卡死，不再向下進行了  # Thread-1 拿到A鎖  # Thread-1 拿到B鎖  # Thread-1 拿到B鎖  # Thread-2 拿到A鎖

from threading import Thread,Lock,RLock  import time    mutexA=mutexB=RLock()    class MyThread(Thread):      def run(self):          self.f1()          self.f2()        def f1(self):          mutexA.acquire()          print('%s 拿到A鎖' %self.name)            mutexB.acquire()          print('%s 拿到B鎖' %self.name)          mutexB.release()            mutexA.release()        def f2(self):          mutexB.acquire()          print('%s 拿到B鎖' % self.name)          time.sleep(0.1)          mutexA.acquire()          print('%s 拿到A鎖' % self.name)          mutexA.release()            mutexB.release()    if __name__ == '__main__':      for i in range(5):          t=MyThread()          t.start()  # 下面是運行結果：不會產生死鎖  # Thread-1 拿到A鎖  # Thread-1 拿到B鎖  # Thread-1 拿到B鎖  # Thread-1 拿到A鎖  # Thread-2 拿到A鎖  # Thread-2 拿到B鎖  # Thread-2 拿到B鎖  # Thread-2 拿到A鎖  # Thread-4 拿到A鎖  # Thread-4 拿到B鎖  # Thread-4 拿到B鎖  # Thread-4 拿到A鎖  # Thread-3 拿到A鎖  # Thread-3 拿到B鎖  # Thread-3 拿到B鎖  # Thread-3 拿到A鎖  # Thread-5 拿到A鎖  # Thread-5 拿到B鎖  # Thread-5 拿到B鎖  # Thread-5 拿到A鎖

# import threading,time  # def run(n):  #     semaphore.acquire()  #     time.sleep(1)  #     print("run the thread: %sn" %n)  #     semaphore.release()  #   # if __name__ == '__main__':  #     semaphore  = threading.BoundedSemaphore(5) #最多允許5個執行緒同時運行  #     for i in range(22):  #         t = threading.Thread(target=run,args=(i,))  #         t.start()  #   # while threading.active_count() != 1:  #     pass #print threading.active_count()  # else:  #     print('----all threads done---')      # 程式碼結果說明：這裡可以清晰看到運行時0-4是同時運行的沒有順序，而且是前五個，  # 表示再semaphore這個訊號量的定義下程式同時僅能執行5個執行緒

import time,threading    event = threading.Event()  #第一：寫一個紅綠燈的死循環  def lighter():      count = 0      event.set()               #1先設置為綠燈      while True:          if count > 5 and count <10:      #2改成紅燈              event.clear()          #3把標誌位清了              print("red light is on.....")          elif count > 10:              event.set()            #4再設置標誌位，變綠燈              count = 0          else:              print("green light is on.....")          time.sleep(1)          count += 1    #第二：寫一個車的死循環  def car(name):      while True:          if event.is_set():         #設置了標誌位代表綠燈              print("[%s] is running"%name)              time.sleep(1)          else:              print('[%s] sees red light, waiting......'%name)              event.wait()              print('[%s] green light is on,start going.....'%name)    light = threading.Thread(target=lighter,)  light.start()  car1 = threading.Thread(target=car,args=("Tesla",))  car1.start()

import multiprocessing,time,threading    #3 被多執行緒調用的函數  def thread_run():      print(threading.get_ident())   #列印執行緒id號      time.sleep(2)    #2 被多進程調用的函數，以及在這個函數中起一個進程  def run(name):      time.sleep(2)      print("hello",name)      t = threading.Thread(target=thread_run,)  #在進程調用的函數中啟用一個執行緒      t.start()    #1 一次性啟動多個進程  if __name__ == '__main__':      for i in range(10):          p = multiprocessing.Process(target=run,args=('bob %s'%i,)) #啟用一個多執行緒          p.start()

from multiprocessing import Process  import queue  import threading  def f():      q.put([42, None, 'hello'])    if __name__ == '__main__':      q = queue.Queue()              #1 在父進程中定義一個隊列實例q      # p = threading.Thread(target=f,)    #在執行緒程中就可以相互訪問，執行緒中記憶體共享      p = Process(target=f,)        #2 在父進程中起一個子進程 p，在子進程中使用父進程的q會報錯      p.start()      print(q.get())      p.join()

from multiprocessing import Process, Queue    def f(qq):  # 將符進程中的q傳遞過來叫qq      qq.put([42, None, 'hello'])  # 此時子進程就可以使用符進程中的q    if __name__ == '__main__':      q = Queue()  # 使用Queue()在父進程中定義一個隊列實例q      p = Process(target=f, args=(q,))  # 在父進程中起一個子進程 p，將父進程剛定義的q傳遞給子進程p      p.start()      print(q.get())      p.join()    # 運行結果： [42, None, 'hello']

from multiprocessing import Process, Pipe    def f(conn):      conn.send([42, None, 'hello'])  # 3 子進程發送數據，就像socket一樣      print("son process recv:", conn.recv())      conn.close()    if __name__ == '__main__':      parent_conn, child_conn = Pipe()      # 1 生成一個管道實例，實例一生成就會生成兩個返回對象，一個是管道這頭，一個是管道那頭      p = Process(target=f, args=(child_conn,))  # 2 啟動一個子進程將管道其中一頭傳遞給子進程      p.start()      print(parent_conn.recv())  # 4 父進程收消息 # prints "[42, None, 'hello']"      parent_conn.send('i am parent process')      p.join()    # 運行結果：  # [42, None, 'hello']  # son process recv: i am parent process

from multiprocessing import Process, Manager  import os    def f(d, l):      d[1] = '1'  # 是個進程對字典放入的是同一個值，所以看上去效果不明顯      l.append(os.getpid())  # 將這是個進程的進程id放入列表中      if __name__ == '__main__':      with Manager() as manager:  # 1 將Manager()賦值給manager          d = manager.dict()  # 2 定義一個可以在多個進程間可以共享的字典          l = manager.list(range(5))  # 3 定義一個可以在多個進程間可以共享的列表，默認寫五個數據          p_list = []          for i in range(10):  # 生成是個進程              p = Process(target=f, args=(d, l))  # 將剛剛生成的可共享字典和列表傳遞給子進程              p.start()              p_list.append(p)          for res in p_list:              res.join()          print(d)          print(l)

from multiprocessing import Process, Lock  def f(l, i):      l.acquire()                     #一個進程要列印數據時先鎖定      print('hello world', i)      l.release()                     #列印完畢後就釋放這把鎖  if __name__ == '__main__':      lock = Lock()                   #先生成一把鎖      for num in range(5):          Process(target=f, args=(lock, num)).start()    # 運行結果：  # hello world 4  # hello world 0  # hello world 2  # hello world 3  # hello world 1

from  multiprocessing import Process,Pool  import time,os  def foo(i):      time.sleep(2)      print("in the process",os.getpid()) #列印子進程的pid      return i+100    def call(arg):      print('-->exec done:',arg,os.getpid())    if __name__ == '__main__':      pool = Pool(3)                      #進程池最多允許5個進程放入進程池      print("主進程pid：",os.getpid())     #列印父進程的pid      for i in range(10):          #用法1 callback作用是指定只有當Foo運行結束後就執行callback調用的函數,父進程調用的callback函數          pool.apply_async(func=foo, args=(i,),callback=call)            #用法2 串列 啟動進程不在用Process而是直接用pool.apply()          # pool.apply(func=foo, args=(i,))        print('end')      pool.close()    #關閉pool      pool.join()     #進程池中進程執行完畢後再關閉，如果注釋，那麼程式直接關閉。

#!/usr/bin/env python  #coding=utf8    import os, sys, time  #產生子進程  pid = os.fork()    if pid == 0:      #子進程退出      sys.exit(0)  #父進程休息30秒  time.sleep(30)  # 先產生一個子進程，子進程退出，父進程休息30秒,那就會產生一個殭屍進程

[root@linux-node4 ~]# ps -ef| grep defunct  root     110401  96083  0 19:11 pts/2    00:00:00 python defunct.py  root     110402 110401  0 19:11 pts/2    00:00:00 [python] <defunct>  root     110406  96105  0 19:11 pts/3    00:00:00 grep --color=auto defunct

import time  import queue    def consumer(name):      print("--->starting eating baozi...")      while True:          new_baozi = yield  # 只要遇到yield程式就返回，yield還可以接收數據          print("[%s] is eating baozi %s" % (name, new_baozi))          time.sleep(1)    def producer():      r = con.__next__()  # 直接調用消費者的__next__方法      r = con2.__next__()  # 函數裡面有yield第一次加括弧調用會變成一個生成器函數不執行，運行next才執行      n = 0      while n < 5:          n += 1          con.send(n)  # send恢復生成器同時並傳遞一個值給yield          con2.send(n)          print("33[32;1m[producer]33[0m is making baozi %s" % n)    if __name__ == '__main__':      con = consumer("c1")      con2 = consumer("c2")      p = producer()

from greenlet import greenlet    def test1():      print(12)       #4 gr1會調用test1()先列印12      gr2.switch()    #5 然後gr2.switch()就會切換到gr2這個協程      print(34)       #8 由於在test2()切換到了gr1，所以gr1又從上次停止的位置開始執行      gr2.switch()    #9 在這裡又切換到gr2，會再次切換到test2()中執行    def test2():      print(56)       #6 啟動gr2後會調用test2()列印56      gr1.switch()    #7 然後又切換到gr1      print(78)       #10 切換到gr2後會接著上次執行，列印78    gr1 = greenlet(test1)    #1 啟動一個協程gr1  gr2 = greenlet(test2)    #2 啟動第二個協程gr2  gr1.switch()             #3 首先gr1.switch() 就會去執行gr1這個協程

import gevent    def func1():      print('33[31;1m第一次列印33[0m')      gevent.sleep(2)          # 為什麼用gevent.sleep()而不是time.sleep()因為是為了模仿I/O      print('33[31;1m第六次列印33[0m')    def func2():      print('33[32;1m第二次列印33[0m')      gevent.sleep(1)      print('33[32;1m第四次列印33[0m')    def func3():      print('33[32;1m第三次列印33[0m')      gevent.sleep(1)      print('33[32;1m第五次列印33[0m')    gevent.joinall([            # 將要啟動的多個協程放到event.joinall的列表中，即可實現自動切換      gevent.spawn(func1),    # gevent.spawn(func1)啟動這個協程      gevent.spawn(func2),      gevent.spawn(func3),  ])    # 運行結果：  # 第一次列印  # 第二次列印  # 第三次列印  # 第四次列印  # 第五次列印  # 第六次列印

from urllib import request  import gevent,time  from gevent import monkey  monkey.patch_all()      #把當前程式所有的I/O操作給我單獨做上標記    def f(url):      print('GET: %s' % url)      resp = request.urlopen(url)      data = resp.read()      print('%d bytes received from %s.' % (len(data), url))    #1 並發執行部分  time_binxing = time.time()  gevent.joinall([          gevent.spawn(f, 'https://www.python.org/'),          gevent.spawn(f, 'https://www.yahoo.com/'),          gevent.spawn(f, 'https://github.com/'),  ])  print("並行時間：",time.time()-time_binxing)    #2 串列部分  time_chuanxing = time.time()  urls = [          'https://www.python.org/',          'https://www.yahoo.com/',          'https://github.com/',                                          ]  for url in urls:      f(url)  print("串列時間：",time.time()-time_chuanxing)    # 註：為什麼要在文件開通使用monkey.patch_all()  # 1. 因為有很多模組在使用I / O操作時Gevent是無法捕獲的，所以為了使Gevent能夠識別出程式中的I / O操作。  # 2. 就必須使用Gevent模組的monkey模組，把當前程式所有的I / O操作給我單獨做上標記  # 3.使用monkey做標記僅用兩步即可：        第一步(導入monkey模組)：  from gevent import monkey        第二步(聲明做標記)    ：   monkey.patch_all()

import gevent  from gevent import socket,monkey     #下面使用的socket是Gevent的socket，實際測試monkey沒用  # monkey.patch_all()    def server(port):      s = socket.socket()      s.bind(('0.0.0.0',port))      s.listen(5)      while True:          cli,addr = s.accept()          gevent.spawn(handle_request,cli)    def handle_request(conn):      try:          while True:              data = conn.recv(1024)              print('recv:',data)              conn.send(data)              if not data:                  conn.shutdown(socket.SHUT_WR)      except Exception as e:          print(e)      finally:          conn.close()    if __name__=='__main__':      server(8001)

import socket  HOST = 'localhost'    # The remote host  PORT = 8001           # The same port as used by the server  s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  s.connect((HOST, PORT))  while True:      msg = bytes(input(">>:"),encoding="utf8").strip()      if len(msg) == 0:continue      s.sendall(msg)      data = s.recv(1024)      print('Received', repr(data))  s.close()

from concurrent.futures import ThreadPoolExecutor  import time  def return_future_result(message):      time.sleep(2)      return message  pool = ThreadPoolExecutor(max_workers=2)                 # 創建一個最大可容納2個task的執行緒池  future1 = pool.submit(return_future_result, ("hello"))  # 往執行緒池裡面加入一個task  future2 = pool.submit(return_future_result, ("world"))  # 往執行緒池裡面加入一個task    print(future1.done())      # 判斷task1是否結束  time.sleep(3)  print(future2.done())      # 判斷task2是否結束  print(future1.result())    # 查看task1返回的結果  print(future2.result())    # 查看task2返回的結果    # 運行結果：  # False   # 這個False與下面的True會等待3秒  # True    # 後面三個輸出都是一起打出來的  # hello  # world

import concurrent.futures  import urllib.request  URLS = ['http://httpbin.org', 'http://example.com/', 'https://api.github.com/']  def load_url(url, timeout):      with urllib.request.urlopen(url, timeout=timeout) as conn:          return conn.read()    # We can use a with statement to ensure threads are cleaned up promptly  with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:      # Start the load operations and mark each future with its URL      # future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}   # 這一句相當於下面for循環獲取的字典      future_to_url = {}      for url in URLS:          future_to_url[executor.submit(load_url,url,60)] = url      # {'future對象':'url'}   future對象作為key，url作為value      for future in concurrent.futures.as_completed(future_to_url): # as_completed返回已經有返回結果的future對象          url = future_to_url[future]                                # 通過future對象獲取對應的url          try:              data = future.result()                                 # 獲取future對象的返回結果          except Exception as exc:              print('%r generated an exception: %s' % (url, exc))          else:              print('%r page is %d bytes' % (url, len(data)))

from concurrent.futures import ThreadPoolExecutor    # 創建執行緒池  executor = ThreadPoolExecutor(10)    def test_function(num1,num2):      return "%s + %s = %s"%(num1,num2,num1+num2)  result_iterators = executor.map(test_function,[1,2,3],[5,6,7])    for result in result_iterators:      print(result)    # 1 + 5 = 6  # 2 + 6 = 8  # 3 + 7 = 10

import concurrent.futures  import urllib.request    URLS = ['http://httpbin.org', 'http://example.com/', 'https://api.github.com/']    def load_url(url):      with urllib.request.urlopen(url, timeout=60) as conn:          return conn.read()    # We can use a with statement to ensure threads are cleaned up promptly  with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:      future_dic = {}      for url, data in zip(URLS, executor.map(load_url, URLS)):          print('%r page is %d bytes' % (url, len(data)))          future_dic[url] = data     # {'url':'執行結果'}   url作為key，執行結果作為value    # 'http://httpbin.org' page is 13011 bytes  # 'http://example.com/' page is 1270 bytes  # 'https://api.github.com/' page is 2039 bytes

import requests  url_list = [      'https://www.baidu.com',      'http://dig.chouti.com/',  ]    for url in url_list:      result = requests.get(url)      print(result.text)

import requests  from concurrent.futures import ProcessPoolExecutor    def fetch_request(url):      result = requests.get(url)      print(result.text)    url_list = [      'https://www.baidu.com',      'https://www.google.com/',         #google頁面會卡住，知道頁面超時後這個進程才結束      'http://dig.chouti.com/',          #chouti頁面內容會直接返回，不會等待Google頁面的返回  ]    if __name__ == '__main__':      pool = ProcessPoolExecutor(10)        # 創建執行緒池      for url in url_list:          pool.submit(fetch_request,url)    # 去執行緒池中獲取一個進程，進程去執行fetch_request方法      pool.shutdown(False)

import requests  from concurrent.futures import ThreadPoolExecutor    def fetch_request(url):      result = requests.get(url)      print(result.text)    url_list = [      'https://www.baidu.com',      'https://www.google.com/',         #google頁面會卡住，知道頁面超時後這個進程才結束      'http://dig.chouti.com/',          #chouti頁面內容會直接返回，不會等待Google頁面的返回  ]    pool = ThreadPoolExecutor(10)            # 創建一個執行緒池，最多開10個執行緒  for url in url_list:      pool.submit(fetch_request,url)       # 去執行緒池中獲取一個執行緒，執行緒去執行fetch_request方法    pool.shutdown(True)                      # 主執行緒自己關閉，讓子執行緒自己拿任務執行

from concurrent.futures import ThreadPoolExecutor  import requests    def fetch_async(url):      response = requests.get(url)      return response.text    def callback(future):      print(future.result())    url_list = ['http://www.github.com', 'http://www.bing.com']  pool = ThreadPoolExecutor(5)  for url in url_list:      v = pool.submit(fetch_async, url)      v.add_done_callback(callback)  pool.shutdown(wait=True)

import gevent  import requests  from gevent import monkey    monkey.patch_all()    # 這些請求誰先回來就先處理誰  def fetch_async(method, url, req_kwargs):      response = requests.request(method=method, url=url, **req_kwargs)      print(response.url, response.content)    # ##### 發送請求 #####  gevent.joinall([      gevent.spawn(fetch_async, method='get', url='https://www.python.org/', req_kwargs={}),      gevent.spawn(fetch_async, method='get', url='https://www.google.com/', req_kwargs={}),      gevent.spawn(fetch_async, method='get', url='https://github.com/', req_kwargs={}),  ])