Comment télécharger une image en utilisant des requêtes

Question

J'essaie de télécharger et d'enregistrer une image à partir du web en utilisant la fonction python requests module.

Voici le code (fonctionnel) que j'ai utilisé :

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

Voici le nouveau code (qui ne fonctionne pas) utilisant 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)

Pouvez-vous m'aider à déterminer l'attribut de la réponse à utiliser à partir de requests ?

Answer 1

Vous pouvez soit utiliser le response.raw Objet du fichier ou d'itérer sur la réponse.

Pour utiliser le response.raw ne décodera pas, par défaut, les réponses compressées (avec GZIP ou deflate). Vous pouvez le forcer à décompresser pour vous en définissant l'option decode_content de l'attribut True ( requests le fixe à False pour contrôler le décodage lui-même). Vous pouvez alors utiliser shutil.copyfileobj() pour que Python transmette les données à un objet fichier :

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)        

Pour itérer sur la réponse, utilisez une boucle ; en itérant ainsi, vous vous assurez que les données sont décompressées à ce stade :

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)

Les données seront lues par morceaux de 128 octets ; si vous pensez qu'une autre taille de morceaux est plus appropriée, utilisez la commande Response.iter_content() méthode avec une taille de morceau personnalisé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)

Notez que vous devez ouvrir le fichier de destination en mode binaire pour vous assurer que python n'essaie pas de traduire les nouvelles lignes pour vous. Nous avons également défini stream=True de sorte que requests ne télécharge pas d'abord l'image entière en mémoire.

Answer 2

Obtenir un objet de type fichier à partir de la requête et le copier dans un fichier. Cela évitera également de tout lire en mémoire en une seule fois.

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 3

Que pensez-vous de ça, une solution rapide.

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 4

J'ai le même besoin de télécharger des images en utilisant des requêtes. J'ai d'abord essayé la réponse de Martijn Pieters, et cela fonctionne bien. Mais quand j'ai fait un profil sur cette fonction simple, j'ai trouvé qu'elle utilise beaucoup d'appels de fonction par rapport à urllib et urllib2.

J'ai ensuite essayé le moyen recommandé par l'auteur des demandes de module :

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

Cela a permis de réduire beaucoup plus le nombre d'appels de fonctions, et donc d'accélérer mon application. Voici le code de mon profiler et le résultat.

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

Le résultat de testRequest :

343080 function calls (343068 primitive calls) in 2.580 seconds

Et le résultat pour testRequest2 :

3129 function calls (3105 primitive calls) in 0.024 seconds

Answer 5

Et de cette façon :

# filename.py    
import requests

url = 'http://www.example.com/image.jpg'
page = requests.get(url)
with open('test', 'wb') as test:
test.write(page.content)