Jak mogę pobrać plik przez HTTP za pomocą Pythona?

Mam małe narzędzie, którego używam do pobierania pliku MP3 ze strony internetowej zgodnie z harmonogramem, a następnie buduję / aktualizuje plik XML podcastu, który dodałem do iTunes.

Przetwarzanie tekstu, które tworzy / aktualizuje plik XML, jest napisane w języku Python. Jednak używam wget wewnątrz .batpliku Windows , aby pobrać rzeczywisty plik MP3. Wolałbym mieć całe narzędzie napisane w Pythonie.

Z trudem znalazłem sposób na pobranie pliku w Pythonie, dlatego też zdecydowałem się go użyć wget.

Jak mogę pobrać plik za pomocą Pythona?

W Pythonie 2 użyj urllib2, który jest dostarczany ze standardową biblioteką.

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

Jest to najbardziej podstawowy sposób korzystania z biblioteki, pomijając obsługę błędów. Możesz także wykonywać bardziej złożone czynności, takie jak zmiana nagłówków. Dokumentację można znaleźć tutaj.

Jeszcze jedno, używając urlretrieve:

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

(do użytku w Python 3+ import urllib.requesti urllib.request.urlretrieve)

Jeszcze jeden, z „paskiem postępu”

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()

W 2012 r. Użyj biblioteki żądań python

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

Możesz pobiec, pip install requestsaby go zdobyć.

Żądania mają wiele zalet w porównaniu z alternatywami, ponieważ interfejs API jest znacznie prostszy. Jest to szczególnie prawdziwe, jeśli musisz dokonać uwierzytelnienia. Urllib i urllib2 są w tym przypadku dość nieintuicyjne i bolesne.

30.12.2015

Ludzie wyrazili podziw dla paska postępu. Jasne, na pewno. Obecnie dostępnych jest kilka gotowych rozwiązań, w tym 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)

Zasadniczo jest to implementacja @kvance opisana 30 miesięcy temu.

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

Plik wbin open('test.mp3','wb')otwiera plik (i usuwa każdy istniejący plik) w trybie binarnym, dzięki czemu można zapisywać z nim dane zamiast samego tekstu.

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')

  Uwaga: zgodnie z dokumentacją urllib.request.urlretrievejest „starszym interfejsem” i „może stać się przestarzały w przyszłości” (dzięki gerrit )

Python 2

• urllib2.urlopen(dzięki Corey )

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

• urllib.urlretrieve(dzięki PabloG )

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

użyj modułu wget:

import wget
wget.download('url')

Ulepszona wersja kodu PabloG dla Pythona 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)

Prosty, ale Python 2 & Python 3kompatybilny sposób pochodzi z sixbiblioteki:

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")

W tym celu napisałem bibliotekę wget w czystym języku Python. Jest urlretrievewyposażony w te funkcje od wersji 2.0.

Oto najczęściej używane wezwania do pobierania plików w Pythonie:

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

2. urllib2.urlopen('url_to_file')

3. requests.get(url)

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

Uwaga: urlopena urlretrieveokaże się wykonać stosunkowo źle z pobieraniem dużych plików (rozmiar> 500 MB). requests.getprzechowuje plik w pamięci do momentu zakończenia pobierania.

Zgadzam się z Coreyem, urllib2 jest bardziej kompletny niż urllib i prawdopodobnie powinien być modułem używanym, jeśli chcesz robić bardziej złożone rzeczy, ale aby uzupełnić odpowiedzi, urllib jest prostszym modułem, jeśli potrzebujesz tylko podstaw:

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

Będzie działać dobrze. Lub, jeśli nie chcesz zajmować się obiektem „response”, możesz bezpośrednio wywołać read () :

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

W python3 możesz używać bibliotek urllib3 i shutil. Pobierz je przy użyciu pip lub pip3 (w zależności od tego, czy python3 jest domyślny, czy nie)

pip3 install urllib3 shutil

Następnie uruchom ten kod

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)

Pamiętaj, że pobierasz, urllib3ale używasz urllibkodu

Możesz również uzyskać informację zwrotną o postępach za pomocą 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)

Jeśli masz zainstalowany wget, możesz użyć równoległego synchronizacji.

pip install równoległa_synchronizacja

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)

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

To jest dość potężne. Może pobierać pliki równolegle, próbować w razie awarii, a nawet pobierać pliki na zdalnym komputerze.

Jeśli prędkość ma dla ciebie znaczenie, zrobiłem mały test wydajności dla modułów urllibi wget, i odnośniewget Próbowałem raz pasku stanu, a raz bez. Wziąłem trzy różne pliki 500 MB do przetestowania (różne pliki - aby wyeliminować ryzyko buforowania pod maską). Testowany na maszynie debian z python2.

Po pierwsze, są to wyniki (są podobne w różnych seriach):

$ 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
==============

Sposób, w jaki przeprowadziłem test, to użycie dekoratora „profilowego”. To jest pełny kod:

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 wydaje się być najszybszy

Ze względu na kompletność można również wywołać dowolny program do pobierania plików za pomocą subprocesspakietu. Programy dedykowane do pobierania plików są bardziej wydajne niż funkcje Pythona urlretrieve. Na przykład, wgetmoże pobierać katalogi rekurencyjnie ( -R), radzić sobie z FTP, przekierowaniami, serwerami proxy HTTP, może unikać ponownego pobierania istniejących plików ( -nc) i aria2może pobierać wiele połączeń, co może potencjalnie przyspieszyć pobieranie.

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

W Jupyter Notebook można również wywoływać programy bezpośrednio za pomocą !składni:

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

Kod źródłowy może być:

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

Możesz używać PycURL na Pythonie 2 i 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()

Napisałem następujące, które działają w waniliowym Pythonie 2 lub Pythonie 3.

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()

Uwagi:

• Obsługuje funkcję zwrotną „paska postępu”.
• Plik do pobrania to 4 MB testowy plik .zip z mojej witryny.

To może być trochę późno, ale widziałem kod pabloG i nie mogłem się powstrzymać od dodania systemu os.system ('cls'), aby wyglądał NIESAMOWICIE! Sprawdź to :

    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()

Jeśli działasz w środowisku innym niż Windows, będziesz musiał użyć czegoś innego niż „cls”. W systemach MAC OS X i Linux powinno być „czyste”.

urlretrieve i requests.get są proste, ale w rzeczywistości nie. Pobrałem dane dla kilku witryn, w tym tekst i obrazy, powyższe dwa prawdopodobnie rozwiązują większość zadań. ale dla bardziej uniwersalnego rozwiązania sugeruję skorzystanie z urlopu. Ponieważ jest zawarty w standardowej bibliotece Python 3, Twój kod może działać na dowolnej maszynie, na której działa Python 3 bez wstępnej instalacji pakietu witryny

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()

Ta odpowiedź stanowi rozwiązanie dla HTTP 403 Zabronione podczas pobierania pliku przez HTTP za pomocą Pythona. Próbowałem tylko żądań i modułów urllib, drugi moduł może zapewnić coś lepszego, ale tego właśnie użyłem do rozwiązania większości problemów.

Późna odpowiedź, ale python>=3.6możesz użyć:

import dload
dload.save(url)

Zainstaluj za dloadpomocą:

pip3 install dload

Chciałem pobrać wszystkie pliki ze strony internetowej. Próbowałem, wgetale nie udało się, więc zdecydowałem się na trasę w języku Python i znalazłem ten wątek.

Po przeczytaniu napisałem małą aplikację z linii poleceń soupget, rozwijając doskonałe odpowiedzi PabloG i Stana oraz dodając kilka przydatnych opcji.

Korzysta z BeatifulSoup aby zebrać wszystkie adresy URL strony, a następnie pobrać te z pożądanymi rozszerzeniami. Wreszcie może pobierać wiele plików równolegle.

Oto on:

#!/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)

Przykładem jego użycia jest:

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

I prawdziwy przykład, jeśli chcesz zobaczyć to w akcji:

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