blocks|key|1484533|text|它不在语言核心中，但一个非常成熟的库是Twisted，它可以完成您想要的功能。它引入了延迟对象，您可以将回调或错误处理程序(“errback”)附加到该对象。延迟基本上是一个“承诺”，一个函数最终会有一个结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1484534|entityMap|0|LINK|mutability|MUTABLE|url|http://twistedmatrix.com/^0|J|7|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

It's not in the language core, but a very mature library that does what you want is <a href="http://twistedmatrix.com/" rel="noreferrer">Twisted</a>. It introduces the Deferred object, which you can attach callbacks or error handlers ("errbacks") to. A Deferred is basically a "promise" that a function will have a result eventually.

blocks|key|1484556|text|类似于：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1484557|import+threading

thr+=+threading.Thread(target=foo,+args=(),+kwargs={})
thr.start()+#+Will+run+"foo"
....
thr.is_alive()+#+Will+return+whether+foo+is+running+currently
....
thr.join()+#+Will+wait+till+"foo"+is+done|code-block|syntax|javascript|1484558|有关更多详细信息，请参阅https://docs.python.org/library/threading.html上的文档。|offset|length|1484559|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/library/threading.html^0|0|0|C|1A|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Something like:

<pre><code>import threading

thr = threading.Thread(target=foo, args=(), kwargs={})
thr.start() # Will run "foo"
....
thr.is_alive() # Will return whether foo is running currently
....
thr.join() # Will wait till "foo" is done
</code></pre>

See the documentation at <a href="https://docs.python.org/library/threading.html" rel="noreferrer">https://docs.python.org/library/threading.html</a> for more details.

blocks|key|1484612|text|有什么理由不使用线程吗？您可以使用threading类。使用isAlive()代替finished()函数。result()函数可以对线程执行join()操作并检索结果。如果可以，覆盖run()和__init__函数以调用构造函数中指定的函数，并将值保存到类的实例中的某个位置。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1484613|entityMap^0|H|9|U|9|15|A|1I|8|1Z|6|2K|5|2Q|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|G|$]]

Is there any reason not to use threads? You can use the <code>threading</code> class.
Instead of <code>finished()</code> function use the <code>isAlive()</code>. The <code>result()</code> function could <code>join()</code> the thread and retrieve the result. And, if you can, override the <code>run()</code> and <code>__init__</code> functions to call the function specified in the constructor and save the value somewhere to the instance of the class.

blocks|key|1270132|text|您可以使用Python2.6中添加的multiprocessing+module。您可以使用进程池，然后使用以下命令异步获取结果：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1270133|apply_async(func[,+args[,+kwds[,+callback]]])|code-block|syntax|javascript|1270134|例如：|1270135|from+multiprocessing+import+Pool

def+f(x):
++++return+x*x

if+__name__+==+'__main__':
++++pool+=+Pool(processes=1)++++++++++++++#+Start+a+worker+processes.
++++result+=+pool.apply_async(f,+[10],+callback)+#+Evaluate+"f(10)"+asynchronously+calling+callback+when+finished.|1270136|这只是一种选择。此模块提供了许多工具来实现您想要的功能。此外，用它来制作一个装饰器也很容易。|1270137|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/multiprocessing.html#module-multiprocessing^0|I|M|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

You can use the <a href="http://docs.python.org/library/multiprocessing.html#module-multiprocessing" rel="noreferrer">multiprocessing module</a> added in Python 2.6. You can use pools of processes and then get results asynchronously with: 

<pre><code>apply_async(func[, args[, kwds[, callback]]])
</code></pre>

E.g.:

<pre><code>from multiprocessing import Pool

def f(x):
 return x*x

if __name__ == '__main__':
 pool = Pool(processes=1) # Start a worker processes.
 result = pool.apply_async(f, [10], callback) # Evaluate "f(10)" asynchronously calling callback when finished.
</code></pre>

This is only one alternative. This module provides lots of facilities to achieve what you want. Also it will be really easy to make a decorator from this.

blocks|key|1270175|text|我的解决方案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1270176|import+threading

class+TimeoutError(RuntimeError):
++++pass

class+AsyncCall(object):
++++def+__init__(self,+fnc,+callback+=+None):
++++++++self.Callable+=+fnc
++++++++self.Callback+=+callback

++++def+__call__(self,+*args,+**kwargs):
++++++++self.Thread+=+threading.Thread(target+=+self.run,+name+=+self.Callable.__name__,+args+=+args,+kwargs+=+kwargs)
++++++++self.Thread.start()
++++++++return+self

++++def+wait(self,+timeout+=+None):
++++++++self.Thread.join(timeout)
++++++++if+self.Thread.isAlive():
++++++++++++raise+TimeoutError()
++++++++else:
++++++++++++return+self.Result

++++def+run(self,+*args,+**kwargs):
++++++++self.Result+=+self.Callable(*args,+**kwargs)
++++++++if+self.Callback:
++++++++++++self.Callback(self.Result)

class+AsyncMethod(object):
++++def+__init__(self,+fnc,+callback=None):
++++++++self.Callable+=+fnc
++++++++self.Callback+=+callback

++++def+__call__(self,+*args,+**kwargs):
++++++++return+AsyncCall(self.Callable,+self.Callback)(*args,+**kwargs)

def+Async(fnc+=+None,+callback+=+None):
++++if+fnc+==+None:
++++++++def+AddAsyncCallback(fnc):
++++++++++++return+AsyncMethod(fnc,+callback)
++++++++return+AddAsyncCallback
++++else:
++++++++return+AsyncMethod(fnc,+callback)|code-block|syntax|javascript|1270177|并且完全按照请求工作：|1270178|@Async
def+fnc():
++++pass|1270179|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

My solution is:

<pre><code>import threading

class TimeoutError(RuntimeError):
 pass

class AsyncCall(object):
 def __init__(self, fnc, callback = None):
 self.Callable = fnc
 self.Callback = callback

 def __call__(self, *args, **kwargs):
 self.Thread = threading.Thread(target = self.run, name = self.Callable.__name__, args = args, kwargs = kwargs)
 self.Thread.start()
 return self

 def wait(self, timeout = None):
 self.Thread.join(timeout)
 if self.Thread.isAlive():
 raise TimeoutError()
 else:
 return self.Result

 def run(self, *args, **kwargs):
 self.Result = self.Callable(*args, **kwargs)
 if self.Callback:
 self.Callback(self.Result)

class AsyncMethod(object):
 def __init__(self, fnc, callback=None):
 self.Callable = fnc
 self.Callback = callback

 def __call__(self, *args, **kwargs):
 return AsyncCall(self.Callable, self.Callback)(*args, **kwargs)

def Async(fnc = None, callback = None):
 if fnc == None:
 def AddAsyncCallback(fnc):
 return AsyncMethod(fnc, callback)
 return AddAsyncCallback
 else:
 return AsyncMethod(fnc, callback)
</code></pre>

And works exactly as requested:

<pre><code>@Async
def fnc():
 pass
</code></pre>

blocks|key|1270243|text|您可以实现一个装饰器来使您的函数异步，尽管这有点棘手。multiprocessing模块充满了一些小怪癖和看似随意的限制-尽管如此，我们更有理由将其封装在一个友好的界面中。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1270244|from+inspect+import+getmodule
from+multiprocessing+import+Pool


def+async(decorated):
++++r'''Wraps+a+top-level+function+around+an+asynchronous+dispatcher.

++++++++when+the+decorated+function+is+called,+a+task+is+submitted+to+a
++++++++process+pool,+and+a+future+object+is+returned,+providing+access+to+an
++++++++eventual+return+value.

++++++++The+future+object+has+a+blocking+get()+method+to+access+the+task
++++++++result:+it+will+return+immediately+if+the+job+is+already+done,+or+block
++++++++until+it+completes.

++++++++This+decorator+won't+work+on+methods,+due+to+limitations+in+Python's
++++++++pickling+machinery+(in+principle+methods+could+be+made+pickleable,+but
++++++++good+luck+on+that).
++++'''
++++#+Keeps+the+original+function+visible+from+the+module+global+namespace,
++++#+under+a+name+consistent+to+its+__name__+attribute.+This+is+necessary+for
++++#+the+multiprocessing+pickling+machinery+to+work+properly.
++++module+=+getmodule(decorated)
++++decorated.__name__+%2B=+'_original'
++++setattr(module,+decorated.__name__,+decorated)

++++def+send(*args,+**opts):
++++++++return+async.pool.apply_async(decorated,+args,+opts)

++++return+send|code-block|syntax|javascript|1270245|下面的代码说明了装饰器的用法：|1270246|@async
def+printsum(uid,+values):
++++summed+=+0
++++for+value+in+values:
++++++++summed+%2B=+value

++++print("Worker+%25i:+sum+value+is+%25i"+%25+(uid,+summed))

++++return+(uid,+summed)


if+__name__+==+'__main__':
++++from+random+import+sample

++++#+The+process+pool+must+be+created+inside+__main__.
++++async.pool+=+Pool(4)

++++p+=+range(0,+1000)
++++results+=+[]
++++for+i+in+range(4):
++++++++result+=+printsum(i,+sample(p,+100))
++++++++results.append(result)

++++for+result+in+results:
++++++++print("Worker+%25i:+sum+value+is+%25i"+%25+result.get())|1270247|在现实世界中，我会在装饰器上做更多的说明，提供一些方法来关闭它以进行调试(同时保持未来的接口不变)，或者提供一个用于处理异常的工具；但我认为这已经很好地演示了这个原则。|1270248|entityMap^0|R|F|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

You can implement a decorator to make your functions asynchronous, though that's a bit tricky. The <code>multiprocessing</code> module is full of little quirks and seemingly arbitrary restrictions – all the more reason to encapsulate it behind a friendly interface, though.

<pre><code>from inspect import getmodule
from multiprocessing import Pool


def async(decorated):
 r'''Wraps a top-level function around an asynchronous dispatcher.

 when the decorated function is called, a task is submitted to a
 process pool, and a future object is returned, providing access to an
 eventual return value.

 The future object has a blocking get() method to access the task
 result: it will return immediately if the job is already done, or block
 until it completes.

 This decorator won't work on methods, due to limitations in Python's
 pickling machinery (in principle methods could be made pickleable, but
 good luck on that).
 '''
 # Keeps the original function visible from the module global namespace,
 # under a name consistent to its __name__ attribute. This is necessary for
 # the multiprocessing pickling machinery to work properly.
 module = getmodule(decorated)
 decorated.__name__ += '_original'
 setattr(module, decorated.__name__, decorated)

 def send(*args, **opts):
 return async.pool.apply_async(decorated, args, opts)

 return send
</code></pre>

The code below illustrates usage of the decorator:

<pre><code>@async
def printsum(uid, values):
 summed = 0
 for value in values:
 summed += value

 print("Worker %i: sum value is %i" % (uid, summed))

 return (uid, summed)


if __name__ == '__main__':
 from random import sample

 # The process pool must be created inside __main__.
 async.pool = Pool(4)

 p = range(0, 1000)
 results = []
 for i in range(4):
 result = printsum(i, sample(p, 100))
 results.append(result)

 for result in results:
 print("Worker %i: sum value is %i" % result.get())
</code></pre>

In a real-world case I would ellaborate a bit more on the decorator, providing some way to turn it off for debugging (while keeping the future interface in place), or maybe a facility for dealing with exceptions; but I think this demonstrates the principle well enough.

blocks|key|1270255|text|只是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1270256|import+threading,+time

def+f():
++++print+"f+started"
++++time.sleep(3)
++++print+"f+finished"

threading.Thread(target=f).start()|code-block|syntax|javascript|1270257|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just

<pre><code>import threading, time

def f():
 print "f started"
 time.sleep(3)
 print "f finished"

threading.Thread(target=f).start()
</code></pre>

blocks|key|1270316|text|你可以使用eventlet。它允许您编写看似同步的代码，但让它在网络上异步操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1270317|下面是一个超小型爬虫的例子：|1270318|urls+=+["http://www.google.com/intl/en_ALL/images/logo.gif",
+++++"https://wiki.secondlife.com/w/images/secondlife.jpg",
+++++"http://us.i1.yimg.com/us.yimg.com/i/ww/beta/y3.gif"]

import+eventlet
from+eventlet.green+import+urllib2

def+fetch(url):

++return+urllib2.urlopen(url).read()

pool+=+eventlet.GreenPool()

for+body+in+pool.imap(fetch,+urls):
++print+"got+body",+len(body)|code-block|syntax|javascript|1270319|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You could use eventlet. It lets you write what appears to be synchronous code, but have it operate asynchronously over the network.

Here's an example of a super minimal crawler:

<pre><code>urls = ["http://www.google.com/intl/en_ALL/images/logo.gif",
 "https://wiki.secondlife.com/w/images/secondlife.jpg",
 "http://us.i1.yimg.com/us.yimg.com/i/ww/beta/y3.gif"]

import eventlet
from eventlet.green import urllib2

def fetch(url):

 return urllib2.urlopen(url).read()

pool = eventlet.GreenPool()

for body in pool.imap(fetch, urls):
 print "got body", len(body)
</code></pre>

blocks|key|1484971|text|像这样的东西对我来说是有效的，然后你可以调用这个函数，它会把自己分派到一个新的线程上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1484972|from+thread+import+start_new_thread

def+dowork(asynchronous=True):
++++if+asynchronous:
++++++++args+=+(False)
++++++++start_new_thread(dowork,args)+#Call+itself+on+a+new+thread.
++++else:
++++++++while+True:
++++++++++++#do+something...
++++++++++++time.sleep(60)+#sleep+for+a+minute
++++return|code-block|syntax|javascript|1484973|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Something like this works for me, you can then call the function, and it will dispatch itself onto a new thread.

<pre><code>from thread import start_new_thread

def dowork(asynchronous=True):
 if asynchronous:
 args = (False)
 start_new_thread(dowork,args) #Call itself on a new thread.
 else:
 while True:
 #do something...
 time.sleep(60) #sleep for a minute
 return
</code></pre>

blocks|key|1485002|text|您可以使用concurrent.futures+(在Python3.2中添加)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1485003|import+time
from+concurrent.futures+import+ThreadPoolExecutor


def+long_computation(duration):
++++for+x+in+range(0,+duration):
++++++++print(x)
++++++++time.sleep(1)
++++return+duration+*+2


print('Use+polling')
with+ThreadPoolExecutor(max_workers=1)+as+executor:
++++future+=+executor.submit(long_computation,+5)
++++while+not+future.done():
++++++++print('waiting...')
++++++++time.sleep(0.5)

++++print(future.result())

print('Use+callback')
executor+=+ThreadPoolExecutor(max_workers=1)
future+=+executor.submit(long_computation,+5)
future.add_done_callback(lambda+f:+print(f.result()))

print('waiting+for+callback')

executor.shutdown(False)++#+non-blocking

print('shutdown+invoked')|code-block|syntax|javascript|1485004|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/concurrent.futures.html^0|5|I|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

You can use <a href="https://docs.python.org/3/library/concurrent.futures.html" rel="nofollow noreferrer" title="concurrent futures">concurrent.futures</a> (added in Python 3.2).

<pre><code>import time
from concurrent.futures import ThreadPoolExecutor


def long_computation(duration):
 for x in range(0, duration):
 print(x)
 time.sleep(1)
 return duration * 2


print('Use polling')
with ThreadPoolExecutor(max_workers=1) as executor:
 future = executor.submit(long_computation, 5)
 while not future.done():
 print('waiting...')
 time.sleep(0.5)

 print(future.result())

print('Use callback')
executor = ThreadPoolExecutor(max_workers=1)
future = executor.submit(long_computation, 5)
future.add_done_callback(lambda f: print(f.result()))

print('waiting for callback')

executor.shutdown(False) # non-blocking

print('shutdown invoked')
</code></pre>

blocks|key|1485056|text|您可以使用process。如果你想永远运行它，在你的函数中使用while+(如网络)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1485057|from+multiprocessing+import+Process
def+foo():
++++while+1:
++++++++#+Do+something

p+=+Process(target+=+foo)
p.start()|code-block|syntax|javascript|1485058|如果你只想运行一次，就像这样做：|1485059|from+multiprocessing+import+Process
def+foo():
++++#+Do+something

p+=+Process(target+=+foo)
p.start()
p.join()|1485060|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can use process. If you want to run it forever use while (like networking) in you function:

<pre><code>from multiprocessing import Process
def foo():
 while 1:
 # Do something

p = Process(target = foo)
p.start()
</code></pre>

if you just want to run it one time, do like that:

<pre><code>from multiprocessing import Process
def foo():
 # Do something

p = Process(target = foo)
p.start()
p.join()
</code></pre>

I was wondering if there's any library for asynchronous method calls in <a href="http://en.wikipedia.org/wiki/Python_%28programming_language%29" rel="noreferrer">Python</a>. It would be great if you could do something like

<pre><code>@async
def longComputation():
 &lt;code&gt;


token = longComputation()
token.registerCallback(callback_function)
# alternative, polling
while not token.finished():
 doSomethingElse()
 if token.finished():
 result = token.result()
</code></pre>

Or to call a non-async routine asynchronously

<pre><code>def longComputation()
 &lt;code&gt;

token = asynccall(longComputation())
</code></pre>

It would be great to have a more refined strategy as native in the language core. Was this considered?

Asynchronous method call in Python?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想知道中是否有用于异步方法调用的库。如果你能做像这样的事情那就太好了@asyncdef longComputation(): <code>token = longComputation()token.registerCallback(callback_function)# alternative, pollin...

问Python中的异步方法调用？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中的异步方法调用？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中的异步方法调用？
EN