Configurer un projet et passer en revue les jeux de données
Avant de commencer à écrire du code Python, vous allez télécharger les jeux de données, créer un projet et passer en revue les jeux de données à utiliser.
- Téléchargez les données de ce didacticiel et extrayez le contenu dans un emplacement sur votre ordinateur.
Le fichier .zip contient un dossier nommé NotebookStart.
Dans ce didacticiel, les données sont présentées sur C:\Tutorials\NotebookStart\. Vous pouvez utiliser un autre dossier, mais veillez à adapter les chemins d’accès dans les instructions qui suivent.
- Démarrez ArcGIS Pro. Si vous y êtes invité, connectez-vous via votre compte d’organisation ArcGIS sous licence.
Remarque :
Si vous n’avez pas accès à ArcGIS Pro ou ne disposez pas d’un compte d’organisation ArcGIS, consultez les options disponibles pour accéder aux logiciels.
- Cliquez sur Open another project (Ouvrir un autre projet).
- Dans la fenêtre Open Project (Ouvrir le projet), accédez au dossier que vous avez extrait du fichier NotebookStart.zip, cliquez sur le fichier Notebooks Getting Started.aprx pour le sélectionner, puis cliquez sur OK.
Le projet s’ouvre. La carte actuelle montre la limite de la ville de Toronto, au Canada. Vous allez ajouter plusieurs classes d’entités à cette carte.
- Si la fenêtre Catalog (Catalogue) n’est pas visible, cliquez sur l’onglet View (Vue) et sur Catalog Pane (Fenêtre Catalogue).
- Ancrez la fenêtre Catalog (Catalogue) à droite de la carte.
- Dans la fenêtre Catalog (Catalogue), développez Folders (Dossiers), puis développez NotebookStart.
- Développez la géodatabase Toronto.gdb.
La géodatabase contient plusieurs classes d’entités.
- Cliquez avec le bouton droit sur la classe d’entités etobicoke, puis cliquez sur Add To Current Map (Ajouter à la carte actuelle).
Ces polygones représentent plusieurs communautés au sein de la ville de Toronto.
- Ajoutez les classes d’entités fire_stations et greenspace à la carte.
Ces classes d’entités représentent les emplacements des casernes de pompiers et des espaces verts de la ville de Toronto, respectivement. Vous allez utiliser ces classes d’entités pour exécuter divers outils de géotraitement à l’aide de Python.
Créer un notebook et exécuter du code Python
Dans cette section, vous allez créer un notebook dans ArcGIS Pro et l’utiliser pour exécuter du code Python.
- Sur le ruban, cliquez sur l’onglet Analysis (Analyse), puis, dans le groupe Geoprocessing (Géotraitement), cliquez sur la flèche du menu déroulant du bouton Python et cliquez sur Python Notebook (Notebook Python).
Lorsque vous cliquez sur le bouton Python, un nouveau notebook s’ouvre, mais le menu déroulant vous permet de sélectionner un notebook Python ou une fenêtre Python. La fenêtre Python est une autre méthode pour exécuter du code Python dans ArcGIS Pro.
L’affichage du nouveau notebook peut prendre du temps et le message Initializing Kernel (Initialisation du noyau) peut s’afficher pendant que vous attendez. Ce message indique que ArcGIS Pro se prépare à exécuter le code du notebook. Le noyau est un logiciel qui s’exécute en arrière-plan pour exécuter le code Python saisi dans le notebook.
Une fois le notebook ouvert, il apparaît sous la forme d’une nouvelle vue dans la fenêtre principale de ArcGIS Pro.
Le nouveau notebook est stocké en tant que fichier .ipnyb dans le dossier d’accueil de votre projet. Le nouveau notebook s’affiche également dans le dossier Notebooks de la fenêtre Catalog (Catalogue).
- Cliquez dans la cellule vide dans le notebook.
Le contour devient vert.
- Saisissez la ligne de code suivante :
print("Hello Notebook!")
Ce code appelle la fonction print sur un paramètre d’entrée indiqué entre parenthèses. Ce paramètre est une chaîne car il est encadré de guillemets. Les chaînes sont un type de données important et utile que vous pouvez utiliser dans Python.
- Dans la barre d’outils au-dessus de la cellule, cliquez sur le bouton Run (Exécuter).
Le code figurant dans la cellule est exécuté et le résultat est affiché sous la cellule. La fonction print s’exécute sur la chaîne "Hello Notebook!" et l’affiche. Les guillemets ne sont pas affichés car ils ne font pas partie de la chaîne ; ils identifient seulement celle-ci en tant que chaîne. Le chiffre 1 apparaît entre crochets à gauche de la cellule. Une nouvelle cellule vide est ajoutée en dessous
Vous pouvez également exécuter la cellule sélectionnée en appuyant sur Ctrl+Entrée.
Vous pouvez ajouter plusieurs lignes de code dans une cellule en appuyant sur Entrée après chaque ligne. Cela peut sembler contre-intuitif si vous avez l’habitude d’exécuter du code dans la fenêtre Python ou dans la fenêtre interactive d’un éditeur Python, où le fait d’appuyer sur Entrée déclenche l’exécution de la ligne de code.
- Dans la cellule située sous le code Hello Notebook!, saisissez les lignes de code suivantes :
a = 5 b = 7 c = 9 print(a * b * c)
Ce code crée trois variables, a, b et c, puis leur affecte les valeurs 5, 7 et 9. La dernière ligne affiche le résultat de la multiplication des variables.
- Appuyez sur Ctrl+Entrée.
Après l’exécution de la cellule, la valeur 315 s’affiche sous celle-ci. Le chiffre 2 apparaît entre crochets à gauche de la cellule pour indiquer qu’il s’agit de l’exécution de la seconde cellule.
- En haut du notebook, cliquez sur le menu Insert (Insérer), puis sur Insert Cell Below (Insérer une cellule en dessous).
Une nouvelle cellule est ajoutée sous la cellule actuellement sélectionnée.
- Dans la nouvelle cellule, saisissez la ligne de code suivante :
a * b * c
D’après vous, quel sera le résultat de l’exécution de cette cellule ?
- Exécutez la cellule et examinez le résultat.
Le résultat est-il conforme à vos attentes ?
Les valeurs des variables a, b et c sont stockées en mémoire après leur définition, vous pouvez donc les utiliser dans une autre cellule.
Le résultat de la multiplication des valeurs stockées dans a, b et c s’affiche lorsque vous exécutez la cellule.
L’instruction print n’est pas nécessaire car, dans un notebook, dans la fenêtre Python et dans l’interpréteur Python, Python évalue des expressions simples et affiche leur valeur.
- Si vous avez exécuté la cellule en appuyant sur Ctrl+Entrée, insérez une nouvelle cellule sous celle-ci.
Si vous avez exécuté la cellule en appuyant sur le bouton Run (Exécuter), une nouvelle cellule doit déjà avoir été ajoutée sous celle-ci.
- Dans la nouvelle cellule, saisissez la ligne de code suivante :
a * t
D’après vous, quel sera le résultat de l’exécution de cette cellule ?
- Exécutez la cellule et examinez le résultat.
Le résultat est-il conforme à vos attentes ?
La valeur numérique 5 a été affectée à la variable a, mais la nouvelle variable t n’a pas encore été définie. Cela entraîne une erreur. Dans Python, vous ne pouvez pas utiliser des variables tant que vous ne leur avez pas affecté de valeur.
- Mettez à jour le code dans la cellule comme suit :
a * "t"
D’après vous, quel sera le résultat de l’exécution de cette cellule ?
- Exécutez la cellule et examinez le résultat.
Le résultat est-il conforme à vos attentes ?
En plaçant des guillemets autour de la variable t, vous l’avez identifiée pour Python en tant que variable de type chaîne. Python évalue l’expression comme cinq fois la chaîne t, ce qui produit la nouvelle chaîne 'ttttt'.
- Ajoutez une nouvelle cellule et saisissez le code suivant :
t = 10 a * t
D’après vous, quel sera le résultat de l’exécution de cette cellule ?
- Exécutez la cellule.
Le résultat est-il conforme à vos attentes ?
Comme la variable t était définie comme étant égale à 10 sur la première ligne de la cellule, Python l’a multipliée par la valeur de la variable a.
Vous avez ouvert un nouveau notebook dans ArcGIS Pro et vous avez ajouté et exécuté du code Python de base. Ensuite, vous allez utiliser des fonctions de notebook pour gérer le code dans les cellules.
Gérer le code dans les cellules
Dans les Notebooks, le code est exécuté dans des cellules. L’ordre d’exécution des cellules est indiqué par les nombres situés à côté des cellules après l’exécution de celles-ci. Les Notebooks comportent des outils permettant de gérer les cellules. Vous allez maintenant découvrir ces aspects de l’utilisation de Python dans un notebook.
- Dans la cellule vide suivante (ajoutez une nouvelle cellule s’il le faut), saisissez la ligne de code suivante et exécutez la cellule :
mylist = [1, 2, 3, 4, 5]
Que s’est-il passé ?
Ce code a permis de définir une nouvelle variable et sa valeur, mais n’a rien affiché.
La variable mylist est une liste, comme l’indiquent les crochets. Les listes sont un type de données important dans Python, comportant une série d’éléments. Dans ce cas, ces éléments sont des nombres, mais les listes peuvent également contenir d’autres types de données. Les éléments d’une liste sont séparés par des virgules.
- Dans la cellule vide suivante, saisissez le code suivant et exécutez la cellule :
mylist[-1]
Que s’est-il passé ?
Les éléments d’une liste sont indexés, le premier index portant le numéro zéro. Vous pouvez obtenir des éléments spécifiques d’une liste à l’aide de leur numéro d’index. Le numéro d’index -1 correspond au premier élément en partant de la fin de la liste (c’est-à-dire le dernier élément). Le numéro 5 est retourné.
Comme vous l’avez constaté, les invites d’entrée et de sortie de la cellule affichent un nombre après l’exécution de la cellule. Le premier nombre est 1 et il est incrémenté pour les cellules supplémentaires. Ce nombre est incrémenté à chaque fois que vous exécutez une cellule, même si celle-ci a déjà été exécutée. Ces nombres vous aident à suivre l’ordre d’exécution des cellules.
- Modifiez le code dans la cellule qui définit la variable mylist comme suit en ajoutant des éléments, mais n’exécutez pas la cellule.
mylist = [1, 2, 3, 4, 5, 6, 7, 8]
- Cliquez sur la cellule située sous celle-ci, avec le code mylist[-1], puis cliquez sur le bouton Run (Exécuter).
Le résultat correspond-il à ce que vous attendiez ?
Le résultat est le nombre 5. Pourquoi n’est-ce pas le nombre 8 ?
Dans un notebook, le code est entré cellule par cellule et toute variable déjà utilisée est stockée en mémoire.
Jusqu’à ce que vous exécutiez la cellule avec le code qui redéfinit la variable mylist, la valeur de mylist est toujours celle stockée en mémoire, [1, 2, 3, 4, 5], et la valeur à la position -1 de cette liste est toujours 5.
- Cliquez sur la cellule contenant mylist = [1, 2, 3, 4, 5, 6, 7, 8] et exécutez-la.
- Cliquez sur la cellule contenant mylist[-1] et exécutez-la.
La dernière valeur de la liste est désormais 8.
Une alternative à l’exécution de cellules individuelles consiste à sélectionner plusieurs cellules et à les exécuter ensemble, ou à exécuter toutes les cellules d’un notebook en cliquant sur le menu Cell (Cellule), puis sur Run All (Tout exécuter).
Il est conseillé d’organiser les lignes de code associées dans une seule et même cellule. Par exemple, regrouper les deux cellules précédentes dans une seule semble être judicieux. Vous pouvez copier et coller manuellement du code d’une cellule à une autre, mais vous pouvez également combiner des cellules.
- Cliquez sur la cellule qui définit la variable mylist.
Cette cellule contient mylist = [1, 2, 3, 4, 5, 6, 7, 8].
- Cliquez sur le menu Edit (Mettre à jour), puis sur Merge Cell Below (Fusionner la cellule en dessous).
Le résultat est une cellule contenant les lignes de code combinées. Les résultats situés sous les cellules ont été supprimés. Une ligne vide est ajoutée entre les lignes de code des deux cellules fusionnées, mais vous pouvez modifier la cellule pour supprimer cette ligne, si vous le souhaitez.
- Exécutez la cellule fusionnée.
Le menu Edit (Mettre à jour) propose de nombreuses fonctions utiles pour manipuler les cellules de votre notebook. Vous pouvez copier et coller des cellules, les supprimer, les diviser et les fusionner, puis déplacer une cellule sélectionnée vers le haut ou le bas, par rapport aux autres cellules.
Les menus View (Afficher), Insert (Insérer) et Cell (Cellule) permettent d’accéder à des outils supplémentaires.
Certains des outils les plus fréquemment utilisés sont également disponibles sous forme de boutons dans la barre d’outils du notebook.
On compte les suivantes :
- Insérer une cellule en dessous
- Couper les cellules sélectionnées
- Copier les cellules sélectionnées
- Coller les cellules en dessous
- Déplacer les cellules sélectionnées vers le haut
- Déplacer les cellules sélectionnées vers le bas
D’autres outils sont disponibles dans la Command Palette (Palette de commandes).
- Cliquez sur le bouton Command Palette (Palette de commandes).
Une liste de commandes s’affiche.
Vous pouvez exécuter une commande en cliquant sur celle-ci. La commande est appliquée aux cellules sélectionnées du notebook, ou à toutes les cellules, selon la commande.
- Dans la Command Palette (Palette de commandes), cliquez sur clear all cells output (effacer la sortie de toutes les cellules).
Le code reste inchangé, mais toutes les sorties sont supprimées. Les invites d’entrée et de sortie sont vides, étant donné qu’aucune cellule n’a été exécutée. Lorsque vous exécutez une cellule, les invites reprennent à 1.
La Command Palette (Palette de commandes) contient également des raccourcis pour la plupart des tâches.
- Cliquez sur le bouton Command Palette (Palette de commandes) et faites défiler vers le bas jusqu’à insert cell below (insérer une cellule en dessous).
Le raccourci clavier de cette commande est affiché à droite de celle-ci. Le raccourci est la lettre B lorsque la cellule du notebook est en mode commande.
- Masquez la Command Palette (Palette de commandes) en cliquant en dehors de celle-ci, mais à l’intérieur du notebook.
- Cliquez sur l’espace à gauche de la deuxième cellule ; celle-ci devient bleue.
Veillez à ne pas cliquer dans la section de code, ce qui entraînerait l’affichage de la cellule en vert.
La bordure de la cellule est bleue pour indiquer que celle-ci est en mode commande.
- Appuyez sur la touche B du clavier.
Une nouvelle cellule est insérée sous la cellule sélectionnée. Si la cellule avait été verte, vous auriez ajouté la lettre b au code dans la cellule.
Ces raccourcis ne sont pas sensibles à la casse, b et B sont donc équivalents.
Il n’est pas nécessaire de mémoriser ces commandes, mais les codeurs expérimentés le font pour travailler plus rapidement. Pour la plupart des tâches de base, les boutons et les options de menu du notebook fonctionnent très bien.
Si vous recherchez la commande associée à une tâche spécifique, vous pouvez utiliser la barre de recherche située en haut de la Command Palette (Palette de commandes).
- Ouvrez la Command Palette (Palette de commandes) et entrez run (exécuter) dans la zone Search (Rechercher).
La liste affiche les outils dont le nom contient run (exécuter). Certains outils disposent d’un raccourci. Par exemple, le raccourci de run selected cells (exécuter les cellules sélectionnées) est Ctrl +Entrée.
- Masquez la Command Palette (Palette de commandes) en cliquant en dehors de celle-ci, mais à l’intérieur du notebook.
- Fermez le notebook.
Vous avez appris à saisir et à modifier du code Python dans les cellules d’un notebook, et à interagir avec le notebook pour exécuter et gérer le code. Vous allez ensuite utiliser un notebook pour exécuter des outils de géotraitement dans ArcGIS Pro.
Exécuter des outils de géotraitement dans un notebook
Maintenant que vous avez appris à entrer du code dans un notebook, il est temps d’utiliser certains outils de géotraitement. Vous allez commencer avec un nouveau notebook.
- Cliquez sur l’onglet Analysis (Analyse) et, dans le groupe Geoprocessing (Géotraitement), cliquez sur Python.
Le nouveau notebook s’affiche.
- Dans la fenêtre Cataog (Catalogue), développez la section Notebooks.
- Cliquez avec le bouton droit de la souris sur le nouveau notebook, New Notebook (1).ipynb, puis cliquez sur Rename (Renommer).
- Saisissez geoprocessing_demo et appuyez sur Entrée.
Le nouveau notebook est renommé. Dans la fenêtre Catalog (Catalogue), vous voyez que l’extension .ipynb a été ajoutée automatiquement au nom du fichier. L’onglet du notebook s’intitule désormais geoprocessing_demo.
Pour les étapes suivantes, il est utile d’afficher la carte et le notebook côte à côte.
- Faites glisser l’onglet geoprocessing_demo vers la cible d’ancrage qui s’affiche en dessous.
Le notebook est ancré sous la carte. Vous pourrez ainsi voir les résultats de votre code lorsque vous utiliserez Python dans le notebook pour appliquer des opérations aux classes d’entités dans la carte.
- Dans la cellule vide, saisissez la ligne de code suivante et exécutez la cellule :
import arcpy
Cette ligne de code importe le paquetage ArcPy. ArcPy est un paquetage Python qui met à disposition la plupart des fonctionnalités de ArcGIS Pro dans Python, y compris le géotraitement.
Comme vous utilisez ce notebook dans ArcGIS Pro, le code qui utilise des outils de géotraitement ne produit pas d’erreur si vous n’avez pas importé ArcPy. Toutefois, il est conseillé de toujours faire figurer import arcpy en haut de votre code de géotraitement, afin qu’il fonctionne également lorsqu’il est exécuté en dehors de ArcGIS Pro.
- Dans la même cellule, ajoutez une nouvelle ligne et saisissez le code suivant :
arcpy.GetCount_management("fire_stations")
Ce code utilise ArcPy pour exécuter l’outil Get Count (Compter) pour calculer le nombre d’entités dans la classe d’entités fire_stations.
- Exécutez la cellule.
GetCount est une fonction de ArcPy qui exécute l’outil de géotraitement Get Count (Compter) disponible dans la boîte d’outils Data Management Tools (Outils de gestion des données).
Le résultat s’affiche sous la cellule de code. Il y a 84 lignes (entités) dans la classe d’entités. Ces résultats sont semblables aux messages que vous voyez après l’exécution d’un outil à partir de la boîte de dialogue de l’outil dans ArcGIS Pro. Les Notebooks sont intégrés dans la structure de géotraitement de ArcGIS Pro. Cela signifie que l’exécution d’un outil dans un notebook est semblable à son exécution dans la boîte de dialogue de l’outil. Tout outil que vous exécutez dans un notebook s’affiche également dans la fenêtre History (Historique).
- Sur le ruban, cliquez sur l’onglet Analyse. Dans le groupe Géotraitement, cliquez sur Historique.
L’outil apparaît dans l’historique de géotraitement.
- Fermez la fenêtre History (Historique)
- Modifiez la ligne de code arcpy.GetCount comme suit :
arcpy.GetCount_management("ambulances")
- Exécutez la cellule.
Ce code échoue avec un message d’erreur. À la fin du message, les informations suivantes s’affichent :
ExecuteError: Failed to execute. Parameters are not valid. ERROR 000732: Input Rows: Dataset ambulances does not exist or is not supported Failed to execute (GetCount).
Pourquoi le code a-t-il échoué, alors que le code de calcul du nombre de casernes de pompiers a fonctionné ?
La classe d’entités fire_stations est une couche de la carte active. Dans un notebook, vous pouvez faire référence à un jeu de données à l’aide du nom de la couche dans la carte active, comme lorsque vous exécutez un outil de géotraitement à partir de son interface utilisateur graphique.
La classe d’entités ambulances ne figure pas dans la carte active en tant que couche, et il ne s’agit pas non plus d’une classe d’entités de la géodatabase par défaut du projet. Vous pouvez désigner une classe d’entités qui ne se trouve pas dans la carte active ni dans la géodatabase par défaut en indiquant son chemin d’accès complet.
Ensuite, vous allez rechercher le chemin d’accès de la classe d’entités ambulances.
- Dans la fenêtre Catalog (Catalogue), développez la section Databases (Bases de données), puis Toronto.gdb.
- Cliquez avec le bouton droit de la souris sur ambulances, puis cliquez sur Copy Path (Copier le chemin d’accès).
Le chemin d’accès à la classe d’entités ambulances est copié. Ce chemin d’accès contient également le nom de la classe d’entités.
Le chemin d’accès de cet exemple est le suivant :
C:\Tutorials\NotebookStart\Toronto.gdb\ambulances
Sur votre ordinateur, le chemin d’accès sera différent, selon l’emplacement où vous avez décompressé le fichier .zip contenant les données, et la façon dont vous l’avez fait. Par exemple, il est possible que vous n’ayez pas placé les données sur le lecteur C, ni dans un dossier nommé Tutorials (Didacticiels). À l’étape suivante, indiquez le chemin d’accès utilisé sur votre ordinateur.
- Cliquez dans la cellule de notebook et mettez en évidence ambulances. Collez le chemin d’accès que vous avez copié.
arcpy.GetCount_management("C:\Tutorials\NotebookStart\Toronto.gdb\ambulances")
La cellule est presque prête à être exécutée. Le chemin d’accès semble correct, mais il ne l’est pas. Un élément est manquant.
- Cliquez juste après la parenthèse ouvrante et avant le premier guillemet, puis entrez la lettre r.
arcpy.GetCount_management(r"C:\Tutorials\NotebookStart\Toronto.gdb\ambulances")
Vous devez entrer la lettre r pour indiquer à Python que ce chemin d’accès est une chaîne brute. Les ordinateurs Windows utilisent une barre oblique inverse comme séparateur dans un chemin. Dans Python, la barre oblique inverse est un caractère d’échappement qui, lorsqu’il est placé à côté d’autres caractères dans une chaîne, encode une tabulation, un saut de ligne ou un autre caractère spécial. Ainsi, lorsque \N apparaît dans le chemin d’accès (\NotebookStart), Python comprend que cette chaîne comporte un saut de ligne. Placer la lettre r devant la chaîne indique à Python d’ignorer les caractères d’échappement.
- Exécutez la cellule.
L’outil Compter est exécuté et renvoie un message indiquant que la classe d’entités contient 48 entités.
Vous pouvez également utiliser une barre oblique (/) comme séparateur de chemin dans le code Python, ou doubler les barres obliques inverses.
Les notations suivantes du chemin d’accès sont toutes valides dans Python :
r"C:\Tutorials\NotebookStart\Toronto.gdb\ambulances" "C:/Tutorials/NotebookStart/Toronto.gdb/ambulances" "C:\\Tutorials\\NotebookStart\\Toronto.gdb\\ambulances"
Si vous utilisez une barre oblique (/) ou deux barres obliques inverses (\\) comme séparateur, il n’est pas nécessaire d’ajouter la lettre r devant la chaîne du chemin d’accès.
Pour un utilisateur habitué aux chemins Windows délimités par des barres obliques inverses, cette règle peut être déroutante, mais il est important de s’en souvenir.
Un moyen d’éviter de spécifier des chemins d’accès complets pour les outils consiste à définir l’espace de travail.
- Modifiez le code pour ajouter une ligne entre les deux lignes commençant par import arcpy et arcpy.GetCount. Ajoutez la ligne suivante :
arcpy.env.workspace =
Cette ligne définit une propriété de la classe d’environnement, arcpy.env, comme étant égale à une valeur donnée. Vous allez ensuite couper le chemin de Toronto.gdb et le coller après ce code pour définir le chemin d’accès.
- Coupez le chemin de la géodatabase, y compris l’extension .gdb, à partir de la ligne arcpy.GetCount, puis collez-le après le signe égal.
arcpy.env.workspace = r"C:\Tutorials\NotebookStart\Toronto.gdb
N’oubliez pas que votre chemin d’accès peut être différent de celui indiqué ici. Indiquez le chemin d’accès utilisé sur votre ordinateur.
Il reste encore quelques modifications à apporter. Savez-vous lesquelles ?
Si vous exécutez le code tel quel, une erreur de syntaxe semblable à la suivante s’affichera :
EOL signifie fin de ligne, et ce message indique que Python a atteint la fin de la ligne de code lors du traitement de la chaîne sur la ligne 2. Pour terminer le chemin, un autre guillemet est requis.
- Ajoutez un guillemet pour terminer la chaîne.
La ligne doit maintenant se présenter comme suit :
arcpy.env.workspace = r"C:\Tutorials\NotebookStart\Toronto.gdb"
La deuxième ligne est terminée et correcte. Une autre modification est nécessaire, savez-vous laquelle ?
- Remplacez la barre oblique inverse avant ambulances par un guillemet.
Le code est maintenant prêt à être exécuté.
- Exécutez la cellule.
L’exécution doit se dérouler correctement et le résultat indiquant le nombre d’entités de la classe d’entités ambulances doit s’afficher.
La géodatabase Toronto comporte plusieurs classes d’entités. À présent, vous pouvez déterminer le nombre d’entités dans chacune d’elles.
- Insérez une nouvelle cellule dans le notebook, copiez et collez la ligne GetCount dans une nouvelle cellule, modifiez le nom en bikeways, puis exécutez la cellule.
arcpy.GetCount_management("bikeways")
Vous pouvez avoir besoin de savoir combien d’entités comporte chaque classe d’entités de la géodatabase. Vous pouvez copier la cellule et modifier le nom de la classe d’entités, mais Python vous permet d’obtenir une liste de toutes les classes d’entités, puis d’exécuter la fonction GetCount sur celles-ci.
- Insérez une nouvelle cellule dans le notebook et ajoutez le code suivant :
# List the feature classes in a workspace # works on the current workspace or a path fc_list = arcpy.ListFeatureClasses() # Print the list print(fc_list) # use a loop to set the variable fc to be # equal to each feature class name in the list for fc in fc_list: # Run Get Count on the current fc from the list # Set the variable count equal to the result of Get Count count = arcpy.GetCount_management(fc) # Print out the name of the feature class and the count print(fc, count)
Ce code contient des commentaires expliquant ce que fait chaque étape. Ces commentaires figurent après les signes #. Les lignes de commentaires ne sont pas exécutées ; elles vous aident à comprendre ce que fait le code.
Vous avez déjà utilisé une liste et l’indexation de liste. Ce code crée une variable nommée fc_list et la définit comme étant égale au résultat de l’exécution d’arcpy.ListFeatureClasses sur l’espace de travail actuel, Toronto.gdb. La liste précédente contenait des entiers. Cette fois, la liste contient des chaînes correspondant aux noms des classes d’entités.
Ensuite, le code affiche cette liste. L’affichage de la liste n’est pas nécessaire, mais il permet de vérifier que la variable contient les résultats attendus. En cas de problème, il est utile de savoir ce que contient la variable.
La partie suivante du code utilise une boucle for. Les boucles for exécutent un bloc de code indenté sur chaque entrée d’un ensemble d’entrées.
Dans ce cas, les entrées sont les noms figurant dans la liste. La variable fc prend comme valeur chaque entrée de la liste, et le code du bloc indenté est exécuté.
Le bloc de code crée une variable nommée count, qui prend comme valeur le résultat de l’appel de GetCount sur l’élément en cours de la liste.
Le bloc de code affiche ensuite le nom de la classe d’entités (le contenu de la variable fc) et le nombre (contenu de la variable count).
Le code, sans commentaires, ne comprend que quelques lignes.
fc_list = arcpy.ListFeatureClasses() print(fc_list) for fc in fc_list: count = arcpy.GetCount_management(fc) print(fc, count)
- Exécutez la cellule.
Les résultats montrent la liste des classes d’entités de la géodatabase et le nombre d’entités qu’elles contiennent.
Exécuter une analyse à l’aide d’un notebook
Vous allez ensuite procéder à des analyses SIG à l’aide du notebook. Supposons que vous souhaitiez identifier les zones du district administratif d’Etobicoke qui sont les plus éloignées des casernes de pompiers. Pour ce faire, vous pouvez utiliser des outils de géotraitement dans un notebook.
- Ajoutez une cellule en dessous de la cellule en cours.
- Placez le curseur dans la cellule et entrez ce qui suit :
arcpy.
- Appuyez sur la touche Tab.
La liste des options ArcPy disponibles s’affiche.
Vous pouvez faire défiler la liste vers le bas et cliquer sur un élément pour le sélectionner, ou vous pouvez continuer votre saisie.
- Entrez un B majuscule.
- Cliquez sur Buffer_Analysis.
La cellule contient maintenant arcpy.Buffer_analysis.
L’opération consistant à commencer à entrer du code et à appuyer sur Tab pour afficher des options correspondantes et les sélectionner s’appelle complétion automatique. Elle vous permet de trouver les commandes dont vous avez besoin et d’y accéder plus rapidement.
- Une fois le curseur placé à la fin de la ligne de code, appuyez sur Maj+Tab.
Une fenêtre contenant les conseils de syntaxe de l’outil Buffer_analysis s’affiche. Vous pouvez cliquer sur la flèche pour agrandir cette fenêtre et lire la rubrique entière.
- Cliquez sur le bouton de fermeture pour fermer la fenêtre Signature.
- Entrez une parenthèse ouvrante.
Une parenthèse fermante est également ajoutée et le curseur est placé entre les deux. Vous pouvez ajouter des paramètres pour l’outil Buffer_analysis à cet endroit.
- Entrez un guillemet.
Un deuxième guillemet est ajouté. Pour Python, les chaînes doivent être encadrées de guillemets, c’est pourquoi il en ajoute un second, et place le curseur entre les deux.
Les trois paramètres requis par l’outil Buffer_analysis sont la classe d’entités en entrée, la classe d’entités en sortie et la distance de la zone tampon. Seuls ces paramètres sont obligatoires. Il en existe d’autres, mais ils sont facultatifs.
Vous allez créer une zone tampon pour la classe d’entités fire_stations, nommer la classe d’entités en sortie fire_buffer, et spécifier une distance de zone tampon de 1 000 mètres pour les casernes de pompiers.
- Complétez la ligne de code comme suit :
arcpy.Buffer_analysis("fire_stations", "fire_buffer", "1000 METERS")
Les trois paramètres de l’outil sont des chaînes. L’outil peut localiser la classe d’entités fire_stations à l’aide de son nom uniquement car il s’agit d’une couche de la carte, et parce que vous avez défini l’espace de travail sur Toronto.gdb. L’outil peut écrire une classe d’entités en sortie en utilisant seulement le nom "fire_buffer" car l’espace de travail est défini. L’outil comporte une logique intégrée permettant de détecter la distance de la zone tampon et les unités de mesure dans la chaîne "1000 METERS".
- Exécutez l'outil.
Les entités en sortie sont ajoutées à la carte.
Les résultats montrent les zones situées à 1 000 mètres (1 kilomètre) ou moins d’une caserne de pompiers, et celles qui ne le sont pas. Laisser ouverts le notebook et la carte en même temps permet de visualiser facilement les résultats de différentes options.
- Indiquez une distance de zone tampon de 1 750 mètres et réexécutez la cellule.
arcpy.Buffer_analysis("fire_stations", "fire_buffer", "1750 METERS")
Remarque :
Si le message d’erreur « ExecuteError: Failed to execute. Parameters are not valid (ExecuteError : exécution impossible). Les paramètres ne sont pas valides » s’affiche et mentionne que fire_buffer existe déjà, vos paramètres d’environnement ArcGIS Pro, geoprocessing options, ne sont pas définis de manière à autoriser l’écrasement des classes d’entités existantes. Pour résoudre ce problème, insérez une nouvelle ligne dans la cellule avant la ligne arcpy.Buffer_analysis. Sur la nouvelle ligne, ajoutez le code suivant :
arcpy.env.overwriteOutput = True
Cela permettra à l’outil Buffer (Zone tampon) d’écraser la sortie précédente. La cellule devrait maintenant contenir :
arcpy.env.overwriteOutput = True arcpy.Buffer_analysis("fire_stations", "fire_buffer", "1750 METERS")
Exécutez la cellule.
Les secteurs situés en dehors de ces zones tampons sont les plus éloignés des casernes de pompiers, ce qui peut rallonger le délai d’intervention après un appel. Pour identifier les secteurs concernés, plutôt que ceux qui ne le sont pas, utilisez l’outil d’effacement pour supprimer les secteurs au sein des zones tampons du district administratif d’Etobicoke.
- Ajoutez une cellule et saisissez le code suivant :
arcpy.PairwiseErase_analysis("etobicoke", "fire_buffer", "no_service")
Ce code lance l’outil PairwiseErase_analysis sur la classe d’entités etobicoke, en efface les secteurs de la classe d’entités fire_buffer, puis écrit les résultats dans une nouvelle classe d’entités nommée "no_service".
Effacement deux par deux est une version alternative de l’outil Effacer, qui utilise un autre jeu de bibliothèques et gère les relations topologiques des sommets différemment de l’outil Effacer. Si vous avez des doutes sur la qualité de vos jeux de données en entrée, avant d’exécuter Effacement deux par deux, vous devez exécuter l’outil Intégration deux par deux sur vos données. Dans cette situation simple, cela n’est pas nécessaire.
- Exécutez la cellule.
- Dans la fenêtre Contents (Contenu), désélectionnez les couches fire_buffer, greenspace, etobicoke et boundary.
- Cliquez avec le bouton droit de la souris sur la couche no_service et sélectionnez Zoom To Layer (Zoom sur la couche).
La couche no_service affiche les emplacements les plus éloignés des casernes de pompiers.
- Cliquez sur la cellule arcpy.PairwiseErase_analysis puis, dans la fenêtre Notebook, cliquez sur le menu Edit (Mettre à jour) et sélectionnez Merge Cell Above (Fusionner la cellule au-dessus).
Les cellules sont fusionnées.
Un avantage des Notebooks, et du code Python en général, est qu’ils permettent d’exécuter rapidement une séquence d’outils. Dans ce cas, la séquence est composé de deux outils seulement, mais cela permet d’illustrer le concept.
- Modifiez la valeur de distance de 1 750 en 2 500 et exécutez la cellule.
- Désactivez la nouvelle couche fire_buffer pour voir la nouvelle couche no_service.
Vous devrez peut-être zoomer sur la couche pour voir les autres zones plus petites.
Le résultat montre les zones susceptibles d’être les plus défavorisées en termes de services de pompiers. Vous avez obtenu ce résultat mis à jour en exécutant plusieurs lignes de code dans une seule cellule du notebook. Si vous aviez utilisé les outils à partir de leur interface graphique, vous auriez dû réexécuter à la fois Zone tampon et Effacement deux par deux pour obtenir le résultat mis à jour.
Avec deux outils seulement, le gain de temps est minime, mais de nombreux processus sont composés de séquences d’outils plus longues. En outre, Python permet d’exécuter un outil ou plusieurs au sein d’une boucle, ce qui est utile si vous devez exécuter le même processus sur plusieurs entrées.
- Enregistrez votre projet.
Code Python exécuté à l’intérieur et à l’extérieur de notebooks
Vous avez appris à créer un notebook et à écrire et exécuter du code Python dans un notebook. L’utilisation de Notebooks présente plusieurs avantages, qui ne sont pas tous décrits dans ce didacticiel :
- Les Notebooks permettent de se familiariser rapidement avec l’écriture de code Python et ils ne nécessitent pas d’installer ou de configurer un éditeur Python.
- Vous pouvez interagir avec les données et les cartes directement dans ArcGIS Pro. Cela vous permet de visualiser rapidement les résultats de l’exécution de votre code.
- Les Notebooks sont intégrés dans la structure de géotraitement de ArcGIS Pro. Ainsi, l’expérience d’utilisation des outils dans les notebooks est semblable à leur exécution à partir de la boîte de dialogue associée. Les résultats sont ajoutés à la carte active et les outils exécutés apparaissent dans l’historique de géotraitement.
- Les Notebooks dans ArcGIS Pro proposent plusieurs fonctions de complétion qui facilitent l’écriture de code correct.
- Les Notebooks peuvent également être exécutés en dehors de ArcGIS Pro, y compris certains éditeurs Python et Jupyter Notebook.
- Les Notebooks incluent des outils de visualisation intégrés (par exemple, des widgets de carte et autres).
- Tous les contenus sont enregistrés sous forme de fichiers .ipynb pouvant être partagés.
- Les Notebooks peuvent être hébergés dans ArcGIS Enterprise ou ArcGIS Online. Vous pouvez ainsi rendre un fichier .ipynb disponible pour les autres utilisateurs de votre organisation.
Il existe également des inconvénients potentiels à l’exécution de code Python dans un Notebooks :
- Il manque dans les Notebooks certaines fonctions disponibles dans d’autres environnements IDE Python, telles que la vérification de syntaxe, le débogage, etc.
- L’aide à la complétion de code nécessite des raccourcis clavier et n’est pas aussi intuitive ni performante que dans d’autres éditeurs Python.
- Toutes les fonctions de Jupyter Notebook ne fonctionnent pas dans ArcGIS Pro (mais des améliorations sont en cours).
Il existe plusieurs autres moyens d’exécuter du code Python : exécution dans un Notebooks, exécution d’un script à l’aide d’une ligne de commande ou programmation de l’exécution d’un script à partir du système d’exploitation. Ces aspects sont abordés dans d’autres didacticiels.
Vous avez appris à écrire et exécuter du code Python dans un notebook dans ArcGIS Pro. Vous avez découvert les variables et les boucles, deux concepts très importants dans Python. Vous avez également appris à définir l’environnement dans Python, et à utiliser les outils de géotraitement ArcGIS standard dans Python. Ce didacticiel est le deuxième d’une série consacrée à l’utilisation de Python dans ArcGIS Pro. D’autres didacticiels seront bientôt disponibles.
Les documentations Script pour Python pour ArcGIS Pro et Script Python avancé pour ArcGIS Pro par le Dr Paul A. Zandbergen, publiées par Esri Press, peuvent vous intéresser également.