Exécuter les outils de géotraitement avec Python
Ouvrir un projet et passer en revue les jeux de données
Avant de commencer à utiliser Python pour exécuter les outils de géotraitement, vous allez télécharger les jeux de données, ouvrir un nouveau projet et vérifier 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é PythonGP (PythonGP).
Dans ce didacticiel, les données sont présentées sur C:\Lessons\PythonGP\. Vous pouvez utiliser un autre dossier, mais veillez à adapter les chemins d’accès dans les instructions qui suivent.
- Démarrez ArcGIS Pro.
- Dans ArcGIS Pro, en regard de Recent Projects (Projets récents), 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 PythonGP.zip (PythonGP.zip), cliquez sur Python Geoprocessing.aprx (Python Geoprocessing.aprx) pour le sélectionner, puis cliquez sur OK (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 PythonGP (PythonGP).
- Développez la géodatabase fichier Toronto.gdb.
La géodatabase contient plusieurs classes d’entités.
- Cliquez avec le bouton droit sur la classe d’entités ambulances (ambulances) et sélectionnez Add To Current Map (Ajouter à la carte actuelle).
Cette classe d’entités représente les emplacements de répartition des ambulances à Toronto.
- Ajoutez les classes d’entités fire_stations (fire_stations) et communities (communautés) à la même carte.
Ces classes d’entités représentent respectivement les limites des casernes de pompiers et des communautés de la ville de Toronto. Dans ce didacticiel, vous allez exécuter des outils de géotraitement sur ces classes d’entités à l’aide de Python.
Exécuter un outil dans la fenêtre Python
L'un des moyens d'exécuter Python dans ArcGIS Pro est la fenêtre Python. Il est conseillé pour commencer à écrire du code Python car il vous propose des conseils de syntaxe.
- Sur le ruban, cliquez sur l’onglet Analysis (Analyse), puis, dans la section Geoprocessing (Géotraitement), cliquez sur la flèche du menu déroulant à droite du bouton Python (Python) et cliquez surPython Window (Fenêtre Python).
Si vous cliquez directement sur le bouton Python (Python), un notebook Python s'ouvre. C’est un autre moyen d’écrire du code Python, mais dans ce didacticiel, vous utiliserez la fenêtre Python. Pour en savoir plus sur l’utilisation des notebooks, reportez-vous au didacticiel Prise en main des notebooks dans ArcGIS Pro.
La fenêtre Python se compose de deux sections. La section supérieure est appelée transcription et la section inférieure, invite. Vous saisissez du code dans la section invite et la section transcription affiche le code exécuté, ainsi que les éventuels messages, tels que les résultats imprimés ou les messages d'erreur.
- Saisissez le code suivant dans la section invite de la fenêtre Python et appuyez sur Entrée :
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.
Remarque :
Comme vous utilisez la fenêtre Python à l'intérieur de ArcGIS Pro, vous pouvez exécuter les outils de géotraitement sans importer ArcPy au préalable. Toutefois, il est conseillé de toujours utiliser import arcpy au début de votre code afin que le même code fonctionne en dehors de ArcGIS Pro.
Le premier outil que vous allez utiliser est l'outil Add XY Coordinates (Ajouter des coordonnées XY). Vous allez ouvrir la table attributaire d'une classe d'entités pour afficher les résultats de l'exécution de l'outil.
- Dans la fenêtre Contents (Contenu), cliquez avec le bouton droit sur la couche ambulances (ambulances) et sélectionnez Attribute table (Table attributaire).
- Organisez l'interface ArcGIS Pro de sorte à pouvoir facilement afficher la carte, la table attributaire de la couche des ambulances et la fenêtre Python.
Vous pouvez organiser l'interface comme vous le souhaitez, mais les cartes et les tables sont souvent affichées dans la partie supérieure et la fenêtre Python, en dessous.
- Saisissez le code suivant dans la section invite de la fenêtre Python et appuyez sur Entrée :
arcpy.management.AddXY("ambulances")
Lorsque vous appuyez sur Entrée, le code est exécuté et les champs POINT_X and POINT_Y sont ajoutés à la table attributaire de la classe d'entités des ambulances.
Exécuter la ligne de code revient à exécuter l'outil Add XY Coordinates (Ajouter des coordonnées XY), comme s'il était exécuté à partir de sa boîte de dialogue. Le code que vous avez exécuté apparaît maintenant dans la section transcription de la fenêtre Python et les résultats de l'exécution de l'outil apparaissent en dessous. Dans le cas présent, l'outil ne génère pas de nouvelle classe d'entités, mais il met à jour la table attributaire de la classe d'entités existante. Le résultat renvoyé par l'outil est une référence à la classe d'entités des ambulances existante dans la carte actuelle.
La ligne de code arcpy.management.AddXY("ambulances") contient plusieurs parties distinctes. La première, arcpy, correspond au module ArcPy, qui permet d'utiliser la plupart des fonctionnalités de ArcGIS Pro dans Python et notamment presque tous les outils de géotraitement. L'élément suivant, management, correspond à l'alias de boîte à outils de la boîte à outils Data Management (Gestion des données), qui contient l'outil Add XY Coordinates (Ajouter des coordonnées XY). L'élément suivant est AddXY, le nom de la fonction ArcPy équivalente à l'outil Add XY Coordinates (Ajouter des coordonnées XY) dans ArcGIS Pro.
Ces parties sont séparées par des points, conformément à la notation par points dans Python, et aucun espace n'est utilisé. Le nom de l'outil est Add XY Coordinates (Ajouter des coordonnées XY) dans ArcGIS, mais le nom de la fonction dans ArcPy est AddXY, sans espace. Les noms de fonction sont parfois identiques au nom d'outil, mais certains utilisent une version abrégée, comme celle-ci. Les noms de fonction Python ne contiennent pas d'espace. Comme il s'agit d'une fonction de ArcPy, elle est suivie de parenthèses (). Des parenthèses ouvrante et fermante sont requises. Ces parenthèses renferment les paramètres de la fonction. Ils sont identiques à ceux de l'outil si la boîte de dialogue de cet outil est utilisée.
Dans le cas de l'outil Add XY Coordinates (Ajouter des coordonnées XY), le seul paramètre est le nom d'une classe d’entités en entrée.
Une autre méthode est disponible pour écrire la syntaxe d'exécution des outils. Vous verrez des exemples de code écrits à l'aide de ces deux méthodes et devez donc les connaître toutes les deux.
- Saisissez le code suivant dans la section invite de la fenêtre Python et appuyez sur Entrée :
arcpy.AddXY_management("ambulances")
Exécuter la ligne de code revient à exécuter de nouveau l'outil Add XY Coordinates (Ajouter des coordonnées XY). Aucune différence n'est visible dans le résultat car les résultats précédents sont écrasés.
Les deux notations peuvent être utilisées indifféremment :
arcpy.<toolboxalias>.<toolname> arcpy.<toolname>_<toolboxalias>la deuxième notation utilise un trait de soulignement et non un point. Cela signifie que arcpy.<toolname>.<toolboxalias> est incorrect et générera une erreur.
- Saisissez le code suivant dans la section invite de la fenêtre Python et appuyez sur Entrée :
arcpy.AddXY.management("ambulances")
Une erreur est générée car la fonction AddXY est introuvable à l'aide de cette notation.
La fenêtre Python dispose de plusieurs entités intégrées pour vous aider à écrire un code sans erreur.
- Saisissez le code suivant et interrompez-vous au niveau du point :
arcpy.
Lorsque vous vous interrompez après le point, une longue liste de suggestions apparaît dans l'ordre alphabétique. Il s'agit d'invites de remplissage automatique de code.
Vous pouvez faire défiler cette liste ou continuer de saisir des caractères. À mesure de la saisie, la liste de suggestions est mise à jour en conséquence.
- Continuez la saisie :
arcpy.man
Cela limite la liste aux éléments de code qui font partie de ArcPy et commencent par les lettres "man".
- Survolez l'entrée management (gestion).
Une petite fenêtre contextuelle avec le nom complet de la boîte à outils apparaît.
- Cliquez sur management (gestion) dans la liste.
L’alias de la boîte à outils suivi d'un point est ajouté :
arcpy.management.
- Saisissez la lettre a et faites défiler la liste jusqu'à AddXY (AddXY), puis cliquez sur AddXY() management (gestion d'AddXY()).
Le nom de l'outil est ajouté et une paire de parenthèses est ajoutée automatiquement.
Le curseur se trouvant entre les parenthèses, une fenêtre contextuelle apparaît avec les noms des deux classes d’entités ponctuelles sur la carte. Sous la ligne de code, une fenêtre contextuelle affiche une brève explication de l'outil. Cette dernière inclut la syntaxe de l'outil, à savoir :
management.AddXY(in_features)
Elle est similaire à celle que vous trouverez dans les pages d'aide de l'outil. L'affichage de la syntaxe à mesure que vous saisissez votre code est pratique. Il existe également une brève explication du premier (et seul) paramètre de l'outil.
Au-dessus de la ligne de code, une fenêtre contextuelle affiche une suggestion pour la valeur du premier paramètre de l'outil. Les entités en entrée de l'outil ne peuvent comporter que des entités ponctuelles. Les valeurs suggérées regroupent toutes les couches d'entités ponctuelles dans la carte ouverte. Dans cet exemple, les couches d'entités ponctuelles sont ambulances (ambulances) et fire_stations (fire_stations). Les communautés des couches de données n'apparaissent pas car il s'agit d'une couche d'entités surfaciques. Ces invites de remplissage automatique de code vous aident à écrire du code correct car elles n'affichent que les entités en entrée significatives.
- Cliquez sur l'entrée fire_stations (fire_stations) dans la fenêtre contextuelle.
Le nom de la couche d’entités est ajouté à la ligne de code et des guillemets sont ajoutés automatiquement.
arcpy.management.AddXY('fire_stations')
Conseil :
Si vous éloignez votre curseur de la fenêtre Python, les fenêtres contextuelles disparaissent. Pour les afficher à nouveau, placez votre curseur dans la ligne de code en dehors des parenthèses, puis à l'intérieur des parenthèses.La ligne de code est maintenant complète.
- Appuyez sur Entrée pour exécuter la ligne de code.
- Dans la fenêtre Contents (Contenu), cliquez avec le bouton droit sur la couche fire_stations (fire_stations) et sélectionnez Attribute table (Table attributaire).
Les champs POINT_X et POINT_Y ont été ajoutés à la classe d’entités.
- Fermez la table attributaire.
Vous allez ensuite utiliser les invites de remplissage automatique de code pour obtenir la syntaxe correcte des outils de géotraitement qui utilisent des paramètres d'outil plus complexes.
Comprendre les paramètres d’outil
L'outil Add XY Coordinates (Ajouter des coordonnées XY) n'utilise qu'un seul paramètre. Le code est donc très court. La plupart des outils de géotraitement possèdent davantage de paramètres, obligatoires et facultatifs. Vous allez examiner l'outil Buffer (Zone tampon) comme exemple d'outil possédant davantage de paramètres.
Vous allez commencer par examiner la syntaxe de l'outil dans la page d'aide.
- Accédez à l’URL suivante :
- Accédez à la section Parameters (Paramètres) et cliquez sur l'onglet Dialog (Boîte de dialogue).
Cette table fournie une explication détaillée des paramètres de l'outil, avec leur type de données. Une bonne connaissance des paramètres de l'outil en facilite l'utilisation dans le code Python.
- Cliquez sur l’onglet Python.
Affiche la syntaxe de l’outil Buffer (Zone tampon) dans Python. L'outil Buffer (Zone tampon) se trouvant dans la boîte à outils Analysis Tools (Outils d'analyse), le code commence par arcpy.analysis. Les paramètres de l'outil Buffer (Zone tampon) sont entre parenthèses. Ils sont identiques à ceux de la boîte de dialogue de l'outil et affichés dans le même ordre. Un nom est affecté à chaque paramètre (par exemple, in_features) et les paramètres sont séparés par une virgule, suivie d'un espace. La désignation des paramètres respecte les conventions des noms de variable dans Python : minuscules uniquement et mots séparés par un trait de soulignement à des fins de lisibilité.
Les outils de géotraitement possèdent des paramètres obligatoires et facultatifs. Les paramètres obligatoires précèdent les paramètres facultatifs. Dans la syntaxe, vous pouvez reconnaître les paramètres facultatifs car ils utilisent des accolades { }. En lisant la syntaxe, vous pouvez déterminer que l'outil Buffer (Zone tampon) possède trois paramètres requis, suivis de cinq paramètres facultatifs.
À chaque paramètre d'outil facultatif correspond une valeur par défaut. Si vous ne spécifiez pas de valeur pour un paramètre facultatif, cette valeur par défaut est utilisée.
Vous allez commencer par exécuter l'outil Buffer (Zone tampon) à l'aide des seuls paramètres obligatoires.
- Dans ArcGIS Pro, dans la Python Window (Fenêtre Python), saisissez le code suivant dans la section d'invite :
arcpy.Buf
- Cliquez sur l'entrée Buffer() analysis (Analyse de Buffer()) dans la liste de la fenêtre contextuelle.
Vous pouvez également utiliser les flèches vers le haut et vers le bas du clavier pour mettre en évidence des éléments de la liste. Une fois qu'une entrée est mise en évidence, appuyez sur la touche Tab pour ajouter l'élément.
L'invite de remplissage automatique est Buffer_analysis, mais le code est ajouté à l'aide de la syntaxe suivante :
arcpy.analysis.Buffer()
N'oubliez pas que arcpy.analysis.Buffer() et arcpy.Buffer_analysis() représentent deux manières différentes de faire référence au même outil. Les deux sont correctes.
Si le curseur se trouve à l'intérieur des parenthèses, la syntaxe de l'outil apparaît en dessous et les couches d’entités suggérées pour le premier paramètre apparaissent au-dessus.
Le premier paramètre de l'outil Buffer (Zone tampon) est appelé in_features. Ce paramètre est affiché en gras dans la fenêtre contextuelle de la syntaxe. Vous trouverez une explication de ce paramètre ci-après. Cet écran est mis à jour à mesure que vous complétez les paramètres de l'outil.
- Dans la fenêtre contextuelle, cliquez sur fire_stations (fire_stations).
Le nom de la couche d’entités est ajouté à la ligne de code et des guillemets sont ajoutés automatiquement.
arcpy.analysis.Buffer('fire_stations')
- Saisissez ensuite une virgule, suivie d'un espace.
arcpy.analysis.Buffer('fire_stations', )
Dans la fenêtre contextuelle de la syntaxe, le prochain paramètre, out_feature_class, est maintenant affiché en gras. Aucune suggestion n'est fournie pour le nom car il s'agit d'une sortie.
- Saisissez 'fire_buffer' entre guillemets pour le nom out_feature_class.
La ligne de code devient :
arcpy.analysis.Buffer('fire_stations', 'fire_buffer')
Vous pouvez utiliser des apostrophes ou des guillemets dans le nom d'une classe d’entités. Lorsque vous sélectionnez une couche dans une liste de couches d’entités suggérées, les invites de remplissage automatique préfèrent les apostrophes, mais vous pouvez changer de style dans une même ligne de code à partir du moment où chaque chaîne est entourée de manière cohérente, soit par des apostrophes, soit par des guillements. Par exemple, la syntaxe suivante est correcte :
arcpy.analysis.Buffer('fire_stations', "fire_buffer")
Toutefois, la syntaxe suivante n'est pas correcte et génère une erreur de syntaxe :
arcpy.analysis.Buffer('fire_stations', 'fire_buffer")
- Remplacez la dernière apostrophe par un guillemet.
Le deuxième paramètre d'outil est mis en évidence en orange, ce qui indique une erreur de syntaxe. Cela est utile car vous savez que cette ligne de code générera une erreur avant même d'essayer de l'exécuter.
- Remplacez le guillemet par une apostrophe.
- Saisissez ensuite une virgule, suivie d'un espace.
Le troisième paramètre est la distance à utiliser dans la création de zones tampon. Il peut s'agir d'une valeur que vous saisissez ou d'un champ dans la table attributaire des entités en entrée. Les suggestions du remplissage automatique de code affichent les champs de la couche d’entités fire_stations (fire_stations). Toutefois, dans le cas présent, vous allez saisir une valeur numérique.
- Saisissez "1000 meters" avec les guillemets.
arcpy.analysis.Buffer('fire_stations', 'fire_buffer', "1000 meters")
La distance est une valeur numérique, mais elle requiert également une unité linéaire. La valeur correspond donc à une chaîne constituée d'un nombre, suivi d'un espace et de l'unité linéaire. Python est généralement sensible à la casse, mais la casse de l'unité importe peu. Par conséquent, vous pouvez utiliser "1000 mètres", "1000 MÈTRES" ou "1000 Mètres" ; les trois chaînes sont correctes. Comme auparavant, vous pouvez utiliser une paire d'apostrophes ou de guillemets ; les deux sont corrects.
Vous savez tout des paramètres obligatoires. L'outil est prêt à être exécuté. Vous pouvez continuer de saisir des valeurs pour les paramètres facultatifs, mais cela n'est pas requis pour exécuter l'outil.
- À la fin de la ligne de code, appuyez sur Entrée pour exécuter l'outil.
L'outil est exécuté, le résultat est imprimé dans la transcription de la fenêtre Python et la classe d’entités résultante est ajoutée à la carte actuelle.
Dans la transcription, sous la ligne de code ayant exécuté l'outil, le résultat de l'exécution apparaît. Dans le cas présent, le résultat de l'outil Buffer (Zone tampon) est une nouvelle classe d’entités. Rappelez-vous que dans l'exemple de l'outil Add XY Coordinates (Ajouter les coordonnées XY), le résultat était une référence à une couche d'entités existante et non à une nouvelle classe d’entités.
Le résultat imprimé affiche l'emplacement de la classe d’entités nouvellement créée :
<Result 'C:\\Lessons\\PythonGP\\Toronto.gdb\\fire_buffer'>
Lorsque vous avez spécifié la classe d’entités en sortie, seul le nom de la classe d’entités a été fourni. Pourquoi la classe d'entités se retrouve-t-elle dans la géodatabase fichier Toronto.gdb ? Car il s'agit de l'espace de travail courant du projet. Le code dans la fenêtre Python respecte les paramètres d'environnement de l'application.
Remarque :
Deux barres obliques inverses (\\) sont utilisées dans le chemin au lieu d'une seule (\). Une barre oblique inverse unique dans Python est utilisée comme caractère d’échappement et peut avoir des conséquences imprévisibles. Au lieu de deux barres obliques inverses, vous pouvez également utiliser la lettre r (raw) avant la chaîne (à savoir, r"C:\Lessons\PythonGP\Toronto.gdb") ou utiliser une barre oblique inverse (à savoir, "C:/Lessons/PythonGP/Toronto.gdb"). Les trois notations sont considérées comme correctes et peuvent être utilisées indifféremment.Vous pouvez exécuter l'outil Buffer (Zone tampon) à l'aide des trois paramètres obligatoires seuls. Vous allez à présent exécuter de nouveau l'outil avec l'un des paramètres facultatifs.
- Examinez de nouveau la syntaxe de l'outil Buffer (Zone tampon) :
arcpy.analysis.Buffer(in_features, out_feature_class, buffer_distance_or_field, {line_side}, {line_end_type}, {dissolve_option}, {dissolve_field}, {method})
Le paramètre intitulé dissolve_option indique le mode de traitement des polygones de zone tampon qui se chevauchent. La valeur par défaut de ce paramètre est NONE, qui signifie que toutes les zones tampon individuelles sont conservées, qu'elles se chevauchent ou non. Vous allez définir cette valeur sur ALL, qui signifie que toutes les entités en sortie seront fusionnées et les éventuels chevauchements, supprimés.
Au lieu de saisir de nouveau le code, vous allez utiliser un raccourci pour récupérer la ligne de code précédente.
- Votre curseur se trouvant dans l'invite, appuyez sur la flèche Haut de votre clavier.
La ligne de code précédente utilisée pour exécuter l'outil Buffer (Zone tampon) est récupérée. Cela fonctionne pour toutes les lignes de code précédentes. Vous pouvez parcourir plusieurs lignes de code à l'aide des flèches Haut et Bas. Une fois que vous avez trouvé la ligne de code qui vous intéresse, vous pouvez effectuer des modifications dans l'invite et appuyer sur Entrée pour exécuter de nouveau le code.
- Placez le curseur à la fin du troisième paramètre, entre le dernier guillemet et la parenthèse fermante.
- Saisissez une virgule, suivie d'un espace.
Affiche les invites de remplissage automatique du paramètre line_side. La valeur par défaut de ce paramètre est Full (Complet) et il est inutile de la modifier. Au lieu de spécifier cette valeur, vous pouvez ignorer le paramètre. Vous pouvez ignorer ce paramètre en spécifiant une chaîne vide.
- Saisissez un guillemet.
Un deuxième guillemet est ajouté automatiquement. Le code se présente maintenant comme suit :
arcpy.analysis.Buffer('fire_stations', 'fire_buffer', "1000 meters", "")
La valeur du paramètre line_side est définie sur "", qui correspond à une chaîne vide. Cela signifie que la valeur par défaut de ce paramètre est utilisée.
Le prochain paramètre est line_end_type, qui peut également être ignoré.
- Placez le curseur à la fin du quatrième paramètre, entre le dernier guillemet et la parenthèse fermante.
- Saisissez une virgule, suivie d'un espace, puis d'un guillemet.
Un deuxième guillemet est ajouté automatiquement. Le code se présente maintenant comme suit :
arcpy.analysis.Buffer('fire_stations', 'fire_buffer', "1000 meters", "", "")
Vous pouvez à présent spécifier la valeur du paramètre dissolve_option.
- Saisissez une virgule, suivie d'un espace, puis d'un guillemet.
- Dans la liste des options qui apparaissent, sélectionnez Dissolve all output features into a single feature (Fusionner toutes les entités en sortie en une seule entité).
Le paramètre est alimenté avec la valeur ALL comme chaîne. Notez que les invites de remplissage automatique fournissent une description plus longue, mais que le code affiche 'ALL'. En effet, le mot-clé du paramètre est ALL et c'est ce que vous trouverez dans la documentation de l'outil. La description plus longue est l'étiquette du mot-clé et correspond aux options de ce paramètre dans la boîte de dialogue de l'outil. Si vous saisissez le code manuellement, vous devez saisir le mot-clé du paramètre comme une chaîne Python (par exemple, 'ALL' ou "ALL").
Le code se présente maintenant comme suit :
arcpy.analysis.Buffer('fire_stations', 'fire_buffer_diss', "1000 meters", "", "", 'ALL')
Enfin, il est utile dans le cas présent de changer le nom de la classe d’entités en sortie afin de la distinguer de la version précédente non fusionnée.
- Remplacez le nom de la classe d’entités en sortie 'fire_buffer' par 'fire_buffer_diss'.
arcpy.analysis.Buffer('fire_stations', 'fire_buffer_diss', "1000 meters", "", "", 'ALL')
L'outil est maintenant prêt à être exécuté.
- Appuyez sur Entrée pour exécuter l'outil.
La classe d’entités résultante est ajoutée à la carte active et les nom et chemin de la classe d’entités en sortie sont imprimés sous la ligne de code. Les zones tampon ont été fusionnées et tous les chevauchements, supprimés.
Vous vous êtes peut-être demandé la raison pour laquelle il était nécessaire d'ignorer les paramètres facultatifs. La raison est la suivante : dans la syntaxe de l'outil, l'ordre des paramètres est prédéfini. Le paramètre dissolve_option est le sixième paramètre dans cet ordre. Si les paramètres ne sont pas explicitement désignés par leur nom, cet ordre doit être conservé. Vous allez voir ce qui se passe lorsque cet ordre n'est pas conservé.
- Votre curseur se trouvant dans l'invite, appuyez sur la flèche Haut de votre clavier pour récupérer la ligne de code précédente.
- Modifiez la ligne de code en supprimant les deux paramètres ignorés. Le code doit se présenter comme suit :
arcpy.analysis.Buffer('fire_stations', 'fire_buffer_diss', "1000 meters", 'ALL')
- Appuyez sur Entrée pour exécuter le code.
Une erreur est générée :
Cela signifie que la valeur ALL est utilisée pour le quatrième paramètre, à savoir line_side. La seule valeur valide de ce paramètre étant Full, l'utilisation de ALL ici génère une erreur.
Au lieu d'utiliser une chaîne vide (""), vous disposez de plusieurs autres options pour ignorer les paramètres facultatifs. Vous pouvez également utiliser le signe dièse ("#") ou la valeur None. Les lignes suivantes sont alors toutes correctes et peuvent être utilisées indifféremment :
arcpy.analysis.Buffer('fire_stations', 'fire_buffer_diss', "1000 meters", "", "", 'ALL')
arcpy.analysis.Buffer('fire_stations', 'fire_buffer_diss', "1000 meters", "#", "#", 'ALL')
arcpy.analysis.Buffer('fire_stations', 'fire_buffer_diss', "1000 meters", None, None, 'ALL')
Le signe dièse doit être placé entre guillemets, à savoir "#" et non#. Le signe dièse sans guillemet étant utilisé pour les commentaires dans Python, il ne peut pas être utilisé ici.
Par contre, la valeur None est utilisée sans guillemet. None est un mot-clé et représente son propre type de données dans Python. Cela diffère d'une chaîne vide, mais a le même effet ici. Une confusion est donc possible car certains paramètres d'outil possèdent "NONE" comme l'une de leurs valeurs possibles. La valeur None est utilisée pour ignorer un paramètre facultatif et signifie en réalité que la valeur par défaut est utilisée. La valeur "NONE" est utilisée pour définir celle du paramètre sur cette valeur spécifique à l'aide d'une chaîne.
Vous avez vu comment utiliser le remplissage automatique pour obtenir la syntaxe correcte d'exécution des outils de géotraitement dans la fenêtre Python (Python). Vous allez à présent découvrir comment spécifier plusieurs paramètres par nom et ajouter plusieurs lignes d'entrées dans la fenêtre Python (Python).
Spécifier des paramètres d’outil par nom
Au lieu d’ignorer les paramètres facultatifs, qui peuvent conserver leur valeur par défaut à l'aide d'une chaîne vide, d'un signe dièse ou de la valeur None, vous pouvez spécifier des paramètres à partir de leur nom.
- Votre curseur se trouvant dans l'invite, appuyez sur la flèche Haut de votre clavier.
- Modifiez la ligne de code comme suit :
arcpy.analysis.Buffer('fire_stations', 'fire_buffer_diss', "1000 meters", dissolve_option='ALL')
Le paramètre dissolve_option est défini sur 'ALL'.
- Appuyez sur Entrée pour exécuter le code.
L'outil est exécuté correctement sans erreur.
Vous avez vu plusieurs solutions permettant d'utiliser des paramètres facultatifs qui requièrent une valeur autre que leur valeur par défaut.
- Ignorer les paramètres facultatifs, qui peuvent conserver leur valeur par défaut à l'aide d'une chaîne vide (""), d'un signe dièse ("#") ou du mot-clé None, jusqu'à ce que vous arriviez au paramètre facultatif qui vous intéresse.
Faire référence au paramètre facultatif qui vous intéresse en spécifiant son nom, sans tenir compte des autres paramètres facultatifs, qui peuvent conserver leur valeur par défaut.
Toutes ces solutions sont correctes et vous pouvez utiliser celle de votre choix. Vous pouvez vous en tenir à un style particulier, mais il est bon de connaître les autres car vous les rencontrerez tous dans du code écrit par des tiers.
Il est possible de faire référence aux paramètres d'outil par leur nom pour les paramètres facultatifs, mais la même approche peut être appliquée à tous les paramètres. Par exemple :
arcpy.analysis.Buffer(in_features='fire_stations', out_feature_class='fire_buffer_diss', buffer_distance_or_field="1000 meters", dissolve_option='ALL')
Par convention, lorsque des paramètres d'outil sont référencés par leur nom, aucun espace n'est utilisé autour de l'opérateur =, bien que l'utilisation d'espaces n'a aucun impact sur l'exécution du code. Sachez également qu'une fois que vous nommez un paramètre, vous devez nommer tous ceux qui le suivent.
Notez que tous ces noms font référence aux noms de paramètre tels qu'ils sont écrits dans l'aide à la syntaxe de l'outil, ce qui est indispensable pour que cela fonctionne.
Le code est donc considérablement plus long, mais la vérification et la compréhension du code sont simplifiées car les paramètres son expliqués dans le code lui-même. Pour les outils relativement simples avec peu de paramètres, ces explications peuvent ne pas être nécessaires. Toutefois, surtout si vous examinez un code existant pour des outils plus complexes comportant un grand nombre de paramètres, ces explications facilitent la compréhension du code sans avoir à consulter la syntaxe.
L'un des inconvénients de l'utilisation des noms de paramètre est la longueur de la ligne de code, qui peut être très importante et dépasser la longueur maximale recommandée de 79 caractères du code Python. La solution consiste à diviser la ligne de code en plusieurs lignes.
arcpy.analysis.Buffer(in_features='fire_stations', out_feature_class='fire_buffer_diss', buffer_distance_or_field="1000 meters", dissolve_option='ALL')Cela divise la ligne de code en plusieurs lignes à des fins de lisibilité, mais le code est toujours exécuté comme une seule ligne de code. Ce style utilise ce que l'on appelle la continuation de ligne implicite. Python requiert de faire suivre la parenthèse ouvrante d'une parenthèse fermante. Cette parenthèse fermante n'apparaissant pas sur la première ligne, les quelques lignes qui suivent sont considérées comme partie intégrante de la même ligne de code jusqu'à la parenthèse fermante. L'espace blanc supplémentaire est utilisé à des fins d'alignement et n'est pas considéré comme une indentation.
Vous allez ensuite créer ces lignes multiples dans la fenêtre Python.
- Ajoutez le code ci-après à la fenêtre Python (sans appuyer sur Entrée).
arcpy.analysis.Buffer(in_features='fire_stations', out_feature_class='fire_buffer_diss', buffer_distance_or_field="1000 meters", dissolve_option='ALL')
La première étape consiste à diviser le code en plusieurs lignes. Pour cela, vous appuyez normalement sur Entrée. Toutefois, dans la fenêtre Python, cette action exécute la ligne de code. Pour ajouter une ligne sans exécuter le code, vous devez appuyer sur Maj+Entrée à la place.
- Placez le curseur de la souris après la virgule qui suit le premier paramètre, in_features='fire_stations',, et appuyez sur Maj+Entrée.
- Ajoutez des espaces avant le nom du deuxième paramètre afin qu'il soit aligné avec le premier.
- Placez le curseur de la souris après la virgule qui suit le deuxième paramètre et appuyez sur Maj+Entrée.
- Placez le curseur de la souris après la virgule qui suit le troisème paramètre et appuyez sur Maj+Entrée.
Chaque paramètre apparaît maintenant sur une nouvelle ligne, mais comme les paramètres se trouvent tous à l'intérieur des parenthèses, Python considère le bloc comme une même ligne de code.
L'alignement des paramètres d'outil améliore la lisibilité.
- Appuyez deux fois sur Entrée pour exécuter l'outil.
Les divers éditeurs Python gèrent la continuation de ligne implicite de manière légèrement différente. Par exemple, lorsque vous écrivez un script dans des éditeurs tels qu'IDLE et PyCharm, il n'est pas nécessaire de saisir le premier ensemble d'espaces ; l'alignement des lignes multiples est automatisé.
Répartir les paramètres sur plusieurs lignes de cette manière peut sembler générer du travail supplémentaire pour un gain de lisibilité. Dans la fenêtre Python, ce gain de lisibilité n'est peut-être pas important, mais si vous écrivez des scipts plus longs dans l'éditeur de scipt, il peut devenir significatif. Il est par ailleurs utile de connaître la continuation de ligne implicite car vous rencontrerez des exemples qui l'utilisent.
Définir un espace de travail
Jusqu'à présent, les exemples ont utilisé la géodatabaseToronto.gdb comme espace de travail. Un espace de travail fournit un emplacement par défaut pour les jeux de données que vous utiliserez dans votre code, notamment les jeux de données en entrée et en sortie des outils de géotraitement. Lorque vous utilisez la fenêtre Python, l'espace de travail est contrôlé par les paramètres d’environnement de ArcGIS Pro. Vous pouvez confirmer l'espace de travail actuel dans la fenêtre Python.
- Saisissez le code suivant dans l'invite et appuyez sur Entrée :
print(arcpy.env.workspace)
Le chemin suivant est renvoyé :
C:\\Lessons\\PythonGP\\Toronto.gdb
Pour modifier l'espace de travail, vous disposez de plusieurs options. Tout d'abord, vous pouvez modifier l'espace de travail de votre projet ArcGIS Pro. Cette solution est pratique si vous utilisez la fenêtre Python, mais elle ne fonctionne pas si vous utilisez le même code Python dans un éditeur Python en dehors de ArcGIS Pro, comme IDLE ou PyCharm. Deuxièmement, vous pouvez utiliser les chemins complets de toutes entrée et sortie comme paramètre d'outil. Cela fonctionne mais génère des chemins très répétitifs et potentiellement longs dans votre code. Votre code est donc moins lisible et moins fiable. Troisièmement, vous pouvez définir l'espace de travail à l'aide d'un code Python, ce qui est recommandé.
Vous allez ajouter une ligne de code pour définir l'espace de travail.
- Saisissez le code suivant dans l'invite :
arcpy.env.workspace =
Vous devez à présent spécifier l'espace de travail sous forme de chaîne Python. Vous pouvez la saisir, mais vous pouvez également faire glisser le chemin depuis la fenêtre Catalog (Catalogue).
- Cliquez sur la géodatabase Results.gdb dans la fenêtre Catalog (Catalogue) et faites-la glisser dans l'invite Python.
Le chemin est ajouté à l’invite.
En plus des espaces de travail, vous pouvez faire glisser des classes d’entités et d'autres éléments de données de votre code dans la fenêtre Python. Il est pratique de pouvoir faire glisser ces éléments car le résultat est un chemin complet avec une mise en forme correcte. Cela permet de gagner du temps et d'éviter les erreurs typographiques.
- Appuyez sur Entrée pour exécuter la ligne de code.
L'espace de travail est défini et remplacé au niveau de l'application. Cela signifie que tout code exécuté dans la fenêtre Python à partir de ce moment utilisera cet espace de travail. L'espace de travail défini sous Environments (Environnements) n'étant pour autant pas modifié, les outils exécutés à partir de leur boîte de dialogue continuent d'utiliser l'espace de travail précédent.
Vous allez à présent exécuter de nouveau l'outil Buffer (Zone tampon) pour constater l'effet de la modification de l'espace de travail.
- Votre curseur se trouvant dans l'invite, appuyez sur la flèche Haut de votre clavier pour récupérer la dernière exécution de l'outil Buffer (Zone tampon).
- Le curseur étant placé à la fin de la ligne de code, appuyez deux fois sur Entrée.
- Développez Results.gdb.
La nouvelle classe d’entités est ajoutée dans cette géodatabase.
.Notez que la classe d’entités en entrée est fire_stations (fire_stations). Cette classe d’entités ne se trouve pas dans l’espace de travail actuel (Results.gdb). Toutefois, fire_stations (fire_stations) est une couche d’entités dans la carte actuelle. Lors de l'exécution d'outils de géotraitement dans la fenêtre Python, vous pouvez utiliser les deux couches d'entités dans la carte actuelle, ainsi que celles sur disque comme entrées. Il est donc primordial de bien comprendre l'espace de travail utilisé.
- Saisissez le code suivant dans l'invite et appuyez sur Entrée :
arcpy.management.AddXY("fountains")
Une erreur est générée :
ERROR 000732: Input Features: Dataset fountains does not exist or is not supported Failed to execute (AddXY).La classe d’entités fountains (fontaines) se trouve dans la géodatabase Toronto, qui n'est plus l'espace de travail de la fenêtre Python. La classe d'entités n'ayant pas été ajoutée à la carte active, elle est introuvable.
Pour utiliser une classe d’entités qui ne se trouve pas dans l'espace de travail, vous devez au préalable l'ajouter à la carte active ou utiliser le chemin complet. Vous allez ajouter le chemin complet.
- Appuyez sur la flèche Haut pour récupérer la ligne de code précédente.
- Supprimez le nom de la classe d’entités ("fountains").
Le code doit maintenant se présenter comme suit :
arcpy.management.AddXY()
- Dans la fenêtre Catalog (Catalogue), développez Toronto.gdb et faites glisser la classe d’entités fountains (fontaines) dans l'invite Python.
Le chemin complet de la classe d’entités fountains (fontaines) est ajouté aux paramètres d'outil.
- Le curseur étant placé à la fin de la ligne de code, appuyez sur Entrée.
L'outil Add XY Coordinates (Ajouter des coordonnées XY) est exécuté sans erreur. Le chemin complet ne remplace l'espace de travail que pour cette ligne de code.
Dans la plupart des scripts, vous commencez par définir l'espace de travail au début de votre script. Il existe un paramètre supplémentaire couramment utilisé. L'une des options d'un projet ArcGIS Pro consiste à autoriser le géotraitement à écraser les jeux de données existants. Cela facilite les exécutions multiples des mêmes outils. Dans Python, vous pouvez définir cette propriété en exécutant cette ligne de code :
arcpy.env.overwriteOutput = True
Un script type utilisant des outils de géotraitement commence souvent ainsi :
import arcpy arcpy.env.workspace = <path to workspace as a string> arcpy.env.overwriteOutput = TrueLe chemin <path to workspace as a string> est remplacé par le véritable chemin de l'espace de travail.
Lorque vous utilisez la fenêtre Python, les importations et environnements sont contrôlés par ArcGIS Pro, ce qui signifie que ces lignes ne sont pas requises. Toutefois, les scripts autonomes dans un éditeur Python comme IDLE et PyCharm requiérant l'utilisation d'importations et la définition d'environnements, il est recommandé de les inclure.
Exportation de code depuis l'historique
Enfin, une dernière approche permet d'obtenir de l'aide lors de l'écriture de code pour exécuter des outils de géotraitement. Vous pouvez exécuter un outil à partir de sa boîte de dialogue et exporter le code de cette exécution de la fenêtre History (Historique) dans la fenêtre Python.
- Dans la fenêtre Catalog (Catalogue), accédez à la géodatabaseToronto.gdb.
- Ajoutez les classes d'entités greenspace (greenspace) et etobicoke (etobicoke) à la carte active.
- Sur le ruban, cliquez sur Analysis (Analyse), puis, dans le groupe Geoprocessing (Géotraitement), cliquez sur Tools (Outils).
- Dans la fenêtre Geoprocessing (Géotraitement), saisissez Clip (Découper) dans la barre de recherche, puis appuyez sur Entrée.
- Double-cliquez sur l’outil Clip (Découper).
- Pour les Input Features (Entités en entrée), sélectionnez greenspace (greenspace).
- Pour les Clip Features (Entités de découpage), sélectionnez etobicoke (etobicoke).
- Pour Output Features or Dataset (Entités ou jeu de données en sortie), accédez à Results.gdb et nommez la classe d’entités en sortie greenspace_clip.
- Cliquez sur Run (Exécuter).
L’outil Clip (Découper) est exécuté et la classe d’entités résultante est ajoutée à la carte.
- Sur le ruban, dans le groupe Geoprocessing (Géotraitement), cliquez sur History (Historique).
La fenêtre Geoprocessing History (Historique de géotraitement) apparaît.
Vous pouvez également cliquer sur Open History (Ouvrir l’historique) dans la partie inférieure de la fenêtre de l'outil Clip (Découper) pour ouvrir l'historique.
- Dans la liste Geoprocessing History (Historique de géotraitement), cliquez avec le bouton droit sur Clip (Découper) et sélectionnez Send To Python window (Envoyer vers la fenêtre Python).
Le code Python permettant d'exécuter l'outil Clip (Découper) est envoyé à la fenêtre Python. Ce code est appelé fragment de code ; il s'agit d'un petit morceau de code.
Remarque :
Les autres options sont Copy Python command (Copier la commande Python) et Save as Python script (Enregistrer comme script Python). Le code résultant est identique, mais ces options sont utiles si vous utilisez un éditeur Python en dehors de ArcGIS Pro ou un notebook.Les premier et deuxième paramètres correspondent aux noms des couches de données d'entité et n'incluent pas de chemin. Le troisième paramètre représente le nom des entités en sortie et inclut un chemin complet. Un espace de travail ayant déjà été défini à l'aide de arcpy.env.workspace, ce chemin n'est pas nécessaire. Le dernier paramètre (Cluster tolerance (Tolérance d’agrégat), qui n'apparaît pas dans la boîte de dialogue de l'outil) conserve sa valeur par défaut None (Aucun) et peut donc être ignoré. Le code peut donc être raccourci.
- Simplifiez le code comme suit :
arcpy.analysis.Clip("greenspace", "etobicoke", "greenspace_clip")
- Exécutez le code pour vérifier qu'il fonctionne.
L'outil Clip (Découper) ayant déjà été exécuté avec les mêmes paramètres, il peut sembler que rien n’ait changé. Vous pouvez le tester en supprimant la couche greenspace_clip (greenspace_clip) de la carte active et en exécutant à nouveau l'outil. Cette fois, vous constatez que la classe d’entités résultante a été ajoutée à la carte.
Vous avez maintenant appris à copier du code Python depuis l'historique de géotraitement après avoir exécuté l'outil à partir de sa boîte de dialogue. Il est utile d'apprendre la syntaxe des outils, mais le code peut nécessiter un nettoyage afin de respecter les bonnes pratiques, comme ignorer les paramètres qui peuvent conserver leur valeur par défaut.
Analyser
- Un code Python peut être utilisé pour exécuter des outils de géotraitement. Bien comprendre un outil de géotraitement facilite l'écriture de ce code.
- La fenêtre Python offre plusieurs entités pour vous aider à écrire du code, notamment diverses invites de remplissage automatique de code et d'autres aides sur la syntaxe.
- Les paramètres d’outil peuvent être requis ou facultatifs. Les paramètres facultatifs ayant conservé leur valeur par défaut peuvent être retirés du code. Lorsqu'un paramètre facultatif doit être utilisé, plusieurs options permettent d'ignorer les autres paramètres facultatifs si nécessaire.
- Les résultats de l'exécution d'un outil à partir de sa boîte de dialogue peuvent être exportés dans le code Python comme point de départ de l'exécution de l'outil à l'aide de Python.
Dans ce didacticiel, vous avez appris à exécuter des outils de géotraitement dans la fenêtre Python et à obtenir de l’aide sur la syntaxe Python. Vous avez découvert les paramètres d'outil, les paramètres obligatoires et facultatifs et la manière de les spécifier. Vous avez appris le comportement des chemins d'accès aux données et des environnements de géotraitement dans la fenêtre Python. Enfin, vous avez appris à copier le code d'un outil de géotraitement exécuté à partir de l'historique de géotraitement dans la fenêtre Python.
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.
