pythonyield异步
① 如何利用python asyncio编写异步爬虫
你要安装 python3.4 ，asyncio是Python 3.4版本引入的标准库，直接内置了对异步IO的支持。
例子
https://github.com/michaelliao/learn-python3/blob/master/samples/async/async_hello.py
importasyncio
@asyncio.coroutine
defhello():
print("Helloworld!")
#异步调用asyncio.sleep(1):
r=yieldfromasyncio.sleep(1)
print("Helloagain!")
#获取EventLoop:
loop=asyncio.get_event_loop()
#执行coroutine
loop.run_until_complete(hello())
loop.close()
### 这里异步爬虫 里面不要用太多阻塞的类 如:python-mysqldb
async 学习资料：
https://github.com/python/asyncio/wiki
https://docs.python.org/3.4/library/asyncio.html
http://asyncio.org/
② python yield怎么实现的
yield是生成器关键词，是在函数内使用的生成器语法（你也可以理解为是用在函数内的创建生成器的方法），让函数返回的是一个生成器而不再返回函数计算得到的结果。比如：
同样的迭代完再迭代则会报错
③ 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 语句
我在2x版本下测试下显式调用throw来抛出GeneratorExit异常是可以被捕获的
我查了一下文档,楼主你的理解可能错了,文档的意思是说迭代器调用close退出时如果处于暂停状态就会内部产生一个GeneratorExit异常,这个异常是不能捕获的,内部会转换成RuntimeError抛出
正常退出的话则产生StopIteration异常
测试代码如下
defmy_generator():
try:
yield'dosomething'
exceptValueError:
yield'dealingwiththeexceptions'
exceptGeneratorExit:
yield"Yes,Icanyieldavalue"
finally:
print"Ok,let'sclean"
gen=my_generator()
gen.next()#这行注释掉后则不会抛出异常
try:
gen.close()
exceptRuntimeError:
print"closeerror"
⑤ 如何看待 Python 3.5支持Async/Await异步编程
根据Python增强提案(PEP) 第0492号， Python 3.5将通过async和await语法增加对协程的支持。该提案目的是使协程成为Python语言的原生特性，并“建立一种普遍、易用的异步编程思维模型。”
这个新提议中声明一个协程的语法如下：
async def read_data(db):
pass
async是明确将函数声明为协程的关键字，即便没有使用await表达式。这样的函数执行时会返回一个协程对象。
在协程函数内部，可在某个表达式之前使用await关键字来暂停协程的执行，以等待某进程完成：
async def read_data(db):
data = await db.fetch('SELECT ...')
...
由于增强版生成器的存在，Python中其实早已有了协程的形式，例如当yield或yield from声明在Python生成器内部出现，该生成器就会被当作协程。
以下示例展示基于生成器的协程的用法：
>>> def createGenerator():
... mylist = range(3)
... for i in mylist:
... yield i*i
...
>>> mygenerator = createGenerator()
>>> for i in mygenerator:
... print(i)
0
1
4
以上代码中，每当生成器在for循环中被调用，该生成器中的for循环就会返回一个新的值。
关于await用法的更多示例请参见上文提到的PEP #0492.
这个关于协程的新提案想明确地把生成器与协程区分开，这么做有如下好处：
使这两个概念对新开发者来说更易于理解，因为它们二者的语法并不一样；
能消除由于重构时不小心移除了协程中的yield声明而导致的“不明确错误”，这会导致协程变成普通的生成器。
- async def read_data(db):
- data = await db.fetch('SELECT ...')
- if (data...)
- await api.send(data ...')
async/await语法能让程序员以序列方式编写代码，但编译器则会将其当作一系列的协程来处理，从而实现有效的并发。回到我们之前的例子，async/await使我们可以顺序地编写多个await声明语句，就好像每个语句都会阻塞并等待结果，但实际上这并不会导致任何阻塞：
⑥ 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
⑦ python中yield的用法问题
yield就是保存当前程序执行状态。
你用for循环的时候，每次取一个元素的时候就会计算一次。
用yield的函数叫generator，和iterator一样，它的好处是不用一次计算所有元素，而是用一次算一次，可以节省很多空间。generator每次计算需要上一次计算结果，所以用yield，否则一return，上次计算结果就没了。
所以保存列表的说法是完全错误的。
⑧ Python的yield问题
python yield from
defgenerator2():
foriinrange(10):
yieldidefgenerator3():
forjinrange(10,20):
yieldjdefgenerator():
foriingenerator2():
yieldi
forjingenerator3():
yieldj
==
defgenerator():
yieldfromgenerator2()
yieldfromgenerator3()
⑨ 关于python中yield函数
next()一次执行一次，并不一次性执行完，是个itertator.也可以通过for来执行
⑩ python中yield是什么意思
一个带有 yield 的函数就是一个 generator，它和普通函数不同，生成一个 generator 看起来像函数调用，但不会执行任何函数代码，直到对其调用 next()（在 for 循环中会自动调用 next()）才开始执行。虽然执行流程仍按函数的流程执行，但每执行到一个 yield 语句就会中断，并返回一个迭代值，下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。
具体，请参考下以下资料：
http://www.ibm.com/developerworks/cn/opensource/os-cn-python-yield/