Installation de Python

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Compatibilité avec Python

La bibliothèque cliente Python Earth Engine est compatible avec les versions Python compatibles avec Google Cloud. La prise en charge est mise à jour chaque année conformément au calendrier de publication des versions ponctuelles de Python (PEP 602, État des versions de Python). L'utilisation de versions Python non compatibles peut entraîner des échecs d'authentification, un comportement inattendu ou l'échec de certaines opérations.

Options d'installation

Si vous utilisez Google Colab, la dernière version de la bibliothèque cliente Python Earth Engine a déjà été installée (via pip). Essayez le notebook suivant pour commencer à utiliser Earth Engine et Colab:

Exécuter dans Google Colab

Afficher la source sur GitHub

Si vous n'utilisez pas Colab, vous pouvez installer et mettre à jour manuellement la bibliothèque cliente Earth Engine sur votre système à l'aide de conda (recommandé) ou de pip:

pip install earthengine-api

pip install earthengine-api --upgrade

Importation de packages

Le package d'API Python s'appelle ee. Il doit être importé et initialisé pour chaque nouvelle session et script Python:

import ee

Authentification et initialisation

Avant d'utiliser la bibliothèque cliente Python Earth Engine, vous devez vous authentifier et utiliser les identifiants obtenus pour initialiser le client Python. Exécutez la commande suivante :

ee.Authenticate()

Le meilleur mode d'authentification pour votre environnement sera sélectionné, et vous serez invité à confirmer l'accès pour vos scripts. Pour l'initialiser, vous devez fournir un projet dont vous êtes le propriétaire ou dont vous disposez des autorisations d'utilisation. Ce projet sera utilisé pour exécuter toutes les opérations Earth Engine:

ee.Initialize(project='my-project')

Consultez le guide d'authentification pour résoudre les problèmes et en savoir plus sur les modes d'authentification et les projets Cloud.

Bonjour tout le monde !

Voici un court script pour vérifier que vous êtes prêt à utiliser Earth Engine.

import ee
ee.Authenticate()
ee.Initialize(project='my-project')
print(ee.String('Hello from the Earth Engine servers!').getInfo())

Syntaxe

Les API Python et JavaScript accèdent à la même fonctionnalité côté serveur, mais les expressions côté client (en savoir plus sur le client par rapport au serveur) peuvent varier en raison des différences de syntaxe entre les langages. Le tableau suivant inclut une liste des différences de syntaxe courantes que vous rencontrerez lorsque vous utiliserez l'API Python par rapport à l'API JavaScript.

function myFun(arg) {
  return arg;
}

var myFun = function(arg) {
  return arg;
};

def my_fun(arg):
  return arg

var foo = col.map(function(arg) {
  return arg;
});

foo = col.map(lambda arg: arg)

var myVar = 'var';

my_var = 'var'

var match = such.and(that);
var match = such.or(that);
var match = such.not(that);

match = such.And(that)
match = such.Or(that)
match = such.Not(that)

var foo = my.really()
              .reallyLong()
              .methodChain();

foo = (my.really()
       .reallyLong()
       .methodChain())

var dic = {'key': value};
var dic = {key: value};

dic = {'key': value}

var value = dic.key;
var value = dic['key'];

value = dic['key']

// Positional arguments.
var foo = fun(argX, argY, argZ);
// Keyword arguments object.
var foo = fun({y: argY});

# Positional arguments.
foo = fun(arg_x, arg_y, arg_z)
# Keyword arguments dictionary.
foo = fun(**{'y': arg_y})
# Keyword arguments.
foo = fun(x=arg_x, z=arg_z)

var t = true;
var f = false;

t = True
f = False

var na = null;

na = None

//

#

Objets Date

Définissez et manipulez des objets de date côté client avec le module datetime. Incluez le module dans votre script:

import datetime

Convertir ee.Date en date côté client:

ee_date = ee.Date('2020-01-01')
py_date = datetime.datetime.utcfromtimestamp(ee_date.getInfo()['value']/1000.0)

Convertir la date côté client en ee.Date:

py_date = datetime.datetime.utcnow()
ee_date = ee.Date(py_date)

Exportation de données

L'exportation de données avec l'API Python nécessite l'utilisation du module ee.batch, qui fournit une interface aux fonctions Export. Transmettez les arguments de paramètre comme vous le feriez avec l'API JavaScript, en tenant compte des différences indiquées dans le tableau de syntaxe ci-dessus. Les tâches d'exportation doivent être démarrées en appelant la méthode start() sur une tâche définie. Interrogez l'état d'une tâche en appelant la méthode status(). L'exemple suivant montre comment exporter un objet ee.Image.

Créez une tâche d'exportation:

task = ee.batch.Export.image.toDrive(image=my_image,  # an ee.Image object.
                                     region=my_geometry,  # an ee.Geometry object.
                                     description='mock_export',
                                     folder='gdrive_folder',
                                     fileNamePrefix='mock_export',
                                     scale=1000,
                                     crs='EPSG:4326')

Lancer une tâche d'exportation:

task.start()

Vérifiez l'état de la tâche d'exportation:

task.status()

Le résultat de task.status() est un dictionnaire contenant des informations telles que l'état de la tâche et son ID.

{
  'state': 'READY',
  'description': 'my_export_task',
  'creation_timestamp_ms': 1647567508236,
  'update_timestamp_ms': 1647567508236,
  'start_timestamp_ms': 0,
  'task_type': 'EXPORT_IMAGE',
  'id': '56TVJIZABUMTD5CJ5YHTMYK4',
  'name': 'projects/earthengine-legacy/operations/56TVJIZABUMTX5CJ5HHTMYK4'
}

Vous pouvez surveiller la progression des tâches à l'aide du champ state. Consultez la page "Environnements de traitement" pour obtenir une liste des valeurs state et plus d'informations sur le cycle de vie des tâches.

Imprimer des objets

L'impression d'un objet Earth Engine en Python imprime la requête sérialisée pour l'objet, et non l'objet lui-même. Consultez la page Client par rapport au serveur pour comprendre pourquoi.

Appelez getInfo() sur les objets Earth Engine pour obtenir l'objet souhaité du serveur au client:

# Load a Landsat image.
img = ee.Image('LANDSAT/LT05/C02/T1_L2/LT05_034033_20000913')

# Print image object WITHOUT call to getInfo(); prints serialized request instructions.
print(img)

# Print image object WITH call to getInfo(); prints image metadata.
print(img.getInfo())

Objets d'interface utilisateur

Le module ui Earth Engine n'est disponible que via l'éditeur de code de l'API JavaScript. Utilisez des bibliothèques tierces pour les éléments d'interface utilisateur en Python. Des bibliothèques telles que geemap, Folium et ipyleaflet permettent d'afficher des cartes interactives, tandis que les graphiques peuvent être créés avec Matplotlib, Altair ou seaborn, pour n'en citer que quelques-unes. Consultez les exemples dans le notebook de configuration d'Earth Engine dans Colab pour utiliser geemap et Matplotlib.

Python dans le guide du développeur

Le code Python est inclus dans l'ensemble du guide du développeur Earth Engine. Le cas échéant, vous pouvez afficher des exemples de code en cliquant sur l'onglet "Colab (Python)" en haut des blocs de code. Les pages de guide peuvent également inclure des boutons en haut pour exécuter la page en tant que notebook Colab ou l'afficher sur GitHub. Les exemples de code Python sont destinés à être exécutés à l'aide de Google Colab. La carte interactive et l'exploration des objets sont gérées par la bibliothèque geemap. La bibliothèque cliente Python Earth Engine et geemap sont préinstallées dans Colab.

Configuration d'Earth Engine

Pour exécuter du code Python, vous devez importer la bibliothèque Earth Engine, vous authentifier et l'initialiser. Les commandes suivantes sont utilisées dans des exemples (consultez la page Authentification et initialisation pour connaître les alternatives).

import ee
ee.Authenticate()
ee.Initialize(project='my-project')

Exploration interactive avec geemap

La bibliothèque geemap permet d'afficher des tuiles de carte et d'imprimer des représentations riches d'objets Earth Engine. La bibliothèque dépend respectivement de ipyleaflet et de eerepr pour ces fonctionnalités. La bibliothèque geemap et ses dépendances sont préinstallées dans Google Colab. Importez-la dans chaque session.

import geemap.core as geemap

Les classes de données géographiques Earth Engine, telles que ee.Image et ee.FeatureCollection, peuvent être affichées à l'aide de l'objet geemap.Map. Commencez par définir l'objet carte. Ajoutez ensuite des calques ou modifiez sa fenêtre d'affichage.

# Initialize a map object.
m = geemap.Map()

# Define an example image.
img = ee.Image.random()

# Add the image to the map.
m.add_layer(img, None, 'Random image')

# Display the map (you can call the object directly if it is the final line).
display(m)