පයිතන් භාවිතයෙන් HTTP හරහා ගොනුවක් බාගත කරන්නේ කෙසේද?


895

කාලසටහනකට අනුව වෙබ් අඩවියකින් MP3 ගොනුවක් බාගත කිරීම සඳහා මා භාවිතා කරන කුඩා උපයෝගීතාවයක් මා සතුව ඇති අතර පසුව මම අයිටියුන්ස් වෙත එකතු කළ පෝඩ්කාස්ට් එක්ස්එම්එල් ගොනුවක් සාදමි / යාවත්කාලීන කරමි.

XML ගොනුව නිර්මාණය / යාවත්කාලීන කරන පෙළ සැකසීම පයිතන් හි ලියා ඇත. කෙසේ වෙතත්, මම .batසත්‍ය MP3 ගොනුව බාගත කිරීම සඳහා වින්ඩෝස් ගොනුවක් තුළ wget භාවිතා කරමි . සම්පූර්ණ උපයෝගීතාව පයිතන්හි ලිවීමට මම කැමැත්තෙමි.

පයිතන් හි ගොනුව සැබවින්ම බාගත කර ගැනීමට ක්‍රමයක් සොයා ගැනීමට මම වෙහෙසුණා wget.

ඉතින්, මම පයිතන් භාවිතයෙන් ගොනුව බාගත කරන්නේ කෙසේද?



පහත දැක්වෙන බොහෝ පිළිතුරු සඳහා සතුටුදායක ආදේශනයක් නොවේ wget. වෙනත් දේ අතර, wget(1) කාලරාමු ආරක්ෂා කරයි (2) යූආර්එල් වෙතින් ගොනු නාමය ස්වයංක්‍රීයව තීරණය .1කරයි, ගොනුව දැනටමත් තිබේ නම් එකතු කිරීම (ආදිය) (3) වෙනත් බොහෝ විකල්ප තිබේ, ඒවායින් සමහරක් ඔබ තුළ තබා ඇත .wgetrc. ඔබට ඒවායින් කිසිවක් අවශ්‍ය නම්, ඔබ ඒවා පයිතන් තුළ ක්‍රියාත්මක කළ යුතුය, නමුත් wgetපයිතන් වෙතින් ආයාචනා කිරීම සරල ය .
ශ්‍රීවාට්සාර්

2
පයිතන් 3 සඳහා කෙටි විසඳුම:import urllib.request; s = urllib.request.urlopen('http://example.com/').read().decode()
Basj

Answers:


461

භාවිතා කරන්න urllib.request.urlopen():

import urllib.request
with urllib.request.urlopen('http://www.example.com/') as f:
    html = f.read().decode('utf-8')

පුස්තකාලය භාවිතා කිරීමට ඇති මූලිකම ක්‍රමය මෙයයි. ශීර්ෂ වෙනස් කිරීම වැනි වඩාත් සංකීර්ණ දේවල් ඔබට කළ හැකිය.

පයිතන් 2 හි, ක්‍රමය පහත පරිදි වේ urllib2:

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

11
ඔබ සපයන url හි අවකාශ තිබේ නම් මෙය ක්‍රියා නොකරනු ඇත. එවැනි අවස්ථාවකදී, ඔබට යූආර්එල් විග්‍රහ කර මාර්ගය යූරන්කෝඩ් කිරීමට අවශ්‍ය වේ.
ජේසන් සුන්ද්‍රම්

95
මෙන්න පයිතන් 3 විසඳුම: stackoverflow.com/questions/7243750/…
tommy.carstensen

6
යොමු කිරීම සඳහා පමණි. මාර්ගය යූරෙන්කෝඩ් කිරීමේ මාර්ගයurllib2.quote
ඇන්ඩ්‍රේ පුයෙල්

11
Ason ජේසන් සුන්ද්‍රම්: එහි අවකාශ තිබේ නම් එය යූආර්අයි නොවේ.
Zaz

1
විශාල ගොනු සහිත කවුළු වල මෙය ක්‍රියා නොකරයි. ඔබ සියලු කොටස් කියවිය යුතුය!
Avia

1135

තවත් එකක්, භාවිතා කරමින් 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()

1
පුදුමයට කරුණක් නම්, මෙය වින්ඩෝස් හි මට වැඩ කළේ urllib2 ක්‍රමය නොමැති විටය. Urllib2 ක්‍රමය මැක් මත ක්‍රියාත්මක වුවද.
InFreefall

6
දෝෂය: file_size_dl + = block_sz අවසන් වරට කියවීම බොහෝ විට සම්පූර්ණ block_sz නොවන බැවින් + = len (buffer) විය යුතුය. කවුළු වලද ඔබ පෙළ ගොනුවක් නොවේ නම් ප්‍රතිදාන ගොනුව "wb" ලෙස විවෘත කළ යුතුය.
වම්බටු ජෙෆ්

1
මමත් urllib සහ urllib2 වැඩ කළේ නැත, නමුත් urlretrieve හොඳින් වැඩ කළා, කලකිරීමට පත්වුණා - ස්තූතියි :)
funk-shun

2
if not os.path.isfile(file_name):පොඩ්කාස්ට් නැවත ලිවීම වළක්වා ගැනීම සඳහා සියල්ලම (file_name හි අර්ථ දැක්වීම හැර) ඔතා ! .html ගොනුවක ඇති යූආර්එල්ස් සමඟ එය ක්‍රොන්ජොබ් ලෙස ධාවනය කිරීමේදී ප්‍රයෝජනවත් වේ
ශ්‍රීරාම් මුරලි

මට යෝජනාවක් ඇත,% string formatting සහ sys.stdout.write () වෙනුවට .format () භාවිතා කරන්න: gist.github.com/3176958
Savvas Radevic

353

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)

මෙය අත්‍යවශ්‍යයෙන්ම මාස 30 කට පෙර විස්තර කරන ලද ක්වන්ස් ක්‍රියාත්මක කිරීමකි.


සිප් ගොනුව ඇත්ත වශයෙන්ම එහි බොහෝ ගොනු ඇති ෆෝල්ඩරයක් නම් මම ඉතිරි කරන්නේ හෝ උපුටා ගන්නේ කෙසේද?
අබ්දුල් මුනීර්

6
මෙය විශාල ලිපිගොනු හසුරුවන්නේ කෙසේද, සියල්ල මතකයේ ගබඩා වන්නේද නැතහොත් විශාල මතක අවශ්‍යතාවයකින් තොරව ගොනුවකට මෙය ලිවිය හැකිද?
බිබ්ස්ටා

8
ඉල්ලීමෙහි stream = true ලෙස සැකසීමෙන් විශාල ගොනු ප්‍රවාහනය කළ හැකිය. ඔබට වරකට කැබැල්ලක් කියවීම සඳහා ප්‍රතිචාරය මත iter_content () අමතන්න.
kvance

7
යූආර්එල් පුස්තකාලයකට ලිපිගොනු ඉවත් කිරීමේ පහසුකමක් අවශ්‍ය වන්නේ ඇයි? යූආර්එල් වෙතින් ගොනුව කියවා එය සුරකින්න සහ ඔබේ බෝට්ටුව පාවෙන ඕනෑම ආකාරයකින් එය ඉවත් කරන්න. සිප් ගොනුවක් කවුළුවල පෙන්වන ආකාරයට 'ෆෝල්ඩරයක්' නොවේ, එහි ගොනුවකි.
හරෙල්

2
Li අලි :: r.textපෙළ හෝ යුනිකෝඩ් අන්තර්ගතය සඳහා. යුනිකෝඩ් ලෙස නැවත ලබා දෙන ලදි. r.content: ද්විමය අන්තර්ගත සඳහා. බයිට් ලෙස ආපසු ලබා දෙන ලදි. ඒ ගැන මෙතැනින් කියවන්න: docs.python-requests.org/en/latest/user/quickstart
hughdbrown

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

මෙම wbතුළ open('test.mp3','wb')ඔබට ඒ වෙනුවට හුදෙක් පෙළ එය සමග දත්ත සුරැකීමට හැකි නිසා ද්විමය ආකාරයෙන් ගොනු විවෘත කරයි (සහ දැනට පවතින ගොනු මකා දමයි).


31
මෙම විසඳුමේ අවාසිය නම්, තැටියට සුරැකීමට පෙර මුළු ගොනුවම රැම් තුළට පටවා තිබීම, සීමිත රැම් සහිත රවුටරයක් ​​වැනි කුඩා පද්ධතියක විශාල ගොනු සඳහා මෙය භාවිතා කරන්නේ නම් මතක තබා ගත යුතු දෙයකි.
ට්‍රිප්ලට්

2
අපි එය නිවැරදි කරන්නේ කෙසේද?
ලූකස් හෙන්රික්

11
සම්පූර්ණ ගොනුව මතකයට කියවීම වලක්වා ගැනීම සඳහා, තර්කයක් ඉදිරිපත් කිරීමට උත්සාහ කරන්න file.readකියවීමට ඇති බයිට් ගණන. බලන්න: gist.github.com/hughdbrown/c145b8385a2afa6570e2
hughdbrown

ughughdbrown ඔබේ ස්ක්‍රිප්ට් එක ප්‍රයෝජනවත් බව මට පෙනී ගියේය, නමුත් එක් ප්‍රශ්නයක් ඇත: පශ්චාත් සැකසුම් සඳහා මට ගොනුව භාවිතා කළ හැකිද? මට OpenCV සමඟ සැකසීමට අවශ්‍ය jpg ගොනුවක් බාගත කර ඇතැයි සිතමු, දිගටම වැඩ කිරීමට මට 'දත්ත' විචල්‍යය භාවිතා කළ හැකිද? නැතහොත් බාගත කළ ගොනුවෙන් මට එය නැවත කියවිය යුතුද?
රොඩ්රිගෝ ඊ. ප්‍රින්සිප්

5
shutil.copyfileobj(mp3file, output)ඒ වෙනුවට භාවිතා කරන්න .
ඕරලියන් ඕම්ස්

135

පයිතන් 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')

    සටහන: ප්‍රලේඛනයට අනුව, urllib.request.urlretrieveඑය “උරුම අතුරු මුහුණතක්” වන අතර “අනාගතයේදී එය අතහැර දැමිය හැකිය” (ස්තූතියි ගෙරිට් )

පයිතන් 2


2
එය නිසැකවම මඳ වේලාවක් ගත විය, නමුත් අවසාන වශයෙන්, මම පයිතන් ස්ටඩ්ලිබ් එකකින් බලාපොරොත්තු වන පහසුම api :)
ThorSummoner

Python3 සඳහා ඉතා හොඳ පිළිතුරක්, docs.python.org/3/library/… ද බලන්න
එඩ්වඩ්

DEdouardThiel ඔබ urllib.request.urlretrieveඉහත ක්ලික් කළහොත් එය ඔබව එම සබැඳියට ගෙන එනු ඇත. චියර්ස්!
bmaupin

2
urllib.request.urlretrieve"උරුම අතුරු මුහුණතක්" ලෙස ලේඛනගත කර ඇති අතර "අනාගතයේදී එය අවලංගු විය හැකිය".
ගෙරිට්

ඔබට පසුව බයිට් පොකුරක් ලැබෙන බව සඳහන් කළ යුතුය.
thoroc


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

21

පයිතන් 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)

පළමු පේළියේ සිට වරහන් ඉවත් කරමි, මන්ද එය පැරණි අංගයක් නොවන බැවිනි.
ආර්පාඩ් හෝර්වාත්

21

සරල නමුත් Python 2 & Python 3අනුකූල ක්‍රමයක් sixපුස්තකාලය සමඟ පැමිණේ :

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

1
2 + 3 අනුකූලතාව සඳහා එය කළ හැකි හොඳම ක්‍රමය මෙයයි.
Fush

18

මේ සඳහා පිරිසිදු පයිතන්හි wget පුස්තකාලය ලිවීය . 2.0 අනුවාදය අනුව එය මෙම අංගurlretrieve සමඟ පොම්ප කර ඇත .


3
අභිරුචි ගොනු නාමය සමඟ සුරැකීමට විකල්පයක් නැද්ද?
ඇලෙක්ස්

2
Lex ඇලෙක්ස් 2.1 අනුවාදයට FILENAME විකල්පය එක් කළේය
ඇනටෝලි ටෙක්ටොනික්

මම සිග්වින් යටතේ මෙම මොඩියුලය භාවිතා කරන විට ප්‍රගති තීරුව නොපෙන්වයි.
ජෝ කෝඩර්

GNU wget හි ඇති ආකාරයට ව්‍යාකූලත්වය වළක්වා ගැනීම -oසඳහා ඔබ වෙනස් විය යුතුය -O. නැතහොත් අවම වශයෙන් විකල්ප දෙකම වලංගු විය යුතුය.
එරික්

@eric මට wget.pyයථාර්ථය වෙනුවට තැනින් තැන ආදේශ කිරීමට අවශ්‍ය බව මට විශ්වාස නැත wget. මෙම -oදැනටමත් වෙනස් ලෙස හැසිරෙන - එය සමග අනුකූල වේ curlමේ ආකාරයට. ප්‍රලේඛනයේ සටහනක් ගැටළුව විසඳීමට උපකාරී වේද? එසේත් නැතිනම් එවැනි නමක් ඇති උපයෝගීතාවයකට විධාන රේඛා අනුකූල වීම අත්‍යවශ්‍ය අංගයක්ද?
anatoly techtonik

16

පයිතන් හි ගොනු බාගත කිරීම සඳහා බහුලව භාවිතා වන ඇමතුම් පහත දැක්වේ:

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

  2. urllib2.urlopen('url_to_file')

  3. requests.get(url)

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

සටහන: urlopenහා urlretrieveවිශාල ගොනු (ප්රමාණය> 500 MB) බාගත සාපේක්ෂව නරක ඉටු කිරීමට දක්නට ලැබේ. requests.getබාගත කිරීම අවසන් වන තුරු ගොනුව මතකයේ ගබඩා කරයි.


14

මම, කුරේ සමග එකඟ 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()

12

Python3 හි ඔබට urllib3 සහ shutil පුස්තකාල භාවිතා කළ හැකිය. පයිප්ප හෝ පයිප් 3 භාවිතයෙන් ඒවා බාගන්න (පයිතන් 3 පෙරනිමි ද නැද්ද යන්න මත පදනම්ව)

pip3 install urllib3 shutil

ඉන්පසු මෙම කේතය ක්‍රියාත්මක කරන්න

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)

ඔබ බාගත කළ urllib3නමුත් urllibකේතයෙන් භාවිතා කරන බව සලකන්න


9

ඔබ wget ස්ථාපනය කර ඇත්නම්, ඔබට සමාන්තර_සයින්ක් භාවිතා කළ හැකිය.

පයිප්ප ස්ථාපනය සමාන්තර_සයින්ක්

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

මෙය තරමක් බලවත් ය. එයට සමාන්තරව ලිපිගොනු බාගත කළ හැකිය, අසමත් වූ විට නැවත උත්සාහ කරන්න, දුරස්ථ යන්ත්‍රයකින් ගොනු බාගත කළ හැකිය.


මෙය ලිනක්ස් සඳහා පමණක් බව
සලකන්න

7

ඔබට ප්‍රගති ප්‍රතිපෝෂණය 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)

5

සම්පූර්ණත්වය සඳහා පමණක්, subprocessපැකේජය භාවිතයෙන් ලිපිගොනු ලබා ගැනීම සඳහා ඕනෑම වැඩසටහනක් කැඳවිය හැකිය . ලිපිගොනු ලබා ගැනීම සඳහා කැප කරන වැඩසටහන් පයිතන් ක්‍රියාකාරිත්වයට වඩා බලවත් ය urlretrieve. උදාහරණයක් ලෙස, wgetඩිරෙක්ටරි පුනරාවර්තන ලෙස බාගත කළ හැකිය ( -R), එෆ්ටීපී සමඟ ගනුදෙනු කළ හැකිය, යළි-යොමුවීම්, එච්ටීටීපී ප්‍රොක්සි, පවතින ගොනු නැවත බාගත කිරීමෙන් වළක්වා ගත හැකිය ( -nc), සහ aria2ඔබේ බාගැනීම් වේගවත් කළ හැකි බහු සම්බන්ධතා බාගැනීම් කළ හැකිය.

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

ජුපිටර් නෝට්බුක්හි, කෙනෙකුට !වාක්‍ය ඛණ්ඩය සමඟ කෙලින්ම වැඩසටහන් ඇමතිය හැකිය :

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

4

වේගය ඔබට වැදගත් නම්, මම ෙම ල සඳහා කුඩා කාර්ය සාධන පරීක්ෂණය සිදු urllibහා wget, හා සම්බන්ධයෙන්wget මම තත්ව තීරුව සහිතව සහ රහිතව වරක් එක් වරක් උත්සාහ කළා. පරීක්ෂා කිරීම සඳහා මම විවිධ 500MB ලිපිගොනු තුනක් ගත්තා (විවිධ ලිපිගොනු- හුඩ් යට යම් හැඹිලියක් සිදුවීමේ අවස්ථාව ඉවත් කිරීම සඳහා). පයිතන් 2 සමඟ ඩෙබියන් යන්ත්‍රය මත පරීක්ෂා කර ඇත.

පළමුව, මේවා ප්‍රති results ල වේ (ඒවා විවිධ ලකුණු වල සමාන වේ):

$ 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 වේගවත්ම බව පෙනේ


බාර්එක කාලය වැඩි කර ගැනීම සඳහා හුඩ් යට සම්පූර්ණයෙන්ම භයානක දෙයක් සිදුවිය යුතුය.
ඇලිස්ටෙයාර් කාර්ස්කැඩන්

3

ප්‍රභව කේතය විය හැක්කේ:

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

3

ඔබට Python 2 සහ 3 මත PycURL භාවිතා කළ හැකිය .

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

2

මම පහත සඳහන් දේ ලිවූ අතර එය වැනිලා පයිතන් 2 හෝ පයිතන් 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()

සටහන්:

  • "ප්‍රගති තීරුව" ඇමතුමකට සහය දක්වයි.
  • බාගත කිරීම 4 MB පරීක්ෂණයකි .zip මගේ වෙබ් අඩවියෙන්.

නියමයි, ජුපිටර් හරහා ධාවනය කරන්න මට අවශ්‍ය දේ ලැබුණා :-)
සමීර් ඕල්ඩ්සාඩි

2

මෙය මඳක් ප්‍රමාද විය හැකිය, නමුත් මම පැබ්ලොග්ගේ කේතය දුටුවෙමි. එය පරික්ෂා කරන්න :

    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'. MAC OS X සහ Linux වල එය 'පැහැදිලි' විය යුතුය.


3
clsමගේ OS X හෝ මගේ උබුන්ටු සේවාදායකයේ කිසිවක් නොකරයි. සමහර පැහැදිලි කිරීම් හොඳ විය හැකිය.
kqw

මම හිතන්නේ ඔබ clearලිනක්ස් සඳහා භාවිතා කළ යුතුයි , නැතහොත් සම්පූර්ණ විධාන රේඛා ප්‍රතිදානය ඉවත් කරනවා වෙනුවට මුද්‍රණ රේඛාව ප්‍රතිස්ථාපනය කරන්න.
අරිජූන්

4
මෙම පිළිතුර තවත් පිළිතුරක් පිටපත් කර, අවලංගු කරන ලද ශ්‍රිතයකට ( os.system()) ඇමතුමක් එක් කරන අතර එය වේදිකා විශේෂිත විධානයක් ( cls) භාවිතා කර තිරය හිස් කිරීම සඳහා උප ක්‍රියාවලියක් දියත් කරයි . කොහොමද මේ කුමක්ද ඕනෑම upvotes ?? සම්පූර්ණයෙන්ම නිෂ් less ල "පිළිතුර" IMHO.
කොරී ගෝල්ඩ්බර්ග්

1

urlretrieve සහ request.get සරලයි, කෙසේ වෙතත් යථාර්ථය එසේ නොවේ. පෙළ සහ රූප ඇතුළුව මම යුවල අඩවි සඳහා දත්ත ලබාගෙන ඇත, ඉහත දෙක බොහෝ කාර්යයන් විසඳනු ඇත. නමුත් වඩාත් විශ්වීය විසඳුමක් සඳහා මම යෝජනා කරන්නේ urlopen භාවිතා කිරීමයි. එය පයිතන් 3 සම්මත පුස්තකාලයට ඇතුළත් කර ඇති බැවින්, ඔබේ කේතය අඩවි-පැකේජය පූර්ව ස්ථාපනය නොකර පයිතන් 3 ධාවනය කරන ඕනෑම යන්ත්‍රයක ක්‍රියාත්මක විය හැකිය.

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

පයිතන් භාවිතයෙන් http හරහා ගොනුව බාගත කිරීමේදී මෙම පිළිතුර HTTP 403 තහනම් කර ඇත. මම උත්සාහ කර ඇත්තේ ඉල්ලීම් සහ යූරලිබ් මොඩියුල පමණි, අනෙක් මොඩියුලය වඩා හොඳ යමක් ලබා දිය හැකිය, නමුත් බොහෝ ගැටලු විසඳීමට මා භාවිතා කළේ මෙයයි.


0

ප්‍රමාද පිළිතුර, නමුත් python>=3.6ඔබට මෙය භාවිතා කළ හැකිය:

import dload
dload.save(url)

dloadසමඟ ස්ථාපනය කරන්න :

pip3 install dload

0

මට අවශ්‍ය වූයේ සියලුම ලිපිගොනු වෙබ් පිටුවකින් බාගත කිරීමයි. මම උත්සාහ කළ wgetනමුත් එය අසාර්ථක වූ නිසා මම පයිතන් මාර්ගය තීරණය කළ අතර මට මෙම ත්‍රෙඩ් එක හමු විය.

එය කියවීමෙන් පසු, මම කුඩා විධාන රේඛා යෙදුමක් soupgetකර ඇති අතර, පැබ්ලොග් සහ ස්ටැන්ගේ විශිෂ්ට පිළිතුරු පුළුල් කරමි කරමින් ප්‍රයෝජනවත් විකල්ප කිහිපයක් එකතු කර .

එය BeatifulSoup භාවිතා කරයි පිටුවේ සියලුම URL එක්රැස් කිරීමට කර අපේක්ෂිත දිගුව (ය) සමඟ බාගත කරන්න. අවසාන වශයෙන් එයට සමාන්තරව ගොනු කිහිපයක් බාගත කළ හැකිය.

මේ තියෙන්නේ:

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

එහි භාවිතයට උදාහරණයක්:

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

ඔබට එය ක්‍රියාවෙන් දැකීමට අවශ්‍ය නම් සත්‍ය උදාහරණයක්:

python3 soupget.py -p -e .xlsx .pdf .csv -u https://healthdata.gov/dataset/chemicals-cosmetics
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.