Présentation rapide d'ArcPy
ArcPy est un site-package qui repose sur le module arcgisscripting éprouvé (et lui succède). Son but est de créer le fondement d'une méthode pratique et productive permettant d'effectuer l'analyse, la conversion et la gestion de données géographiques ainsi que de procéder à l'automatisation de cartes avec Python.
ArcPy fournit l'accès à des outils de géotraitement ainsi qu'à des fonctions, des classes et des modules supplémentaires qui vous permettent de créer rapidement et facilement des workflow simples ou complexes.
Les applications et scripts ArcGIS écrits à l'aide d'ArcPy bénéficient de la capacité d'accès et d'utilisation des nombreux modules Python développés par des professionnels du SIG et des programmeurs issus de nombreuses disciplines différentes. En outre, l'utilisation d'ArcPy dans Python offre plusieurs avantages étant donné que Python est un langage de programmation destiné à un usage général, facile à maîtriser et à utiliser. Il est saisi et interprété de manière dynamique, ce qui permet d'ébaucher et de tester rapidement des scripts dans un environnement interactif, tout en restant assez puissant pour prendre en charge l'écriture d'applications importantes.
ArcPy fournit l'accès à des outils de géotraitement ainsi qu'à des fonctions, des classes et des modules supplémentaires qui vous permettent de créer des workflows simples ou complexes. D'une façon générale, ArcPy est organisé en différents outils, fonctions, classes et modules.
Techniquement parlant, les outils de géotraitement sont des fonctions disponibles dans arcpy, c’est-à-dire qu’ils sont accessibles comme n’importe quelle autre fonction Python. Toutefois, pour éviter toute confusion, une distinction est toujours faite entre les fonctions de type outil et autre (telles que les fonctions utilitaires comme ListFeatureClasses ()).
- Les outils sont documentés différemment des fonctions. Chaque outil a sa propre page de référence de l'outil dans le système d'aide d'ArcGIS Desktop. Les fonctions sont documentées dans la documentation ArcPy.
- Les outils renvoient un objet Résultat, ce qui n’est pas le cas des fonctions.
- Les outils génèrent des messages, accessibles par le biais de différentes fonctions, telles que GetMessages (). Les fonctions ne génèrent pas de messages.
- Les Outils sont immatriculés par niveau de produit (ArcGIS for Desktop Basic, Standard ou Advanced) et par extension (Extension ArcGIS Network Analyst, Extension ArcGIS Spatial Analyst, et ainsi de suite). Consultez la page de référence de l'outil pour connaître les niveaux de licence requis. Les fonctions ne sont pas dotées de licence, elles sont installées avec ArcPy.
Attention :Exécution d'un outil
L'exemple suivant indique comment exécuter l’outil Zone tampon. Lorsque l'outil s'exécute, les messages apparaissent par défaut du côté droit de la fenêtre Python dans la section d'aide.
>>> arcpy.Buffer_analysis("c:/data/Portland.gdb/streets", "c:/data/Portland.gdb/steets_buffer", "500 METERS")
Voici un autre exemple d'exécution d'outils. Cet exemple utilise des outils des boîtes à outils Data Management et Conversion. Un champ est ajouté à la classe d'entités Streets en entrée, le champ est calculé, puis la classe d'entités est chargée dans une géodatabase ArcSDE Enterprise.
>>> import arcpy
>>> arcpy.AddField_management("c:/data/Portland.gdb/streets", "LENGTH_MILES", "TEXT")
>>> arcpy.CalculateField_management("c:/data/Portland.gdb/streets", "LENGTH_MILES", "!shape.length@miles!", "PYTHON_9.3")
>>> arcpy.FeatureClassToFeatureClass_conversion("c:/data/Portland.gdb/streets", "Database Connections/MySDE.sde/PortlandDataset", "streets")
Obtention de résultats à partir d'un outil
Lorsqu'un outil de géotraitement est exécuté, les résultats de l'outil sont renvoyés dans un objet Résultat. En général, cet objet permet d’accéder au jeu de données en sortie produit ou mis à jour par l'outil. Dans d'autres cas, il peut contenir d’autres types de valeur, tels qu'un nombre ou une valeur booléenne. Si une sortie d’un outil est un paramètre à plusieurs valeurs, les valeurs peuvent être renvoyées sous forme de liste au sein d’une autre liste.
Les exemples de code suivants montrent comment les valeurs renvoyées sont capturées et les valeurs qu'elles peuvent afficher :
Renvoyez le chemin de la classe d'entités en sortie. Le résultat peut être utilisé en entrée pour une autre fonction.
>>> result = arcpy.Buffer_analysis("rivers", "riverBuf", "50 METERS")
>>> print result
C:\Portland\Portland_OR.gdb\riverBuf
>>> arcpy.Clip_analysis("streets", result, "streets_50m_of_rivers")
Renvoyez le nombre d'entités.
>>> result = arcpy.GetCount_management("streets_50m_of_rivers")
>>> print result.getOutput(0)
54
Renvoyez une liste de valeurs de grille d'index spatial par défaut pour une classe d'entités.
>>> result = arcpy.CalculateDefaultGridIndex_management("streets_50m_of_rivers")
>>> for i in range(0, result.outputCount):
... print result.getOutput(i)
...
560
200
0
Utilisation des paramètres d'environnement
Les paramètres d'environnement de géotraitement peuvent être considérés comme des paramètres supplémentaires qui affectent les résultats d'un outil. Ils diffèrent des paramètres d'outils normaux en cela qu’ils sont définis séparément de l'outil et sont interrogés et utilisés par les outils lorsqu'ils sont exécutés. Les paramètres d’environnement, tels qu'une zone d'intérêt, le système de coordonnées du jeu de données en sortie et la taille de cellule d'un nouveau jeu de données raster, peuvent tous être définis à l'aide des outils et pris en compte par ces derniers.
Les paramètres d'environnement sont disponibles dans la classe env sous forme de propriétés. Ces propriétés peuvent servir à extraire les valeurs d'environnement actuelles et à les définir. Voici des exemples d'utilisation des valeurs d'environnement :
Définissez l'environnement de l'espace de travail.
>>> arcpy.env.workspace = "c:/data/Portland.gdb"
>>> arcpy.Buffer_analysis("streets", "streetBuf", "500 METERS")
Définissez la valeur d'index spatial selon la valeur renvoyée d'un outil.
>>> arcpy.env.spatialGrid1 = arcpy.CalculateDefaultSpatialGridIndex_management("streets").getOutput(0)
Obtenez le paramètre de taille de cellule raster courant pour vérifier qu'il s'agit d'une taille spécifique pour une sortie standard.
if arcpy.env.cellSize != 30:
arcpy.env.cellSize = 30
Utilisation des fonctions
Une fonction est un élément de fonctionnalité défini qui réalise une tâche spécifique et peut être intégré dans un programme plus important. En plus des outils, ArcPy présente plusieurs fonctions permettant une meilleure prise en charge des workflows de géotraitement. Les fonctions peuvent servir à répertorier certains jeux de données, à extraire les propriétés d'un jeu de données, à vérifier l’existence de données, à valider un nom de table avant de l'ajouter à une géodatabase ou à effectuer de nombreuses autres tâches de script utiles.
L’exemple de code ci-dessous montre comment obtenir les propriétés des données et extraire une extension :
import arcpy
# prints True
print arcpy.Exists("c:/data/Portland.gdb/streets")
# prints NAD_1983_StatePlane_Oregon_North_FIPS_3601_Feet
sr = arcpy.Describe("c:/data/Portland.gdb/streets").spatialReference
print sr.name
# prints Available
print arcpy.CheckExtension("spatial")
arcpy.CheckOutExtension("spatial")
Utilisation des classes
Les classes ArcPy, telles que les classes SpatialReference et Extent, sont souvent utilisées comme raccourcis vers des paramètres d'outil de géotraitement complets qui présenteraient autrement un équivalent de chaîne plus compliqué. Une classe est analogue à un plan architectural. Le plan fournit la structure pour une création. Les classes permettent de créer des objets, souvent désignés par le terme instance.
import arcpy
spatial_ref = arcpy.SpatialReference("Hawaii Albers Equal Area Conic")
Utilisation des modules
ArcPy inclut des modules qui couvrent d’autres domaines d'ArcGIS. ArcPy est pris en charge par toute une série de modules et notamment un module d’accès aux données (arcpy.da), un module de cartographie (arcpy.mapping), un module Extension ArcGIS Spatial Analyst (arcpy.sa) et un module Extension ArcGIS Network Analyst (arcpy.na).
Par exemple, les outils du module arcpy.sa utilisent les outils de la boîte à outils Spatial Analyst, mais ils sont configurés pour prendre en charge Algèbre spatial. Par conséquent, exécuter arcpy.sa.Slope revient au même que d'exécuter l'outil Pente de la boîte à outils Spatial Analyst.