Mehrere (asynchron) - verbindungen mit urllib2 oder andere http-Bibliothek?

Habe ich code wie diesen.

for p in range(1,1000):
    result = False
    while result is False:
        ret = urllib2.Request('http://server/?'+str(p))
        try:
            result = process(urllib2.urlopen(ret).read())
        except (urllib2.HTTPError, urllib2.URLError):
            pass
    results.append(result)

Ich würde gerne zwei oder drei bitte in der gleichen Zeit zu beschleunigen. Kann ich mit urllib2 für diese, und wie? Wenn nicht, welche andere Bibliothek soll ich benutzen? Danke.

InformationsquelleAutor der Frage | 2010-11-07

Können Sie asynchrone IO, dies zu tun.

Anfragen + gevent = grequests

GRequests ermöglicht die Verwendung von Anfragen mit Gevent, um asynchrone HTTP-Anfragen leicht.

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)
grequests.map(rs)

InformationsquelleAutor der Antwort Piotr Dobrogost

Werfen Sie einen Blick auf gevent — eine koroutine-Python-basierte Netzwerk-Bibliothek, die verwendet greenlet, um eine high-level-synchrone API von oben auf libevent-event-Schleife.

Beispiel:

#!/usr/bin/python
# Copyright (c) 2009 Denis Bilenko. See LICENSE for details.

"""Spawn multiple workers and wait for them to complete"""

urls = ['http://www.google.com', 'http://www.yandex.ru', 'http://www.python.org']

import gevent
from gevent import monkey

# patches stdlib (including socket and ssl modules) to cooperate with other greenlets
monkey.patch_all()

import urllib2


def print_head(url):
    print 'Starting %s' % url
    data = urllib2.urlopen(url).read()
    print '%s: %s bytes: %r' % (url, len(data), data[:50])

jobs = [gevent.spawn(print_head, url) for url in urls]

gevent.joinall(jobs)

InformationsquelleAutor der Antwort thereisnospoon

So, es ist 2016 ? und wir haben Python 3.4+ mit gebaut-in asyncio Modul für asynchrone I/O. Wir können aiohttp als HTTP-client zum download mehrere URLs parallel.

import asyncio
from aiohttp import ClientSession

async def fetch(url):
    async with ClientSession() as session:
        async with session.get(url) as response:
            return await response.read()

async def run(loop, r):
    url = "http://localhost:8080/{}"
    tasks = []
    for i in range(r):
        task = asyncio.ensure_future(fetch(url.format(i)))
        tasks.append(task)

    responses = await asyncio.gather(*tasks)
    # you now have all response bodies in this variable
    print(responses)

loop = asyncio.get_event_loop()
future = asyncio.ensure_future(run(loop, 4))
loop.run_until_complete(future)

Quelle: kopieren-einfügen von http://pawelmhm.github.io/asyncio/python/aiohttp/2016/04/22/asyncio-aiohttp.html

InformationsquelleAutor der Antwort Messa

1

Ich weiß, diese Frage ist ein wenig alt, aber ich dachte, es könnte sein nützlich, um zu fördern ein weiteres async-Lösung, basierend auf den Anforderungen der Bibliothek.
```
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
```
Die docs sind hier: http://pythonhosted.org/simple-requests/

InformationsquelleAutor der Antwort Monkey Boson
0

Entweder Sie herausfinden,threadsoder Sie verwenden Sie Twisted (das ist asynchron).

InformationsquelleAutor der Antwort Jochen Ritzel

vielleicht mit multiprocessing und teilen Sie die Arbeit auf 2-Verfahren oder so .

Hier ist ein Beispiel (ist nicht getestet)

import multiprocessing
import Queue
import urllib2


NUM_PROCESS = 2
NUM_URL = 1000


class DownloadProcess(multiprocessing.Process):
    """Download Process """

    def __init__(self, urls_queue, result_queue):

        multiprocessing.Process.__init__(self)

        self.urls = urls_queue
        self.result = result_queue

    def run(self):
        while True:

             try:
                 url = self.urls.get_nowait()
             except Queue.Empty:
                 break

             ret = urllib2.Request(url)
             res = urllib2.urlopen(ret)

             try:
                 result = res.read()
             except (urllib2.HTTPError, urllib2.URLError):
                     pass

             self.result.put(result)


def main():

    main_url = 'http://server/?%s'

    urls_queue = multiprocessing.Queue()
    for p in range(1, NUM_URL):
        urls_queue.put(main_url % p)

    result_queue = multiprocessing.Queue()

    for i in range(NUM_PROCESS):
        download = DownloadProcess(urls_queue, result_queue)
        download.start()

    results = []
    while result_queue:
        result = result_queue.get()
        results.append(result)

    return results

if __name__ == "__main__":
    results = main()

    for res in results:
        print(res)

InformationsquelleAutor der Antwort mouad

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.