Instalacja Pythona

Wsparcie Pythona

Biblioteka klienta Python Earth Engine jest zgodna z wersjami Pythona obsługiwanymi przez Google Cloud. Obsługa jest aktualizowana co roku zgodnie z harmonogramem wydawania wersji Pythona (PEP 602; Stan wersji Pythona). Korzystanie z nieobsługiwanych wersji Pythona może powodować błędy uwierzytelniania, nieoczekiwane działanie lub niepowodzenie niektórych operacji.

Opcje instalacji

Jeśli używasz Google Colab, najnowsza wersja biblioteki klienta Earth Engine w Pythonie została już zainstalowana (za pomocą pip). Aby rozpocząć pracę z Earth Engine i Colabem, wypróbuj ten notatnik:

Logo Colab Uruchom w Google Colab Logo GitHub Wyświetl źródło na GitHubie

Jeśli nie korzystasz z Colab, bibliotekę klienta Earth Engine możesz zainstalować i aktualizować ręcznie w swoim systemie za pomocą conda (zalecane) lub pip:


Zainstaluj interfejs API w dowolnym środowisku Pythona za pomocą pip. W terminalu lub wierszu poleceń:

pip install earthengine-api

Po zainstalowaniu pakietu możesz zaimportować, uwierzytelnić i zainicjować interfejs API Earth Engine zgodnie z instrukcjami podanymi tutaj.

Zaktualizuj interfejs API:

pip install earthengine-api --upgrade

Importowanie pakietu

Pakiet interfejsu API w Pythonie nazywa się ee. Musisz go zaimportować i inicjializować w przypadku każdej nowej sesji i skryptu Pythona:

import ee

Uwierzytelnianie i inicjowanie

Zanim użyjesz biblioteki klienta Earth Engine w Pythonie, musisz uwierzytelnić się i użyć uzyskanych danych logowania do zainicjowania klienta Pythona. Uruchomienie: 

ee.Authenticate()

Spowoduje to wybranie najlepszego trybu uwierzytelniania dla Twojego środowiska i wyświetlenie prośby o potwierdzenie dostępu dla skryptów. Aby zainicjować, musisz podać projekt, którego jesteś właścicielem lub do którego masz uprawnienia. Ten projekt będzie używany do wykonywania wszystkich operacji w Earth Engine: 

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

Aby rozwiązać problemy i dowiedzieć się więcej o trybach uwierzytelniania oraz projektach w Cloud, zapoznaj się z przewodnikiem dotyczącym uwierzytelniania.

Witaj świecie!

Oto krótki skrypt, który pozwoli Ci sprawdzić, czy wszystko jest gotowe do pracy z Earth Engine. 

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

Składnia

Zarówno interfejsy API Pythona, jak i JavaScriptu uzyskują dostęp do tych samych funkcji po stronie serwera, ale wyrażenia po stronie klienta (więcej informacji o kliencie i serwerze) mogą się różnić ze względu na różnice w składni języka. W tabeli poniżej znajdziesz listę typowych różnic w składni, które występują podczas korzystania z interfejsu Python API w porównaniu z interfejsem JavaScript API.

Typowe różnice w składni między JavaScriptem a Pythonem
Właściwość JavaScript Python
Definicja funkcji 
function myFun(arg) {
  return arg;
}

var myFun = function(arg) {
  return arg;
};
 
def my_fun(arg):
  return arg
Anonimowe mapowanie funkcji 
var foo = col.map(function(arg) {
  return arg;
});
 
foo = col.map(lambda arg: arg)
Definicja zmiennej 
var myVar = 'var';
 
my_var = 'var'
Operatory logiczne 
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)
Wielowierszowy łańcuch metod 
var foo = my.really()
              .reallyLong()
              .methodChain();
 
foo = (my.really()
       .reallyLong()
       .methodChain())
Klucze słownika 
var dic = {'key': value};
var dic = {key: value};
 
dic = {'key': value}
Dostęp do obiektów słownika 
var value = dic.key;
var value = dic['key'];
 
value = dic['key']
Definicja argumentu funkcji 
// 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)
Wartość logiczna 
var t = true;
var f = false;
 
t = True
f = False
Wartości null 
var na = null;
 
na = None
Komentarz 
//
 
#

Obiekty Date

Definiuj obiekty dat po stronie klienta i zmieniaj je za pomocą modułu datetime. Dodaj moduł do skryptu:

import datetime

Konwertowanie ee.Date na datę po stronie klienta:

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

Konwertowanie daty po stronie klienta na ee.Date:

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

Eksportowanie danych

Eksportowanie danych za pomocą interfejsu Python API wymaga użycia modułu ee.batch, który udostępnia interfejs do funkcji Export. Przekazuj argumenty parametrów tak jak w przypadku interfejsu JavaScript API, z uwzględnieniem różnic podanych w powyżej wymienionej tabeli składni. Zadania eksportu muszą być uruchamiane przez wywołanie metody start() zdefiniowanego zadania. Zapytanie o stan zadania poprzez wywołanie metody status(). Ten przykład pokazuje eksportowanie obiektu ee.Image.

Tworzenie zadania eksportu:

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

Rozpocznij zadanie eksportowania:

task.start()

Sprawdzanie stanu zadania eksportu:

task.status()

Wynik funkcji task.status() to słownik zawierający informacje takie jak stan zadania i jego identyfikator. 

{
  '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'
}

Postęp zadania możesz sprawdzać w polu state. Na stronie Przetwarzanie środowisk znajdziesz listę wartości state oraz więcej informacji o cyklu życia zadania.

Drukowanie obiektów

Wyświetlenie obiektu Earth Engine w Pythonie powoduje wydrukowanie zaszyfrowanego żądania dotyczącego obiektu, a nie samego obiektu. Aby poznać przyczynę tego problemu, zapoznaj się ze stroną Tagowanie po stronie klienta i po stronie serwera.

Wywołaj funkcję getInfo() w obiektach Earth Engine, aby pobrać żądany obiekt z serwera na klienta:

# 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())
 Zauważ, że getInfo() to operacja synchroniczna, co oznacza, że wykonywanie wyrażeń po wywołaniu getInfo() jest blokowane, dopóki wynik nie zostanie zwrócony do klienta. Dodatkowo żądania dotyczące dużej ilości danych lub wymagające kosztownych obliczeń mogą zwracać błąd lub zawieszać się. Ogólnie zalecamy eksportowanie wyników, a potem zaimportowanie ich do nowego skryptu w celu dalszej analizy.

Obiekty interfejsu

Moduł Earth Engine ui jest dostępny tylko w edytorze kodu interfejsu JavaScript API. Korzystanie z bibliotek innych firm do elementów interfejsu użytkownika w Pythonie. Biblioteki takie jak geemap, Folium i ipyleaflet zapewniają wyświetlanie interaktywnych map, a wykresy można tworzyć za pomocą Matplotlib, Altair lub seaborn. Przykłady korzystania z geemap i Matplotlib znajdziesz w  notatniku konfiguracyjnym Earth Engine w Colab.

Python w Przewodniku dla deweloperów

Kod Pythona jest zawarty w przewodniku dla deweloperów Earth Engine. Przykłady kodu można wyświetlić, jeśli są dostępne, klikając kartę „Colab (Python)” u góry bloków kodu. Strony z przewodnikiem mogą też zawierać przyciski u góry, które umożliwiają uruchomienie strony jako notatnika Colab lub wyświetlenie jej na GitHub. Przykłady kodu Pythona należy uruchamiać za pomocą Google Colab. Interaktywne mapy i przeglądanie obiektów są obsługiwane przez bibliotekę geemap. Zarówno biblioteka klienta Earth Engine w Pythonie, jak i geemap są wstępnie zainstalowane w Colab.

Konfiguracja Earth Engine

Aby uruchomić kod Pythona, musisz zaimportować bibliotekę Earth Engine, uwierzytelnić ją i zainicjować. W przykładach używamy tych poleceń (Uwierzytelnianie i inicjowanie – alternatywy).

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

Interaktywna eksploracja za pomocą geemap

Biblioteka geemap służy do wyświetlania kafelków mapy i drukowania bogatych reprezentacji obiektów Earth Engine. Biblioteka zależy odpowiednio od ipyleaflet i eerepr. Biblioteka geemap i jej zależności są wstępnie zainstalowane w Google Colab; są importowane do każdej sesji.

import geemap.core as geemap

Klasy danych geograficznych Earth Engine, takie jak ee.Image i ee.FeatureCollection, można wyświetlać za pomocą obiektu geemap.Map. Najpierw zdefiniuj obiekt mapy. Następnie dodaj do niego warstwy lub zmień widoczny obszar.

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