Jak mogę przyspieszyć pobieranie stron za pomocą urllib2 w Pythonie?

Użyj twisted ! To sprawia, że takie rzeczy są absurdalnie łatwe w porównaniu do, powiedzmy, używania wątków.

from twisted.internet import defer, reactor
from twisted.web.client import getPage
import time

def processPage(page, url):
    # do somewthing here.
    return url, len(page)

def printResults(result):
    for success, value in result:
        if success:
            print 'Success:', value
        else:
            print 'Failure:', value.getErrorMessage()

def printDelta(_, start):
    delta = time.time() - start
    print 'ran in %0.3fs' % (delta,)
    return delta

urls = [
    'http://www.google.com/',
    'http://www.lycos.com/',
    'http://www.bing.com/',
    'http://www.altavista.com/',
    'http://achewood.com/',
]

def fetchURLs():
    callbacks = []
    for url in urls:
        d = getPage(url)
        d.addCallback(processPage, url)
        callbacks.append(d)

    callbacks = defer.DeferredList(callbacks)
    callbacks.addCallback(printResults)
    return callbacks

@defer.inlineCallbacks
def main():
    times = []
    for x in xrange(5):
        d = fetchURLs()
        d.addCallback(printDelta, time.time())
        times.append((yield d))
    print 'avg time: %0.3fs' % (sum(times) / len(times),)

reactor.callWhenRunning(main)
reactor.run()

Ten kod działa również lepiej niż jakiekolwiek inne opublikowane rozwiązania (edytowane po zamknięciu niektórych rzeczy, które używały dużej przepustowości):

Success: ('http://www.google.com/', 8135)
Success: ('http://www.lycos.com/', 29996)
Success: ('http://www.bing.com/', 28611)
Success: ('http://www.altavista.com/', 8378)
Success: ('http://achewood.com/', 15043)
ran in 0.518s
Success: ('http://www.google.com/', 8135)
Success: ('http://www.lycos.com/', 30349)
Success: ('http://www.bing.com/', 28611)
Success: ('http://www.altavista.com/', 8378)
Success: ('http://achewood.com/', 15043)
ran in 0.461s
Success: ('http://www.google.com/', 8135)
Success: ('http://www.lycos.com/', 30033)
Success: ('http://www.bing.com/', 28611)
Success: ('http://www.altavista.com/', 8378)
Success: ('http://achewood.com/', 15043)
ran in 0.435s
Success: ('http://www.google.com/', 8117)
Success: ('http://www.lycos.com/', 30349)
Success: ('http://www.bing.com/', 28611)
Success: ('http://www.altavista.com/', 8378)
Success: ('http://achewood.com/', 15043)
ran in 0.449s
Success: ('http://www.google.com/', 8135)
Success: ('http://www.lycos.com/', 30349)
Success: ('http://www.bing.com/', 28611)
Success: ('http://www.altavista.com/', 8378)
Success: ('http://achewood.com/', 15043)
ran in 0.547s
avg time: 0.482s

I używając kodu Nicka T, można też dać średnią z pięciu i lepiej pokazać wyjście:

Starting threaded reads:
...took 1.921520 seconds ([8117, 30070, 15043, 8386, 28611])
Starting threaded reads:
...took 1.779461 seconds ([8135, 15043, 8386, 30349, 28611])
Starting threaded reads:
...took 1.756968 seconds ([8135, 8386, 15043, 30349, 28611])
Starting threaded reads:
...took 1.762956 seconds ([8386, 8135, 15043, 29996, 28611])
Starting threaded reads:
...took 1.654377 seconds ([8117, 30349, 15043, 8386, 28611])
avg time: 1.775s

Starting sequential reads:
...took 1.389803 seconds ([8135, 30147, 28611, 8386, 15043])
Starting sequential reads:
...took 1.457451 seconds ([8135, 30051, 28611, 8386, 15043])
Starting sequential reads:
...took 1.432214 seconds ([8135, 29996, 28611, 8386, 15043])
Starting sequential reads:
...took 1.447866 seconds ([8117, 30028, 28611, 8386, 15043])
Starting sequential reads:
...took 1.468946 seconds ([8153, 30051, 28611, 8386, 15043])
avg time: 1.439s

I używając kodu Wai Yip Tung:

Fetched 8117 from http://www.google.com/
Fetched 28611 from http://www.bing.com/
Fetched 8386 from http://www.altavista.com/
Fetched 30051 from http://www.lycos.com/
Fetched 15043 from http://achewood.com/
done in 0.704s
Fetched 8117 from http://www.google.com/
Fetched 28611 from http://www.bing.com/
Fetched 8386 from http://www.altavista.com/
Fetched 30114 from http://www.lycos.com/
Fetched 15043 from http://achewood.com/
done in 0.845s
Fetched 8153 from http://www.google.com/
Fetched 28611 from http://www.bing.com/
Fetched 8386 from http://www.altavista.com/
Fetched 30070 from http://www.lycos.com/
Fetched 15043 from http://achewood.com/
done in 0.689s
Fetched 8117 from http://www.google.com/
Fetched 28611 from http://www.bing.com/
Fetched 8386 from http://www.altavista.com/
Fetched 30114 from http://www.lycos.com/
Fetched 15043 from http://achewood.com/
done in 0.647s
Fetched 8135 from http://www.google.com/
Fetched 28611 from http://www.bing.com/
Fetched 8386 from http://www.altavista.com/
Fetched 30349 from http://www.lycos.com/
Fetched 15043 from http://achewood.com/
done in 0.693s
avg time: 0.715s

I ' ve gotta say, I do like that the sequential dla mnie lepsze .

Oto przykład użycia Pythona Threads. Inne przykłady wątków uruchamiają wątek na adres url, co nie jest zbyt przyjaznym zachowaniem, jeśli powoduje zbyt wiele trafień dla serwera (na przykład często zdarza się, że pająki mają wiele adresów URL na tym samym hoście) {]}

from threading import Thread
from urllib2 import urlopen
from time import time, sleep

WORKERS=1
urls = ['http://docs.python.org/library/threading.html',
        'http://docs.python.org/library/thread.html',
        'http://docs.python.org/library/multiprocessing.html',
        'http://docs.python.org/howto/urllib2.html']*10
results = []

class Worker(Thread):
    def run(self):
        while urls:
            url = urls.pop()
            results.append((url, urlopen(url).read()))

start = time()
threads = [Worker() for i in range(WORKERS)]
any(t.start() for t in threads)

while len(results)<40:
    sleep(0.1)
print time()-start

Uwaga: podane czasy dotyczą 40 adresów URL i w dużej mierze zależą od szybkości połączenia internetowego i opóźnienia na serwerze. Będąc w Australii, mój ping wynosi > 300ms

Z WORKERS=1 zajęło 86 seconds to run
Z WORKERS=4 bieganie zajęło 23 sekundy
z WORKERS=10 to trwało 10 sekund, aby uruchomić

Więc pobieranie 10 wątków jest 8,6 razy szybsze niż pojedynczy wątek.

Oto ulepszona wersja, która używa kolejki. Jest co najmniej kilka zalet.
1. Adresy URL są wymagane w kolejności, w jakiej pojawiają się na liście
2. Można użyć q.join() do wykrycia, kiedy wszystkie żądania zostały zakończone
3. Wyniki są przechowywane w tej samej kolejności Co adres url lista

from threading import Thread
from urllib2 import urlopen
from time import time, sleep
from Queue import Queue

WORKERS=10
urls = ['http://docs.python.org/library/threading.html',
        'http://docs.python.org/library/thread.html',
        'http://docs.python.org/library/multiprocessing.html',
        'http://docs.python.org/howto/urllib2.html']*10
results = [None]*len(urls)

def worker():
    while True:
        i, url = q.get()
        # print "requesting ", i, url       # if you want to see what's going on
        results[i]=urlopen(url).read()
        q.task_done()

start = time()
q = Queue()
for i in range(WORKERS):
    t=Thread(target=worker)
    t.daemon = True
    t.start()

for i,url in enumerate(urls):
    q.put((i,url))
q.join()
print time()-start

Rzeczywiste oczekiwanie prawdopodobnie nie jest w urllib2, ale w serwerze i / lub twoim połączeniu sieciowym z serwerem.

1. utrzymuj połączenie przy życiu (zobacz to pytanie, Jak to zrobić: Python urllib2 z keep alive )
2. Użyj wielu połączeń, możesz użyć wątków lub podejścia asynchronicznego, jak zasugerował Aaron Gallagher. W tym celu po prostu użyj dowolnego przykładu wątków i powinieneś zrobić dobrze :) Możesz również użyć multiprocessing lib do Ułatw to sobie.

Większość odpowiedzi skupiała się na pobieraniu wielu stron z różnych serwerów w tym samym czasie (threading) ale nie przy ponownym użyciu już otwarte połączenie HTTP. Jeśli OP składa wiele żądań na ten sam serwer/stronę.

W urlib2 tworzone jest oddzielne połączenie z każdym żądaniem, które wpływa na wydajność i w rezultacie na wolniejsze tempo pobierania stron. urllib3 rozwiązuje ten problem za pomocą puli połączeń. Możesz przeczytać więcej tutaj urllib3 [również thread-safe]

Istnieje również Requests biblioteka HTTP, która używa urllib3

To w połączeniu z threadingiem powinno zwiększyć szybkość pobierania stron

Obecnie istnieje znakomita lib Pythona, która robi to za Ciebie o nazwie requests .

Użyj standardowego api żądań, jeśli chcesz rozwiązania opartego na wątkach lub asynchronicznego api (używając gevent pod maską), jeśli chcesz rozwiązania opartego na nieblokujących IO.

Odkąd to pytanie zostało opublikowane, wygląda na to, że dostępna jest abstrakcja wyższego poziomu, ThreadPoolExecutor:

Https://docs.python.org/3/library/concurrent.futures.html#threadpoolexecutor-example

Przykład stamtąd wklejony tutaj dla wygody:

import concurrent.futures
import urllib.request

URLS = ['http://www.foxnews.com/',
        'http://www.cnn.com/',
        'http://europe.wsj.com/',
        'http://www.bbc.co.uk/',
        'http://some-made-up-domain.com/']

# Retrieve a single page and report the url and contents
def load_url(url, timeout):
    with urllib.request.urlopen(url, timeout=timeout) as conn:
        return conn.read()

# We can use a with statement to ensure threads are cleaned up promptly
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    # Start the load operations and mark each future with its URL
    future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
    for future in concurrent.futures.as_completed(future_to_url):
        url = future_to_url[future]
        try:
            data = future.result()
        except Exception as exc:
            print('%r generated an exception: %s' % (url, exc))
        else:
            print('%r page is %d bytes' % (url, len(data)))

Jest też {[2] } co chyba ułatwia kod: https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Executor.map

Pobieranie stron internetowych oczywiście zajmie trochę czasu, ponieważ nie masz dostępu do niczego lokalnego. Jeśli masz kilka do uzyskania dostępu, możesz użyć threading Moduł do uruchomienia kilku na raz.

Oto bardzo prymitywny przykład

import threading
import urllib2
import time

urls = ['http://docs.python.org/library/threading.html',
        'http://docs.python.org/library/thread.html',
        'http://docs.python.org/library/multiprocessing.html',
        'http://docs.python.org/howto/urllib2.html']
data1 = []
data2 = []

class PageFetch(threading.Thread):
    def __init__(self, url, datadump):
        self.url = url
        self.datadump = datadump
        threading.Thread.__init__(self)
    def run(self):
        page = urllib2.urlopen(self.url)
        self.datadump.append(page.read()) # don't do it like this.

print "Starting threaded reads:"
start = time.clock()
for url in urls:
    PageFetch(url, data2).start()
while len(data2) < len(urls): pass # don't do this either.
print "...took %f seconds" % (time.clock() - start)

print "Starting sequential reads:"
start = time.clock()
for url in urls:
    page = urllib2.urlopen(url)
    data1.append(page.read())
print "...took %f seconds" % (time.clock() - start)

for i,x in enumerate(data1):
    print len(data1[i]), len(data2[i])

To było wyjście kiedy go uruchomiłem:

Starting threaded reads:
...took 2.035579 seconds
Starting sequential reads:
...took 4.307102 seconds
73127 19923
19923 59366
361483 73127
59366 361483

Pobieranie danych z wątku przez dodanie do listy jest prawdopodobnie nierozsądne (Kolejka byłaby lepsza), ale pokazuje to, że jest różnica.

Oto standardowe rozwiązanie biblioteki. Nie jest tak szybki, ale zużywa mniej pamięci niż rozwiązania gwintowane.

try:
    from http.client import HTTPConnection, HTTPSConnection
except ImportError:
    from httplib import HTTPConnection, HTTPSConnection
connections = []
results = []

for url in urls:
    scheme, _, host, path = url.split('/', 3)
    h = (HTTPConnection if scheme == 'http:' else HTTPSConnection)(host)
    h.request('GET', '/' + path)
    connections.append(h)
for h in connections:
    results.append(h.getresponse().read())

Ponadto, jeśli większość twoich żądań dotyczy tego samego hosta, ponowne użycie tego samego połączenia http prawdopodobnie pomogłoby bardziej niż robienie rzeczy równolegle.

Proszę znaleźć Python network benchmark script do identyfikacji powolności pojedynczego połączenia:

"""Python network test."""
from socket import create_connection
from time import time

try:
    from urllib2 import urlopen
except ImportError:
    from urllib.request import urlopen

TIC = time()
create_connection(('216.58.194.174', 80))
print('Duration socket IP connection (s): {:.2f}'.format(time() - TIC))

TIC = time()
create_connection(('google.com', 80))
print('Duration socket DNS connection (s): {:.2f}'.format(time() - TIC))

TIC = time()
urlopen('http://216.58.194.174')
print('Duration urlopen IP connection (s): {:.2f}'.format(time() - TIC))

TIC = time()
urlopen('http://google.com')
print('Duration urlopen DNS connection (s): {:.2f}'.format(time() - TIC))

I przykład wyników z Pythonem 3.6:

Duration socket IP connection (s): 0.02
Duration socket DNS connection (s): 75.51
Duration urlopen IP connection (s): 75.88
Duration urlopen DNS connection (s): 151.42

Python 2.7.13 ma bardzo podobne wyniki.

W tym przypadku powolność DNS i urlopen jest łatwa do zidentyfikowania.