python - httperror - Cómo descargar la imagen usando peticiones

urllib2 python 3

Question

Estoy tratando de descargar y guardar una imagen de la web usando el módulo de requests 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 utilizar de las requests ?

Answer 1

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

Answer 2

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

Solo define estas funciones y llama a getImage() . Utilizará el mismo nombre de archivo que la URL y escribirá en el directorio actual de forma predeterminada, pero ambos pueden cambiarse.

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 agallas de request de getImage() se basan en la respuesta here y las agallas de getImageFast() se basan en la respuesta above .

Answer 3

Cuando trato de ejecutar el código de abajo, la imagen se está degradando, pero el tamaño siempre se limita a 34 KB.

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)

Y también déjame saber qué son las configuraciones.STATICMAP_URL.format (** datos), estoy usando mi usl en lugar de las configuraciones.STATICMAP_URL.format (** datos)

Answer 4

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://beispiel.dort/ichbineinbild.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)

Answer 5

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

Dos trazadores de líneas que utilizan urllib :

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

También hay un buen módulo de Python llamado wget que es bastante fácil de usar. Encontrado here

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 parámetro de out para especificar una ruta.

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

Answer 6

Hay 2 formas principales:

1. Uso de .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. Usando .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.

Answer 7

Obtenga un objeto similar a un archivo de la solicitud y cópielo en un archivo. Esto también evitará leer todo en 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

Answer 8

Puede utilizar el objeto de archivo response.raw o iterar sobre la respuesta.

Para utilizar el objeto response.raw -like, el objeto no decodificará, de forma predeterminada, las respuestas comprimidas (con GZIP o desinflado). Puede forzarlo a descomprimir para usted de todos modos estableciendo el atributo decode_content en True (las requests establecen en False para controlar la decodificación en sí misma). 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; una iteración como esta 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 trozo funciona mejor, use el método Response.iter_content() con un tamaño de trozo 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 las nuevas líneas por usted. También configuramos stream=True para que las requests no descarguen primero la imagen completa en la memoria.

Answer 9

Tan fácil como importar imagen y peticiones.

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

Answer 10

Tengo la misma necesidad de descargar imágenes usando peticiones. 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.

Entonces probé el modo recomendado por el autor del módulo de solicitudes:

import requests
from PIL import Image
from StringIO 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, lo que aceleró 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

Answer 11

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

 wget.download(url, out=path)