Formation Python pour géomaticiens 🐍🌏

11 Décembre 2023

Matthieu Viry

matthieu.viry@cnrs.fr

Programme de la demi-journée 📝

• Partie 1 : Introduction à Python
• Partie 2 : Mise en pratique
• Partie 3 : Python et QGIS
• Partie 4 : Mise en pratique
• Conclusion

Objectifs : Découvrir le langage de programmation Python et son écosystème, et apprendre à l’utiliser pour réaliser des traitements géomatiques dans QGIS.

Rappels des instructions pour installer l’environnement Python : Installation d’un environnement Python pour Windows avec Anaconda et VSCodium

Partie 1 - Introduction à Python

Pourquoi programmer ?

• Automatiser des tâches répétitives (et ainsi gagner en productivité)
• Prendre le contrôle des analyses et des traitements que vous réalisez
• Réaliser des analyses reproductibles
• Pour le fun ! 🎉

Et pourquoi en Python ?

• C’est un des langages de programmation les plus populaires et les plus utilisés dans le monde
• C’est un langage relativement simple à apprendre

Historique et présentation sur le papier…

• Langage créé à la toute fin des années 80 - première version publique sortie en 1991.

• Libre (régit par la Python Software Foundation License, équivalent à BSD)

• Langage polyvalent, interprété, multi-paradigme (impératif, fonctionnel, OO, ..)

• Typage dynamique fort (et duck typing)

• Toujours en développement actif (dernière version stable en octobre 2023)

En 1989 aux Pays-Bas, Guido van Rossum invente le langage de programmation Python. C’est un fan de la série télévisée Monty Python’s Flying Circus, donc pour rendre un hommage à la série il donne le nom Python. Ce n’est qu’en 1991 que la première version de ce langage a été publiée.

C’est la Python Software Foundation qui se charge de développer Python et de faire vivre la communauté de développeurs et utilisateurs.

• Il est multiplateforme : fonctionne sur des nombreux systèmes d’exploitation ;
• C’est un logiciel libre
• C’est un langage interprété : le script python est directement exécuté, il n’a pas besoin d’être compilé avant d’être exécuté ;
• C’est un langage orienté objet : on peut créer des programmes qui imite le comportement du monde réel ;
• Enfin, il est notamment utilisé en bio-informatique, et plus couramment en analyse de données.

Sur le site web, la description en une phrase du projet est “Python is a programming language that lets you work quickly and integrate systems more effectively”

Pour sa part le projet R naît en 1993 comme un projet de recherche de Ross Ihaka et Robert Gentleman à l’université d’Auckland.

• C’est une implémentation du langage S (développé au milieu des années 70 dans les laboratoires Bell)

• Libre (licence GNU GPL)

• Langage interprété, multi-paradigme (impératif, fonctionnel, OO, ..)

• Typage dynamique

• Toujours en développement actif (dernière version en avril 2023)

Sur le site web, le titre est “The R Project for Statistical Computing” et la description en une phrase du projet est : “R is a free software environment for statistical computing and graphics”.

Python

Python vs. R 🥊

Python

• General-purpose programming language

• “Jack of all trades, master of none” ?

• Utilisé par Google, Facebook, Microsoft, etc.

R

• For statistical computing and graphics

• “By statisticians, for statisticians”

• Utilisé par Google, Facebook, Microsoft, etc.

• Les deux langages sont souvent comparés, notamment dans le domaine de l’analyse de données.

• La question se pose car Python est de plus en plus compétent pour l’analyse de données…

Présentation de l’écosystème

Implémentation de référence et distributions

• Une implémentation de référence du langage Python : CPython (mais d’autres implémentations : Jython, IronPython, PyPy, etc.)

• Plusieurs distributions de Python (principalement Anaconda, une distribution des langages de programmation Python et R dédiée à la science des données et à l’apprentissage automatique)

Source: anaconda.org

• CPython est l’implémentation de référence de Python. C’est la version que la plupart des gens utilisent, notamment parce qu’elle est la plus facile à installer et à utiliser. Il est écrit en langage C et est maintenu par la Python Software Foundation.

• Jython est une implémentation de Python écrite en Java. Il permet aux développeurs d’écrire des programmes Python qui peuvent être exécutés sur n’importe quelle machine virtuelle Java (JVM). Cela le rend particulièrement utile pour les développeurs qui travaillent dans un environnement Java.

• IronPython est une implémentation de Python écrite en C# et destinée à être utilisée dans l’environnement .NET. Il permet aux développeurs d’écrire des programmes Python qui peuvent être exécutés sur la plate-forme .NET. Il est particulièrement utile pour les développeurs qui travaillent dans un environnement .NET.

• PyPy est une implémentation alternative de Python qui est destinée à être plus rapide que CPython. Il est écrit en langage RPython et utilise une technique d’optimisation appelée compilation à la volée pour accélérer l’exécution des programmes.

Anaconda est une distribution gratuite et open source de Python et R, qui a été développée pour simplifier le processus d’installation et de gestion des packages, ainsi que le processus de configuration et de gestion des environnements de développement scientifique de données.

Il a été créé par Continuum Analytics, une entreprise qui a depuis été acquise par Anaconda, Inc.

Anaconda est livré avec une gamme complète de bibliothèques scientifiques et de packages préinstallés, tels que NumPy, pandas, Matplotlib, SciPy, scikit-learn, TensorFlow et Jupyter Notebook, pour n’en citer que quelques-uns. Il est également facile à étendre avec des packages tiers, en utilisant le gestionnaire de packages conda, qui permet de télécharger et d’installer des packages à partir de sources externes.

L’un des avantages les plus importants d’Anaconda est son système de gestion d’environnement, qui permet de créer des environnements Python isolés pour différents projets.

Environnements de développement

• Plusieurs IDE appréciés par les utilisateurs de Python : Spyder (IDE “scientifique”, interface comparable à RStudio), PyCharm (logiciel propriétaire, plutôt pour développer des bibliothèques), Jupyter Lab et plus récemment Visual Studio Code (VSCode, VSCodium).

Batteries included 🔋

Le langage de programmation Python a une bibliothèque standard très complète, comportant de nombreux modules qui permettent de réaliser des tâches courantes sans avoir à réinventer la roue.

Modules de la bibliothèque standard :

• math (fonctions mathématiques de base)
• statistics (statistiques descriptives)
• random (génération de nombres aléatoires)
• datetime (gestion des dates et heures)
• os (fonctions d’interaction avec le système d’exploitation)
• sys (fonctions et variables d’interaction avec l’interpréteur Python)
• re (expressions régulières)
• csv (lecture et écriture de fichiers CSV)
• json (lecture et écriture de fichiers JSON)
• sqlite3 (interface avec la base de données SQLite)
• etc.

Modules additionnels (bibliothèques)

Une des forces du langage de programmation Python est son écosystème, qui est très riche et très actif.

Les packages sont des bibliothèques Python qui peuvent être installées à l’aide du gestionnaire de packages pip (ou conda dans le cas d’Anaconda).

Ces packages sont généralement hébergés sur PyPI (Python Package Index) (et conda-forge pour les utilisateurs d’Anaconda).

Avant de se lancer dans une tâche de programmation, il est donc important de vérifier si un package spécialisé existe déjà pour réaliser cette tâche.

Il est fréquent de se dire “je vais écrire un programme pour faire ça” et de se lancer dans le développement d’un programme Python. Mais avant de se lancer dans une tâche de programmation, il est important de vérifier si un package spécialisé existe déjà pour réaliser cette tâche. Si c’est le cas, ces auteurs ont déjà fait le travail de développement et de test, et il est probable que leur package soit plus robuste et plus performant que ce que vous pourriez écrire vous-même (il n’est pas rare de sous-estimer les difficultés qui pourraient être rencontrées lors du développement d’un programme, là où un package existant gère peut-être déjà ces difficultés).

Modules additionnels (bibliothèques)

Écosystème Python scientifique

Documentation

Un point fort de Python est sa documentation officielle, qui contient tout le nécessaire pour utiliser le langage de manière proactive (tutoriel, référence de l’ensemble des fonctions et des objets de tous les modules de la bibliothèque standard, etc.) et qui est mise à disposition dans plusieurs langues (Anglais, Français, Espagnol, Coréen, Japonais, Chinois, etc.).

Documentation / Modules additionnels

Il n’existe toutefois pas un seul standard pour consulter la documentation des différents modules additionnels Python (cf. Documentation Matplotlib, Documentation pandas).

En terme de syntaxe ça donne quoi ?

Premier pas avec la syntaxe Python

# On importe deux fonctions du module statistics
from statistics import mean, stdev

# Définition d'une fonction
def cv(x):
    moy = mean(x)
    s = stdev(x)
    result = s / moy
    # Retourne le résultat
    return result 

# La fonction est appelée avec une liste de valeurs,
# et le résultat est stocké dans une variable 
res = cv([5, 6, 3, 8, 9, 12])

# Affichage du résultat
print(res)

0.44490991790020906

Python et l’indentation du code…

my_list = [1, 2, 3]

for item in my_list:
    if item % 2 == 0:
        print('even')
    else:
    print('odd')

IndentationError: expected an indented block after 'else' statement on line 6 (660691277.py, line 7)

Python et l’indentation du code…

my_list = [1, 2, 3]

for item in my_list:
    if item % 2 == 0:
        print('even')
    else:
        print('odd')

odd
even
odd

Python et l’indentation du code…

• Respecter les règles d’indentations est obligatoire en Python.

• Ce n’est pas une contrainte lors d’une session de travail car les IDE guident la position du curseur.

• Cette indentation a un rôle direct sur le contrôle du flux d’exécution.

• Elle permet notamment d’éviter l’utilisation d’accolades (curly brackets) pour délimiter les blocs et de point-virgules pour délimiter les instructions.

Python et l’indentation du code…

Le code qui suit est volontairement incorrect mais ne génère pas d’erreur lors de l’exécution :

li1 = [1, 2, 3, 4, 5, 6]
li2 = [4, 20, 31, 87, 123, 621]

# Additionnons les deux listes, éléments par éléments,
# et stockons chaque résultat dans une nouvelle liste
result = []

for item1, item2 in zip(li1, li2):
    new_item = item1 + item2
result.append(new_item)

print(result)

[627]

Python et l’indentation du code…

Une fois l’indentation corrigée…

li1 = [1, 2, 3, 4, 5, 6]
li2 = [4, 20, 31, 87, 123, 621]

# Additionnons les deux listes, éléments par éléments,
# et stockons chaque résultat dans une nouvelle liste
result = []

for item1, item2 in zip(li1, li2):
    new_item = item1 + item2
    result.append(new_item)

print(result)

[5, 22, 34, 91, 128, 627]

L’interpréteur Python

• L’interpréteur Python est un programme qui lit et exécute du code Python.
• Il est possible d’interagir avec l’interpréteur Python en utilisant un terminal (ou une console) ou en utilisant un IDE.
• L’interpréteur Python est lancé en tapant python dans un terminal.
• Il est possible de quitter l’interpréteur Python en tapant exit() ou en appuyant sur Ctrl + D.
• L’interpréteur Python peut être utilisé pour exécuter des scripts Python (fichiers .py) en utilisant la commande python mon_script.py.

Ouvrir l’interpréteur Python (installé par Anaconda)

• Dans le menu Démarrer, chercher “Anaconda Prompt” et cliquer dessus. Une fenêtre de terminal s’ouvre. Celle-ci est prête à exécuter des commandes Python (dans l’environnement de base d’Anaconda).

• Il est possible d’installer des packages Python supplémentaires dans l’environnement de base d’Anaconda en utilisant des commandes telles que :

  • conda install mon_package (pour installer un package depuis le dépôt Anaconda)
  • pip install mon_package (pour installer un package depuis le dépôt PyPI)
  • conda install --channel conda-forge mon_package (pour installer un package depuis le dépôt conda-forge)

• Il est possible de lancer un interpréteur Python en tapant python dans le terminal.

🚀 Ouvrez un terminal et lancez l’interpréteur Python ! Lors des démonstrations qui suivent, vous pourrez tester les commandes dans l’interpréteur Python. 🚀

Calculs simples et variables

Une des premières fonctionnalités que l’on souhaite tester dans un langage de programmation est la possibilité d’effectuer des calculs simples.

>>> 1 + 2
3
>>> 3 * 4
12

Vous pouvez ou non utiliser des espaces autour des opérateurs (+, -, *, /, etc.) :

>>> 1+2
3

La double étoile représente l’exposant.

>>> 2 ** 3
8

Calculs simples et variables

Il est possible de stocker des valeurs dans des variables :

>>> a = 1
>>> b = 2
>>> result = a + b

Le résultat n’est donc plus affiché directement dans l’interpréteur Python mais stocké dans la variable result. On peut ensuite afficher le contenu de la variable result :

>>> result
3

Ou en utilisant la fonction print :

>>> print(result)

Calculs simples et variables

En Python le typage est dynamique, il n’est pas nécessaire de déclarer le type d’une variable avant de l’utiliser et il est possible de changer le type d’une variable au cours de son existence :

>>> a = 1
>>> type(a)
<class 'int'>
>>> a = 'Hello world!'
>>> type(a)
<class 'str'>

Types natifs
et data structures natives

Les structures de données sont les éléments fondamentaux autour desquels vous construisez vos programmes. Chaque structure de données fournit une manière particulière d’organiser les données afin d’y accéder efficacement.

Types de base

Les types de base sont les types de données les plus simples disponibles dans Python. Ils sont utilisés pour représenter des valeurs simples.

• int (entier)

my_int = 42

• float (nombre à virgule flottante)

my_float = 3.14

• bool (booléen)

my_bool = True # ou False

• str (chaîne de caractères)

my_str = 'Hello world!'

my_str = "Hello world!"

• NoneType (type spécial pour la valeur None)

my_none = None

Types de base - str

• Création, avec des guillemets simples ou doubles :

my_str = 'Hello world!'

my_str = "Hello world!"

my_long_str = '''Hello
world
and Python!'''

• Concaténation :

my_str = 'Hello' + ' ' + 'world!'

• Accès aux caractères :

print(my_str[0]) # Premier caractère

H

print(my_str[-1]) # Dernier caractère

!

print(my_str[0:5]) # Sous-chaîne

Hello

Pour en savoir plus : Documentation officielle : string — Opérations usuelles sur des chaînes

Types de base - str

• Formatage :

a = 'world'

my_str = 'Hello {}!'.format(a)
print(my_str)

Hello world!

a = 'world'

my_str = f'Hello {a}!'
print(my_str)

Hello world!

• Remplacement :

my_str = 'Hello world!'
my_str = my_str.replace('world', 'Python')
print(my_str)

Hello Python!

La méthode replace retourne une nouvelle chaîne de caractères, la chaîne de caractères initiale n’est pas modifiée. Cette méthode remplace toutes les occurrences de la sous-chaîne par la nouvelle sous-chaîne.

Elle peut aussi être utilisée pour supprimer une sous-chaîne :

my_str = 'Hello world!'

my_str = my_str.replace(' world', '')
print(my_str)

Hello!

Structures de données

Python est livré avec un ensemble complet de structures de données dans sa bibliothèque standard :

• dict (tableau associatif)

my_dict = { 'john': 32, 'jane': 27, 'jack': 30 }

• tuple (un conteneur immuable),

my_coordinates = (2.349014, 48.864716)

• list (tableau dynamique mutable),

my_list = [12, 34, 2, 1, 21, 4]
other_list = ['a', 12, (2.349014, 48.864716), { "foo": 42 }]

• array (tableau typé de base), enum (énumération), etc.

En informatique, une structure de données est une manière d’organiser les données pour les traiter plus facilement. Une structure de données est une mise en œuvre concrète d’un type abstrait.

Pour prendre un exemple de la vie quotidienne, on peut présenter des numéros de téléphone par département, par nom, par profession (comme les Pages jaunes), par numéro téléphonique (comme les annuaires destinés au télémarketing), par rue et/ou une combinaison quelconque de ces classements. À chaque usage correspondra une structure d’annuaire appropriée.

En organisant d’une certaine manière les données, on permet un traitement automatique de ces dernières plus efficace et rapide.

Souvent (en tout cas pour les cas qui nous concernent ici) il s’agira de collections d’objets, par exemple un tableau de nombre, un tableau associatif (dictionnaire) permettant de faire correspondre des clés (noms par ex) à des valeurs (numéro de téléphone par ex), etc.

Structures de données - list (1)

Les listes sont des tableaux dynamiques, elles peuvent contenir des éléments de différents types et sont mutables.

• Création :

Liste vide :

ma_liste = []

Ou création d’une liste avec des éléments :

ma_liste = [12, 34, 2, 1, 21, 43]

• Connaitre la taille d’une liste :

len(ma_liste)

6

• Accès aux éléments :

ma_liste[0] # Premier élément

12

ma_liste[-1] # Dernier élément

43

ma_liste[1] = 42 # Modification d'un élément

• Accès à un sous-ensemble d’éléments (slicing) :

my_slice = ma_liste[1:3]
my_slice

[42, 2]

Structures de données - list (2)

De nombreuses méthodes permettant de manipuler les listes.

• Ajouter des éléments à une liste existante :

ma_liste.append(322)

• Supprimer un élément d’une liste :

 # Supprime la première occurrence de l'élément 322
ma_liste.remove(322)

 # Supprime l'élément à l'indice 0 (et le retourne)
ma_liste.pop(0)

12

Il existe également des méthodes permettant de trier une liste (sort), d’ajouter un élément à une position précise (insert), etc. etc.

Structures de données - tuple

Puisqu’il s’agit d’un type immuable, il n’est pas possible de modifier un tuple une fois qu’il a été créé :

• Création :

my_tuple = (1, 2, 3)

• Accès aux éléments :

my_tuple[0] # Comme pour une liste

1

• Pas de modification possible :

my_tuple[0] = 42

TypeError: 'tuple' object does not support item assignment

Structures de données - dict (1)

Il s’agit d’un tableau associatif, les éléments sont stockés sous forme de clé / valeur. Il ne s’agit donc pas d’objets séquentiels comme les listes, mais plutôt d’objets dits de correspondance (mapping objects en anglais).

• Création d’un dictionnaire vide :

my_dict = {}

• Création d’un dictionnaire avec des éléments :

my_dict = { 'john': 32, 'jane': 27, 'jack': 30 }

• Accès aux éléments :

my_dict['john']

32

• Modification d’un élément :

my_dict['john'] = 33

• Ajout d’un élément :

my_dict['jill'] = 29

• Suppression d’un élément :

del my_dict['john']

Structures de données - dict (2)

• Accès aux éléments :

my_dict['jill']

29

Une erreur est renvoyée si la clé n’existe pas :

my_dict['johana']

KeyError: 'johana'

Tester l’existence d’une clé dans un dictionnaire :

'johana' in my_dict

False

Demander la valeur associée à une clé en utilisant la méthode get (et de spécifier une valeur par défaut si la clé n’existe pas) :

my_dict.get('johana')

my_dict.get('johana', -1)

-1

• Récupérer l’ensemble des clés :

my_dict.keys()

dict_keys(['jane', 'jack', 'jill'])

• Récupérer l’ensemble des valeurs :

my_dict.values()

dict_values([27, 30, 29])

Des listes de listes ?

Il est possible et fréquent de combiner des listes (ou des listes et des tuples) pour représenter des données tabulaires :

data = [
    ['Jill', 32, 1.65],
    ['Jack', 27, 1.73],
    ['Jane', 30, 1.80]
]

print(data[0][1])

32

data = [
    ('Jill', 32, 1.65),
    ('Jack', 27, 1.73),
    ('Jane', 30, 1.80)
]

print(data[0][1])

32

Des listes de dictionnaires ?

Il est également classique de combiner des listes et des dictionnaires pour représenter, par exemple, des données tabulaires :

data = [
    { 'name': 'Jill', 'age': 32,  'height': 1.65 },
    { 'name': 'Jack', 'age': 27,  'height': 1.73 },
    { 'name': 'Jane', 'age': 30,  'height': 1.80 }
]

print(data[0]['age'])

32

Des dictionnaires de dictionnaires ?

Il est très fréquent de rencontrer des dictionnaires emboîtés dans des dictionnaires :

data = {
    'jill': { 'age': 32,  'height': 1.65 },
    'jack': { 'age': 27,  'height': 1.73 },
    'jane': { 'age': 30,  'height': 1.80 }
}

print(data['jill']['age'])

32

Des dictionnaires de dictionnaires ?

Il est très fréquent de rencontrer des dictionnaires emboîtés dans des dictionnaires :

geojson_pt = {
    'type': 'Feature',
    'geometry': {
        'type': 'Point',
        'coordinates': [2.349014, 48.864716]
    },
    'properties': {
        'name': 'Paris'
    }
}

print(geojson_pt['geometry']['coordinates'])
print(geojson_pt['properties']['name'])

[2.349014, 48.864716]
Paris

Contrôle du flux d’exécution - if

Le contrôle du flux d’exécution permet de contrôler l’ordre dans lequel les instructions sont exécutées.

• if :

altitude = 2500

if altitude >= 2000:
    print('Haute altitude')

Haute altitude

• if / else :

altitude = 2500

if altitude >= 2000:
    print('Haute altitude')
else:
    print('Basse altitude')

Haute altitude

• if / elif / else :

altitude = 2500

if altitude >= 6000:
    print('Altitude extrêmement élevée')
elif altitude >= 4000:
    print('Très haute altitude')
elif altitude >= 2000:
    print('Haute altitude')
else:
    print('Basse altitude')

Haute altitude

Les seuils proviennent de Wikipedia:Altitude#Adaptations_physiologiques_et_réponses_physiopathologiques_du_corps_humain

Contrôle du flux d’exécution - for (1)

La boucle for permet d’itérer sur une séquence (une liste, un tuple, un dictionnaire, etc.) :

• for :

for i in range(5):
    print(i)

0
1
2
3
4

Ici, range() est une fonction native qui retourne une séquence d’entiers :

• range(5) retourne la séquence 0, 1, 2, 3, 4.

• range(2, 7) retourne la séquence 2, 3, 4, 5, 6.

• for sur une liste :

my_list = [12, 34, 2, 1, 3]

for item in my_list:
    print(item)

12
34
2
1
3

• for sur une liste, en utilisant enumerate :

for index, item in enumerate(my_list):
    print(f'Index: {index}, item: {item}')

Index: 0, item: 12
Index: 1, item: 34
Index: 2, item: 2
Index: 3, item: 1
Index: 4, item: 3

Contrôle du flux d’exécution - for (2)

• for sur un dictionnaire :

my_dict = { 'john': 32, 'jane': 27, 'jack': 30 }

for key in my_dict:
    print(key)

john
jane
jack

for key, value in my_dict.items():
    print(f'{key} a {value} ans')

john a 32 ans
jane a 27 ans
jack a 30 ans

• for sur une chaîne de caractères :

for letter in 'Hello !':
    print(letter)

H
e
l
l
o
 
!

for letter in 'Hello !':
    if letter.lower() in 'aeiouy':
        print(letter)

e
o

Contrôle du flux d’exécution - while

La boucle while permet d’exécuter un bloc d’instructions tant qu’une condition est vraie :

• while :

i = 0

while i < 5:
    print(i)
    i += 1

0
1
2
3
4

• while avec break :

i = 0

while True:
    print(i)
    i += 1
    if i >= 5:
        break

0
1
2
3
4

Fonctions

Les fonctions permettent de regrouper des instructions et de les exécuter plusieurs fois, en leur passant des paramètres différents.

• Définition d’une fonction :

def my_function():
    print('Hello world!')

• Appel d’une fonction :

my_function()

Hello world!

• Fonction avec paramètres et valeur de retour :

def compute_NDVI(red, nir):
    ndvi = (nir - red) / (nir + red)
    return ndvi

ndvi = compute_NDVI(0.2, 0.8)
print(ndvi)

0.6000000000000001

Classes

Comme Python est un langage orienté-objet, il est également possible de définir des classes, permettant de facilement modéliser des catégories d’objets…

class Point:
    def __init__(self, x, y):
      self.x = x
      self.y = y

    def distance(self, other):
      return (
        (other.x - self.x) ** 2 + (other.y - self.y) ** 2
      ) ** 0.5

La programmation orientée objet (ou programmation par objet) est un paradigme de programmation qui consiste à modéliser des objets du monde réel sous forme de briques logicielles appelées objet. Un objet représente un concept, une idée ou toute entité du monde physique (telle qu’une voiture, une personne, un point dans le plan, etc.).

• class est un mot-clé permettant de définir une classe.
• __init__ est une méthode spéciale appelée constructeur, elle est appelée lors de la création d’un objet de la classe Point.
• self est une référence à l’objet lui-même.
• self.x et self.y sont des attributs de l’objet.
• distance est une méthode de l’objet.
• other est un autre objet de la classe Point.

Classes

Instanciation et utilisation :

p1 = Point(2, 6)
p2 = Point(9, 9)

print('Distance =', p1.distance(p2))

Distance = 7.615773105863909

Classes, méthodes et attributs

Méthodes :

Une méthode est une fonction qui appartient à une classe. Elle s’applique donc à l’instance de la classe sur laquelle elle est appelée.

Dans les exemples précédents :

• append, remove et pop sont des méthodes de la classe list
• keys, get et values sont des méthodes de la classe dict
• format et replace sont des méthodes de la classe str
• distance est une méthode de notre classe Point
• etc.

Attributs :

Un attribut est une variable qui appartient à une classe.

Elle est donc accessible depuis toutes les instances de la classe.

p1 = Point(2, 6)
print(p1.x)

p2 = Point(9, 9)
print(p2.x)

2
9

Actions courantes : lire et écrire des fichiers

• open permet d’ouvrir un fichier en lecture ou en écriture.
• read permet de lire le contenu d’un fichier.
• write permet d’écrire dans un fichier.
• close permet de fermer un fichier.
• with (il s’agit d’un context manager) permet d’ouvrir un fichier et de s’assurer que ce dernier sera bien fermé à la fin du bloc d’instructions.

Actions courantes : lire et écrire des fichiers

• Lire le contenu d’un fichier :

f = open('data/data.txt', 'r')
content = f.read()
f.close()

print(content)

Ceci est une fichier test
avec plusieurs
lignes de texte.

with open('data/data.txt', 'r') as f:
    content = f.read()
    
print(content)

Ceci est une fichier test
avec plusieurs
lignes de texte.

• Écrire dans un fichier :

with open('data/test.txt', 'w') as f:
    f.write('Hello world!')

• Lire le contenu d’un fichier ligne par ligne :

with open('data/data.txt', 'r') as f:
    for line in f:
        print(line)

Ceci est une fichier test

avec plusieurs

lignes de texte.

• Écrire dans un fichier ligne par ligne :

content = ['Hello', 'world', '!']

with open('data/test.txt', 'w') as f:
    for line in content:
        f.write(line + '\n')

Actions courantes : lire et écrire des fichiers

Une action très courante est de lire le contenu d’un fichier pour remplacer une sous-chaîne par une autre sous-chaîne (ex: changer un chemin d’accès dans un fichier de configuration, etc.).

with open('data/data.txt', 'r') as f:
    content = f.read()

# Si on veut replacer plusieurs sous-chaîne
# il suffit d'utiliser la méthode `replace` plusieurs fois
content = content.replace('world', 'Python')
content = content.replace('Hello', 'Hi')

with open('data/test.txt', 'w') as f:
    f.write(content)

Actions courantes : lire et écrire des fichiers

Il est également possible d’utiliser la bibliothèque re (pour regular expressions) pour remplacer une sous-chaîne par une autre sous-chaîne à l’aide d’une expression régulière.

import re

with open('data/data.txt', 'r') as f:
    content = f.read()

content = re.sub(r'Python', 'world', content)
content = re.sub(r'H[a-z]+', 'Hello', content)

with open('data/test.txt', 'w') as f:
    f.write(content)

Actions courantes : lire et écrire des fichiers

• Lire le contenu d’un fichier JSON :

import json

with open('data/data.json', 'r') as f:
    data = json.load(f)

print(data.keys()) # Affiche les clés du dictionnaire
print(data['width']) # Affiche la valeur associée à la clé 'width'
print(data['height']) # Affiche la valeur associée à la clé 'height'
print(data['values']) # Affiche la valeur associée à la clé 'values'

dict_keys(['name', 'width', 'height', 'values'])
10
8
[4.89660102624323, 44.28666475726375, 63.19205593664028, 25.600654682048397, 12.396597859405256, 47.74217773481377, 82.1282233918879, 20.461709629717117, 43.14007201145414, 92.09111564877499, 66.10474793901118, 5.981854240753348, 62.36444980847118, 26.484129728400106, 28.585238255340673, 18.168713356537314, 58.29298433750647, 36.72646161808159, 39.21966177175944, 2.5239257181935315, 25.68948435710354, 5.746177258012164, 83.17560682114357, 92.41140143912419, 81.95913926172874, 17.95672256157632, 54.73222062966203, 34.14726213372885, 37.66069091485904, 4.9971489135753, 9.629874863571587, 26.11616061595896, 52.39279104216252, 4.409036771310193, 87.94817236709085, 86.90800909249256, 40.131680383106236, 34.757243107452055, 68.34846216933484, 9.115225836083486, 96.2948762888116, 14.785000870870913, 82.90458952078782, 94.3546533775768, 36.070853187885696, 48.61360572542684, 48.80266621681662, 95.97637602986042, 88.09463273968636, 46.16549471860469, 98.85130425205733, 95.07729375139553, 60.12494077469199, 96.41099703758123, 93.03262834682238, 18.029942680392775, 11.578224489176737, 66.54777051141645, 66.24579571250378, 77.35832658434794, 66.48245778316362, 89.47373075457898, 47.62754695573741, 6.491000041761219, 6.9108065570427035, 28.117695769441255, 90.3767310590909, 57.09679362132212, 8.449761608454299, 81.09668828848551, 70.18367543675741, 72.39998306179697, 19.07599243099758, 11.172563819832316, 62.83339916658433, 3.210529148078445, 74.17682507195889, 83.82816776965089, 59.02166349796729, 81.46110256415608]

• Écrire dans un fichier JSON :

import json

data = { 'name': 'John', 'age': 32 }

with open('data/test.json', 'w') as f:
    json.dump(data, f)

Actions courantes : lire et écrire des fichiers

• Lire le contenu d’un fichier CSV :

import csv

with open('data/data.csv', 'r') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

['name', 'age', 'height']
['John', '30', '1.65']
['Mary', '29', '1.7']
['Tom', '31', '1.9']
['Jill', '48', '1.6']
['Sue', '22', '1.75']

• Écrire dans un fichier CSV :

import csv

data = [
    ['name', 'age'],
    ['John', 32],
    ['Jane', 27],
    ['Jack', 30]
]

with open('data/test.csv', 'w') as f:
    writer = csv.writer(f)
    writer.writerows(data)

Python pour l’analyse de données

• Python est un langage de programmation généraliste, sa bibliothèque standard n’est pas dédiée à l’analyse de données.

• Il existe de nombreuses bibliothèques additionnelles pour l’analyse de données (et il s’agit d’un écosystème très riche et vivant).

• La bibliothèque la plus utilisée pour l’analyse de données est pandas. Cette bibliothèque permet de manipuler des données tabulaires (des tableaux de données).

• Une autre composante de base de l’écosystème Python pour l’analyse de données est NumPy. Cette bibliothèque permet de manipuler des tableaux de données typés de manière efficace (la bibliothèque pandas est basée sur NumPy).

La bibliothèque NumPy est écrite en C et en Fortran, elle est donc très performante. Elle est utilisée par de nombreuses autres bibliothèques Python pour l’analyse de données et pour le calcul scientifique.

C’est également le cas pour de nombreuses bibliothèques Python pour le géospatial (les rasters seront par exemple représentés sous forme de tableaux NumPy).

Analyse de données - pandas

Pandas permet d’ouvrir des fichiers CSV, JSON, Excel, etc. et de les manipuler facilement grâce à des DataFrames (comparables aux data.frames de R).

• Ouverture :

import pandas as pd

df = pd.read_csv('data/data.csv')

• Affichage :

df.head()

	name	age	height
0	John	30	1.65
1	Mary	29	1.70
2	Tom	31	1.90
3	Jill	48	1.60
4	Sue	22	1.75

• Sélection d’une colonne :

df['name']

0    John
1    Mary
2     Tom
3    Jill
4     Sue
Name: name, dtype: object

• Sélection selon une condition :

df[df['age'] > 30]

	name	age	height
2	Tom	31	1.9
3	Jill	48	1.6

df.query('height > 1.70').query('age > 30')

	name	age	height
2	Tom	31	1.9

Analyse de données - pandas

• Ajout d’une colonne :

df['weight'] = [80, 65, 75, 54, 90]

df['BMI'] = df['weight'] / df['height'] ** 2

df.head()

	name	age	height	weight	BMI
0	John	30	1.65	80	29.384757
1	Mary	29	1.70	65	22.491349
2	Tom	31	1.90	75	20.775623
3	Jill	48	1.60	54	21.093750
4	Sue	22	1.75	90	29.387755

• Suppression d’une (ou plusieurs) colonne(s) :

df.drop(
  columns=['weight', 'height'],
  inplace=True,
)

• Tri :

df.sort_values(by='BMI', inplace=True)

df.head()

	name	age	BMI
2	Tom	31	20.775623
3	Jill	48	21.093750
1	Mary	29	22.491349
0	John	30	29.384757
4	Sue	22	29.387755

• Export :

df.to_csv('data/test.csv', index=False)

Analyse de données - pandas

La bibliothèque pandas permet également de faire des statistiques descriptives, de réaliser simplement des graphiques, etc.

• Visualisation :

df.plot.bar(x='name', y='BMI')

<Axes: xlabel='name'>

• Statistiques descriptives :

df.describe()

	age	BMI
count	5.000000	5.000000
mean	32.000000	24.626647
std	9.617692	4.392579
min	22.000000	20.775623
25%	29.000000	21.093750
50%	30.000000	22.491349
75%	31.000000	29.384757
max	48.000000	29.387755

Analyse de données - Autres bibliothèques

• NumPy - Manipulation de tableaux de données typés (voir le notebook sur NumPy pour découvrir les fonctionnalités de base)
• SciPy - Bibliothèque d’algorithmes scientifiques
• Matplotlib - Visualisation de données
• Scikit-learn - Apprentissage automatique
• Statsmodels - Modèles statistiques
• Seaborn - Visualisation de données
• Plotly - Visualisation de données

Écosystème pour le géospatial

Données vectorielles

• Bindings Python de GDAL/OGR (GDAL/OGR contributors, 2022)
• Fiona (Gillies, Buffat, et al., 2023) - I/O (wrapper de haut niveau autour d’OGR)
• Shapely (Gillies, Wel, et al., 2023) - bindings Python de GEOS (GEOS contributors, 2021)
• Pyproj (Snow, Whitaker, et al., 2023) - bindings Python de PROJ (PROJ contributors, 2021)
• Geopandas (Jordahl et al., 2020) - Étend les DataFrames de pandas (The pandas development team, s. d.)

Le package GeoPandas

Un projet open source pour faciliter le travail avec des données géospatiales vectorielles en Python. GeoPandas étend Pandas pour permettre de disposer d’un type de colonne géométrique (comme sf en R) et pour permettre d’effectuer des opérations spatiales.

Les opérations géométriques sont réalisées avec shapely (bindings de GEOS) les accès en lecture / écriture aux fichiers utilisent fiona (bindings de OGR) et la visualisation utilise matplotlib.

Format des GeoDataFrame

Le package GeoPandas - Exemples

• Import et lecture
• Affichage
• SCR
• Affichage avec fond de carte
• Centroide
• Boundary
• Zone tampon
• Aggrégation
• Intersection

Avec la fonction read_file :

import geopandas as gpd

nybb = gpd.read_file(file_path)

Avec la méthode plot des GeoDataFrame :

nybb.plot()

<Axes: >

Affichage :

print(nybb.crs)

epsg:2263

Transformation :

nybb_geo = nybb.to_crs('EPSG:4326')

En utilisant la bibliothèque contextily :

import contextily as cx

ax = nybb.to_crs('EPSG:3857').plot()
cx.add_basemap(ax, source='https://tile.openstreetmap.org/{z}/{x}/{y}.png')
ax.set_axis_off()
ax

<Axes: >

Simplement en utilisant l’attribut centroid des GeoDataFrame :

nybb.centroid.plot()

<Axes: >

Simplement en utilisant l’attribut boundary des GeoDataFrame :

nybb.boundary.plot()

<Axes: >

En utilisant la méthode buffer des GeoDataFrame :

buff_nybb = nybb.buffer(3000)

ax = buff_nybb.plot(color="red")
nybb.plot(ax=ax, color="aliceblue")

<Axes: >

En utilisant la méthode dissolve des GeoDataFrame :

# On peut utiliser dissolve(by="nom_colonne") si on veut aggréger selon les valeurs d'une colonne
agg = nybb.dissolve()
agg.plot()

<Axes: >

En utilisant la méthode intersection des GeoDataFrame :

from shapely import wkt

point = wkt.loads('Point(998769.1146889535 174169.7607268664)')
intersecting = nybb.intersection(point.buffer(35000))

ax = nybb.plot()
ax = intersecting.plot(ax=ax, color="red")
ax

<Axes: >

Et/ou voir le notebook correspondant

Données raster

Rasterio (Gillies et al., 2013) :

• lecture / écriture de raster (wrapper de haut niveau autour de GDAL)
• données représentées sous forme d’array NumPy
• reprojection
• resampling
• virtual files
• etc.

Rasterstats :

• résumer des données raster sur la base de géométries vectorielles
• extraction de valeurs à un point précis

xarray (Hoyer et al., s. d.) et rioxarray (Snow, Brochart, et al., 2023):

• xarray pour travailler avec des tableaux multidimensionnels étiquetés
• rioxarray pour ouvrir des jeux des données raster avec rasterio, les stocker dans le format de xarray, et avoir accès à différentes fonctionnalités de rasterio
• moins “rustique” que d’utiliser rasterio seul / dépend de l’usage souhaité

Le package Rasterio

Exemple d’utilisation :

import rasterio as rio

with rio.open('./data/MODIS_ARRAY.nc') as f:
    # Métadonnées :
    metadata = f.meta
    # Lire toutes les bandes :
    data = f.read()
    # Ou f.read(1) pour lire seulement la première bande

• Un dictionnaire de métadonnées + un tableau NumPy contenant la (ou les) bande(s) :

print(metadata)
print(data)

{'driver': 'netCDF', 'dtype': 'int16', 'nodata': -28672.0, 'width': 200, 'height': 200, 'count': 1, 'crs': CRS.from_wkt('PROJCS["unknown",GEOGCS["unknown",DATUM["unknown",SPHEROID["unknown",6371007.181,0]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]]],PROJECTION["Sinusoidal"],PARAMETER["longitude_of_center",0],PARAMETER["false_easting",0],PARAMETER["false_northing",0],UNIT["metre",1,AUTHORITY["EPSG","9001"]],AXIS["Easting",EAST],AXIS["Northing",NORTH]]'), 'transform': Affine(231.6563582639561, 0.0, -7274009.649486291,
       0.0, -231.65635826375018, 5050108.61015275)}
[[[-28672 -28672 -28672 ...    656    656    554]
  [-28672 -28672 -28672 ...    694    694    642]
  [-28672 -28672 -28672 ...    456    575    642]
  ...
  [   993    817    817 ...    471    479    498]
  [   893    893    816 ...    479    479    469]
  [   816    816    832 ...    515    469    485]]]

Les package xarray et rioxarray

Exemple d’utilisation :

• Import et lecture
• Complétion des valeurs manquantes
• Affichage
• SCR
• Découpage

import rioxarray
import xarray

xds = xarray.open_dataarray("./data/MODIS_ARRAY.nc")

• Un objet de type xarray.DataArray ou xarray.Dataset qui contient les différentes méta-données et les données :

<xarray.DataArray (y: 200, x: 200)>
[40000 values with dtype=float32]
Coordinates:
  * y        (y) float64 5.05e+06 5.05e+06 5.05e+06 ... 5.004e+06 5.004e+06
  * x        (x) float64 -7.274e+06 -7.274e+06 ... -7.228e+06 -7.228e+06
Attributes:
    crs:        +a=6371007.181 +b=6371007.181 +lon_0=0 +no_defs +proj=sinu +u...
    res:        [231.65635826 231.65635826]
    is_tiled:   0
    nodata:     -28672.0
    transform:  [ 2.31656358e+02  0.00000000e+00 -7.27400965e+06  0.00000000e...

xarray.DataArray

• y: 200
• x: 200

• ...

  [40000 values with dtype=float32]

• Coordinates: (2)
  • y
    (y)
    float64
    5.05e+06 5.05e+06 ... 5.004e+06

    axis :

    Y

    long_name :

    y coordinate of projection

    standard_name :

    projection_y_coordinate

    units :

    metre

    array([5049992.781974, 5049761.125615, 5049529.469257, 5049297.812899,
           5049066.156541, 5048834.500182, 5048602.843824, 5048371.187466,
           5048139.531108, 5047907.874749, 5047676.218391, 5047444.562033,
           5047212.905674, 5046981.249316, 5046749.592958, 5046517.9366  ,
           5046286.280241, 5046054.623883, 5045822.967525, 5045591.311167,
           5045359.654808, 5045127.99845 , 5044896.342092, 5044664.685734,
           5044433.029375, 5044201.373017, 5043969.716659, 5043738.0603  ,
           5043506.403942, 5043274.747584, 5043043.091226, 5042811.434867,
           5042579.778509, 5042348.122151, 5042116.465793, 5041884.809434,
           5041653.153076, 5041421.496718, 5041189.84036 , 5040958.184001,
           5040726.527643, 5040494.871285, 5040263.214927, 5040031.558568,
           5039799.90221 , 5039568.245852, 5039336.589493, 5039104.933135,
           5038873.276777, 5038641.620419, 5038409.96406 , 5038178.307702,
           5037946.651344, 5037714.994986, 5037483.338627, 5037251.682269,
           5037020.025911, 5036788.369553, 5036556.713194, 5036325.056836,
           5036093.400478, 5035861.74412 , 5035630.087761, 5035398.431403,
           5035166.775045, 5034935.118686, 5034703.462328, 5034471.80597 ,
           5034240.149612, 5034008.493253, 5033776.836895, 5033545.180537,
           5033313.524179, 5033081.86782 , 5032850.211462, 5032618.555104,
           5032386.898746, 5032155.242387, 5031923.586029, 5031691.929671,
           5031460.273313, 5031228.616954, 5030996.960596, 5030765.304238,
           5030533.647879, 5030301.991521, 5030070.335163, 5029838.678805,
           5029607.022446, 5029375.366088, 5029143.70973 , 5028912.053372,
           5028680.397013, 5028448.740655, 5028217.084297, 5027985.427939,
           5027753.77158 , 5027522.115222, 5027290.458864, 5027058.802506,
           5026827.146147, 5026595.489789, 5026363.833431, 5026132.177072,
           5025900.520714, 5025668.864356, 5025437.207998, 5025205.551639,
           5024973.895281, 5024742.238923, 5024510.582565, 5024278.926206,
           5024047.269848, 5023815.61349 , 5023583.957132, 5023352.300773,
           5023120.644415, 5022888.988057, 5022657.331698, 5022425.67534 ,
           5022194.018982, 5021962.362624, 5021730.706265, 5021499.049907,
           5021267.393549, 5021035.737191, 5020804.080832, 5020572.424474,
           5020340.768116, 5020109.111758, 5019877.455399, 5019645.799041,
           5019414.142683, 5019182.486325, 5018950.829966, 5018719.173608,
           5018487.51725 , 5018255.860891, 5018024.204533, 5017792.548175,
           5017560.891817, 5017329.235458, 5017097.5791  , 5016865.922742,
           5016634.266384, 5016402.610025, 5016170.953667, 5015939.297309,
           5015707.640951, 5015475.984592, 5015244.328234, 5015012.671876,
           5014781.015518, 5014549.359159, 5014317.702801, 5014086.046443,
           5013854.390084, 5013622.733726, 5013391.077368, 5013159.42101 ,
           5012927.764651, 5012696.108293, 5012464.451935, 5012232.795577,
           5012001.139218, 5011769.48286 , 5011537.826502, 5011306.170144,
           5011074.513785, 5010842.857427, 5010611.201069, 5010379.544711,
           5010147.888352, 5009916.231994, 5009684.575636, 5009452.919277,
           5009221.262919, 5008989.606561, 5008757.950203, 5008526.293844,
           5008294.637486, 5008062.981128, 5007831.32477 , 5007599.668411,
           5007368.012053, 5007136.355695, 5006904.699337, 5006673.042978,
           5006441.38662 , 5006209.730262, 5005978.073904, 5005746.417545,
           5005514.761187, 5005283.104829, 5005051.44847 , 5004819.792112,
           5004588.135754, 5004356.479396, 5004124.823037, 5003893.166679])

  • x
    (x)
    float64
    -7.274e+06 ... -7.228e+06

    axis :

    X

    long_name :

    x coordinate of projection

    standard_name :

    projection_x_coordinate

    units :

    metre

    array([-7273893.821307, -7273662.164949, -7273430.508591, -7273198.852232,
           -7272967.195874, -7272735.539516, -7272503.883158, -7272272.226799,
           -7272040.570441, -7271808.914083, -7271577.257725, -7271345.601366,
           -7271113.945008, -7270882.28865 , -7270650.632291, -7270418.975933,
           -7270187.319575, -7269955.663217, -7269724.006858, -7269492.3505  ,
           -7269260.694142, -7269029.037784, -7268797.381425, -7268565.725067,
           -7268334.068709, -7268102.412351, -7267870.755992, -7267639.099634,
           -7267407.443276, -7267175.786918, -7266944.130559, -7266712.474201,
           -7266480.817843, -7266249.161484, -7266017.505126, -7265785.848768,
           -7265554.19241 , -7265322.536051, -7265090.879693, -7264859.223335,
           -7264627.566977, -7264395.910618, -7264164.25426 , -7263932.597902,
           -7263700.941544, -7263469.285185, -7263237.628827, -7263005.972469,
           -7262774.31611 , -7262542.659752, -7262311.003394, -7262079.347036,
           -7261847.690677, -7261616.034319, -7261384.377961, -7261152.721603,
           -7260921.065244, -7260689.408886, -7260457.752528, -7260226.09617 ,
           -7259994.439811, -7259762.783453, -7259531.127095, -7259299.470737,
           -7259067.814378, -7258836.15802 , -7258604.501662, -7258372.845303,
           -7258141.188945, -7257909.532587, -7257677.876229, -7257446.21987 ,
           -7257214.563512, -7256982.907154, -7256751.250796, -7256519.594437,
           -7256287.938079, -7256056.281721, -7255824.625363, -7255592.969004,
           -7255361.312646, -7255129.656288, -7254897.99993 , -7254666.343571,
           -7254434.687213, -7254203.030855, -7253971.374496, -7253739.718138,
           -7253508.06178 , -7253276.405422, -7253044.749063, -7252813.092705,
           -7252581.436347, -7252349.779989, -7252118.12363 , -7251886.467272,
           -7251654.810914, -7251423.154556, -7251191.498197, -7250959.841839,
           -7250728.185481, -7250496.529122, -7250264.872764, -7250033.216406,
           -7249801.560048, -7249569.903689, -7249338.247331, -7249106.590973,
           -7248874.934615, -7248643.278256, -7248411.621898, -7248179.96554 ,
           -7247948.309182, -7247716.652823, -7247484.996465, -7247253.340107,
           -7247021.683749, -7246790.02739 , -7246558.371032, -7246326.714674,
           -7246095.058315, -7245863.401957, -7245631.745599, -7245400.089241,
           -7245168.432882, -7244936.776524, -7244705.120166, -7244473.463808,
           -7244241.807449, -7244010.151091, -7243778.494733, -7243546.838375,
           -7243315.182016, -7243083.525658, -7242851.8693  , -7242620.212942,
           -7242388.556583, -7242156.900225, -7241925.243867, -7241693.587508,
           -7241461.93115 , -7241230.274792, -7240998.618434, -7240766.962075,
           -7240535.305717, -7240303.649359, -7240071.993001, -7239840.336642,
           -7239608.680284, -7239377.023926, -7239145.367568, -7238913.711209,
           -7238682.054851, -7238450.398493, -7238218.742135, -7237987.085776,
           -7237755.429418, -7237523.77306 , -7237292.116701, -7237060.460343,
           -7236828.803985, -7236597.147627, -7236365.491268, -7236133.83491 ,
           -7235902.178552, -7235670.522194, -7235438.865835, -7235207.209477,
           -7234975.553119, -7234743.896761, -7234512.240402, -7234280.584044,
           -7234048.927686, -7233817.271327, -7233585.614969, -7233353.958611,
           -7233122.302253, -7232890.645894, -7232658.989536, -7232427.333178,
           -7232195.67682 , -7231964.020461, -7231732.364103, -7231500.707745,
           -7231269.051387, -7231037.395028, -7230805.73867 , -7230574.082312,
           -7230342.425954, -7230110.769595, -7229879.113237, -7229647.456879,
           -7229415.80052 , -7229184.144162, -7228952.487804, -7228720.831446,
           -7228489.175087, -7228257.518729, -7228025.862371, -7227794.206013])

• Indexes: (2)
  • y
    PandasIndex

    PandasIndex(Index([ 5049992.781973618,  5049761.125615354,   5049529.46925709,
            5049297.812898827,  5049066.156540562,  5048834.500182299,
           5048602.8438240355,  5048371.187465771,  5048139.531107508,
            5047907.874749244,
           ...
            5005978.073903505,  5005746.417545241,  5005514.761186978,
            5005283.104828713,   5005051.44847045,  5004819.792112187,
            5004588.135753923,  5004356.479395659,  5004124.823037395,
            5003893.166679132],
          dtype='float64', name='y', length=200))

  • x
    PandasIndex

    PandasIndex(Index([ -7273893.821307159,  -7273662.164948896,  -7273430.508590631,
            -7273198.852232368,  -7272967.195874103,   -7272735.53951584,
           -7272503.8831575755,  -7272272.226799311,  -7272040.570441048,
            -7271808.914082783,
           ...
           -7229879.1132370075,  -7229647.456878743,   -7229415.80052048,
            -7229184.144162215,  -7228952.487803951,  -7228720.831445687,
            -7228489.175087423,   -7228257.51872916,  -7228025.862370895,
            -7227794.206012632],
          dtype='float64', name='x', length=200))

• Attributes: (5)

  crs :

  +a=6371007.181 +b=6371007.181 +lon_0=0 +no_defs +proj=sinu +units=m +x_0=0 +y_0=0

  res :

  [231.65635826 231.65635826]

  is_tiled :

  0

  nodata :

  -28672.0

  transform :

  [ 2.31656358e+02 0.00000000e+00 -7.27400965e+06 0.00000000e+00 -2.31656358e+02 5.05010861e+06 0.00000000e+00 0.00000000e+00 1.00000000e+00]

filled = xds.rio.interpolate_na()

En utilisant la méthode plot des objets xarray.DataArray (ici après sélection d’un subset des données) :

import matplotlib.pyplot as plt

fig = plt.figure(figsize=(15, 5))
ax1, ax2 = (fig.add_subplot(131), fig.add_subplot(133))

xds.isel(x=slice(0, 20), y=slice(0, 20)).plot(ax=ax1)
filled.isel(x=slice(0, 20), y=slice(0, 20)).plot(ax=ax2)

<matplotlib.collections.QuadMesh at 0x7f34ec9eaf50>

• Affichage :

xds.rio.crs

CRS.from_wkt('PROJCS["unknown",GEOGCS["unknown",DATUM["unknown",SPHEROID["unknown",6371007.181,0]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]]],PROJECTION["Sinusoidal"],PARAMETER["longitude_of_center",0],PARAMETER["false_easting",0],PARAMETER["false_northing",0],UNIT["metre",1,AUTHORITY["EPSG","9001"]],AXIS["Easting",EAST],AXIS["Northing",NORTH]]')

• Transformation :

xds = xds.rio.reproject("EPSG:6623")

• Découpage selon l’emprise des données contenues dans un GeoDataFrame (ici gdf) :

clipped = xds.rio.clip(gdf.geometry.values, gdf.crs, drop=False, invert=True)

Analyse spatiale

Écosystème de bibliothèques pour l’analyse spatiale PySAL
(Python Spatial Analysis Library, Rey et Anselin (2007)) :

Explorer :

• Analyse exploratoire des données spatiales (package esda)
• Analyse de la dynamique des données spatiales longitudinales (package giddy)
• Mesure des inégalités dans l’espace et dans le temps (package inequality)
• Analyse statistique de motifs ponctuels planaires (package pointpats)
• Mesure de la ségrégation dans le temps et dans l’espace (package segregation)
• Morphométrie urbaine (package momepy)

Modéliser :

• Régression géographiquement pondérée à plusieurs échelles (package mgwr)
• Modèles linéaires généralisés épars (package spglm)
• Modèles d’interaction spatiale (package spint)
• Modèles de régression spatiale (package spreg)
• Modèles de composantes de variance à corrélation spatiale à plusieurs niveaux (package spvcm)
• Areal interpolation et cartographie dasymétrique (package tobler)
• Accessibilité spatiale (package access)
• Optimisation spatiale (package spopt)

Autres packages utiles …

• Binding Python pour GRASS + Intégration dans les notebooks Jupyter

Source

• Iris - Analyse et visualisation de données des sciences de la Terre.

• Pour la cartographie : cartopy et geoplot basés sur cartopy ; PyGMT ; geoviews (selon les usages).

• Voir aussi https://github.com/sacridini/Awesome-Geospatial#python.

Python pour quoi d’autre ?

Un écosystème riche pour de nombreux autres usages.

Machine learning et Deep learning :

• Scikit-learn (apprentissage automatique, developpé par des membres de l’INRIA - dispose d’une documentation très détaillée)
• TensorFlow et PyTorch (voir par exemple ce tutoriel).
• Keras (API de haut niveau pour TensorFlow, Theano et CNTK).

Python pour quoi d’autre ?

Web scraping :

• Beautiful Soup (pour extraire des données de pages web)
• Selenium (pour automatiser des actions dans un navigateur web)
• Scrapy (pour créer des robots d’indexation de sites web)

Web development :

• Django (pour créer des sites web)
• Flask (pour créer des sites web)
• FastAPI (pour créer des API web)
• Dash (pour créer des applications web interactives)
• Streamlit (pour créer des applications web interactives)

Python pour quoi d’autre ?

• Gradio - Créer des interfaces graphiques pour des modèles d’apprentissage automatique en quelques lignes de code

import gradio as gr

def greet(name, is_morning, temperature):
    salutation = "Good morning" if is_morning else "Good evening"
    greeting = f"{salutation} {name}. It is {temperature} degrees today"
    celsius = (temperature - 32) * 5 / 9
    return greeting, round(celsius, 2)

demo = gr.Interface(
    fn=greet,
    inputs=["text", "checkbox", gr.Slider(0, 100)],
    outputs=["text", "number"],
)

if __name__ == "__main__":
    demo.launch()

Python pour quoi d’autre ?

• Gradio - Créer des interfaces graphiques pour des modèles d’apprentissage automatique en quelques lignes de code

Python pour quoi d’autre ?

Développement d’applications :

• PyQt / PySide (pour créer des applications de bureau)
• Kivy (pour créer des applications de bureau et des applications mobiles)
• PySimpleGUI (pour créer des interfaces graphiques - Exemple en ligne)

Python dans des logiciels

Python dans Inkscape

La majorité des extensions de Inkscape sont des scripts Python (d’après la documentation), et il existe des ressources pour faciliter l’écriture de scripts Python pour Inkscape.

Et bien sûr dans QGIS ! Mais aussi dans ArcGIS, dans Autodesk Maya, etc.

Python dans Blender

• Logiciel libre de modélisation, d’animation et de rendu en 3D

• Intègre une console Python, permet d’interagir avec de nombreux aspects de Blender dont notamment l’animation, le rendu, l’import et l’export, la création d’objet et l’éxécution automatisée de tâches répétitives

Ressources pour l’apprentissage de Python

• Le tutoriel de la documentation officielle

• Le MOOC “Python : des fondamentaux aux concepts avancés du langage” de l’Université Côte d’Azur (6 semaines + semaines optionnelles, dont une semaine “écosystème data-science”) (selon vos centres d’intérêt, d’autres MOOC comme “Recherche reproductible : principes méthodologiques pour une science transparente” de l’INRIA font appel à Python ainsi qu’à des compétences transverses comme l’utilisation de Git, du Markdown, etc.)

• Openclassrooms - Apprenez les bases du langage Python

• Cours “Geo-Python” (en anglais - présente les bases de la programmation en Python pour l’analyse de données, avec une coloration géospatiale et sans nécessiter de connaissances préalables)

• Cours “Introduction à la programmation Python pour la biologie” (en français)

Ressources Python Géospatial

Les ressources qui suivent supposent pour la plupart une connaissance de base du langage Python (boucles, conditions, fonctions, types de base, etc.). Elles mobilisent les bibliothèques Python le plus souvent utilisées pour l’analyse de données et le traitement de données géospatiales (pandas, geopandas, rasterio, scipy, etc.).

• Livre gratuit “Geocomputation with Python” (en anglais) (Dorman et al., 2022)

• Cours “Automating GIS processes” (en anglais)

• Cours “Use Data for Earth and Environmental Science in Open Source Python” (en anglais)

• Livre gratuit “Geographic Data Science with Python” (en anglais)

Partie 2 - Mise en pratique

Utiliser Python depuis VSCodium

• L’extension Python permet d’utiliser Python depuis VSCodium et l’extension Jupyter permet d’utiliser des notebooks Jupyter depuis VSCodium.

• Il est possible d’ouvrir un terminal depuis VSCodium en utilisant la commande Ctrl + Shift + P puis en tapant Terminal: Create New Integrated Terminal.

• Il est possible d’exécuter un script Python depuis VSCodium en utilisant la commande Ctrl + Shift + P puis en tapant Python: Run Python File in Terminal.

• Il est possible d’exécuter seulement une partie d’un script Python depuis VSCodium en sélectionnant le code à exécuter puis en utilisant la commande Ctrl + Shift + P puis en tapant Python: Run Selection/Line in Python Terminal.

Utiliser des notebooks Jupyter depuis VSCodium

• Ouvrir un notebook Jupyter depuis VSCodium : Ctrl + Shift + P puis en tapant Jupyter: Create New Blank Notebook.

• Exécuter une cellule de code dans un notebook Jupyter : Ctrl + Enter.

• Exécuter une cellule de code dans un notebook Jupyter et passer à la cellule suivante : Shift + Enter.

• Exécuter une cellule de code dans un notebook Jupyter et créer une nouvelle cellule en dessous : Alt + Enter.

Exercice 1 - Modifier un fichier texte existant

Objectif : Créez un programme en Python qui permet de modifier un fichier texte existant.

Instructions :

1. Créez un fichier texte nommé cities.csv contenant le texte présent dans l’encart situé à droite.

2. Créez un programme Python qui permet de modifier l’entête du fichier cities.csv en remplaçant les valeurs coord1 et coord2 par latitude et longitude. Nous traitons ici ce fichier comme un fichier texte, il n’est donc pas nécessaire d’utiliser la bibliothèque csv. Le nouveau contenu doit être écrit dans un nouveau fichier nommé cities-new.csv.

3. Exécutez le programme et vérifiez que le fichier cities-new.csv a bien été créé et qu’il contient le nouveau contenu.

• Pour aller plus loin : importer la classe date du module datetime (from datetime import date) et essayez d’utiliser sa méthode today() pour faire en sortes que le nom du fichier de sortie contienne la date de l’exécution du programme (par exemple cities-2021-01-01.csv).

Contenu du fichier data.csv :

nom,coord1,coord2,value
Paris,48.8566,2.3522,10
Lyon,45.7640,4.8357,20
Marseille,43.2964,5.3700,30
Grenoble,45.1885,5.7245,40

Modèle de programme Python à utiliser :

with open('cities.csv', 'r') as f:
    # Lire le contenu du fichier
    content = f.read()

# Écrire ici la ou les instructions permettant
# de modifier le contenu du fichier

with open('cities-new.csv', 'w') as f:
    # Écrire le nouveau contenu dans le fichier
    f.write(content)

Exercice 2 - Lister les couches d’un flux WMS ou WFS

Dans cet exercice, vous utiliserez un notebook Jupyter existant et contenant déjà des instructions Python pour lister les couches d’un flux WMS ou WFS et les sauvegarder dans un fichier CSV.

L’utilisation d’un notebook Jupyter permet de tester facilement des instructions Python et de les exécuter pas à pas.

Instructions :

• Récupérez le notebook Jupyter ogc-web-services.ipynb et ouvrez-le dans VSCodium. Modifiez le selon les consignes que vous y trouverez.

Exercice 3 - Effectuer des géotraitements simples avec GeoPandas et Rasterio

Dans cet exercice, vous utiliserez un notebook Jupyter existant et contenant déjà des instructions Python pour effectuer des géotraitements simples avec GeoPandas et Rasterio.

L’utilisation d’un notebook Jupyter permet de tester facilement des instructions Python et de les exécuter pas à pas.

Instructions :

• Récupérer les données d’exemple data.zip et décompresser cette archive.

• Récupérez le notebook Jupyter geopandas-rasterio.ipynb et ouvrez-le dans VSCodium. Modifiez-le selon les consignes que vous y trouverez. Vous devrez peut-être y modifier le chemin vers les données d’exemple.

Partie 3 - Python et

Pourquoi Python-QGIS ?

• Lancer des commandes dans la console Python de QGIS

• Créer et utiliser des extensions

• Exécuter automatiquement un programme Python quand QGIS démarre

• Créer des algorithmes de traitement

• Créer des fonctions pour des expressions dans QGIS

• Créer des applications personnalisées basées sur l’API QGIS

L’interface de programmation PyQGIS

L’interface de programmation PyQGIS permet d’accéder à la majorité des fonctionnalités de QGIS depuis Python.

Elle est générée automatiquement à partir du code C++ de QGIS et comporte plus de 2000 classes décrivant les différents aspects de l’application (QgsProject, QgsProcessingAlgorithm, QgsDialog, etc.), des données qui y figurent (QgsVectorLayer, QgsRasterLayer, QgsFeature, QgsGeometry, etc.) et des fonctionnalités disponibles (QgsVectorFileWriter, etc.).

Il est nécessaire de consulter la documentation pour connaitre les méthodes et les attributs disponibles pour chaque classe.

Étendre les expressions QGIS avec Python

Dans QGIS, les expressions peuvent être utilisées dans différents mécanismes de base : sélection par expression, calcul des valeurs d’un champ (calculatrice de champ), règles de style, étiquettes, etc.

QGIS prend également en charge les expressions définies par l’utilisateur. Grâce à Python, vous pouvez définir vos propres fonctions qui peuvent être utilisées dans le moteur d’expression.

Étendre les expressions QGIS avec Python

Étendre les expressions QGIS avec Python

Étendre les expressions QGIS avec Python

Console Python dans QGIS

QGIS fournit une console interactive Python.

Elle peut être ouverte de plusieurs manières :

• depuis le menu Extensions > Console Python
• en utilisant le raccourci clavier Ctrl + Alt + P`
• en utilisant le bouton dans la barre d’outils

Lors de l’utilisation de la console Python dans QGIS, une variable iface est déjà existante. Cette variable est une instance de la classe QgisInterface et permet d’accéder à la majorité des fonctions de QGIS (accès au canevas de la carte, aux couches, aux menus, barres d’outils, etc. etc.).

Exécuter des commandes dans la console Python

Exemple 1 : Afficher le nom des couches vecteur ou raster chargées dans QGIS et le nombre d’entités pour les couches vecteur

for layer in iface.mapCanvas().layers():
    if layer.type() == QgsMapLayer.VectorLayer:
        print(f"Vecteur : {layer.name()} ({layer.featureCount()} entités) - {layer.crs().authid()}")
    elif layer.type() == QgsMapLayer.RasterLayer:
        print(f"Raster : {layer.name()} - {layer.crs().authid()}")

Exemple 2 : Accéder à la projection du projet

print(iface.mapCanvas().mapSettings().destinationCrs().authid())

Exécuter des commandes dans la console Python

Exemple 3 : Obtenir une référence vers une couche vecteur à partir de son nom et itérer sur ses entités

layer = QgsProject.instance().mapLayersByName('cities')[0]

# Une expression peut être utilisée pour filtrer les entités
expression = "$id < 5"

# On peut utiliser la méthode getFeatures() de la couche
# pour obtenir un itérateur sur les entités :
# - si on ne lui donne pas d'argument,
#   on obtient toutes les entités de la couche
# - si on lui donne une expression,
#   on obtient seulement les entités qui vérifient l'expression
for feature in layer.getFeatures(expression):
    # Ici 'feature' est donc un objet de type QgsFeature
    # Nous pouvons consulter la documentation pour connaitre les méthodes et les attributs disponibles
    print(feature['name'])
    # On peut aussi accéder à la géométrie de l'entité
    geom = feature.geometry()
    print(geom.asWkt())

Exécuter des commandes dans la console Python

Exemple 4 : Créer une couche vecteur à partir d’une couche existante et l’ajouter au projet

import random

layer = QgsProject.instance().mapLayersByName('cities')[0]

# On crée une couche mémoire vide
mem_layer = QgsVectorLayer('Polygon?crs=EPSG:4326', 'cities-buffer', 'memory')
pr = mem_layer.dataProvider()

# Spécification de deux champs
pr.addAttributes([
    QgsField("Buffer_value", QVariant.Double),
])
mem_layer.updateFields()

for feature in layer.getFeatures():
    ft = QgsFeature()
    # On calcule le buffer
    geom = QgsGeometry(feature.geometry())
    buffer_value = random.randint(1, 20)
    buffer = geom.buffer(buffer_value, 5)
    # On ajoute la géométrie à l'entité
    ft.setGeometry(buffer)
    ft.setAttributes([buffer_value])
    # On ajoute l'entité à la couche mémoire
    pr.addFeature(ft)

mem_layer.updateExtents()
    
# On ajoute la couche mémoire au projet
QgsProject.instance().addMapLayer(mem_layer)

Utiliser les algorithmes de traitement existants

QGIS fournit un ensemble d’algorithmes de traitement qui peuvent être utilisés dans la console Python, en utilisant le module Python processing.

# On peut lister les algorithmes disponibles
for alg in QgsApplication.processingRegistry().algorithms():
    print("{}:{} --> {}".format(
        alg.provider().name(), alg.name(), alg.displayName()))

Il est possible de consulter la documentation de chaque algorithme en utilisant la méthode help().

processing.algorithmHelp("qgis:voronoipolygons")

Ou de consulter la documentation en ligne : https://docs.qgis.org/latest/en/docs/user_manual/processing_algs/qgis/vectorgeometry.html#voronoi-polygons

C’est grâce à ces informations que vous aurez connaissance des paramètres nécessaires pour utiliser un algorithme.

Notez que les paramètres sont les mêmes que ceux utilisés dans l’interface graphique (et qui peuvent être consultés dans la boite de dialogue de l’algorithme).

Utiliser les algorithmes de traitement existants

import processing

# Pour utiliser un algorithme, il faut connaitre son nom complet
# Généralement, deux arguments sont nécessaires : son nom et les paramètres
result = processing.run("qgis:voronoipolygons", {
    'INPUT': 'cities',
    'BUFFER': 0,
    'OUTPUT': 'TEMPORARY_OUTPUT'
})

# On peut ensuite ajouter le résultat au projet
# (l'objet retourné par la méthode run() est un dictionnaire,
# on peut donc accéder à la couche résultat avec la clé 'OUTPUT')
QgsProject.instance().addMapLayer(result['OUTPUT'])

Utiliser les algorithmes de traitement existants

Notez que les paramètres sont les mêmes que ceux utilisés dans l’interface graphique (et qui peuvent être consultés dans la boite de dialogue de l’algorithme).

Créer des algorithmes de traitement

Il est possible de créer des algorithmes de traitement personnalisés sous forme d’un script Python.

Ils seront ajoutés à la boite à outils de traitement et pourront être utilisés comme n’importe quel autre algorithme.

Créer des algorithmes de traitement

Ces algorithmes peuvent réutiliser d’autres algorithmes existants déjà dans la boite à outils géotraitement (cf. exemple dans la documentation) ou non (cf. exemple ci-dessous).

from qgis import processing
from qgis.processing import alg
from qgis.core import (
    QgsProject,
    QgsVectorLayer,
    QgsField,
    QgsFeature,
    QgsGeometry
)
from PyQt5.QtCore import QVariant
import random

@alg(name='bufferrandomdistance', label='Our custom buffer operation with random distance',
     group='examplescripts', group_label='Example scripts')
@alg.input(type=alg.SOURCE, name='INPUT', label='Input vector layer')
@alg.input(type=alg.VECTOR_LAYER_DEST, name='OUTPUT', label='Buffer output')
@alg.input(type=alg.INT, name='BUFFERDISTMIN', label='BUFFER MINIMUM DISTANCE',
           default=1.0)
@alg.input(type=alg.INT, name='BUFFERDISTMAX', label='BUFFER MAXIMUM DISTANCE',
           default=100.0)
@alg.output(type=alg.NUMBER, name='NUMBEROFFEATURES',
            label='Number of features processed')
def bufferrandomdistance(instance, parameters, context, feedback, inputs):
    """
    Description of the algorithm.
    (If there is no comment here, you will get an error)
    """
    input_featuresource = instance.parameterAsSource(
      parameters, 'INPUT', context)
    numfeatures = input_featuresource.featureCount()
    bufferdistmin = instance.parameterAsInt(
      parameters, 'BUFFERDISTMIN', context)
    bufferdistmax = instance.parameterAsInt(
        parameters, 'BUFFERDISTMAX', context)

    if feedback.isCanceled():
        return {}

    # On crée une couche mémoire vide
    mem_layer = QgsVectorLayer(
    f'Polygon?crs={input_featuresource.sourceCrs().authid()}',
    'Buffer output',
    'memory',
    )
    pr = mem_layer.dataProvider()
    
    # Spécification de deux champs
    pr.addAttributes([
        QgsField("Buffer_value", QVariant.Double),
    ])
    mem_layer.updateFields()
    
    for feature in input_featuresource.getFeatures():
        ft = QgsFeature()
        # On calcule le buffer
        geom = QgsGeometry(feature.geometry())
        buffer_value = random.randint(bufferdistmin, bufferdistmax)
        buffer = geom.buffer(buffer_value, 5)
        # On ajoute la géométrie à l'entité
        ft.setGeometry(buffer)
        ft.setAttributes([buffer_value])
        # On ajoute l'entité à la couche mémoire
        pr.addFeatures([ft])
    
    if feedback.isCanceled():
        return {}

    QgsProject.instance().addMapLayer(mem_layer)
    
    return {
      'OUTPUT': mem_layer.id(),
      'NUMBEROFFEATURES': numfeatures
    }

Créer un plugin QGIS

Il est possible de créer des plugins QGIS en Python. Par rapport à la création d’algorithmes de traitement, les plugins :

• permettent de créer des interfaces graphiques plus complexes (avec plusieurs fenêtres, des onglets, etc.),
• permettent d’inclure une documentation complexe au format HTML,
• permettent d’ajouter des données d’exemples,
• permettent d’ajouter des fonctionnalités à QGIS qui ne sont pas des algorithmes de traitement (par exemple : ajouter une barre d’outils, ajouter un menu, etc.),
• peuvent être partagés avec la communauté via le QGIS Python Plugins Repository.

À l’inverse des algorithmes de traitement, vous dévelloperez un plugin QGIS dans un environnement de développement Python classique (VSCodium, Spyder, etc.) et non dans l’éditeur de code de QGIS.

Créer un plugin QGIS

Étude de cas : Le plugin DistanceCartogram permet de créer des cartogrammes de distance dans QGIS.

Références sur l’API Python de QGIS

• PyQGIS developer cookbook (documentation officielle)
• PyQGIS API documentation (documentation officielle)

• TP Python pour QGIS (TP de 12h donné en Licence Pro.)
• QGIS tutorials - Rubrique “Python Scripting (PyQGIS)”

Partie 4 - Mise en pratique

Choisir une des 3 mises en situation proposées dans ce qui suit.

Mise en situation 1

Objectif : Étendre les expressions QGIS avec Python

Instructions :

• Ouvrez un nouveau projet QGIS et ajoutez les données d’exemple (vous pouvez utiliser un projet QGIS personnel si vous le souhaitez).
• Copiez-collez le code de la fonction (présentée précédemment et rappelé ci-contre) dans la fenêtre permettant de définir une nouvelle fonction dans QGIS.
• Testez la fonction dans la fenêtre de sélection par expression pour la couche de points.
• Que manque-t-il à cette fonction pour qu’elle soit utilisable pour une couche de lignes ou de polygones ? Modifiez la fonction pour qu’elle puisse être utilisée pour des couches de lignes ou de polygones.
• Testez la fonction dans la fenêtre de sélection par expression pour la couche de polygones.

from qgis.core import *
from qgis.gui import *
import math

@qgsfunction(args='auto', group='Custom', usesgeometry=True)
def get_utm_zone(feature, parent):
    """
    Return the UTM Zone of the
    feature's geometry as a String
    """
    pt = feature.geometry().asPoint()
    longitude = pt.x()
    latitude = pt.y()
    zone_number = math.floor(((longitude + 180) / 6) % 60) + 1

    if latitude >= 0:
        zone_letter = 'N'
    else:
        zone_letter = 'S'

    return f"{int(zone_number)}{zone_letter}"

Mise en situation 2

Objectif : Se familiariser avec la console Python de QGIS et manipuler les données du projet actuel.

Instructions :

• Ouvrez un nouveau projet QGIS et ajoutez les données d’exemple (vous pouvez utiliser un projet QGIS personnel si vous le souhaitez).

• Ouvrez la console Python de QGIS.

• Testez l’ensemble des commandes présentées précédemment dans la console Python. Vous pouvez d’abord copier ces morceaux de code dans l’éditeur de texte de la console Python puis les exécuter en utilisant le bouton ▶ ou le raccourci clavier Ctrl + e.

• Testez de nouveaux géotraitements, au choix :

  • un ou plusieurs algorithmes de traitement existants (voir la liste des algorithmes disponibles dans la console Python),
  • en itérant sur les entités d’une couche vecteur et en choisissant une méthode de traitement (par exemple : calcul de la distance entre deux entités, calcul de la longueur d’une ligne, etc.),

Mise en situation 3

Objectif : Comprendre le fonctionnement d’un plugin QGIS existant (pas de code à écrire dans cette mise en situation).

Instructions :

• Consultez le code source du plugin Semi-Automatic Classification sur GitHub.
• Sur la base des indications, présentes dans la documentation officielle et affichées ci-dessous, identifiez les différents fichiers Python responsables de :
  • définir de la classe principale (permettant d’enregistrer le plugin dans QGIS),
  • définir des interfaces graphiques,
  • définir les fonctionnalités centrales du plugin (calcul du profil altimétrique, etc.).

Outro

Corrections des exercices

Partie 2

• Exercice 1 : Correction
• Exercice 2 : Notebook / Version HTML
• Exercice 3 : Correction / Version HTML

Partie 4

• Mise en situation 1 : Correction
• Mise en situation 2 : Correction

Références bibliographiques

Dorman, M., Graser, A., Nowosad, J. et Lovelace, R. (2022). Geocomputation with Python. CRC Press. https://py.geocompx.org/

GDAL/OGR contributors. (2022). GDAL/OGR Geospatial Data Abstraction software Library. Open Source Geospatial Foundation. https://doi.org/10.5281/zenodo.5884351

GEOS contributors. (2021). GEOS coordinate transformation software library. Open Source Geospatial Foundation. https://libgeos.org/

Gillies, S. et al. (2013). Rasterio: geospatial raster I/O for Python programmers. Mapbox. https://github.com/rasterio/rasterio

Gillies, S., Buffat, R., Arnott, J., Taves, M. W., Wurster, K., Snow, A. D., Cochran, M., Sales de Andrade, E. et Perry, M. (2023, janvier). Fiona. https://github.com/Toblerity/Fiona

Gillies, S., Wel, C. van der, Van den Bossche, J., Taves, M. W., Arnott, J., Ward, B. C., et al. (2023, janvier). Shapely. https://doi.org/10.5281/zenodo.5597138

Hoyer, S., Roos, M., Joseph, H., Magin, J., Cherian, D., Fitzgerald, C., Hauser, M., Fujii, K., Maussion, F., Imperiale, G., Clark, S., Kleeman, A., Nicholas, T., Kluyver, T., Westling, J., Munroe, J., Amici, A., Barghini, A., Banihirwe, A., Bell, R., et al.Wolfram, P. J. (s. d.). xarray. https://doi.org/10.5281/zenodo.598201

Jordahl, K., Bossche, J. V. den, Fleischmann, M., Wasserman, J., McBride, J., Gerard, J., Tratner, J., Perry, M., Badaracco, A. G., Farmer, C., Hjelle, G. A., Snow, A. D., Cochran, M., Gillies, S., Culbertson, L., Bartos, M., Eubank, N., maxalbert, Bilogur, A., Rey, S., et al.Leblanc, F. (2020, juillet). geopandas/geopandas: v0.8.1. Zenodo. https://doi.org/10.5281/zenodo.3946761

PROJ contributors. (2021). PROJ coordinate transformation software library. Open Source Geospatial Foundation. https://proj.org/

Rey, S. J. et Anselin, L. (2007). PySAL: A Python Library of Spatial Analytical Methods. The Review of Regional Studies, 37(1), 5‑27.

Snow, A. D., Brochart, D., Raspaud, M., Taves, M., Bell, R., RichardScottOZ, Chegini, T., stefank0, Amici, A., Braun, R. et al., et. (2023). corteva/rioxarray: 0.14.1 Release. https://doi.org/10.5281/zenodo.7829704

Snow, A. D., Whitaker, J., Cochran, M., Miara, I., Bossche, J. V. den, Mayo, C., Cochrane, P., Lucas, G., Kloe, J. de, Karney, C. et al., et. (2023). pyproj4/pyproj: 3.5.0 Release. https://doi.org/10.5281/zenodo.7776548

The pandas development team. (s. d.). pandas-dev/pandas: Pandas. https://github.com/pandas-dev/pandas