Python urllib2.urlopen () est lent, nécessite un meilleur moyen de lire plusieurs URL

Je réécris Gars Muet de code ci-dessous, en utilisant les modules Python comme threading et Queue.

import threading, urllib2
import Queue

urls_to_load = [
'http://stackoverflow.com/',
'http://slashdot.org/',
'http://www.archive.org/',
'http://www.yahoo.co.jp/',
]

def read_url(url, queue):
    data = urllib2.urlopen(url).read()
    print('Fetched %s from %s' % (len(data), url))
    queue.put(data)

def fetch_parallel():
    result = Queue.Queue()
    threads = [threading.Thread(target=read_url, args = (url,result)) for url in urls_to_load]
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    return result

def fetch_sequencial():
    result = Queue.Queue()
    for url in urls_to_load:
        read_url(url,result)
    return result

Meilleur moment pour find_sequencial() à 2s. Meilleur moment pour fetch_parallel() est de 0,9 s.

Aussi il est incorrect de dire thread est inutile en Python en raison de GIL. C'est un de ces cas, lorsque le thread est utile en Python parce que les threads sont bloqués sur les I/O. Comme vous pouvez le voir dans mon résultat le parallèle est 2 fois plus rapide.

Il est maby pas parfait. Mais quand j'ai besoin de données à partir d'un site. Je viens de le faire:

import socket
def geturldata(url):
    #NO HTTP URLS PLEASE!!!!! 
    server = url.split("/")[0]
    args = url.replace(server,"")
    returndata = str()
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((server, 80)) #lets connect :p

    s.send("GET /%s HTTP/1.0\r\nHost: %s\r\n\r\n" % (args, server)) #simple http request
    while 1:
        data = s.recv(1024) #buffer
        if not data: break
        returndata = returndata + data
    s.close()
    return returndata.split("\n\r")[1]

Scrapy pourraient être utiles pour vous. Si vous n'avez pas besoin de toutes ses fonctionnalités, vous pouvez simplement utiliser tordu's twisted.web.client.getPage à la place. Asynchrone IO dans un thread va être plus performant et facile à déboguer que tout ce qui utilise plusieurs threads et de blocage IO.

1) Êtes-vous d'ouvrir le même site plusieurs fois, ou de beaucoup d'autre site? Si de nombreux sites différents, je pense que urllib2 est bon. Si vous faites le même site, encore et encore, j'ai eu certains personnels de la chance avec urllib3 http://code.google.com/p/urllib3/

2) BeautifulSoup est facile à utiliser, mais est assez lent. Si vous n'avez pas à l'utiliser, assurez-vous de décomposer vos balises pour se débarrasser de fuites de mémoire.. ou il risque de mener à des problèmes de mémoire (pour moi).

Quoi faire de votre mémoire et de cpu? Si vous dépasser le maximum de votre CPU, assurez-vous que vous utilisez véritable poids lourd de threads, de sorte que vous pouvez exécuter sur plus de 1 de base.

Tout d'abord, vous devriez essayer de multithreading/multitraitement paquets. Actuellement, les trois plus populaires sont multitraitement;de façon concomitante.les contrats à terme et [enfilage][3]. Ces paquets peuvent vous aider à ouvrir multi url dans le même temps, ce qui pourrait augmenter la vitesse.

Plus important, après l'utilisation de multi thread de traitement, et si vous essayez d'ouvrir des centaines d'url dans le même temps, vous trouverez urllib.demande.urlopen est très lente, d'ouverture et de lire le contexte de devenir le plus de temps. Donc, si vous voulez le rendre encore plus rapide, vous devriez essayer de demandes de paquets, les demandes.get(url).contenu() est plus rapide que urllib.demande.urlopen(url).read().

Donc, ici, je liste deux exemple pour faire rapide multi url de l'analyse, et la vitesse est plus rapide que les autres réponses.
Le premier exemple de l'utilisation classique d'enfilage de package et de générer des centaines de threads en même temps. (Un trivial inconvénient est qu'elle ne peut pas garder l'original afin de le ticker.)

import time
import threading
import pandas as pd
import requests
from bs4 import BeautifulSoup


ticker = pd.ExcelFile('short_tickerlist.xlsx')
ticker_df = ticker.parse(str(ticker.sheet_names[0]))
ticker_list = list(ticker_df['Ticker'])

start = time.time()

result = []
def fetch(ticker):
    url = ('http://finance.yahoo.com/quote/' + ticker)
    print('Visit ' + url)
    text = requests.get(url).content
    soup = BeautifulSoup(text,'lxml')
    result.append([ticker,soup])
    print(url +' fetching...... ' + str(time.time()-start))



if __name__ == '__main__':
    process = [None] * len(ticker_list)
    for i in range(len(ticker_list)):
        process[i] = threading.Thread(target=fetch, args=[ticker_list[i]])

    for i in range(len(ticker_list)):    
        print('Start_' + str(i))
        process[i].start()



    # for i in range(len(ticker_list)):
    #     print('Join_' + str(i))    
    #     process[i].join()

    print("Elapsed Time: %ss" % (time.time() - start))

Le deuxième exemple utilise le multitraitement paquet, et il est un peu plus simple. Car vous avez juste besoin de préciser le numéro de la piscine et la carte de fonction. L'ordre ne changera pas après l'extraction du contexte et de la vitesse est similaire à la première exemple, mais beaucoup plus rapide que les autres méthodes.

from multiprocessing import Pool
import requests
from bs4 import BeautifulSoup
import pandas as pd
import os
import time

os.chdir('file_path')

start = time.time()

def fetch_url(x):
    print('Getting Data')
    myurl = ("http://finance.yahoo.com/q/cp?s=%s" % x)
    html = requests.get(myurl).content
    soup = BeautifulSoup(html,'lxml')
    out = str(soup)
    listOut = [x, out]
    return listOut

tickDF = pd.read_excel('short_tickerlist.xlsx')
li = tickDF['Ticker'].tolist()    

if __name__ == '__main__':
    p = Pool(5)
    output = p.map(fetch_url, ji, chunksize=30)
    print("Time is %ss" %(time.time()-start))