Conseils et astuces Python dans ArcGIS

TravisOrmsby

Découvrez le séminaire de formation Python Tips and Tricks for ArcGIS où @DerekNelson1 et moi-même présentons des dizaines de stratégies pour vous aider à automatiser des tâches répétitives et des flux de travail complexes.

Recherchez des solutions existantes avant de repartir de zéro.

Il y a de fortes chances que quelqu’un d’autre ait rencontré un problème similaire et créé un module Python que vous pouvez utiliser pour aider à résoudre ce problème. 

ArcPy est destiné aux types de tâches que vous feriez dans ArcGIS Pro.

Si vous cherchez à automatiser des tâches de géotraitement ou à travailler avec des fichiers locaux et des bases de données, la bibliothèque ArcPy dispose de fonctions Python qui reproduisent ce que vous pouvez faire manuellement dans l’interface graphique utilisateur.

L’ArcGIS API for Python est destinée aux types de tâches que vous feriez dans votre portail.

L’automatisation de la gestion des utilisateurs, groupes et contenus dans votre portail ArcGIS Online ou ArcGIS Enterprise est un excellent cas d’utilisation pour l’ArcGIS API for Python. L’API Python dispose également d’outils pour créer un Spatially Enabled DataFrame à partir de données locales ou de services d’entités. Il s’agit d’une extension d’un Pandas DataFrame, donc elle bénéficie de toute la puissance de la manipulation tabulaire des données Pandas ainsi que des propriétés et méthodes spatiales pour gérer les données géographiques.

Les Notebooks sont excellents pour enseigner, partager et raconter des histoires avec du code.

La possibilité de découper le code en cellules, d’ajouter du markdown pour expliquer le code, et d’inclure la sortie dans le notebook en fait des outils puissants pour aider à itérer sur votre code et aider les autres à comprendre le contexte et l’importance du travail représenté dans le notebook.

Un IDE dispose d’outils puissants pour faciliter l’écriture du code.

Un environnement de développement intégré comme PyCharm ou VS Code inclut des outils sophistiqués de débogage, la détection d’erreurs et d’avertissements, le linting automatisé, et des outils utiles d’auto-complétion pour faciliter l’écriture de beaucoup de code. Il devient même courant que les IDE intègrent des assistants IA pour accélérer encore plus le développement.

Gérer un environnement Python est difficile. Attendez-vous à rencontrer des défis.

Chaque module dans un environnement Python doit être compatible avec tous les autres modules. Il peut être facile de casser accidentellement votre environnement de manière subtile.

Utilisez l’environnement Python par défaut d’ArcGIS Pro pour minimiser les défis.

Heureusement, l’environnement arcgispro-py3 fourni avec ArcGIS Pro contient un ensemble de packages sélectionnés par les développeurs Esri qui comprend les bibliothèques dont vous aurez besoin pour la grande majorité des tâches SIG. Comme vous ne pouvez pas modifier cet environnement par défaut, vous aurez toujours au moins un environnement Python fonctionnel si vous travaillez avec ArcGIS Pro.

Clonez l’environnement par défaut pour créer un environnement personnalisé.

Dans les cas où vous avez besoin de bibliothèques supplémentaires qui ne sont pas incluses avec arcgispro-py3, vous pouvez cloner l’environnement par défaut et ajouter ces bibliothèques depuis le Gestionnaire de Packages dans l’onglet Projet d’ArcGIS Pro. Vous avez accès à des milliers de bibliothèques Python via conda que vous pouvez installer depuis l’interface.

Utilisez conda pour une gestion avancée des environnements. Évitez pip si possible.

Certaines tâches avancées nécessitent une gestion plus complexe des environnements que ce qui peut être fait via l’interface ArcGIS Pro. Vous pouvez accéder à conda depuis l’invite de commande pour ces tâches, comme spécifier un canal particulier pour obtenir un package, ou exporter votre environnement sous forme de fichier texte. Bien qu’il soit possible d’installer des packages avec pip, vous prenez le risque d’installer des packages incompatibles, car pip ne résout pas complètement toutes les dépendances dans votre environnement. Parfois, il faut utiliser pip si un package requis n’est disponible dans aucun canal conda, mais il vaut mieux éviter son utilisation si possible.

Soyez conscient des dépendances et licences des packages/bibliothèques listées dans le Gestionnaire de Packages.

Le Gestionnaire de Packages vous aidera à identifier les dépendances pour toutes vos bibliothèques installées. Il fournira également un lien vers la licence pour tout package disponible à l’installation, afin que vous puissiez être sûr que les exigences de licence sont compatibles avec votre cas d’utilisation.

Envoyer vers la fenêtre Python/Notebook.

Vous pouvez glisser-déposer un outil depuis le volet Géotraitement dans la fenêtre Python pour obtenir la syntaxe correcte pour cet outil. Dans les versions récentes d’ArcGIS Pro, vous pouvez aussi le glisser dans un ArcGIS Notebook.

Tirez parti des ressources existantes comme les modèles ModelBuilder.

Si vous avez déjà un modèle qui effectue une tâche, vous n’avez pas besoin de le réécrire depuis zéro pour l’utiliser dans un script Python. Vous pouvez appeler le modèle comme un outil géotraitement dans votre script. Vous avez aussi la possibilité qu’ArcGIS Pro exporte votre modèle en code Python.

Vérifiez que les fichiers et classes d’entités existent avant d’exécuter du code dessus.

La fonction Exists testera si un objet de données particulier existe réellement ou non. Si ce n’est pas le cas, vous pouvez éviter d’exécuter une partie du code. Les stratégies de retours précoces aident votre code à s’exécuter plus rapidement.

Vérifiez que les lignes/valeurs existent avant exécution.

Même si un objet de données existe, il peut contenir des données vides. Vous pouvez utiliser la fonction GetCount pour identifier si une table est vide et éviter l’exécution du code si c’est le cas.

Paramétrez les éléments du modèle pour permettre une saisie utilisateur.

Les modèles avec paramètres sont plus faciles à intégrer dans un script car vous pouvez insérer programmatiquement différentes valeurs d’entrée pour ses paramètres.

Copiez la commande Python depuis l’interface graphique utilisateur dans ArcGIS Pro.

Lorsque vous ouvrez un outil dans le volet Géotraitement, il y a une petite flèche vers le haut à côté du bouton Exécuter. Une des options est Copier la commande Python. Cela copiera un extrait Python qui représente les paramètres nécessaires pour reproduire ceux que vous avez renseignés dans l’interface utilisateur. C’est notre astuce la plus impactante pour les utilisateurs familiers avec les tâches géotraitement dans ArcGIS Pro mais débutants en Python. Vous pouvez voir la correspondance entre les paramètres choisis dans l’interface familière et les valeurs passées en arguments à la fonction Python. En plus d’obtenir une copie de la commande Python depuis le volet Géotraitement, vous pouvez aussi faire clic droit sur n’importe quel élément dans votre Historique Géotraitement et obtenir le même extrait.

Utilisez Copier le chemin dans l’interface utilisateur ArcGIS Pro.

Taper les chemins fichiers est pénible et il est facile de faire une erreur. Dans le volet Catalogue d’ArcGIS Pro, vous pouvez faire clic droit sur un objet de données et Copier le chemin afin de ne pas avoir à le taper. 

Vérifiez régulièrement que votre code retourne les résultats attendus pendant sa construction.

Vous ne voulez pas passer des heures à écrire du code sans vérifier s’il fonctionne réellement. Plus vous écrivez du code entre deux tests, plus il y aura du code à vérifier en cas d’erreur inévitable. Des vérifications fréquentes peuvent aider à identifier tôt le code problématique.

Seaborn est excellent pour les graphiques/chartes.

Les visualisations graphiques peuvent aider vous (et d’autres personnes) à mieux comprendre vos données. Seaborn est une bonne bibliothèque pour créer ces visualisations, et lorsque vous l’exécutez dans un notebook, vous voyez directement la sortie avec votre code.

 

import seaborn as sns

# Dictionnaire des valeurs
cryptid_data = {
    "Lochness Monster":LochnessMonsterCount, 
    "Chupacabra":ChupacabraCount, 
    "Bigfoot":BigfootCount
}

# Diagramme en barres depuis le dictionnaire
cryptid_plot = sns.barplot(
    x=list(cryptid_data.keys()), 
    y=list(cryptid_data.values())
)

 

N’insérez jamais vos identifiants dans votre code.

C’est un énorme risque en matière de sécurité. L’ArcGIS API for Python permet d’utiliser les identifiants de connexion de votre environnement si vous travaillez dans ArcGIS Pro, Notebook Server ou ArcGIS Online

Carnet. Vous pouvez également utiliser des profils, qui utilisent les outils de gestion des secrets de votre système d'exploitation, ou PKI qui utilise des certificats de sécurité. Consultez la documentation Working with different authentication schemes pour plus de détails.<\/P>

Les notebooks ont une sortie riche qui peut inclure des images, des hyperliens et du texte formaté.<\/STRONG><\/P>C'est en partie ce qui rend un notebook si utile pour l'enseignement et le partage. La sortie riche aide les gens à mieux comprendre les résultats du travail que vous avez effectué dans votre code.<\/P>Utilisez des paramètres supplémentaires pour affiner votre recherche dans l'ArcGIS API for Python.<\/STRONG><\/P>La méthode search du ContentManager peut rechercher par catégories ou item_type ou par une requête sur plusieurs champs. Vous pouvez voir quelques exemples de requêtes dans cet article de la base de connaissances.<\/P>Attribuez des noms de variables significatifs aux objets avec lesquels vous travaillez.<\/STRONG><\/P>L'attribution de noms de variables vous permettra d'utiliser les valeurs que vous créez. Leur donner des noms significatifs vous aidera à comprendre ce que ces valeurs signifient. <\/P> <\/P>x = 2405<\/code><\/pre> <\/P>Ne signifie pas vraiment quelque chose.<\/P> <\/P>population = 2405<\/code><\/pre> <\/P>Fournit le contexte pertinent pour la valeur dans le script.<\/P>Soyez conscient du type spécifique d'objet avec lequel vous travaillez.<\/STRONG><\/P>Différents objets ont différentes propriétés et méthodes. Il est facile de se tromper avec des types d'objets similaires, tels que FeatureLayerCollection, FeatureLayer, et FeatureSet. Utilisez la vérification de type pour confirmer ce avec quoi vous travaillez, et la documentation pour vérifier ce que vous pouvez faire avec un objet particulier.<\/P>Cherchez arcpy <chose que vous essayez de faire>.<\/STRONG><\/P>Les moteurs de recherche comme Google et Bing retourneront presque toujours la documentation correcte dans les premiers résultats. Les résultats provenant d'Esri Community et Stack Exchange sont également souvent des ressources précieuses car ils proviennent de personnes posant des questions. Il y a une très bonne chance que quelqu'un ait déjà posé la même question que vous, et vous pouvez voir ce qui a fonctionné pour eux.<\/P>La documentation est votre meilleure amie<\/STRONG><\/P>Personne ne se souvient de tout cela. La compétence la plus importante que vous pouvez cultiver est la familiarité avec la documentation. Utilisez le code d'exemple pour voir comment fonctionnent différentes fonctions et objets.<\/P>Utilisez des arguments nommés au lieu d'arguments positionnels uniquement.<\/STRONG><\/P>L'utilisation d'arguments nommés lors de l'appel des fonctions, au lieu de se fier uniquement à l'ordre des arguments, rend votre code plus lisible. Cela vous permet de sauter certains paramètres optionnels et rend plus évident pour ceux qui liront votre code plus tard à quoi servent les différentes valeurs.<\/P>Utilisez help() ou ?<\/STRONG><\/P>Passez un objet à la fonction help pour accéder à la documentation de cette fonction sans quitter votre environnement de développement. Cela réduit le coût cognitif du changement de contexte et facilite le retour à l'écriture du code. Dans un environnement notebook, vous pouvez également ajouter un ? à un objet pour obtenir une documentation bien formatée.<\/P>Utilisez des listes et des boucles pour traiter les données par lots.<\/STRONG><\/P>ArcPy dispose de plusieurs fonctions de liste comme ListWorkspaces ou ListFiles qui génèrent automatiquement des listes d'objets de données. Une fois que vous avez une liste, vous pouvez parcourir tous les éléments de cette liste pour effectuer une tâche.<\/P> <\/P># Définir l'espace de travail
arcpy.env.workspace = r"C:\Input_Data"

# Lister toutes les géodatabases fichier dans cet espace de travail
fgdbs = arcpy.ListWorkspaces(workspace_type="FileGDB")

# Exécuter le modèle pour chaque géodatabase fichier dans l'espace de travail
for gdb in fgdbs:
arcpy.PythonTipsandTricksatbx.Model1(Database=gdb)<\/code><\/pre> <\/P>Planifiez des tâches périodiques<\/STRONG><\/P>Si un processus doit être exécuté chaque mois, semaine ou même chaque minute, vous pouvez planifier cette tâche. Les outils locaux peuvent être planifiés depuis l'interface ArcGIS Pro. Vous pouvez également planifier l'exécution automatique des notebooks dans ArcGIS Notebook Server ou dans ArcGIS Online.<\/P>Définissez les variables d'environnement pour contrôler le fonctionnement des outils géotraitement arcpy<\/STRONG><\/P>Si vous devez définir un espace de travail, garantir que les sorties peuvent être écrasées, spécifier une référence spatiale en sortie ou toute autre variable d'environnement géotraitement, vous pouvez les déclarer en utilisant la classe env dans ArcPy. Tous les outils ne respectent pas toutes les variables d'environnement, alors assurez-vous de vérifier la documentation spécifique à cet outil pour voir quelles variables il prend en charge.<\/P>Utilisez des variables pour les chemins de fichiers, ne les codez pas en dur dans les paramètres des fonctions.<\/STRONG><\/P>Les chemins de fichiers sont longs, difficiles à lire et ne reflètent souvent pas le but ou la signification des données qu'ils représentent. En leur attribuant des noms de variables, vous pouvez simplifier la référence aux données au chemin donné et donner aux données un nom qui fournit le contexte approprié.<\/P>Utilisez la fonction Describe pour obtenir des informations sur un élément de données.<\/STRONG><\/P>Dans l'interface utilisateur, si vous voulez en savoir plus sur un élément de données, vous pouvez généralement cliquer droit et sélectionner Propriétés. Dans un script, vous ne pouvez cliquer droit sur rien. La fonction Describe peut créer un objet qui contient toutes les propriétés de cet élément de données. Vous pouvez accéder à ces propriétés et les utiliser dans votre script. <\/P> <\/P>import pandas as pd
import arcpy

# Les outils ArcPy respectent l'environnement workspace, mais pandas non
# Utilisez Describe pour extraire le chemin complet d'un élément
arcpy.env.workspace = r"C:\Data"
delays = "AA_delays_jan_2023.csv"
desc = arcpy.Describe(delays)
delays_df = pd.read_csv(desc.catalogPath)<\/code><\/pre> <\/P>Utilisez la bibliothèque pandas pour manipuler les données tabulaires.<\/STRONG><\/P>Importer des tables ou classes d'entités dans un DataFrame pandas vous permet d'utiliser les puissants outils de cette bibliothèque pour nettoyer, résumer, grouper et agréger vos données (et plus encore !). L'extension Spatially Enabled DataFrame à pandas créée par l'ArcGIS API for Python vous permet de combiner les outils pandas standard avec une fonctionnalité spatiale supplémentaire pour les données géographiques.<\/P> <\/P>delays_df.fillna(0, inplace=True)
airport_group = delays_df.groupby(['ORIGIN_AIRPORT_SEQ_ID'])
delays_by_airport_df = airport_group.agg({'WEATHER_DELAY': 'mean'})<\/code><\/pre> <\/P>Joignez des données non spatiales aux données spatiales pour profiter des outils d'analyse spatiale.<\/STRONG><\/P>Les ensembles de données avec lesquels vous travaillez seront souvent implicitement spatiaux, mais sans géométrie réelle. Par exemple, des données sur un lieu connu ou des données avec adresses au lieu de coordonnées. Vous pouvez intégrer ces ensembles dans votre analyse spatiale si vous pouvez les joindre avec des géométries pour ces lieux grâce à des outils comme Join, Spatial Join ou Geocoding. Si vous avez un Spatially Enabled DataFrame, vous pouvez utiliser la fonction merge dans pandas pour joindre données spatiales et non spatiales dans un nouveau Spatially Enabled DataFrame.<\/P> <\/P>airports_sdf = pd.DataFrame.spatial.from_featureclass(airports_fc)
airport_delays_sdf = airports_sdf.merge(
right=delays_by_airport_df,
how='inner',
left_on='AIRPORT_SEQ_ID',
right_on='ORIGIN_AIRPORT_SEQ_ID'
)<\/code>
 <\/p>


Spatially Enabled DataFrames peuvent être utilisés comme entrées pour beaucoup d’outils géotraitement.
<\strong>
<\p>

Bien qu’un DataFrame ne soit pas une classe d’entités, vous pouvez le traiter comme tel aux fins de nombreux outils. C’est utile car cela évite d’exporter le DataFrame vers un nouveau format juste pour effectuer un traitement supplémentaire. 
<\p>
 <\p>
# Jointure spatiale entre un DataFrame et une classe d’entités
arcpy.analysis.SpatialJoin(
airport_delays_sdf,
climate_data,
delays_by_airport_weather,
match_option=\"CLOSEST\"
)<\code>
 <\p>


Utilisez des variables pour rendre it plus facile d'enchaîner les outils de géotraitement ensemble.<\/STRONG><\/P>Dans les analyses complexes, vous souhaitez souvent prendre la sortie d'un outil et la passer comme entrée à un autre outil. Les variables facilitent l'écriture d'un code flexible, car vous pouvez changer la valeur de la variable sans avoir à modifier tout le code des outils de géotraitement que vous avez écrit. <\/P> <\/P># Joindre spatialement un DataFrame à une classe d'entités
arcpy.analysis.SpatialJoin(
airport_delays_sdf,
climate_data,
delays_by_airport_weather,
match_option="CLOSEST"
)

# Passer la sortie de Spatial Join comme entrée à GLR
arcpy.GeneralizedLinearRegression_stats(
in_features=delays_by_airport_weather,
dependent_variable="WEATHER_DELAY",
explanatory_variables= ["Mean_T_f_01_Jan", "Mean_mmPr_01_Jan"]
model_type="CONTINUOUS",
output_features=delay_climate_glr",
)<\/code><\/pre> <\/P>Utilisez des variables pour faciliter l'itération / l'expérimentation avec les valeurs des paramètres.<\/STRONG><\/P>Souvent, avec une tâche complexe, vous voudrez essayer différentes valeurs pour certains paramètres. Ou vous voudrez rendre ces paramètres définis par l'utilisateur afin que le script puisse gérer les entrées de différents utilisateurs. Coder en dur les valeurs dans les paramètres rend cela plus difficile. Assigner des variables à ces valeurs et les sortir de l'appel de fonction facilite cela.<\/P> <\/P># Sortir les valeurs de l'appel de fonction
dependent_variable = "WEATHER_DELAY"
explanatory_variables = [
"Mean_T_f_01_Jan",
"Mean_mmPr_01_Jan"
]

arcpy.GeneralizedLinearRegression_stats(
in_features=delays_by_airport_weather,
dependent_variable=dependent_variable,
explanatory_variables= explanatory_variables
model_type="CONTINUOUS",
output_features=delay_climate_glr
)<\/code><\/pre> <\/P>Apprenez les raccourcis productifs de votre environnement de développement<\/STRONG><\/P>Vous connaissez probablement des outils comme ctrl+c pour copier ou ctrl+z pour annuler. Différents environnements de développement ont aussi leurs propres raccourcis clavier et macros qui vous permettent d'être plus productif. Il peut prendre un certain temps pour apprendre ces raccourcis, mais plus vous écrivez du code, plus vous gagnerez du temps à long terme en les apprenant. Dans un environnement notebook, vous pouvez cliquer sur la palette de commandes sur le côté droit de la barre d'outils pour voir tous les raccourcis.<\/P>Quand vous obtenez une erreur frustrante, éloignez-vous un moment.<\/STRONG><\/P>De loin, la meilleure stratégie de débogage est une pause. Faites une promenade. Buvez un verre d'eau. Travaillez sur autre chose. Allez dormir. Quand vous revenez au problème, vous aurez souvent une perspective différente qui vous permet de résoudre le problème. Si vous devenez en colère ou frustré, c'est le signe qu'il est temps de faire une pause.<\/P>Trouvez un partenaire pour vous aider.<\/STRONG><\/P>La deuxième stratégie de débogage la plus précieuse est de demander de l'aide. Passez un peu de temps à essayer de résoudre le problème par vous-même d'abord, mais ne gardez pas le problème pour vous indéfiniment. Parfois, un partenaire peut repérer un problème très rapidement que vous n'avez pas vu. Et quand votre partenaire a un problème, il peut venir vers vous pour obtenir de l'aide.<\/P>Commencez par le bas du message d'erreur.<\/STRONG><\/P>Un message d'erreur n'est pas un roman. Ne le lisez pas du début à la fin pour le plaisir. C'est un roman policier. Sautez à la fin pour trouver le coupable. Les dernières lignes d'un message d'erreur seront probablement les plus utiles.<\/P>Réussir à déboguer signifie obtenir une erreur différente de celle que vous aviez avant.<\/STRONG><\/P>Ceci est un conseil clé pour gérer votre état émotionnel pendant une session de débogage. Si vous conceptualisez le succès comme obtenir un code parfait, vous ne gagnerez jamais. Parce qu'un code qui fait quelque chose d'intéressant est toujours imparfait. Mais si vous pensez au succès comme avancer progressivement vers la perfection, vous vivrez beaucoup de victoires en chemin. <\/P>Utilisez des instructions print pour vérifier les valeurs et les types de données.<\/STRONG><\/P>Les variables Python peuvent changer de valeur et même de type. Cela rend Python extrêmement flexible, mais cette flexibilité est aussi la source de nombreuses erreurs. La façon la plus simple de vérifier si une variable a la bonne valeur ou le bon type est de l'imprimer.<\/P> <\/P># Imprimer la valeur du csv_list pour s'assurer qu'elle est correcte
arcpy.env.workspace = r"C:\LTS"
csv_list = arcpy.ListFiles("*.csv")
print(csv_list)<\/code><\/pre> <\/P>Les chemins de fichiers incorrects sont une source fréquente d'erreur.<\/STRONG><\/P>Copier/coller des chemins de fichiers peut aider à éviter les problèmes liés aux fautes de frappe dans les chemins. Mais il se peut que vous copiez quand même le mauvais chemin. Ou quelqu'un d'autre utilisant votre script peut ne pas avoir les données au même chemin que celui codé en dur dans le script. S'il y a un problème d'accès ou de chargement des données, le chemin du fichier doit être parmi les toutes premières choses que vous vérifiez.<\/P>Les fautes de frappe sont une autre source fréquente d'erreur.<\/STRONG><\/P>Une chose amusante avec le cerveau humain est que vous savez ce que vous vouliez taper, donc vous voyez ce que vous vouliez taper, pas ce que vous avez réellement tapé. Les chemins de fichiers, les noms longs de fonctions ou les caractères spéciaux sont des sources courantes de fautes de frappe. Trouver des fautes de frappe est un excellent cas d'utilisation pour avoir un partenaire qui vous aide, car lui ne voit que ce que vous avez réellement tapé.<\/P>L'autocomplétion peut aider à éviter les fautes de frappe.<\/STRONG><\/P>Un IDE dispose d'outils sophistiqués d'autocomplétion qui peuvent vous aider à trouver le bon nom de fonction ou paramètre. Cela non seulement vous fait gagner du temps en utilisant beaucoup l'autocomplétion, mais réduit aussi considérablement le risque de taper une mauvaise valeur. Ces outils d'autocomplétion sont parmi les premières choses que vous devriez pratiquer pour tirer pleinement parti de votre environnement de développement.<\/P>Python complète votre expertise métier. Il ne la remplace pas.<\/STRONG><\/P>Un code parfait qui s'exécute sans erreur mais résout le mauvais problème est inutile. Votre expertise métier en climatologie, démographie, transport ou tout autre domaine utilisant des données spatiales compte énormément. Python est un outil supplémentaire que vous pouvez utiliser pour multiplier la valeur de cette expertise.<\/P>Ressources supplémentaires<\/STRONG><\/P>Pour une formation Python supplémentaire, consultez le cours Esri Creating Python Scripts for ArcGIS : https:\/\/go.esri.com\/python-course<\/A>.<\/SPAN><\/SPAN><\/LI>Posez et répondez aux questions dans les Esri Communities pour Python/ArcPy<\/A> et l'ArcGIS API for Python<\/A><\/UL>