So laden Sie Bilder mithilfe von Anfragen herunter

Ich versuche, ein Bild mit dem Python- requestsModul aus dem Internet herunterzuladen und zu speichern .

Hier ist der (Arbeits-) Code, den ich verwendet habe:

img = urllib2.urlopen(settings.STATICMAP_URL.format(**data))
with open(path, 'w') as f:
    f.write(img.read())

Hier ist der neue (nicht funktionierende) Code mit requests:

r = requests.get(settings.STATICMAP_URL.format(**data))
if r.status_code == 200:
    img = r.raw.read()
    with open(path, 'w') as f:
        f.write(img)

Können Sie mir helfen, welches Attribut aus der Antwort verwendet werden soll requests?

Sie können entweder die Verwendung response.rawDateiobjekt oder Iterierte über die Antwort.

Wenn Sie das response.rawdateiähnliche Objekt verwenden, werden komprimierte Antworten standardmäßig nicht dekodiert (mit GZIP oder Deflate). Sie können die Dekomprimierung ohnehin für Sie erzwingen, indem Sie das decode_contentAttribut auf setzen True( requestssetzt es auf False, um die Dekodierung selbst zu steuern). Anschließend können Sie shutil.copyfileobj()Python die Daten in ein Dateiobjekt streamen lassen:

import requests
import shutil

r = requests.get(settings.STATICMAP_URL.format(**data), stream=True)
if r.status_code == 200:
    with open(path, 'wb') as f:
        r.raw.decode_content = True
        shutil.copyfileobj(r.raw, f)        

Verwenden Sie eine Schleife, um die Antwort zu durchlaufen. Wenn Sie so iterieren, wird sichergestellt, dass die Daten in dieser Phase dekomprimiert werden:

r = requests.get(settings.STATICMAP_URL.format(**data), stream=True)
if r.status_code == 200:
    with open(path, 'wb') as f:
        for chunk in r:
            f.write(chunk)

Dadurch werden die Daten in 128-Byte-Blöcken gelesen. Wenn Sie der Meinung sind, dass eine andere Blockgröße besser funktioniert, verwenden Sie die Response.iter_content()Methode mit einer benutzerdefinierten Blockgröße:

r = requests.get(settings.STATICMAP_URL.format(**data), stream=True)
if r.status_code == 200:
    with open(path, 'wb') as f:
        for chunk in r.iter_content(1024):
            f.write(chunk)

Beachten Sie, dass Sie die Zieldatei im Binärmodus öffnen müssen, um sicherzustellen, dass Python nicht versucht, Zeilenumbrüche für Sie zu übersetzen. Wir haben auch festgelegt stream=True, dass requestsnicht zuerst das gesamte Bild in den Speicher heruntergeladen wird.

Holen Sie sich ein dateiähnliches Objekt aus der Anforderung und kopieren Sie es in eine Datei. Dadurch wird auch vermieden, dass das Ganze sofort in den Speicher eingelesen wird.

import shutil

import requests

url = 'http://example.com/img.png'
response = requests.get(url, stream=True)
with open('img.png', 'wb') as out_file:
    shutil.copyfileobj(response.raw, out_file)
del response

Wie wäre es damit, eine schnelle Lösung.

import requests

url = "http://craphound.com/images/1006884_2adf8fc7.jpg"
response = requests.get(url)
if response.status_code == 200:
    with open("/Users/apple/Desktop/sample.jpg", 'wb') as f:
        f.write(response.content)

Ich habe das gleiche Bedürfnis, Bilder mithilfe von Anfragen herunterzuladen. Ich habe zuerst die Antwort von Martijn Pieters versucht, und es funktioniert gut. Aber als ich ein Profil für diese einfache Funktion erstellt habe, habe ich festgestellt, dass sie im Vergleich zu urllib und urllib2 so viele Funktionsaufrufe verwendet.

Ich habe dann den vom Autor des Anforderungsmoduls empfohlenen Weg ausprobiert :

import requests
from PIL import Image
# python2.x, use this instead  
# from StringIO import StringIO
# for python3.x,
from io import StringIO

r = requests.get('https://example.com/image.jpg')
i = Image.open(StringIO(r.content))

Dadurch wurde die Anzahl der Funktionsaufrufe erheblich reduziert und meine Anwendung beschleunigt. Hier ist der Code meines Profilers und das Ergebnis.

#!/usr/bin/python
import requests
from StringIO import StringIO
from PIL import Image
import profile

def testRequest():
    image_name = 'test1.jpg'
    url = 'http://example.com/image.jpg'

    r = requests.get(url, stream=True)
    with open(image_name, 'wb') as f:
        for chunk in r.iter_content():
            f.write(chunk)

def testRequest2():
    image_name = 'test2.jpg'
    url = 'http://example.com/image.jpg'

    r = requests.get(url)

    i = Image.open(StringIO(r.content))
    i.save(image_name)

if __name__ == '__main__':
    profile.run('testUrllib()')
    profile.run('testUrllib2()')
    profile.run('testRequest()')

Das Ergebnis für testRequest:

343080 function calls (343068 primitive calls) in 2.580 seconds

Und das Ergebnis für testRequest2:

3129 function calls (3105 primitive calls) in 0.024 seconds

Dies ist möglicherweise einfacher als die Verwendung requests. Dies ist das einzige Mal, dass ich vorschlagen werde, es nicht zu verwendenrequests HTTP zu verwenden.

Zwei Liner mit urllib:

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

Es gibt auch ein schönes Python-Modul namens wget, das ziemlich einfach zu bedienen ist. gefunden hier .

Dies zeigt die Einfachheit des Designs:

>>> import wget
>>> url = 'http://www.futurecrew.com/skaven/song_files/mp3/razorback.mp3'
>>> filename = wget.download(url)
100% [................................................] 3841532 / 3841532>
>> filename
'razorback.mp3'

Genießen.

Bearbeiten: Sie können auch einen outParameter hinzufügen , um einen Pfad anzugeben.

>>> out_filepath = <output_filepath>    
>>> filename = wget.download(url, out=out_filepath)

Das folgende Code-Snippet lädt eine Datei herunter.

Die Datei wird mit ihrem Dateinamen wie in der angegebenen URL gespeichert.

import requests

url = "http://example.com/image.jpg"
filename = url.split("/")[-1]
r = requests.get(url, timeout=0.5)

if r.status_code == 200:
    with open(filename, 'wb') as f:
        f.write(r.content)

Es gibt zwei Hauptwege:

1. Verwenden .content(am einfachsten / offiziellsten) (siehe Zhenyi Zhangs Antwort ):

   import io  # Note: io.BytesIO is StringIO.StringIO on Python2.
   import requests
   
   r = requests.get('http://lorempixel.com/400/200')
   r.raise_for_status()
   with io.BytesIO(r.content) as f:
       with Image.open(f) as img:
           img.show()

2. Verwenden .raw(siehe Martijn Pieters Antwort ):

   import requests
   
   r = requests.get('http://lorempixel.com/400/200', stream=True)
   r.raise_for_status()
   r.raw.decode_content = True  # Required to decompress gzip/deflate compressed responses.
   with PIL.Image.open(r.raw) as img:
       img.show()
   r.close()  # Safety when stream=True ensure the connection is released.

Das Timing zeigt keinen merklichen Unterschied.

So einfach wie das Importieren von Bildern und Anfragen

from PIL import Image
import requests

img = Image.open(requests.get(url, stream = True).raw)
img.save('img1.jpg')

Hier ist eine benutzerfreundlichere Antwort, die weiterhin Streaming verwendet.

Definieren Sie einfach diese Funktionen und rufen Sie auf getImage(). Es wird den gleichen Dateinamen wie die URL verwenden und standardmäßig in das aktuelle Verzeichnis schreiben, aber beide können geändert werden.

import requests
from StringIO import StringIO
from PIL import Image

def createFilename(url, name, folder):
    dotSplit = url.split('.')
    if name == None:
        # use the same as the url
        slashSplit = dotSplit[-2].split('/')
        name = slashSplit[-1]
    ext = dotSplit[-1]
    file = '{}{}.{}'.format(folder, name, ext)
    return file

def getImage(url, name=None, folder='./'):
    file = createFilename(url, name, folder)
    with open(file, 'wb') as f:
        r = requests.get(url, stream=True)
        for block in r.iter_content(1024):
            if not block:
                break
            f.write(block)

def getImageFast(url, name=None, folder='./'):
    file = createFilename(url, name, folder)
    r = requests.get(url)
    i = Image.open(StringIO(r.content))
    i.save(file)

if __name__ == '__main__':
    # Uses Less Memory
    getImage('http://www.example.com/image.jpg')
    # Faster
    getImageFast('http://www.example.com/image.jpg')

Die requestEingeweide von getImage()basieren auf der Antwort hier und die Eingeweide von getImageFast()basieren auf der obigen Antwort .

Ich werde eine Antwort posten, da ich nicht genug Repräsentanten habe, um einen Kommentar abzugeben, aber mit wget, wie von Blairg23 gepostet, können Sie auch einen out-Parameter für den Pfad angeben.

 wget.download(url, out=path)

Dies ist die erste Antwort, die bei Google-Suchanfragen zum Herunterladen einer Binärdatei mit Anforderungen angezeigt wird. Falls Sie eine beliebige Datei mit Anforderungen herunterladen müssen, können Sie Folgendes verwenden:

import requests
url = 'https://s3.amazonaws.com/lab-data-collections/GoogleNews-vectors-negative300.bin.gz'
open('GoogleNews-vectors-negative300.bin.gz', 'wb').write(requests.get(url, allow_redirects=True).content)

So habe ich es gemacht

import requests
from PIL import Image
from io import BytesIO

url = 'your_url'
files = {'file': ("C:/Users/shadow/Downloads/black.jpeg", open('C:/Users/shadow/Downloads/black.jpeg', 'rb'),'image/jpg')}
response = requests.post(url, files=files)

img = Image.open(BytesIO(response.content))
img.show()

Sie können so etwas tun:

import requests
import random

url = "https://images.pexels.com/photos/1308881/pexels-photo-1308881.jpeg? auto=compress&cs=tinysrgb&dpr=1&w=500"
name=random.randrange(1,1000)
filename=str(name)+".jpg"
response = requests.get(url)
if response.status_code.ok:
   with open(filename,'w') as f:
    f.write(response.content)