Bon marre de rechercher sans arrêt : google sametmax datetime...
alors je le mets ici !

et aussi :
http://sametmax.com/serialiser-et-parser-une-date-en-python-formats-de-strftimestrptime-et-timestamps/

########################
with open('output.jpg', 'wb') as handle:
   response = requests.get('http://www.example.com/image.jpg', stream=True)

   if not response.ok:
       # Something went wrong

   for block in response.iter_content(1024):
       if not block:
           break
       handle.write(block)
########################
/*I usually just use urllib.urlretrieve(). It works, but if you need to use a session or some sort of authentication, the above code works as well.*/

voir aussi : https://stackoverflow.com/questions/13137817/how-to-download-image-using-requests
-----------------------------------------------------------------------------------------------------------------------------------------


Get a file-like object from the request and copy it to a file. This will also avoid reading the whole thing into memory at once.
########################
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
########################

Note that the .raw file-like object does not decompress a response using Content-Encoding: gzip or Content-Encoding: deflate. You can use response.raw.read(decode_content=True) but shutil.copyfileobj cannot do that because it assumes a generic .read() method

########################
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)
########################
ou :
#######################
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)
########################

Présentation rapide de kivy (développement d'application pour mobile android, IOS,..) en python

En résumé :

   yield permet de faire des générateurs
   On peut demander la prochaine valeur du générateur avec next(). Dans ce cas, le code s’exécute jusqu’au prochain yield.
   On peut envoyer une valeur au générateur avec send(). Dans ce cas, on DOIT partir d’un yield existant duquel on récupère la valeur envoyée via une assignation. Donc il faut au moins un next() avant d’utiliser un send() et un signe égal sur le yield.
   send() va aussi aller au prochain yield et retourner sa valeur.
   Une coroutine n’est qu’une formalisation de la manière d’éffectuer une tâche avec un init, une exécution et une finalisation optionelle en utilisant un générateur. C’est une solution générique à un problème courant, mais plus léger qu’une classe.
   Généralement on décore les générateurs coroutines avec un décorateur @coroutine pour s’éviter d’appeler next() à la main et notifier l’usage qu’il est fait de ce générateur.
   On peut chaîner des coroutines comme on chaîne des générateurs, mais au lieu de lire les données une à une (PULL), on les envoie une par une (PUSH). Cela est pratique quand on ne sait pas à l’avance quand une nouvelle donnée va arriver.

static_files (css, images,...)
from bottle import static_file
@route('/images/<filename:re:.*\.png>')
def send_image(filename):
   return static_file(filename, root='/path/to/image/files', mimetype='image/png')

@route('/static/<filename:path>')
def send_static(filename):
   return static_file(filename, root='/path/to/static/files')