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