Cómo descargar imágenes usando solicitudes

Estoy tratando de descargar y guardar una imagen de la web usando el requestsmódulo de Python .

Aquí está el código (de trabajo) que utilicé:

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

Aquí está el nuevo código (que no funciona) usando 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)

¿Me pueden ayudar en qué atributo de la respuesta usar requests?

Puede usar el response.rawobjeto de archivo o iterar sobre la respuesta.

El uso del response.rawobjeto tipo archivo no descodificará, de forma predeterminada, las respuestas comprimidas (con GZIP o desinflado). De todos modos, puede forzarlo a descomprimirse configurando el decode_contentatributo en True(lo requestsconfigura Falsepara controlar la decodificación). Luego puede usar shutil.copyfileobj()para que Python transmita los datos a un objeto de archivo:

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)        

Para iterar sobre la respuesta, use un bucle; iterar así asegura que los datos se descompriman en esta etapa:

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)

Esto leerá los datos en fragmentos de 128 bytes; Si cree que otro tamaño de fragmento funciona mejor, utilice el Response.iter_content()método con un tamaño de fragmento personalizado:

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)

Tenga en cuenta que debe abrir el archivo de destino en modo binario para asegurarse de que Python no intente traducir nuevas líneas por usted. También lo configuramos stream=Truepara que requestsno descargue la imagen completa en la memoria primero.

Obtenga un objeto similar a un archivo de la solicitud y cópielo en un archivo. Esto también evitará leer todo en la memoria de una vez.

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

Qué tal esto, una solución rápida.

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)

Tengo la misma necesidad de descargar imágenes usando solicitudes. Primero probé la respuesta de Martijn Pieters, y funciona bien. Pero cuando hice un perfil en esta función simple, descubrí que usa tantas llamadas de función en comparación con urllib y urllib2.

Luego probé la forma recomendada por el autor del módulo de solicitudes:

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

Esto redujo mucho más el número de llamadas a funciones, acelerando así mi aplicación. Aquí está el código de mi perfilador y el resultado.

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

El resultado para testRequest:

343080 function calls (343068 primitive calls) in 2.580 seconds

Y el resultado para testRequest2:

3129 function calls (3105 primitive calls) in 0.024 seconds

Esto podría ser más fácil que usar requests. Esta es la única vez que sugeriré no usar requestspara hacer cosas HTTP.

Dos revestimientos usando urllib:

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

También hay un bonito módulo Python llamado wgetque es bastante fácil de usar. Encontrado aquí .

Esto demuestra la simplicidad del diseño:

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

Disfrutar.

Editar: también puede agregar un outparámetro para especificar una ruta.

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

El siguiente fragmento de código descarga un archivo.

El archivo se guarda con su nombre de archivo como en la URL especificada.

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)

Hay 2 formas principales:

1. Usando .content(más simple / oficial) (ver la respuesta de Zhenyi Zhang ):

   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. Utilizando .raw (ver la respuesta de Martijn Pieters ):

   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.

La sincronización de ambos no muestra una diferencia notable.

Tan fácil como importar imágenes y solicitudes

from PIL import Image
import requests

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

Aquí hay una respuesta más fácil de usar que todavía usa la transmisión.

Simplemente defina estas funciones y llame getImage(). Utilizará el mismo nombre de archivo que la url y escribirá en el directorio actual de forma predeterminada, pero ambos se pueden cambiar.

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

Las requestagallas de getImage()se basan en la respuesta aquí y las agallas de getImageFast()se basan en la respuesta anterior .

Voy a publicar una respuesta ya que no tengo suficiente representante para hacer un comentario, pero con wget publicado por Blairg23, también puede proporcionar un parámetro de salida para la ruta.

 wget.download(url, out=path)

Esta es la primera respuesta que surge para las búsquedas de Google sobre cómo descargar un archivo binario con solicitudes. En caso de que necesite descargar un archivo arbitrario con solicitudes, puede usar:

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)

Así es como lo hice

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

Puedes hacer algo como esto:

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)