yieldpython
① python的yield 和callback 求助
for k in ojt:
if k['url']:
print k['url']
yield Request(k['url'],callback=self.parse_item)
print len(ojt)
def parse_item(self,response):
hxs = Selector(response)
movie_name = hxs.xpath('//*[@id="content"]/h1/span[1]/text()').extract()
movie_director =hxs.xpath('//*[@id="info"]/span[1]/span[2]/a/text()').extract()
movie_writer = hxs.xpath('//*[@id="info"]/span[2]/span[2]/a/text()').extract()
在這段代碼裡面的yield執行順序我很不解，這段代碼的意思是將得到的url都輸出，但是每次輸出的時候都滾尺會將url放進yield語句的呀 為什麼沒有執行呢 就是每次輸出遲改一條url就調用下一個函數呢 就是callback函數呢 而且輸出的len（）為什麼碼備判只執行了一次呢？
兄弟，看起來像是scrapy。
yield Request(k['url'],callback=self.parse_item)
這段話的意思大概是說，請求k['url']這個url，然後給parse_item函數做處理。
具體的不說啦。你去網路yield和callback
② python中的yield能嵌套嗎
可以嵌套，給你個例子，用python3可以直接運行
#!/usr/local/bin/python3
#-*- coding:utf-8 -*-
def consum(man):
print("1111111111111111")
while True:
print("22222222222:%s need foods"%man)
bone = yield
print("33333333333:%s eat %s foods"%(man,bone))
def proct(obj):
print("444444444444");
while True:
r = yield
print("55555555555r==%s"%r);
for i in range(r):
print("proct:making food index is %s"%i);
obj.send(i)
if __name__ == "__main__":
con1 = consum("Fat")
con1.send(None)
con2 = proct(con1)
con2.send(None)
con2.send(2)
con2.send(4)
con2.send(6)
③ python中yield是什麼意思
一個帶有 yield 的函數就是一個 generator，它和普通函數不同，生成一個 generator 看起來像函數調用，但不會執行任何函數代碼，直到對其調用 next()（在 for 循環中會自動調用 next()）才開始執行。雖然執行流程仍按函數的流程執行，但每執行到一個 yield 語句就會中斷，並返回一個迭代值，下次執行時從 yield 的下一個語句繼續執行。看起來就好像一個函數在正常執行的過程中被 yield 中斷了數次，每次中斷都會通過 yield 返回當前的迭代值。
具體，請參考下以下資料：
http://www.ibm.com/developerworks/cn/opensource/os-cn-python-yield/
④ 閑話python 45: 淺談生成器yield
生成器似乎並不是一個經常被開發者討論的語法，因此也就沒有它的大兄弟迭代器那麼著名。大家不討論它並不是說大家都已經對它熟悉到人盡皆知，與之相反，即使是工作多年的開發者可能對生成器的運行過程還是知之甚少。這是什麼原因導致的呢？我猜想大概有以下幾點原因： (1)運行流程不同尋常，(2)日常開發不需要，(3)常常將生成器與迭代器混淆。 生成器的運行流程可以按照協程來理解，也就是說 返回中間結果，斷點繼續運行 。這與我們通常對於程序調用的理解稍有差異。這種運行模式是針對什麼樣的需求呢？ 一般而言，生成器是應用於大量磁碟資源的處理。 比如一個很大的文件，每次讀取一行，下一次讀取需要以上一次讀取的位置為基礎。下面就通過代碼演示具體看看生成器的運行機制、使用方式以及與迭代器的比較。
什麼是生成器？直接用文字描述可能太過抽象，倒不如先運行一段代碼，分析這段代碼的運行流程，然後總結出自己對生成器的理解。
從以上演示可以看出，這段代碼定義了一個函數，這個函數除了yield這個關鍵字之外與一般函數並沒有差異，也就是說生成器的魔法都是這個yield關鍵字引起的。 第一點，函數的返回值是一個生成器對象。 上述代碼中，直接調用這個看似普通的函數，然後將返回值列印出來，發現返回值是一個對象，而並不是普通函數的返回值。 第二點，可以使用next對這個生成器對象進行操作 。生成器對象天然的可以被next函數調用，然後返回在yield關鍵字後面的內容。 第三，再次調用next函數處理生成器對象，發現是從上次yield語句之後繼續運行，直到下一個yield語句返回。
生成器的運行流程確實詭異，下面還要演示一個生成器可以執行的更加詭異的操作：運行過程中向函數傳參。
返回生成器和next函數操作生成器已經並不奇怪了，但是在函數運行過程中向其傳參還是讓人驚呆了。 調用生成器的send函數傳入參數，在函數內使用yield語句的返回值接收，然後繼續運行直到下一個yield語句返回。 以前實現這種運行流程的方式是在函數中加上一個從控制台獲取數據的指令，或者提前將參數傳入，但是現在不用了，send方式使得傳入的參數可以隨著讀取到的參數變化而變化。
很多的開發者比較容易混淆生成器和迭代器，而迭代器的運行過程更加符合一般的程序調用運行流程，因此從親進度和使用熟悉度而言，大家對迭代器更有好感。比如下面演示一個對迭代器使用next方法進行操作。
從以上演示來看，大家或許會認為迭代器比生成器簡單易用得太多了。不過，如果你了解迭代器的實現機制，可能就不會這么早下結論了。python內置了一些已經實現了的迭代器使用確實方便，但是如果需要自己去寫一個迭代器呢？下面這段代碼就帶大家見識以下迭代器的實現。
在python中，能被next函數操作的對象一定帶有__next__函數的實現，而能夠被迭代的對象有必須實現__iter__函數。看了這么一段操作，相信大家對迭代器實現的繁瑣也是深有體會了，那麼生成器的實現是不是會讓你覺得更加簡單易用呢？不過千萬別產生一個誤區，即生成器比迭代器簡單就多用生成器。 在實際開發中，如果遇到與大量磁碟文件或者資料庫操作相關的倒是可以使用生成器。但是在其他的任務中使用生成器難免有炫技，並且使邏輯不清晰而導致可讀性下降的嫌疑。 這大概也能解釋生成器受冷落的原因。不過作為一個專業的開發者，熟悉語言特性是分內之事。
到此，關於生成器的討論就結束了。本文的notebook版本文件在github上的cnbluegeek/notebook倉庫中共享，歡迎感興趣的朋友前往下載。
⑤ python的關鍵字yield有什麼作用
yield是python中定義為生成器函數，其本質是封裝了 __iter__和__next__方法 的迭代器；
與return返回的區別：return只能返回一次值，函數就終止了，而yield能多次返回值，每次返回都會將函數暫停，下一次next會從上一次暫停的位置繼續執行；
以下用示例說明：
deftest(a,b):
print("fromtest(),a+b=%d"%(a+b))
return("我是return返回的")
deftest_yield(a,b): #函數體中有yield關鍵字，函數就可以稱為生成器函數
print("fromtest_yield,a+b=%d"%(a+b))
yield("我是第一次碰到yield關鍵字返回的") #程序運行時碰到yield，退出函數體並記錄位置，下次調用跳過之前運行的代碼
print("fromtest_yield,a*2=%d"%(a*2))
yield("我是第二次調用碰到yield關鍵字返回的")
print(test(11,33))
g=test_yield(11,33)
print(next(g)) #通過next()調用生成器函數
print(next(g)) #第二次調用生成器函數
'''
執行結果：
fromtest(),a+b=44
我是return返回的
fromtest_yield,a+b=44
我是第一次碰到yield關鍵字返回的
fromtest_yield,a*2=22
我是第二次調用碰到yield關鍵字返回的
'''
⑥ python非同步有哪些方式
yield相當於return，他將相應的值返回給調用next()或者send()的調用者，從而交出了CPU使用權，而當調用者再次調用next()或者send()的時候，又會返回到yield中斷的地方，如果send有參數，還會將參數返回給yield賦值的變數,如果沒有就和next（）一樣賦值為None。但是這里會遇到一個問題，就是嵌套使用generator時外層的generator需要寫大量代碼，看如下示例：
注意以下代碼均在Python3.6上運行調試
#!/usr/bin/env python# encoding:utf-8def inner_generator():
i = 0
while True:
i = yield i if i > 10: raise StopIterationdef outer_generator():
print("do something before yield")
from_inner = 0
from_outer = 1
g = inner_generator()
g.send(None) while 1: try:
from_inner = g.send(from_outer)
from_outer = yield from_inner except StopIteration: breakdef main():
g = outer_generator()
g.send(None)
i = 0
while 1: try:
i = g.send(i + 1)
print(i) except StopIteration: breakif __name__ == '__main__':
main()041
為了簡化，在Python3.3中引入了yield from
yield from
使用yield from有兩個好處，
1、可以將main中send的參數一直返回給最里層的generator，
2、同時我們也不需要再使用while循環和send (), next()來進行迭代。
我們可以將上邊的代碼修改如下：
def inner_generator():
i = 0
while True:
i = yield i if i > 10: raise StopIterationdef outer_generator():
print("do something before coroutine start") yield from inner_generator()def main():
g = outer_generator()
g.send(None)
i = 0
while 1: try:
i = g.send(i + 1)
print(i) except StopIteration: breakif __name__ == '__main__':
main()
執行結果如下：
do something before coroutine start123456789101234567891011
這里inner_generator()中執行的代碼片段我們實際就可以認為是協程，所以總的來說邏輯圖如下：
我們都知道Python由於GIL(Global Interpreter Lock)原因，其線程效率並不高，並且在*nix系統中，創建線程的開銷並不比進程小，因此在並發操作時，多線程的效率還是受到了很大制約的。所以後來人們發現通過yield來中斷代碼片段的執行，同時交出了cpu的使用權，於是協程的概念產生了。在Python3.4正式引入了協程的概念，代碼示例如下：
import asyncio# Borrowed from http://curio.readthedocs.org/en/latest/[email protected] countdown(number, n):
while n > 0:
print('T-minus', n, '({})'.format(number)) yield from asyncio.sleep(1)
n -= 1loop = asyncio.get_event_loop()
tasks = [
asyncio.ensure_future(countdown("A", 2)),
asyncio.ensure_future(countdown("B", 3))]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()12345678910111213141516
示例顯示了在Python3.4引入兩個重要概念協程和事件循環，
通過修飾符@asyncio.coroutine定義了一個協程，而通過event loop來執行tasks中所有的協程任務。之後在Python3.5引入了新的async & await語法，從而有了原生協程的概念。
async & await
在Python3.5中，引入了aync&await 語法結構，通過」aync def」可以定義一個協程代碼片段，作用類似於Python3.4中的@asyncio.coroutine修飾符，而await則相當於」yield from」。
先來看一段代碼，這個是我剛開始使用async&await語法時，寫的一段小程序。
#!/usr/bin/env python# encoding:utf-8import asyncioimport requestsimport time
async def wait_download(url):
response = await requets.get(url)
print("get {} response complete.".format(url))
async def main():
start = time.time()
await asyncio.wait([
wait_download("http://www.163.com"),
wait_download("http://www.mi.com"),
wait_download("http://www.google.com")])
end = time.time()
print("Complete in {} seconds".format(end - start))
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
這里會收到這樣的報錯：
Task exception was never retrieved
future: <Task finished coro=<wait_download() done, defined at asynctest.py:9> exception=TypeError("object Response can't be used in 'await' expression",)>
Traceback (most recent call last):
File "asynctest.py", line 10, in wait_download
data = await requests.get(url)
TypeError: object Response can't be used in 'await' expression123456
這是由於requests.get()函數返回的Response對象不能用於await表達式，可是如果不能用於await，還怎麼樣來實現非同步呢？
原來Python的await表達式是類似於」yield from」的東西，但是await會去做參數檢查，它要求await表達式中的對象必須是awaitable的，那啥是awaitable呢？ awaitable對象必須滿足如下條件中其中之一：
1、A native coroutine object returned from a native coroutine function .
原生協程對象
2、A generator-based coroutine object returned from a function decorated with types.coroutine() .
types.coroutine()修飾的基於生成器的協程對象，注意不是Python3.4中asyncio.coroutine
3、An object with an await method returning an iterator.
實現了await method，並在其中返回了iterator的對象
根據這些條件定義，我們可以修改代碼如下：
#!/usr/bin/env python# encoding:utf-8import asyncioimport requestsimport time
async def download(url): # 通過async def定義的函數是原生的協程對象
response = requests.get(url)
print(response.text)
async def wait_download(url):
await download(url) # 這里download(url)就是一個原生的協程對象
print("get {} data complete.".format(url))
async def main():
start = time.time()
await asyncio.wait([
wait_download("http://www.163.com"),
wait_download("http://www.mi.com"),
wait_download("http://www.google.com")])
end = time.time()
print("Complete in {} seconds".format(end - start))
loop = asyncio.get_event_loop()
loop.run_until_complete(main())27282930
好了現在一個真正的實現了非同步編程的小程序終於誕生了。
而目前更牛逼的非同步是使用uvloop或者pyuv，這兩個最新的Python庫都是libuv實現的，可以提供更加高效的event loop。
uvloop和pyuv
pyuv實現了Python2.x和3.x，但是該項目在github上已經許久沒有更新了，不知道是否還有人在維護。
uvloop只實現了3.x, 但是該項目在github上始終活躍。
它們的使用也非常簡單，以uvloop為例，只需要添加以下代碼就可以了
import asyncioimport uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())123