index.qmd

---
title: "Formation Python pour géomaticiens 🐍🌏"
author:
  name: "Matthieu Viry"
  email: "matthieu.viry@cnrs.fr"
subtitle: "11 Décembre 2023"
format:
  revealjs:
    embed-resources: false
    slide-number: true
    show-slide-number: all
    chalkboard: true
    logo: images/logos-footer.png
jupyter: python3
title-slide-attributes:
  data-background-image: images/logos-footer.png
  data-background-size: 42%
  data-background-position: 50% 90%
css: ['static/style.css']
prefer-html: true
bibliography: references.bib
csl: "universite-de-montreal-apa.csl"
lang: fr
---

## Programme de la demi-journée 📝

<br />

:::{.medium}

- **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.

<br />

Rappels des instructions pour installer l'environnement Python : [Installation d'un environnement Python pour Windows avec Anaconda et VSCodium](installation.html)

:::

# 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 ! 🎉

:::{.fragment}

**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...

<img src="images/logo-python.png" style="position: absolute;top: 60px;right: 10px;width: 105px !important;height: auto;" />

<br /><br />

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

::: {.notes}


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

:::{.center}

![](images/xkcd-python.png)

:::
   
## Python vs. R 🥊

<br>

:::: {.columns}

::: {.column .medium width="50%"}

### Python

- *General-purpose programming language*

- *"Jack of all trades, master of none"* ?

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

:::

::: {.column .medium width="50%"}

### R

- *For statistical computing and graphics*

- *"By statisticians, for statisticians"*

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

:::

::::

<br />

:::{.small}

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

<img src="images/google-hits.png" class="bordered">

:::

# Présentation de l'écosystème

## Implémentation de référence et distributions

- Une implémentation de référence du langage [**Python**](https://www.python.org/) : [**CPython**](https://github.com/python/cpython)
  (mais d'autres implémentations : Jython, IronPython, PyPy, etc.)

- Plusieurs *distributions* de Python (principalement [**Anaconda**](https://anaconda.org/), une distribution des langages de programmation Python et R dédiée à la science des données et à l'apprentissage automatique)

<div class="center">
<img src="images/logo-anaconda.png" />
<p class="small">Source: <a href="https://anaconda.org">anaconda.org</a></p>
</div>

::: {.notes}

- 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**](https://www.spyder-ide.org/) (IDE "scientifique", interface comparable à RStudio),
  [**PyCharm**](https://www.jetbrains.com/pycharm/) (logiciel propriétaire, plutôt pour développer des bibliothèques), [**Jupyter Lab**](https://jupyter.org/)
  et plus récemment [**Visual Studio Code**](https://code.visualstudio.com/) (VSCode, VSCodium).


<img src="images/spyder.png" style="float:left; width: 46%;" />

<img src="https://www.jetbrains.com/pycharm/img/screenshots/complexLook@2x.jpg" style="float:right; width: 46%;"/>

## *Batteries included 🔋*

:::{.medium}

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.

:::

:::{.small}

[Modules de la bibliothèque standard](https://docs.python.org/3/library/index.html) :

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

<br />

:::{.medium}

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](https://pypi.org/) (Python Package Index) (et [conda-forge](https://conda-forge.org/) pour les utilisateurs d'Anaconda).

<br />

**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**.

:::

:::{.notes}

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

<br />
<center>

![](images/python-stack.png)

</center>

## Documentation

::: {.small}
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.).
:::

<center>

![](images/python-documentation.png)

</center>


## Documentation / Modules additionnels


Il n'existe toutefois pas un seul standard pour consulter la documentation des différents modules additionnels Python
(cf. [Documentation Matplotlib](https://matplotlib.org/stable/api/index), [Documentation pandas](https://pandas.pydata.org/docs/reference/index.html#api)).

<img src="images/doc-geopandas.png" style="width: 40%; position: absolute; border: solid 1px black; left: 10px;" />

<img src="images/doc-matplotlib.png" style="width: 40%; position: absolute; border: solid 1px black; bottom: -60px; left: 29%;" />

<img src="images/doc-samgeo.png" style="width: 40%; position: absolute; border: solid 1px black; right: 10px;" />

# En terme de syntaxe ça donne quoi ?

## Premier pas avec la syntaxe Python

<br>

```{python}
#| error: true
#| echo: true
#| message: true
#| cache: true
# 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)
```

## Python et l'indentation du code...

<br>

```{python}
#| error: true
#| echo: true
#| message: true
#| cache: true
my_list = [1, 2, 3]

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

## Python et l'indentation du code...

<br>

```{python}
#| error: true
#| echo: true
#| message: true
#| cache: true
my_list = [1, 2, 3]

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

## Python et l'indentation du code...

<br>

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

<br>

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

```{python}
#| echo: true
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)
```

## Python et l'indentation du code...

<br>

Une fois l'indentation corrigée...

```{python}
#| echo: true
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)
```

<!-- # Premières commandes dans l'interpréteur Python -->

## L'interpréteur Python

<br>

:::{.medium}

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

<br />

:::{.small}

- 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

<br />

:::{.medium}

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

<br />

:::{.medium}

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

:::{.medium}

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 <br />et *data structures* natives

:::{.small}
*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.

::::{.columns .medium}
:::{.column width="50%"}

- `int` (entier)

```{python}
#| echo: true
my_int = 42
```

<br />

- `float` (nombre à virgule flottante)

```{python}
#| echo: true
my_float = 3.14
```

<br />

- `bool` (booléen)

```{python}
#| echo: true
my_bool = True # ou False
```

:::

:::{.column width="50%"}

- `str` (chaîne de caractères)

```{python}
#| echo: true
my_str = 'Hello world!'
```

<br />

```{python}
#| echo: true
my_str = "Hello world!"
```

- `NoneType` (type spécial pour la valeur `None`)

```{python}
#| echo: true
my_none = None
```

:::
::::

## Types de base - `str`

::::{.columns .medium}

:::{.column width="50%"}

- **Création**, avec des guillemets simples ou doubles :

```{python}

#| echo: true
my_str = 'Hello world!'
```

```{python}
#| echo: true
my_str = "Hello world!"
```

```{python}
#| echo: true
my_long_str = '''Hello
world
and Python!'''
```
  
<br />

- **Concaténation** :

```{python}

#| echo: true
my_str = 'Hello' + ' ' + 'world!'
```

:::

:::{.column width="50%"}

- **Accès aux caractères** :

```{python}

#| echo: true
print(my_str[0]) # Premier caractère
```

```{python}
#| echo: true
print(my_str[-1]) # Dernier caractère
```

```{python}
#| echo: true
print(my_str[0:5]) # Sous-chaîne
```

:::

::::

:::{.small}

Pour en savoir plus : [Documentation officielle : `string` — Opérations usuelles sur des chaînes](https://docs.python.org/fr/3/library/string.html)

:::

## Types de base - `str`

::::{.columns .medium}

:::{.column width="50%"}

- **Formatage** :

```{python}
#| echo: true
a = 'world'

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

```{python}
#| echo: true
a = 'world'

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

:::

:::{.column width="50%"}

- **Remplacement** :

```{python}
#| echo: true
my_str = 'Hello world!'
my_str = my_str.replace('world', 'Python')
print(my_str)
```

:::{.medium}

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 :

:::

```{python}
#| echo: true
my_str = 'Hello world!'

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

:::

::::

## Structures de données

:::{.medium}

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


- `dict` (tableau associatif)

```{python}
#| echo: true
my_dict = { 'john': 32, 'jane': 27, 'jack': 30 }
```

- `tuple` (un conteneur immuable),

```{python}
#| echo: true
my_coordinates = (2.349014, 48.864716)
```

- `list` (tableau dynamique mutable),

```{python}
#| echo: true
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.

:::

:::{.notes}

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.]{.medium}

::::{.columns .medium}

:::{.column width="50%"}

- **Création** :

Liste vide :

```{python}
#| echo: true
ma_liste = []
```

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

```{python}
#| echo: true
ma_liste = [12, 34, 2, 1, 21, 43]
```

<br />

- **Connaitre la taille d'une liste** :

```{python}
#| echo: true
len(ma_liste)
```

:::

:::{.column width="50%"}

- **Accès aux éléments** :


```{python}
#| echo: true
ma_liste[0] # Premier élément
```

```{python}
#| echo: true
ma_liste[-1] # Dernier élément
```

```{python}
#| echo: true
ma_liste[1] = 42 # Modification d'un élément
```

<br />

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

```{python}
#| echo: true
my_slice = ma_liste[1:3]
my_slice
```

:::
::::

## Structures de données - `list` (2)

:::{.medium}

De nombreuses *méthodes* permettant de manipuler les listes.

- **Ajouter des éléments à une liste existante** :

```{python}
#| echo: true
ma_liste.append(322)
```

<br />


- **Supprimer un élément d'une liste** :

```{python}
#| echo: true
 # Supprime la première occurrence de l'élément 322
ma_liste.remove(322)
```

```{python}
#| echo: true
 # Supprime l'élément à l'indice 0 (et le retourne)
ma_liste.pop(0)
```

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`

:::{.medium}

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** :

```{python}
#| echo: true
my_tuple = (1, 2, 3)
```

- **Accès aux éléments** :

```{python}
#| echo: true
my_tuple[0] # Comme pour une liste
```

- **Pas de modification possible** :

```{python}
#| error: true
#| echo: true
my_tuple[0] = 42
```

:::


## Structures de données - `dict` (1)

:::{.medium}

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

:::

::::{.columns .medium}

:::{.column width="50%"}

- **Création** d'un dictionnaire **vide** :

```{python}
#| echo: true
my_dict = {}
```

<br />

- **Création** d'un dictionnaire **avec des éléments** :

```{python}
#| echo: true
my_dict = { 'john': 32, 'jane': 27, 'jack': 30 }
```

<br />

- **Accès aux éléments** :

```{python}
#| echo: true
my_dict['john']
```

:::

:::{.column width="50%"}

- **Modification d'un élément** :

```{python}
#| echo: true
my_dict['john'] = 33
```

<br />

- **Ajout d'un élément** :

```{python}
#| echo: true
my_dict['jill'] = 29
```

<br />

- **Suppression d'un élément** :

```{python}
#| echo: true
del my_dict['john']
```

:::

::::

## Structures de données - `dict` (2)

::::{.columns .medium}

:::{.column width="50%"}

- **Accès aux éléments** :

```{python}
#| echo: true
my_dict['jill']
```

<br />

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

```{python}
#| error: true
#| echo: true
my_dict['johana']
```

<br />

*Tester l'existence d'une clé dans un dictionnaire* :

```{python}
#| echo: true
'johana' in my_dict
```

:::

:::{.column width="50%"}

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

```{python}
#| echo: true
my_dict.get('johana')
```

```{python}
#| echo: true
my_dict.get('johana', -1)
```


<br />

- **Récupérer l'ensemble des clés** :

```{python}
#| echo: true
my_dict.keys()
```

<br />

- **Récupérer l'ensemble des valeurs** :

```{python}
#| echo: true
my_dict.values()
```

:::

::::

## Des listes de listes ?

:::{.medium}

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

```{python}
#| echo: true
data = [
    ['Jill', 32, 1.65],
    ['Jack', 27, 1.73],
    ['Jane', 30, 1.80]
]

print(data[0][1])
```

```{python}
#| echo: true
data = [
    ('Jill', 32, 1.65),
    ('Jack', 27, 1.73),
    ('Jane', 30, 1.80)
]

print(data[0][1])
```

:::

## Des listes de dictionnaires ?

:::{.medium}

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

```{python}
#| echo: true
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'])
```

:::

## Des dictionnaires de dictionnaires ?

:::{.medium}

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

```{python}
#| echo: true
data = {
    'jill': { 'age': 32,  'height': 1.65 },
    'jack': { 'age': 27,  'height': 1.73 },
    'jane': { 'age': 30,  'height': 1.80 }
}

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

:::

## Des dictionnaires de dictionnaires ?

:::{.medium}

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

```{python}
#| echo: true
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'])
```

:::

## Contrôle du flux d'exécution - `if`

:::{.medium}

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

:::

::::{.columns .medium}

:::{.column width="50%"}

- **`if`** :

```{python}
#| echo: true
altitude = 2500

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

<br />

- **`if` / `else`** :

```{python}
#| echo: true
altitude = 2500

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

:::

:::{.column width="50%"}

- **`if` / `elif` / `else`** :

```{python}
#| echo: true
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')
```

[Les seuils proviennent de [Wikipedia:Altitude#Adaptations_physiologiques_et_réponses_physiopathologiques_du_corps_humain](https://fr.wikipedia.org/wiki/Altitude#Adaptations_physiologiques_et_r%C3%A9ponses_physiopathologiques_du_corps_humain)]{.very-small}

:::

::::

## Contrôle du flux d'exécution - `for` (1)

:::{.medium}

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

:::

::::{.columns .medium}

:::{.column width="50%"}

- **`for`** :

```{python}
#| echo: true
for i in range(5):
    print(i)
```

<br />

:::{.medium}

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`.

:::

:::

:::{.column width="50%"}

- **`for`** sur une liste :

```{python}
#| echo: true
my_list = [12, 34, 2, 1, 3]

for item in my_list:
    print(item)
```

<br />

- **`for`** sur une liste, en utilisant `enumerate` :

```{python}
#| echo: true
for index, item in enumerate(my_list):
    print(f'Index: {index}, item: {item}')
```

:::

::::

## Contrôle du flux d'exécution - `for` (2)

::::{.columns .medium}

:::{.column width="50%"}

- **`for`** sur un dictionnaire :

```{python}
#| echo: true
my_dict = { 'john': 32, 'jane': 27, 'jack': 30 }

for key in my_dict:
    print(key)
```

<br />

```{python}
#| echo: true
for key, value in my_dict.items():
    print(f'{key} a {value} ans')
```

:::

:::{.column width="50%"}

- **`for`** sur une chaîne de caractères :

```{python}
#| echo: true

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

<br />

```{python}
#| echo: true

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

:::

::::

## Contrôle du flux d'exécution - `while`

:::{.medium}

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

:::

::::{.columns .medium}

:::{.column width="50%"}

- **`while`** :

```{python}
#| echo: true
i = 0

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

:::

:::{.column width="50%"}

- **`while`** avec `break` :

```{python}
#| echo: true
i = 0

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

:::

::::

## Fonctions

:::{.medium}

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

:::

::::{.columns .medium}

:::{.column width="50%"}

- **Définition d'une fonction** :

```{python}
#| echo: true
def my_function():
    print('Hello world!')
```

<br />

- **Appel d'une fonction** :

```{python}
#| echo: true
my_function()
```

:::

:::{.column width="50%"}

- **Fonction avec paramètres et valeur de retour** :

```{python}
#| echo: true
def compute_NDVI(red, nir):
    ndvi = (nir - red) / (nir + red)
    return ndvi
```

<br />

```{python}
#| echo: true
ndvi = compute_NDVI(0.2, 0.8)
print(ndvi)
```

:::

::::

## Classes

<br>

[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...]{.medium}


```{python}
#| echo: true
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
```

:::{.notes}

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

<br>

Instanciation et utilisation :

```{python}
#| echo: true
p1 = Point(2, 6)
p2 = Point(9, 9)

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

## Classes, méthodes et attributs

::::{.columns .medium}

:::{.column .fragment width="60%"}
**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.

:::

:::{.column .fragment width="40%"}
**Attributs** :

Un attribut est une variable qui appartient à une classe.

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

```{python}
#| echo: true
p1 = Point(2, 6)
print(p1.x)

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

:::

::::

## Actions courantes : lire et écrire des fichiers

:::{.medium}

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

::::{.columns .medium}
:::{.column width="50%"}

- **Lire le contenu d'un fichier** :

```{python}
#| echo: true
f = open('data/data.txt', 'r')
content = f.read()
f.close()

print(content)
```

<br />

```{python}
#| echo: true
with open('data/data.txt', 'r') as f:
    content = f.read()
    
print(content)
```

- **Écrire dans un fichier** :

```{python}
#| echo: true
with open('data/test.txt', 'w') as f:
    f.write('Hello world!')
```

:::

:::{.column width="50%"}

- **Lire le contenu d'un fichier ligne par ligne** :

```{python}
#| echo: true
with open('data/data.txt', 'r') as f:
    for line in f:
        print(line)
```

- **Écrire dans un fichier ligne par ligne** :

```{python}
#| echo: true
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

<br />

:::{.small}

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

```{python}
#| echo: true

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

<br />

:::{.small}

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.

```{python}
#| echo: true
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

::::{.columns .medium}

:::{.column width="50%"}

- **Lire le contenu d'un fichier JSON** :

```{python}
#| echo: true
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'
```

:::

:::{.column width="50%"}

- **Écrire dans un fichier JSON** :

```{python}
#| echo: true
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

::::{.columns .medium}

:::{.column width="50%"}

- **Lire le contenu d'un fichier CSV** :

```{python}
#| echo: true
import csv

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

:::

:::{.column width="50%"}

- **Écrire dans un fichier CSV** :

```{python}
#| echo: true
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

<br />

:::{.medium}

- 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**](https://pandas.pydata.org/). 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**](https://numpy.org/). 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).

:::

:::{.notes}

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`

:::{.medium}

Pandas permet d'ouvrir des fichiers CSV, JSON, Excel, etc. et de les manipuler facilement grâce à des `DataFrame`s (comparables aux `data.frame`s de R).

:::

::::{.columns .medium}

:::{.column width="50%"}

- **Ouverture** :

```{python}
#| echo: true
import pandas as pd

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

<br />

- **Affichage** :

```{python}
#| echo: true
df.head()
```

:::

:::{.column width="50%"}

- **Sélection d'une colonne** :

```{python}
#| echo: true
df['name']
```

- **Sélection selon une condition** :

```{python}
#| echo: true
df[df['age'] > 30]
```

```{python}
#| echo: true
df.query('height > 1.70').query('age > 30')
```

:::

::::

## Analyse de données - `pandas`

::::{.columns .medium}

:::{.column width="50%"}

- **Ajout d'une colonne** :

```{python}
#| echo: true
df['weight'] = [80, 65, 75, 54, 90]

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

df.head()
```

<br />

- **Suppression d'une (ou plusieurs) colonne(s)** :

```{python}
#| echo: true
df.drop(
  columns=['weight', 'height'],
  inplace=True,
)
```

:::

:::{.column width="50%"}

- **Tri** :

```{python}
#| echo: true
df.sort_values(by='BMI', inplace=True)

df.head()
```

<br />

- **Export** :

```{python}
#| echo: true
df.to_csv('data/test.csv', index=False)
```

:::

::::

## Analyse de données - `pandas`

::::{.columns .medium}

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

:::{.column width="50%"}

- **Visualisation** :

```{python}
#| echo: true
df.plot.bar(x='name', y='BMI')
```

:::

:::{.column width="50%"}

- **Statistiques descriptives** :

```{python}
#| echo: true

df.describe()
```

:::

::::


## Analyse de données - Autres bibliothèques

<br />

:::{.medium}

- [**NumPy**](https://numpy.org/) - Manipulation de tableaux de données typés (voir le [notebook sur NumPy](notebooks/ExempleNumpy.html) pour découvrir les fonctionnalités de base)
- [**SciPy**](https://www.scipy.org/) - Bibliothèque d'algorithmes scientifiques
- [**Matplotlib**](https://matplotlib.org/) - Visualisation de données
- [**Scikit-learn**](https://scikit-learn.org/) - Apprentissage automatique
- [**Statsmodels**](https://www.statsmodels.org/) - Modèles statistiques
- [**Seaborn**](https://seaborn.pydata.org/) - Visualisation de données
- [**Plotly**](https://plotly.com/python/) - Visualisation de données

<center>
![](images/logos-sm-scikit-scipy.png)
</center>

:::

# Écosystème pour le géospatial

## Données vectorielles

<br />

::::{.medium}

-   [**Bindings Python de GDAL/OGR**](https://gdal.org/api/python_bindings.html) [@GDAL]
-   [**Fiona**](https://fiona.readthedocs.io/en/stable/) [@fiona] - I/O (*wrapper* de haut niveau autour d'OGR)
-   [**Shapely**](https://shapely.readthedocs.io/)  [@sgillies_2023] - bindings Python de [GEOS](https://github.com/libgeos/geos) [@GEOS]
-   [**Pyproj**](https://pyproj4.github.io/pyproj) [@pyproj] - bindings Python de [PROJ](https://proj.org/) [@PROJ]
-   [**Geopandas**](https://geopandas.org/)  [@kelsey_jordahl_2020_3946761] - Étend les `DataFrame`s de [pandas](https://pandas.pydata.org/) [@pandas]

::::

::::{.columns}
:::{.column width="50%"}

![](./images/logo-pandas.svg){width=300}

:::

:::{.column width="50%"}

![](./images/logo_geopandas.svg){width=340}

:::
::::

## Le package *GeoPandas*

<br />

:::{.medium}

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](./images/geopandas-table.png)

:::

## Le package *GeoPandas* - Exemples

::: {.panel-tabset .custom-tab .small}

### Import et lecture

```{python gpd-tuto-import-1}
#| echo: false
import geodatasets

file_path = geodatasets.get_path("nybb")
```

Avec la fonction `read_file` :

```{python gpd-tuto-import-2}
#| echo: true
import geopandas as gpd

nybb = gpd.read_file(file_path)
```

### Affichage

Avec la méthode `plot` des `GeoDataFrame` :

```{python gpd-tuto-plot}
#| echo: true
nybb.plot()
```

### SCR

Affichage :

```{python gpd-tuto-crs}
#| echo: true
print(nybb.crs)
```

Transformation :

```{python gpd-tuto-transformation}
#| echo: true
nybb_geo = nybb.to_crs('EPSG:4326')
```

### Affichage avec fond de carte

En utilisant la bibliothèque `contextily` :

```{python gpd-tuto-contextily}
#| echo: true
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
```

### Centroide

Simplement en utilisant l'attribut `centroid` des `GeoDataFrame` :

```{python gpd-tuto-centroid}
#| echo: true
nybb.centroid.plot()
```

### Boundary

Simplement en utilisant l'attribut `boundary` des `GeoDataFrame` :

```{python gpd-tuto-boundary}
#| echo: true
nybb.boundary.plot()
```

### Zone tampon

En utilisant la méthode `buffer` des `GeoDataFrame` :

```{python gpd-tuto-buffer}
#| echo: true
buff_nybb = nybb.buffer(3000)
```

```{python gpd-tuto-buffer-2}
#| echo: true
ax = buff_nybb.plot(color="red")
nybb.plot(ax=ax, color="aliceblue")
```


### Aggrégation

En utilisant la méthode `dissolve` des `GeoDataFrame` :

```{python gpd-tuto-agg}
#| echo: true
# On peut utiliser dissolve(by="nom_colonne") si on veut aggréger selon les valeurs d'une colonne
agg = nybb.dissolve()
agg.plot()
```


### Intersection

En utilisant la méthode `intersection` des `GeoDataFrame` :

```{python gpd-tuto-intersection}
#| echo: true
from shapely import wkt

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

<br />

```{python gpd-tuto-intersectiob-2}
#| echo: true
ax = nybb.plot()
ax = intersecting.plot(ax=ax, color="red")
ax
```

:::

:::{.medium}

<br /><br /><br />

*Et/ou voir le [notebook correspondant](notebooks/geopandas-rasterio-demo.html)*

:::

## Données raster

::::{.columns .medium}
:::{.column width="50%"}

[**Rasterio**](https://rasterio.readthedocs.io/) [@gillies_2019] :

:::{.small}

* 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**](https://pythonhosted.org/rasterstats/) :

:::{.small}

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

:::

![](https://raw.githubusercontent.com/perrygeo/python-rasterstats/master/docs/img/zones_elevation.png)

:::

:::{.column width="50%"}

[**xarray**](https://docs.xarray.dev/en/stable/) [@xarray] et [**rioxarray**](https://corteva.github.io/rioxarray/) [@rioxarray]:

:::{.small}

* *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é

:::

![](images/xarray-datastructure.png)

:::
::::

## Le package *Rasterio*

:::{.small}

Exemple d'utilisation :

```{python example-rio-1}
#| echo: true
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) :

```{python example-rio-2}
#| echo: true
print(metadata)
print(data)
```

:::

## Les package *xarray* et *rioxarray*

Exemple d'utilisation :

::: {.panel-tabset .custom-tab .small}

### Import et lecture

```{python xarray-tuto-import-1}
#| echo: true
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 :

```{python xarray-tuto-import-2}
xds
```

### Complétion des valeurs manquantes

```{python xarray-tuto-na}
#| echo: true
filled = xds.rio.interpolate_na()
```

### Affichage

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

```{python xarray-tuto-plot}
#| echo: true
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)
```

### SCR

- Affichage :

```{python xarray-tuto-crs-1}
#| echo: true
xds.rio.crs
```

- Transformation :

```{python xarray-tuto-crs-2}
#| echo: true
xds = xds.rio.reproject("EPSG:6623")
```

### Découpage

- Découpage selon l'emprise des données contenues dans un `GeoDataFrame` (ici `gdf`) :

```{python xarray-tuto-clipping}
#| echo: true
#| eval: false
clipped = xds.rio.clip(gdf.geometry.values, gdf.crs, drop=False, invert=True)
```

:::

## Analyse spatiale

<img src="./images/logo-pysal.png" style="position: absolute; top: 5px; right: 20px; width: 120px; height: auto;"/>


:::{.medium}

Écosystème de bibliothèques pour l'analyse spatiale [PySAL](https://pysal.org/) <br />(Python Spatial Analysis Library, @pysal2007) :

:::

:::: {.columns .small}
::: {.column width="50%"}

**Explorer** :

- Analyse exploratoire des données spatiales (package [esda](https://pysal.org/esda/))
- Analyse de la dynamique des données spatiales longitudinales (package [giddy](https://pysal.org/giddy/))
- Mesure des inégalités dans l'espace et dans le temps (package [inequality](https://inequality.readthedocs.io/en/latest/))
- Analyse statistique de motifs ponctuels planaires (package [pointpats](https://pysal.org/pointpats/))
- Mesure de la ségrégation dans le temps et dans l'espace (package [segregation](https://pysal.org/segregation/))
- Morphométrie urbaine (package [momepy](https://docs.momepy.org/en/stable/))

:::

::: {.column width="50%"}

**Modéliser** :

- Régression géographiquement pondérée à plusieurs échelles (package [mgwr](https://mgwr.readthedocs.io/en/latest/))
- Modèles linéaires généralisés épars (package [spglm](https://spglm.readthedocs.io/en/latest/))
- Modèles d'interaction spatiale (package [spint](https://spint.readthedocs.io/en/latest/))
- Modèles de régression spatiale (package [spreg](https://spreg.readthedocs.io/en/latest/))
- Modèles de composantes de variance à corrélation spatiale à plusieurs niveaux (package [spvcm](https://github.com/pysal/spvcm))
- *Areal interpolation* et cartographie dasymétrique (package [tobler](https://pysal.org/tobler/))
- Accessibilité spatiale (package [access](https://pysal.org/access/))
- Optimisation spatiale (package [spopt](https://pysal.org/spopt/))

:::

::::


## Autres packages utiles ...

::::{.columns .medium}
:::{.column width="48%"}

- Binding Python pour [GRASS](https://grass.osgeo.org/grass82/manuals/libpython/index.html) + Intégration dans les notebooks Jupyter

![[Source](https://grass.osgeo.org/news/2022_06_05_results_student_grant_caitlin/)](./images/grass_jupyter_combo_vis.png)

:::

:::{.column width="50%"}

- [Iris](https://scitools-iris.readthedocs.io/en/stable/) - Analyse et visualisation de données des sciences de la Terre.

- Pour la cartographie : [cartopy](https://scitools.org.uk/cartopy/docs/latest/) et [geoplot](https://residentmario.github.io/geoplot/) basés sur *cartopy* ; [PyGMT](https://www.pygmt.org/latest/) ; [geoviews](https://geoviews.org/) (selon les usages).

![](./images/cartopy.png)

- Voir aussi [https://github.com/sacridini/Awesome-Geospatial#python](https://github.com/sacridini/Awesome-Geospatial#python).

:::
::::

## Python pour quoi d'autre ?

:::{.medium}

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

**_Machine learning_ et _Deep learning_** :

- [Scikit-learn](https://scikit-learn.org/) (apprentissage automatique, developpé par des membres de l'INRIA - dispose d'une [documentation très détaillée](https://scikit-learn.org/stable/tutorial/basic/tutorial.html))
- [TensorFlow](https://www.tensorflow.org/) et [PyTorch](https://pytorch.org/) (voir par exemple [ce tutoriel](https://www.tensorflow.org/tutorials/quickstart/beginner)).
- [Keras](https://keras.io/) (API de haut niveau pour TensorFlow, Theano et CNTK).

<center>

![](images/logos-ML.png)

</center>

:::

## Python pour quoi d'autre ?

:::{.medium}

<br />

**_Web scraping_** :

- [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/bs4/doc/) (pour extraire des données de pages web)
- [Selenium](https://www.selenium.dev/) (pour automatiser des actions dans un navigateur web)
- [Scrapy](https://scrapy.org/) (pour créer des robots d'indexation de sites web)

**_Web development_** :

- [Django](https://www.djangoproject.com/) (pour créer des sites web)
- [Flask](https://flask.palletsprojects.com/) (pour créer des sites web)
- [FastAPI](https://fastapi.tiangolo.com/) (pour créer des API web)
- [Dash](https://dash.plotly.com/) (pour créer des applications web interactives)
- [Streamlit](https://streamlit.io/) (pour créer des applications web interactives)

:::

<a href="https://heranow.reionization.org/" target="_blank"><img src="images/heranow.png" class="w400" style="position: absolute; right: -10px; top: 50%;" /></a>

## Python pour quoi d'autre ?

:::{.medium}

- [**Gradio**](https://www.gradio.app/) - Créer des interfaces graphiques pour des modèles d'apprentissage automatique en quelques lignes de code

```python
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 ?

:::{.medium}

- [**Gradio**](https://www.gradio.app/) - Créer des interfaces graphiques pour des modèles d'apprentissage automatique en quelques lignes de code

<iframe src="https://gradio-hello-world-3.hf.space" width="850" height="450" style="border: solid 1px black;"></iframe>

:::

## Python pour quoi d'autre ?

:::{.medium}

**Développement d'applications** :

- [PyQt](https://riverbankcomputing.com/software/pyqt/) / [PySide](https://wiki.qt.io/PySide) (pour créer des applications de bureau)
- [Kivy](https://kivy.org/) (pour créer des applications de bureau et des applications mobiles)
- [PySimpleGUI](https://pysimplegui.readthedocs.io/) (pour créer des interfaces graphiques - [Exemple en ligne](https://pysimplegui.trinket.io/demo-programs#/demo-programs/intro-to-this-page))

<iframe src="https://trinket.io/embed/pygame/e51fa16b0b" width="100%" height="460" frameborder="0" marginwidth="0" marginheight="0" allowfullscreen="" class="embedded-content"></iframe>

:::

## Python dans des logiciels

:::{.columns .medium}

:::{.column width="50%"}

Python dans **Inkscape**

La majorité des extensions de Inkscape sont des scripts Python
(d’après [la documentation](https://inkscape.org/fr/developper/extensions/)),
et il existe des ressources pour faciliter l’écriture de scripts Python pour Inkscape.

![](images/inkscape_scripting.png)

[_Et bien sûr dans **QGIS** ! Mais aussi dans **ArcGIS**, dans **Autodesk Maya**, etc._]{.fragment}

:::

:::{.column width="50%"}

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

![](https://tabreturn.github.io/img/aqitbcc01/getting-started-blender.png)

:::

::::

## Ressources pour l'apprentissage de Python

<br />

:::{.midly-small}

- [Le tutoriel de la documentation officielle](https://docs.python.org/fr/3/tutorial/)

- [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")](https://www.fun-mooc.fr/fr/cours/python-3-des-fondamentaux-aux-concepts-avances-du-langage/)
  (selon vos centres d'intérêt, d'autres MOOC comme ["Recherche reproductible : principes méthodologiques pour une science transparente"](https://www.fun-mooc.fr/fr/cours/recherche-reproductible-principes-methodologiques-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](https://openclassrooms.com/fr/courses/7168871-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)](https://geo-python-site.readthedocs.io/en/latest/)

- [Cours "Introduction à la programmation Python pour la biologie" (en français)](https://python.sdv.univ-paris-diderot.fr/)

:::


## Ressources Python Géospatial

<br />

:::{.small}

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

:::

<br />

:::{.medium}

- [Livre gratuit "Geocomputation with Python" (en anglais)](https://py.geocompx.org/) [@Dorman2022]

- [Cours "Automating GIS processes" (en anglais)](https://autogis-site.readthedocs.io/en/latest/)

- [Cours "Use Data for Earth and Environmental Science in Open Source Python" (en anglais)](https://www.earthdatascience.org/courses/use-data-open-source-python/)

- [Livre gratuit "Geographic Data Science with Python" (en anglais)](https://geographicdata.science/book/intro.html)

:::

# Partie 2 - Mise en pratique

## Utiliser Python depuis VSCodium

<br>

:::{.medium}

- L'extension [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python) permet d'utiliser Python depuis VSCodium et l'extension [Jupyter](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter) permet d'utiliser des notebooks Jupyter depuis VSCodium.

- Il est possible d'ouvrir un terminal depuis VSCodium en utilisant la commande <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> puis en tapant `Terminal: Create New Integrated Terminal`.

- Il est possible d'exécuter un script Python depuis VSCodium en utilisant la commande <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> 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 <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> puis en tapant `Python: Run Selection/Line in Python Terminal`.

:::

## Utiliser des notebooks Jupyter depuis VSCodium

<br>

:::{.medium}


- Ouvrir un notebook Jupyter depuis VSCodium : <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> puis en tapant `Jupyter: Create New Blank Notebook`.

- Exécuter une cellule de code dans un notebook Jupyter : <kbd>Ctrl</kbd> + <kbd>Enter</kbd>.

- Exécuter une cellule de code dans un notebook Jupyter et passer à la cellule suivante : <kbd>Shift</kbd> + <kbd>Enter</kbd>.

- Exécuter une cellule de code dans un notebook Jupyter et créer une nouvelle cellule en dessous : <kbd>Alt</kbd> + <kbd>Enter</kbd>.

:::

<!--

## Utiliser Python depuis Spyder

:::{.medium}

- L'IDE [Spyder](https://www.spyder-ide.org/) permet d'utiliser Python depuis un environnement de développement dédié à la science des données.

- Cet IDE a été installé avec la distribution Anaconda, sur Windows, vous pouvez le lancer depuis le menu Démarrer.

:::

-->

## Exercice 1 - Modifier un fichier texte existant

::::{.columns .small}

:::{.column width="70%"}

**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`).

:::

:::{.column width="30%"}

**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
```

<br />

:::{.small}
**Modèle de programme Python à utiliser** :

```python
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

<br />

:::{.medium}

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.

<br />

Instructions :

- **Récupérez le notebook Jupyter [`ogc-web-services.ipynb`](notebooks/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

<br />

:::{.midly-small}

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.

<br />

Instructions :

- **Récupérer les données d'exemple [`data.zip`](data/data-notebook.zip) et décompresser cette archive.**

- **Récupérez le notebook Jupyter [`geopandas-rasterio.ipynb`](notebooks/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 <img src="images/QGIS_logo_2017.svg" class="w300">

## Pourquoi Python-QGIS ?

<br />

- 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

<br />

:::{.medium}

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](https://qgis.org/pyqgis/master/) pour connaitre les méthodes et les attributs disponibles pour chaque classe.

:::

## Étendre les expressions QGIS avec Python

<br />

:::{.medium}

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.

<br />

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

![](./images/expression-custom-function.png){.bordered}

## Étendre les expressions QGIS avec Python

![](./images/expression-selection.png){.bordered}

## Étendre les expressions QGIS avec Python

![](./images/expression-new-field.png){.bordered}

## Console Python dans QGIS

<br />

:::{.medium}

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 <kbd>Ctrl</kbd> + <kbd>Alt</kbd> + <kbd>P</kbd>`
- en utilisant le bouton <img src="./images/python-console.png" style="display: inline-block; width: 0.8em; height: auto;"/> 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

::::{.medium}

<br />

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

:::{.small}

```python
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()}")
```

:::

<br />

**Exemple 2** : Accéder à la projection du projet

:::{.small}

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

:::

::::

## Exécuter des commandes dans la console Python

::::{.medium}

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

:::{.small}

```python
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

:::{.small}

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

```python
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

:::{.small}

<br />

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

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

<br />

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

```python
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](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

<br />

:::{.medium}

```python
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

:::{.medium}

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

<img src="images/processing-screenshot.png">

:::

## Créer des algorithmes de traitement

::::{.columns .small}

:::{.column width="60%"}

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.

:::

:::{.column width="40%"}

![](images/processingtoolbox.png)

:::

::::

## Créer des algorithmes de traitement

:::{.small}

Ces algorithmes peuvent réutiliser d'autres algorithmes existants déjà dans la boite à outils géotraitement (cf. [exemple dans la documentation](https://docs.qgis.org/3.28/en/docs/user_manual/processing/scripts.html#the-alg-decorator))
ou non (cf. exemple ci-dessous).


```python
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

:::{.medium}

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](https://plugins.qgis.org/).

<br />

:::{.midly-small}
À 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

:::{.medium}

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

![](./images/cartogram-train.png){.bordered}

:::

## Références sur l'API Python de QGIS

<br />

- [PyQGIS developer cookbook (documentation officielle)](https://docs.qgis.org/latest/en/docs/pyqgis_developer_cookbook/index.html)
- [PyQGIS API documentation (documentation officielle)](https://qgis.org/pyqgis/master/)

<br />

- [TP Python pour QGIS (TP de 12h donné en Licence Pro.)](https://mthh.github.io/TP_PythonQGIS/)
- [QGIS tutorials - Rubrique "Python Scripting (PyQGIS)"](https://www.qgistutorials.com/)


# Partie 4 - Mise en pratique

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

## Mise en situation 1

:::{.medium}

**Objectif** : **Étendre les expressions QGIS avec Python**

:::

::::{.columns}

:::{.column .small width="57%"}

**Instructions** :

- **Ouvrez un nouveau projet QGIS et ajoutez les [données d'exemple](data/data-qgis.zip)** _(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.**

:::

:::{.column .very-small width="43%"}

<br />

```python
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

:::{.midly-small}

**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](data/data-qgis.zip)** _(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 <kbd>Ctrl</kbd> + <kbd>e</kbd>.

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

:::{.small}

**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](https://github.com/semiautomaticgit/SemiAutomaticClassificationPlugin/).
- 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.).

![](./images/qgis-plugin-structure.png){.bordered}

:::

# Outro

## Corrections des exercices

<br />

:::{.medium}

### Partie 2

- **Exercice 1** : <a href="corrections/ex1.py" download>Correction</a>
- **Exercice 2** : <a href="notebooks/ogc-web-services-solution.ipynb" download>Notebook</a> / [Version HTML](notebooks/ogc-web-services-solution.html)
- **Exercice 3** : <a href="notebooks/geopandas-rasterio-solution.ipynb" download>Correction</a> / [Version HTML](notebooks/geopandas-rasterio-solution.html)

<br />

### Partie 4

- **Mise en situation 1** : <a href="corrections/qgis-ex1.py" download>Correction</a>
- **Mise en situation 2** : <a href="corrections/qgis-ex2.py" download>Correction</a>

:::

## Références bibliographiques

<!-- Référence will be added here automatically from 'references.bib' -->