python करन मैं पाइथन का उपयोग कर HTTP पर एक फ़ाइल कैसे डाउनलोड करूं?




हिंदी गाने डाउनलोड (16)

सरल अभी तक Python 2 & Python 3 संगत तरीका six पुस्तकालय के साथ आता है:

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

मेरे पास एक छोटी सी उपयोगिता है जिसका उपयोग मैं एक वेबसाइट से एक एमपी 3 डाउनलोड करने के लिए करता हूं और फिर पॉडकास्ट एक्सएमएल फ़ाइल बनाता / अपडेट करता हूं जिसे मैंने स्पष्ट रूप से आईट्यून्स में जोड़ा है।

पाठ प्रसंस्करण जो XML फ़ाइल बनाता / अद्यतन करता है उसे पायथन में लिखा जाता है। मैं वास्तविक एमपी 3 डाउनलोड करने के लिए विंडोज़ .bat फ़ाइल के अंदर wget का उपयोग करता हूं। हालांकि मैं पाइथन में पूरी उपयोगिता लिखना पसंद करूंगा।

मैं वास्तव में पाइथन में फ़ाइल को लोड करने का एक तरीका खोजने के लिए संघर्ष कर रहा था, इस प्रकार मैंने क्यों wget सहारा लिया।

तो, मैं पायथन का उपयोग कर फ़ाइल कैसे डाउनलोड करूं?


पाइथन में फ़ाइलों को डाउनलोड करने के लिए सबसे अधिक उपयोग की जाने वाली कॉल निम्नलिखित हैं:

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

  2. urllib2.urlopen('url_to_file')

  3. requests.get(url)

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

नोट: urlretrieve और urlretrieve बड़ी फ़ाइलों (आकार> 500 एमबी) डाउनलोड करने के साथ अपेक्षाकृत खराब प्रदर्शन करने के लिए पाए जाते हैं। requests.get फ़ाइल को स्मृति में संग्रहीत करता है जब तक कि डाउनलोड पूर्ण नहीं हो जाता है।


मैं कोरी से सहमत हूं, urllib2 urllib से अधिक पूर्ण है और यदि आप अधिक जटिल चीजें करना चाहते हैं, तो मॉड्यूल का उपयोग किया जाना चाहिए, लेकिन उत्तर को और अधिक पूरा करने के लिए, यदि आप केवल मूल बातें चाहते हैं तो urllib एक साधारण मॉड्यूल है:

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

ठीक काम करेगा। या, यदि आप "प्रतिक्रिया" ऑब्जेक्ट से निपटना नहीं चाहते हैं तो आप सीधे () सीधे कॉल कर सकते हैं:

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

urlretrieve और request.get सरल है, हालांकि वास्तविकता नहीं है। मैंने पाठ और छवियों सहित दो साइटों के लिए डेटा प्राप्त किया है, उपर्युक्त दो शायद अधिकांश कार्यों को हल करते हैं। लेकिन एक अधिक सार्वभौमिक समाधान के लिए मैं urlopen के उपयोग का सुझाव देते हैं। चूंकि इसे पायथन 3 मानक लाइब्रेरी में शामिल किया गया है, इसलिए आपका कोड किसी भी मशीन पर चलाया जा सकता है जो प्री-इंस्टॉलेशन साइट-पैरा के बिना पायथन 3 चलाता है

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

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

पाइथन का उपयोग करते हुए http पर फ़ाइल डाउनलोड करते समय यह उत्तर HTTP 403 को निषिद्ध करने का समाधान प्रदान करता है। मैंने केवल अनुरोध और urllib मॉड्यूल का प्रयास किया है, अन्य मॉड्यूल कुछ बेहतर प्रदान कर सकता है, लेकिन यह वह है जिसे मैं ज्यादातर समस्याओं को हल करने के लिए उपयोग करता था।


अगर आपके पास wget इंस्टॉल है, तो आप parallel_sync का उपयोग कर सकते हैं।

पाइप 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)

डॉक्टर: https://pythonhosted.org/parallel_sync/pages/examples.html

यह बहुत शक्तिशाली है। यह समानांतर में फ़ाइलों को डाउनलोड कर सकता है, विफलता पर पुनः प्रयास कर सकता है, और यह दूरस्थ मशीन पर भी फ़ाइलें डाउनलोड कर सकता है।


पायथन 2 में, urllib2 का उपयोग करें जो मानक लाइब्रेरी के साथ आता है।

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

पुस्तकालय का उपयोग करने के लिए यह सबसे बुनियादी तरीका है, किसी भी त्रुटि प्रबंधन से कम। आप हेडर बदलने जैसे अधिक जटिल सामान भी कर सकते हैं। दस्तावेज here. पाया जा सकता here.


इस उद्देश्य के लिए शुद्ध पायथन में wget लाइब्रेरी wget । यह संस्करण 2.0 के रूप में इन सुविधाओं के साथ urlretrieve पंप है।


यह थोड़ा देर हो सकता है, लेकिन मैंने पाब्लोग के कोड को देखा और ओएससिस्टम ('सीएलएस') को जोड़ने में मदद नहीं कर सका ताकि इसे अद्भुत लगे! इसकी जांच - पड़ताल करें :

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

यदि विंडोज के अलावा किसी अन्य वातावरण में चल रहा है, तो आपको कुछ और 'cls' का उपयोग करना होगा। मैक ओएस एक्स और लिनक्स में यह 'स्पष्ट' होना चाहिए।


यदि गति आपके लिए महत्वपूर्ण है, तो मैंने मॉड्यूल urllib और wget लिए एक छोटा प्रदर्शन परीक्षण किया है, और wget बारे में मैंने स्टेटस बार के साथ एक बार कोशिश की और बिना किसी के। मैंने परीक्षण के लिए तीन अलग-अलग 500 एमबी फाइलें लीं (विभिन्न फाइलें- इस मौके को खत्म करने के लिए कि हुड के नीचे कुछ कैशिंग चल रही है)। पाइथन 2 के साथ डेबियन मशीन पर परीक्षण किया गया।

सबसे पहले, ये परिणाम हैं (वे अलग-अलग रनों में समान हैं):

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

जिस तरह से मैंने परीक्षण किया वह "प्रोफाइल" सजावट का उपयोग कर रहा है। यह पूरा कोड है:

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 सबसे तेज़ लगता है


एक और, urlretrieve का उपयोग कर:

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

(पायथन 3+ के लिए 'import urllib.request' आयात करें और urllib.request.urlretrieve)

फिर भी एक और, एक "प्रगति पट्टी" के साथ

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

पाइथन 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)

पायथन 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')
    

पायथन 2

  • urllib2.urlopen (धन्यवाद Corey )

    import urllib2
    response = urllib2.urlopen('http://www.example.com/')
    html = response.read()
    
  • urllib.urlretrieve (धन्यवाद PabloG )

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

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

open('test.mp3','wb') में wb open('test.mp3','wb') बाइनरी मोड में एक फ़ाइल (और किसी भी मौजूदा फ़ाइल को मिटा देता है open('test.mp3','wb') खोलता है ताकि आप केवल टेक्स्ट के बजाय डेटा को सहेज सकें।


आप 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)

2012 में, पायथन अनुरोध पुस्तकालय का उपयोग करें

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

आप इसे प्राप्त करने के लिए pip install requests चला सकते हैं।

अनुरोधों के विकल्पों पर कई फायदे हैं क्योंकि एपीआई बहुत आसान है। यह विशेष रूप से सच है यदि आपको प्रमाणीकरण करना है। urllib और urllib2 इस मामले में काफी अनजान और दर्दनाक हैं।

2015/12/30

लोगों ने प्रगति पट्टी के लिए प्रशंसा व्यक्त की है। यह अच्छा है, यकीन है। 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)

यह अनिवार्य रूप से कार्यान्वयन @kvance 30 महीने पहले वर्णित है।


स्रोत कोड हो सकता है:

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




urllib