Python istekleriyle Eşzamansız İstekler

Python için istek kitaplığının belgelerinde sağlanan örneği denedim .

İle async.map(rs), yanıt kodlarını alıyorum, ancak istenen her sayfanın içeriğini almak istiyorum. Örneğin, bu çalışmaz:

out = async.map(rs)
print out[0].content

Not

Aşağıdaki cevap v0.13.0 + talepleri için geçerli değildir . Bu soru yazıldıktan sonra eşzamansız işlevsellik mağaralara taşındı . Ancak, sadece aşağıdaki requestsile değiştirebilirsiniz grequestsve çalışması gerekir.

Bu cevabı, <v0.13.0 isteklerini kullanmakla ilgili orijinal soruyu yansıtacak şekilde bıraktım.

async.map Eşzamansız olarak birden fazla görev yapmak için şunları yapmanız gerekir:

1. Her bir nesneyle (göreviniz) ne yapmak istediğinize ilişkin bir işlev tanımlayın
2. Bu işlevi isteğinize bir olay kancası olarak ekleyin
3. async.mapTüm isteklerin / işlemlerin bir listesini arayın

Misal:

from requests import async
# If using requests > v0.13.0, use
# from grequests import async

urls = [
    'http://python-requests.org',
    'http://httpbin.org',
    'http://python-guide.org',
    'http://kennethreitz.com'
]

# A simple task to do to each response object
def do_something(response):
    print response.url

# A list to hold our things to do via async
async_list = []

for u in urls:
    # The "hooks = {..." part is where you define what you want to do
    # 
    # Note the lack of parentheses following do_something, this is
    # because the response will be used as the first argument automatically
    action_item = async.get(u, hooks = {'response' : do_something})

    # Add the task to our list of things to do via async
    async_list.append(action_item)

# Do our list of things to do via async
async.map(async_list)

asyncBağımsız bir modül artık şudur: grequests.

Buraya bakın: https://github.com/kennethreitz/grequests

Ve orada: Python üzerinden birden fazla HTTP isteği göndermek için ideal yöntem?

Kurulum:

$ pip install grequests

kullanımı:

bir yığın oluşturun:

import grequests

urls = [
    'http://www.heroku.com',
    'http://tablib.org',
    'http://httpbin.org',
    'http://python-requests.org',
    'http://kennethreitz.com'
]

rs = (grequests.get(u) for u in urls)

yığını gönder

grequests.map(rs)

sonuç benziyor

[<Response [200]>, <Response [200]>, <Response [200]>, <Response [200]>, <Response [200]>]

grequest'ler, eşzamanlı istekler için, yani aynı sunucuya birden fazla istek gönderildiğinde, bir sınırlama getirmiş gibi görünmemektedir.

Hem test istekleri-gelecekleri ve grequests . Grequests daha hızlıdır, ancak maymun yama ve bağımlılıklarla ilgili ek sorunlar getirir. istek-vadeli işlemleri, mağlubiyetlerden birkaç kat daha yavaştır. Kendi ve sadece isteklerini ThreadPoolExecutor içine yazmaya karar verdim ve neredeyse depquest kadar hızlı, ama dış bağımlılıkları olmadan.

import requests
import concurrent.futures

def get_urls():
    return ["url1","url2"]

def load_url(url, timeout):
    return requests.get(url, timeout = timeout)

with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:

    future_to_url = {executor.submit(load_url, url, 10): url for url in     get_urls()}
    for future in concurrent.futures.as_completed(future_to_url):
        url = future_to_url[future]
        try:
            data = future.result()
        except Exception as exc:
            resp_err = resp_err + 1
        else:
            resp_ok = resp_ok + 1

belki istek-futures başka bir seçimdir.

from requests_futures.sessions import FuturesSession

session = FuturesSession()
# first request is started in background
future_one = session.get('http://httpbin.org/get')
# second requests is started immediately
future_two = session.get('http://httpbin.org/get?foo=bar')
# wait for the first request to complete, if it hasn't already
response_one = future_one.result()
print('response one status: {0}'.format(response_one.status_code))
print(response_one.content)
# wait for the second request to complete, if it hasn't already
response_two = future_two.result()
print('response two status: {0}'.format(response_two.status_code))
print(response_two.content)

Ofis dokümanında da tavsiye edilir . Gevent'i dahil etmek istemiyorsanız, bu iyi bir şeydir.

Gönderilen cevapların çoğuyla ilgili çok fazla sorunum var - ya sınırlı özelliklerle taşınan kullanımdan kaldırılmış kütüphaneleri kullanıyorlar ya da isteğin yürütülmesinde çok fazla sihir içeren bir çözüm sağlayarak hata işlemeyi zorlaştırıyorlar. Yukarıdaki kategorilerden birine girmezlerse, üçüncü taraf kütüphaneleridir veya kullanımdan kaldırılmıştır.

Çözümlerin bazıları tamamen http isteklerinde işe yarıyor, ancak çözümler diğer her türlü istek için yetersiz kalıyor, ki bu gülünç. Burada son derece özelleştirilmiş bir çözüm gerekli değildir.

Basitçe, python yerleşik kütüphanesini kullanmak, asyncioherhangi bir türdeki eşzamansız istekleri gerçekleştirmek için yeterlidir, ayrıca karmaşık ve kullanıcıya özgü hata işleme için yeterli akışkanlık sağlar.

import asyncio

loop = asyncio.get_event_loop()

def do_thing(params):
    async def get_rpc_info_and_do_chores(id):
        # do things
        response = perform_grpc_call(id)
        do_chores(response)

    async def get_httpapi_info_and_do_chores(id):
        # do things
        response = requests.get(URL)
        do_chores(response)

    async_tasks = []
    for element in list(params.list_of_things):
       async_tasks.append(loop.create_task(get_chan_info_and_do_chores(id)))
       async_tasks.append(loop.create_task(get_httpapi_info_and_do_chores(ch_id)))

    loop.run_until_complete(asyncio.gather(*async_tasks))

Nasıl çalıştığı basit. Eşzamansız olarak gerçekleşmesini istediğiniz bir dizi görev oluşturuyorsunuz ve ardından bir döngüden bu görevleri gerçekleştirmesini ve tamamlandıktan sonra çıkmasını istiyorsunuz. Bakım gerektirmeyen ekstra kütüphane, işlevsellik eksikliği gerekmez.

Bunun bir süredir kapalı olduğunu biliyorum, ancak istek kitaplığına dayanan başka bir zaman uyumsuz çözümü teşvik etmenin yararlı olabileceğini düşündüm.

list_of_requests = ['http://moop.com', 'http://doop.com', ...]

from simple_requests import Requests
for response in Requests().swarm(list_of_requests):
    print response.content

Dokümanlar burada: http://pythonhosted.org/simple-requests/

threads=list()

for requestURI in requests:
    t = Thread(target=self.openURL, args=(requestURI,))
    t.start()
    threads.append(t)

for thread in threads:
    thread.join()

...

def openURL(self, requestURI):
    o = urllib2.urlopen(requestURI, timeout = 600)
    o...

Asyncio'yu kullanmak istiyorsanız, - https://github.com/encode/requests-asyncrequests-async için async / await işlevselliği sağlarrequests

Bir süredir github'ın gist API'sine karşı zaman uyumsuz çağrılar için python isteklerini kullanıyorum.

Bir örnek için buradaki koda bakın:

https://github.com/davidthewatson/flasgist/blob/master/views.py#L60-72

Bu python tarzı en açık örnek olmayabilir, ancak kodun çalıştığından emin olabilirim. Bunun sizin için kafa karıştırıcı olup olmadığını bana bildirin ve ben bunu belgeleyeceğim.

Bunun için kullanabilirsiniz httpx.

import httpx

async def get_async(url):
    async with httpx.AsyncClient() as client:
        return await client.get(url)

urls = ["http://google.com", "http://wikipedia.org"]

# Note that you need an async context to use `await`.
await asyncio.gather(*map(get_async, urls))

işlevsel bir sözdizimi istiyorsanız gamla lib bunuget_async .

Sonra yapabilirsin

await gamla.map(gamla.get_async(10), ["http://google.com", "http://wikipedia.org"])

10Saniye cinsinden zaman aşımı olduğunu.

(sorumluluk reddi: Ben onun yazarım)

Ben de python asenkron yöntemleri kullanarak bazı şeyler denedim, ne kadar zaman asenkron programlama için bükülmüş kullanarak çok daha iyi şans oldu. Daha az sorunu vardır ve iyi belgelenmiştir. İşte bükülmüş denediklerinize benzer bir şeyin bağlantısı.

http://pythonquirks.blogspot.com/2011/04/twisted-asynchronous-http-request.html

Ne yazık ki, bildiğim kadarıyla, istek kitaplığı asenkron istekleri gerçekleştirmek için donanımlı değil. async/awaitSözdizimini etrafına sarabilirsiniz requests, ancak temel istekleri daha az senkronize hale getirmez. Gerçek zaman uyumsuz istekleri istiyorsanız, bunu sağlayan diğer araçları kullanmanız gerekir. Böyle bir çözüm aiohttp(Python 3.5.3+). Python 3.7 async/awaitsözdizimi ile kullanma deneyimimde iyi çalışıyor . Aşağıda aşağıdakileri kullanarak üç web isteği gerçekleştirmenin üç uygulamasını yazıyorum:

1. sync_requests_get_allPython kullanarak tamamen senkronize istekler ( )requests kitaplığını
2. Python 3.7 ile sarılmış async_requests_get_allPython requestskütüphanesini kullanarak senkronize istekler ( )async/await sözdiziminde veasyncio
3. Python 3.7 sözdizimine sarılmış async_aiohttp_get_allPython aiohttpkütüphanesi ile gerçek zamanlı olmayan bir uygulama ( ) async/awaitveasyncio

import time
import asyncio
import requests
import aiohttp

from types import SimpleNamespace

durations = []


def timed(func):
    """
    records approximate durations of function calls
    """
    def wrapper(*args, **kwargs):
        start = time.time()
        print(f'{func.__name__:<30} started')
        result = func(*args, **kwargs)
        duration = f'{func.__name__:<30} finsished in {time.time() - start:.2f} seconds'
        print(duration)
        durations.append(duration)
        return result
    return wrapper


async def fetch(url, session):
    """
    asynchronous get request
    """
    async with session.get(url) as response:
        response_json = await response.json()
        return SimpleNamespace(**response_json)


async def fetch_many(loop, urls):
    """
    many asynchronous get requests, gathered
    """
    async with aiohttp.ClientSession() as session:
        tasks = [loop.create_task(fetch(url, session)) for url in urls]
        return await asyncio.gather(*tasks)


@timed
def asnyc_aiohttp_get_all(urls):
    """
    performs asynchronous get requests
    """
    loop = asyncio.get_event_loop()
    return loop.run_until_complete(fetch_many(loop, urls))


@timed
def sync_requests_get_all(urls):
    """
    performs synchronous get requests
    """
    # use session to reduce network overhead
    session = requests.Session()
    return [SimpleNamespace(**session.get(url).json()) for url in urls]


@timed
def async_requests_get_all(urls):
    """
    asynchronous wrapper around synchronous requests
    """
    loop = asyncio.get_event_loop()
    # use session to reduce network overhead
    session = requests.Session()

    async def async_get(url):
        return session.get(url)

    async_tasks = [loop.create_task(async_get(url)) for url in urls]
    return loop.run_until_complete(asyncio.gather(*async_tasks))


if __name__ == '__main__':
    # this endpoint takes ~3 seconds to respond,
    # so a purely synchronous implementation should take
    # little more than 30 seconds and a purely asynchronous
    # implementation should take little more than 3 seconds.
    urls = ['https://postman-echo.com/delay/3']*10

    sync_requests_get_all(urls)
    async_requests_get_all(urls)
    asnyc_aiohttp_get_all(urls)
    print('----------------------')
    [print(duration) for duration in durations]

Makinemde çıktı bu:

sync_requests_get_all          started
sync_requests_get_all          finsished in 30.92 seconds
async_requests_get_all         started
async_requests_get_all         finsished in 30.87 seconds
asnyc_aiohttp_get_all          started
asnyc_aiohttp_get_all          finsished in 3.22 seconds
----------------------
sync_requests_get_all          finsished in 30.92 seconds
async_requests_get_all         finsished in 30.87 seconds
asnyc_aiohttp_get_all          finsished in 3.22 seconds