Come faccio a scaricare un file su HTTP usando Python?

Ho una piccola utility che utilizzo per scaricare un file MP3 da un sito Web in base a una pianificazione e quindi crea / aggiorna un file XML podcast che ho aggiunto ad iTunes.

L'elaborazione del testo che crea / aggiorna il file XML è scritta in Python. Tuttavia, utilizzo wget all'interno di un .batfile Windows per scaricare il file MP3 effettivo. Preferirei avere l'intera utilità scritta in Python.

Ho faticato a trovare un modo per scaricare effettivamente il file in Python, quindi perché ho fatto ricorso all'utilizzo wget.

Quindi, come posso scaricare il file usando Python?

In Python 2, usa urllib2 fornito con la libreria standard.

import urllib2
response = urllib2.urlopen('http://www.example.com/')
html = response.read()

Questo è il modo più semplice per utilizzare la libreria, meno qualsiasi gestione degli errori. Puoi anche fare cose più complesse come cambiare le intestazioni. La documentazione è disponibile qui.

Ancora uno, usando urlretrieve:

import urllib
urllib.urlretrieve ("http://www.example.com/songs/mp3.mp3", "mp3.mp3")

(per uso Python 3+ import urllib.requeste urllib.request.urlretrieve)

Ancora un altro, con una "barra di avanzamento"

import urllib2

url = "http://download.thinkbroadband.com/10MB.zip"

file_name = url.split('/')[-1]
u = urllib2.urlopen(url)
f = open(file_name, 'wb')
meta = u.info()
file_size = int(meta.getheaders("Content-Length")[0])
print "Downloading: %s Bytes: %s" % (file_name, file_size)

file_size_dl = 0
block_sz = 8192
while True:
    buffer = u.read(block_sz)
    if not buffer:
        break

    file_size_dl += len(buffer)
    f.write(buffer)
    status = r"%10d  [%3.2f%%]" % (file_size_dl, file_size_dl * 100. / file_size)
    status = status + chr(8)*(len(status)+1)
    print status,

f.close()

Nel 2012, utilizzare la libreria di richieste python

>>> import requests
>>> 
>>> url = "http://download.thinkbroadband.com/10MB.zip"
>>> r = requests.get(url)
>>> print len(r.content)
10485760

Puoi correre pip install requestsper ottenerlo.

Le richieste hanno molti vantaggi rispetto alle alternative perché l'API è molto più semplice. Ciò è particolarmente vero se è necessario eseguire l'autenticazione. urllib e urllib2 sono piuttosto poco intuitivi e dolorosi in questo caso.

2015/12/30

Le persone hanno espresso ammirazione per la barra di avanzamento. È bello, certo. Ora ci sono diverse soluzioni standard, tra cui tqdm:

from tqdm import tqdm
import requests

url = "http://download.thinkbroadband.com/10MB.zip"
response = requests.get(url, stream=True)

with open("10MB", "wb") as handle:
    for data in tqdm(response.iter_content()):
        handle.write(data)

Questa è essenzialmente l'implementazione di @kvance descritta 30 mesi fa.

import urllib2
mp3file = urllib2.urlopen("http://www.example.com/songs/mp3.mp3")
with open('test.mp3','wb') as output:
  output.write(mp3file.read())

L' wbin open('test.mp3','wb')apre un file (e cancella qualsiasi file esistente) in modo binario in modo da poter salvare i dati con esso invece di testo.

Python 3

• urllib.request.urlopen

  import urllib.request
  response = urllib.request.urlopen('http://www.example.com/')
  html = response.read()

• urllib.request.urlretrieve

  import urllib.request
  urllib.request.urlretrieve('http://www.example.com/songs/mp3.mp3', 'mp3.mp3')

  Nota: secondo la documentazione, urllib.request.urlretrieveè una "interfaccia legacy" e "potrebbe diventare obsoleta in futuro" (grazie gerrit )

Python 2

• urllib2.urlopen(grazie Corey )

  import urllib2
  response = urllib2.urlopen('http://www.example.com/')
  html = response.read()

• urllib.urlretrieve(grazie PabloG )

  import urllib
  urllib.urlretrieve('http://www.example.com/songs/mp3.mp3', 'mp3.mp3')

usa il modulo wget:

import wget
wget.download('url')

Una versione migliorata del codice PabloG per Python 2/3:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import ( division, absolute_import, print_function, unicode_literals )

import sys, os, tempfile, logging

if sys.version_info >= (3,):
    import urllib.request as urllib2
    import urllib.parse as urlparse
else:
    import urllib2
    import urlparse

def download_file(url, dest=None):
    """ 
    Download and save a file specified by url to dest directory,
    """
    u = urllib2.urlopen(url)

    scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
    filename = os.path.basename(path)
    if not filename:
        filename = 'downloaded.file'
    if dest:
        filename = os.path.join(dest, filename)

    with open(filename, 'wb') as f:
        meta = u.info()
        meta_func = meta.getheaders if hasattr(meta, 'getheaders') else meta.get_all
        meta_length = meta_func("Content-Length")
        file_size = None
        if meta_length:
            file_size = int(meta_length[0])
        print("Downloading: {0} Bytes: {1}".format(url, file_size))

        file_size_dl = 0
        block_sz = 8192
        while True:
            buffer = u.read(block_sz)
            if not buffer:
                break

            file_size_dl += len(buffer)
            f.write(buffer)

            status = "{0:16}".format(file_size_dl)
            if file_size:
                status += "   [{0:6.2f}%]".format(file_size_dl * 100 / file_size)
            status += chr(13)
            print(status, end="")
        print()

    return filename

if __name__ == "__main__":  # Only run if this file is called directly
    print("Testing with 10MB download")
    url = "http://download.thinkbroadband.com/10MB.zip"
    filename = download_file(url)
    print(filename)

Un modo semplice ma Python 2 & Python 3compatibile viene fornito con la sixlibreria:

from six.moves import urllib
urllib.request.urlretrieve("http://www.example.com/songs/mp3.mp3", "mp3.mp3")

import os,requests
def download(url):
    get_response = requests.get(url,stream=True)
    file_name  = url.split("/")[-1]
    with open(file_name, 'wb') as f:
        for chunk in get_response.iter_content(chunk_size=1024):
            if chunk: # filter out keep-alive new chunks
                f.write(chunk)


download("https://example.com/example.jpg")

Ha scritto la libreria wget in puro Python solo per questo scopo. È pieno urlretrievedi queste funzionalità a partire dalla versione 2.0.

Di seguito sono riportate le chiamate più comunemente utilizzate per il download di file in Python:

1. urllib.urlretrieve ('url_to_file', file_name)

2. urllib2.urlopen('url_to_file')

3. requests.get(url)

4. wget.download('url', file_name)

Nota: urlopene urlretrievesi riscontrano prestazioni relativamente scarse con il download di file di grandi dimensioni (dimensioni> 500 MB). requests.getmemorizza il file in memoria fino al completamento del download.

Sono d'accordo con Corey, urllib2 è più completo di urllib e probabilmente dovrebbe essere il modulo utilizzato se vuoi fare cose più complesse, ma per rendere le risposte più complete, urllib è un modulo più semplice se vuoi solo le basi:

import urllib
response = urllib.urlopen('http://www.example.com/sound.mp3')
mp3 = response.read()

Funzionerà bene. Oppure, se non si desidera gestire l'oggetto "response", è possibile chiamare direttamente read () :

import urllib
mp3 = urllib.urlopen('http://www.example.com/sound.mp3').read()

In python3 puoi usare urllib3 e shutil libraires. Scaricali usando pip o pip3 (A seconda che python3 sia predefinito o meno)

pip3 install urllib3 shutil

Quindi eseguire questo codice

import urllib.request
import shutil

url = "http://www.somewebsite.com/something.pdf"
output_file = "save_this_name.pdf"
with urllib.request.urlopen(url) as response, open(output_file, 'wb') as out_file:
    shutil.copyfileobj(response, out_file)

Si noti che si scarica urllib3ma si utilizza urllibnel codice

Puoi ottenere il feedback sui progressi anche con urlretrieve:

def report(blocknr, blocksize, size):
    current = blocknr*blocksize
    sys.stdout.write("\r{0:.2f}%".format(100.0*current/size))

def downloadFile(url):
    print "\n",url
    fname = url.split('/')[-1]
    print fname
    urllib.urlretrieve(url, fname, report)

Se hai installato wget, puoi usare parallel_sync.

pip installa parallel_sync

from parallel_sync import wget
urls = ['http://something.png', 'http://somthing.tar.gz', 'http://somthing.zip']
wget.download('/tmp', urls)
# or a single file:
wget.download('/tmp', urls[0], filenames='x.zip', extract=True)

Doc: https://pythonhosted.org/parallel_sync/pages/examples.html

Questo è abbastanza potente. Può scaricare file in parallelo, riprovare in caso di errore e persino scaricare file su un computer remoto.

Se la velocità conta per te, ho fatto un piccolo test delle prestazioni per i moduli urllibe wget, per quanto riguarda wgetho provato una volta con la barra di stato e una volta senza. Ho testato tre diversi file da 500 MB con cui testare (diversi file per eliminare la possibilità che ci sia un po 'di cache in corso sotto il cofano). Testato su debian machine, con python2.

Innanzitutto, questi sono i risultati (sono simili in diverse esecuzioni):

$ python wget_test.py 
urlretrive_test : starting
urlretrive_test : 6.56
==============
wget_no_bar_test : starting
wget_no_bar_test : 7.20
==============
wget_with_bar_test : starting
100% [......................................................................] 541335552 / 541335552
wget_with_bar_test : 50.49
==============

Il modo in cui ho eseguito il test sta utilizzando il decoratore "profilo". Questo è il codice completo:

import wget
import urllib
import time
from functools import wraps

def profile(func):
    @wraps(func)
    def inner(*args):
        print func.__name__, ": starting"
        start = time.time()
        ret = func(*args)
        end = time.time()
        print func.__name__, ": {:.2f}".format(end - start)
        return ret
    return inner

url1 = 'http://host.com/500a.iso'
url2 = 'http://host.com/500b.iso'
url3 = 'http://host.com/500c.iso'

def do_nothing(*args):
    pass

@profile
def urlretrive_test(url):
    return urllib.urlretrieve(url)

@profile
def wget_no_bar_test(url):
    return wget.download(url, out='/tmp/', bar=do_nothing)

@profile
def wget_with_bar_test(url):
    return wget.download(url, out='/tmp/')

urlretrive_test(url1)
print '=============='
time.sleep(1)

wget_no_bar_test(url2)
print '=============='
time.sleep(1)

wget_with_bar_test(url3)
print '=============='
time.sleep(1)

urllib sembra essere il più veloce

Solo per completezza, è anche possibile chiamare qualsiasi programma per recuperare file usando il subprocesspacchetto. I programmi dedicati al recupero dei file sono più potenti delle funzioni di Python urlretrieve. Ad esempio, è wgetpossibile scaricare ricorsivamente directory ( -R), gestire FTP, reindirizzamenti, proxy HTTP, evitare il ri-download di file esistenti ( -nc) e aria2eseguire download multi-connessione che possono potenzialmente velocizzare i download.

import subprocess
subprocess.check_output(['wget', '-O', 'example_output_file.html', 'https://example.com'])

In Jupyter Notebook, è anche possibile chiamare i programmi direttamente con la !sintassi:

!wget -O example_output_file.html https://example.com

Il codice sorgente può essere:

import urllib
sock = urllib.urlopen("http://diveintopython.org/")
htmlSource = sock.read()                            
sock.close()                                        
print htmlSource  

È possibile utilizzare PycURL su Python 2 e 3.

import pycurl

FILE_DEST = 'pycurl.html'
FILE_SRC = 'http://pycurl.io/'

with open(FILE_DEST, 'wb') as f:
    c = pycurl.Curl()
    c.setopt(c.URL, FILE_SRC)
    c.setopt(c.WRITEDATA, f)
    c.perform()
    c.close()

Ho scritto quanto segue, che funziona in Python 2 o Python 3 alla vaniglia.

import sys
try:
    import urllib.request
    python3 = True
except ImportError:
    import urllib2
    python3 = False


def progress_callback_simple(downloaded,total):
    sys.stdout.write(
        "\r" +
        (len(str(total))-len(str(downloaded)))*" " + str(downloaded) + "/%d"%total +
        " [%3.2f%%]"%(100.0*float(downloaded)/float(total))
    )
    sys.stdout.flush()

def download(srcurl, dstfilepath, progress_callback=None, block_size=8192):
    def _download_helper(response, out_file, file_size):
        if progress_callback!=None: progress_callback(0,file_size)
        if block_size == None:
            buffer = response.read()
            out_file.write(buffer)

            if progress_callback!=None: progress_callback(file_size,file_size)
        else:
            file_size_dl = 0
            while True:
                buffer = response.read(block_size)
                if not buffer: break

                file_size_dl += len(buffer)
                out_file.write(buffer)

                if progress_callback!=None: progress_callback(file_size_dl,file_size)
    with open(dstfilepath,"wb") as out_file:
        if python3:
            with urllib.request.urlopen(srcurl) as response:
                file_size = int(response.getheader("Content-Length"))
                _download_helper(response,out_file,file_size)
        else:
            response = urllib2.urlopen(srcurl)
            meta = response.info()
            file_size = int(meta.getheaders("Content-Length")[0])
            _download_helper(response,out_file,file_size)

import traceback
try:
    download(
        "https://geometrian.com/data/programming/projects/glLib/glLib%20Reloaded%200.5.9/0.5.9.zip",
        "output.zip",
        progress_callback_simple
    )
except:
    traceback.print_exc()
    input()

Appunti:

• Supporta un callback "barra di avanzamento".
• Il download è un .zip di prova da 4 MB dal mio sito Web.

Potrebbe essere un po 'tardi, ma ho visto il codice di pabloG e non ho potuto fare a meno di aggiungere un os.system (' cls ') per renderlo FANTASTICO! Controlla :

    import urllib2,os

    url = "http://download.thinkbroadband.com/10MB.zip"

    file_name = url.split('/')[-1]
    u = urllib2.urlopen(url)
    f = open(file_name, 'wb')
    meta = u.info()
    file_size = int(meta.getheaders("Content-Length")[0])
    print "Downloading: %s Bytes: %s" % (file_name, file_size)
    os.system('cls')
    file_size_dl = 0
    block_sz = 8192
    while True:
        buffer = u.read(block_sz)
        if not buffer:
            break

        file_size_dl += len(buffer)
        f.write(buffer)
        status = r"%10d  [%3.2f%%]" % (file_size_dl, file_size_dl * 100. / file_size)
        status = status + chr(8)*(len(status)+1)
        print status,

    f.close()

Se in esecuzione in un ambiente diverso da Windows, dovrai usare qualcosa di diverso da "cls". In MAC OS X e Linux dovrebbe essere "chiaro".

urlretrieve e request.get sono semplici, tuttavia la realtà no. Ho recuperato dati per siti di coppia, inclusi testo e immagini, i due precedenti probabilmente risolvono la maggior parte delle attività. ma per una soluzione più universale suggerisco l'uso di urlopen. Poiché è incluso nella libreria standard di Python 3, il codice potrebbe essere eseguito su qualsiasi macchina che esegue Python 3 senza preinstallare il pacchetto del sito

import urllib.request
url_request = urllib.request.Request(url, headers=headers)
url_connect = urllib.request.urlopen(url_request)

#remember to open file in bytes mode
with open(filename, 'wb') as f:
    while True:
        buffer = url_connect.read(buffer_size)
        if not buffer: break

        #an integer value of size of written data
        data_wrote = f.write(buffer)

#you could probably use with-open-as manner
url_connect.close()

Questa risposta fornisce una soluzione a HTTP 403 Proibito durante il download di file su http utilizzando Python. Ho provato solo richieste e moduli urllib, l'altro modulo potrebbe fornire qualcosa di meglio, ma questo è quello che ho usato per risolvere la maggior parte dei problemi.

Risposta in ritardo, ma per python>=3.6te puoi usare:

import dload
dload.save(url)

Installa dloadcon:

pip3 install dload

Volevo scaricare tutti i file da una pagina web. Ci ho provato wgetma non ci sono riuscito, quindi ho deciso per il percorso Python e ho trovato questo thread.

Dopo averlo letto, ho realizzato una piccola applicazione da riga di comando soupget, espandendo le eccellenti risposte di PabloG e Stan e aggiungendo alcune utili opzioni.

Utilizza BeatifulSoup per raccogliere tutti gli URL della pagina e quindi scaricare quelli con l'estensione o le estensioni desiderate. Finalmente può scaricare più file in parallelo.

Ecco qui:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function, unicode_literals)
import sys, os, argparse
from bs4 import BeautifulSoup

# --- insert Stan's script here ---
# if sys.version_info >= (3,): 
#...
#...
# def download_file(url, dest=None): 
#...
#...

# --- new stuff ---
def collect_all_url(page_url, extensions):
    """
    Recovers all links in page_url checking for all the desired extensions
    """
    conn = urllib2.urlopen(page_url)
    html = conn.read()
    soup = BeautifulSoup(html, 'lxml')
    links = soup.find_all('a')

    results = []    
    for tag in links:
        link = tag.get('href', None)
        if link is not None: 
            for e in extensions:
                if e in link:
                    # Fallback for badly defined links
                    # checks for missing scheme or netloc
                    if bool(urlparse.urlparse(link).scheme) and bool(urlparse.urlparse(link).netloc):
                        results.append(link)
                    else:
                        new_url=urlparse.urljoin(page_url,link)                        
                        results.append(new_url)
    return results

if __name__ == "__main__":  # Only run if this file is called directly
    # Command line arguments
    parser = argparse.ArgumentParser(
        description='Download all files from a webpage.')
    parser.add_argument(
        '-u', '--url', 
        help='Page url to request')
    parser.add_argument(
        '-e', '--ext', 
        nargs='+',
        help='Extension(s) to find')    
    parser.add_argument(
        '-d', '--dest', 
        default=None,
        help='Destination where to save the files')
    parser.add_argument(
        '-p', '--par', 
        action='store_true', default=False, 
        help="Turns on parallel download")
    args = parser.parse_args()

    # Recover files to download
    all_links = collect_all_url(args.url, args.ext)

    # Download
    if not args.par:
        for l in all_links:
            try:
                filename = download_file(l, args.dest)
                print(l)
            except Exception as e:
                print("Error while downloading: {}".format(e))
    else:
        from multiprocessing.pool import ThreadPool
        results = ThreadPool(10).imap_unordered(
            lambda x: download_file(x, args.dest), all_links)
        for p in results:
            print(p)

Un esempio del suo utilizzo è:

python3 soupget.py -p -e <list of extensions> -d <destination_folder> -u <target_webpage>

E un vero esempio se vuoi vederlo in azione:

python3 soupget.py -p -e .xlsx .pdf .csv -u https://healthdata.gov/dataset/chemicals-cosmetics