Ouvrir un projet et passer en revue les jeux de données
Avant de commencer à utiliser Python pour répertorier et décrire les jeux de données, vous allez télécharger et extraire un fichier .zip des données de projet et passer en revue les jeux de données dans ArcGIS Pro.
- 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é PythonDesc.
Dans ce didacticiel, les données sont présentées sur C:\Lessons\PythonDesc\. Vous pouvez utiliser un autre dossier, mais veillez à adapter les chemins d’accès dans les instructions et le code qui suivent.
- Démarrez ArcGIS Pro.
- Dans ArcGIS Pro, sous New Project (Nouveau projet), cliquez sur Start without a template (Démarrer sans modèle).
Un nouveau projet nommé Sans titre s’ouvre. Vous allez uniquement utiliser ArcGIS Pro pour examiner les données, il n’est donc pas nécessaire de renommer le projet et d’enregistrer votre travail.
- Si la fenêtre Catalog (Catalogue) n’est pas déjà visible, cliquez sur l’onglet View (Vue) et sur Catalog pane (Fenêtre Catalogue).
- Dans la fenêtre Catalog (Catalogue), cliquez avec le bouton droit sur Folders (Dossier) et sélectionnez Add Folder Connection (Ajouter une connexion aux dossiers).
- Dans la fenêtre Add Folder Connection (Ajouter une connexion aux dossiers), accédez à l’emplacement d’extraction du fichier PythonDesc.zip (C:\Lessons), cliquez sur le dossier PythonDesc et sur OK.
- Dans la fenêtre Catalog (Catalogue), développez Folders (Dossiers), puis PythonDesc.
Le dossier contient deux shapefiles (bike_routes.shp et watersheds.shp), ainsi qu’un fichier texte (bike_racks.csv) et une table de base de données (gardens.dbf). Il contient également une géodatabase nommée DC.gdb.
- Développez DC.gdb.
La géodatabase contient trois classes d’entités (boundary, neighborhoods et public_schools), une table (car_share_locations) et un jeu de classes d’entités (Transportation (Transports)).
- Développez Transportation (Transports).
Le jeu de classes d’entités contient quatre classes d’entités (roads, street_lights, traffic_analysis_zones et traffic_junctions) et un jeu de données réseau (traffic (trafic)).
Les jeux de données sont typiques des projets SIG : des classes d’entités et des données tabulaires dans différents formats, ainsi que d’autres éléments pour organiser ces données. Vous allez utiliser le code Python pour identifier ces jeux de données en fonction de leur type et d’autres propriétés. Notez que ces groupements signifient que les données du projet présentent une structure imbriquée à plusieurs niveaux.
Avant d’utiliser le code Python, vous allez également explorer ces jeux de données en examinant les fichiers sur votre ordinateur.
- Ouvrez Microsoft File Explorer et accédez au dossier C:\Lessons\PythonDesc\ ou à l’autre emplacement où vous avez placé le dossier PythonDesc.
File Explorer vous montre les fichiers. Les deux tables autonomes, bike_racks.csv et gardens.dbf sont des fichiers uniques. Les shapefiles bike_routes et watersheds sont chacun composés de plusieurs fichiers portant le même nom et différentes extensions. La géodatabase DC est un dossier avec une extension de fichier .gdb.
- Dans File Explorer, développez le dossier DC.gdb.
Ce dossier renferme des douzaines de fichiers. Il n’y a pas de lien clairement reconnaissable entre ces fichiers et les éléments de données qui sont visibles lorsque vous consultez la géodatabase dans la fenêtre Catalog (Catalogue) dans ArcGIS Pro. Par exemple, vous ne pouvez pas identifier un ou plusieurs fichiers constituant une classe d’entités en particulier. Cela est important pour utiliser des jeux de données SIG dans du code Python, car cela a un impact sur le mode d’accès et d’utilisation des jeux de données dans différents formats.
Ouvrir un fichier de script Python
Dans ce didacticiel, vous allez écrire du code Python avec IDLE. IDLE est un éditeur Python de base qui est inclus avec ArcGIS Pro.
Pour vous assurer que la version appropriée de Python qui est installée avec ArcGIS Pro est utilisée pour exécuter votre code, vous allez lancer IDLE avec un raccourci.
Si ArcGIS Desktop (ArcMap) est également installé, le menu contextuel comporte également le raccourci Edit with IDLE (Mettre à jour avec IDLE). N’utilisez pas ce raccourci ; il ouvrirait une version antérieure de Python.
- Dans File Explorer, remontez d’un niveau au dossier C:\Lessons\PythonDesc\.
- Cliquez avec le bouton droit sur describe_data.py et sélectionnez Edit with IDLE (ArcGIS Pro) (Mettre à jour avec IDLE (ArcGIS Pro)).
Ce mode d’ouverture d’IDLE ouvre le script avec l’environnement Python actif de ArcGIS Pro. Cela garantit que la version appropriée de Python est utilisée. Bien que ce didacticiel utilise IDLE comme éditeur de code, le code fonctionne également dans d’autres éditeurs Python, tels que PyCharm ou Spyder, ainsi que dans la fenêtre Python ou Notebooks dans ArcGIS Pro.
Remarque :
Si Edit with IDLE (ArcGIS Pro) (Mettre à jour avec IDLE (ArcGIS Pro)) n’est pas visible dans le menu contextuel, cliquez sur Start (Démarrer), développez ArcGIS, puis cliquez sur Python Command Prompt (Invite de commande Python). Dans la fenêtre Python Command Prompt (Invite de commande Python), saisissez idle et appuyez sur Entrée. IDLE (Python 3.7 Shell) apparaît. Cliquez sur File (Fichier) et sur Open (Ouvrir). Accédez au fichier describe_data.py et ouvrez-le.Le script s’ouvre.
Le script inclut trois lignes de code pour commencer. La première ligne est import arcpy, qui importe le paquetage ArcPy. Cela garantit que les fonctions d’ArcPy, notamment celles que vous allez utiliser pour répertorier et décrire les jeux de données SIG, sont accessibles dans le script.
La deuxième ligne spécifie le chemin d’accès à l’emplacement de stockage des données. Cette valeur est attribuée à une variable nommée mypath.
Une barre oblique unique (/) est utilisée dans le chemin au lieu d’une barre oblique inverse unique (\). Une barre oblique inverse unique dans Python est utilisée comme caractère d’échappement. Son utilisation dans les chemins d’accès peut avoir des conséquences imprévisibles. Lorsqu’elle est suivie par certains autres caractères, elle encode un comportement spécial. Par exemple, \t désigne une tabulation. Avec C:\Lessons\toronto.gdb, une tabulation serait ajoutée dans le chemin, ce qui provoquerait une erreur.
Au lieu d’une barre oblique, vous pouvez également ajouter la lettre r (pour brut) avant la chaîne (r"C:\Lessons\PythonDesc") ou utiliser des barres obliques inverses doubles ("C:\\Lessons\\PythonDesc"). Les trois notations conviennent.
La troisième ligne définit l’espace de travail. Un espace de travail est l’emplacement par défaut des fichiers que vous allez utiliser, par exemple les jeux de données en entrée et en sortie. L’espace de travail est défini sur la variable mypath. Même s’il est possible de définir l’espace de travail directement sans utiliser la variable mypath, il est intéressant d’utiliser une variable distincte pour le chemin d’accès où se trouvent les données.
- Si vous avez enregistré le dossier PythonDesc ailleurs que dans C:\Lessons\PythonDesc\, mettez à jour le chemin d’accès dans le script pour désigner l’emplacement d’enregistrement du dossier.
Par exemple, si vous avez extrait les données de ce didacticiel dans le dossier C:\EsriLessons, mettez à jour la deuxième ligne comme suit :
mypath = "C:/EsriLessons/PythonDesc"
Si votre chemin d’accès est relativement long, vous pouvez le copier depuis l’explorateur de fichiers pour le coller dans le script. Pour ce faire, cliquez avec le bouton droit sur le dossier (Windows 11) ou maintenez la touche Maj enfoncée et cliquez avec le bouton droit sur le dossier (Windows 10), puis cliquez sur Copy as Path (Copier en tant que chemin d’accès). Vous pouvez ensuite sélectionner et supprimer du script l’ancien chemin et appuyer sur Ctrl+V pour coller le nouveau.
Pour utiliser un chemin comme espace de travail valide, il doit s’agir d’une chaîne Python, c’est-à-dire qu’il doit être entouré de guillemets. Vous devez également utiliser l’un des trois styles appropriés aux chemins d’accès mentionnés ci-dessus. Si vous copiez un chemin Windows, il contient des barres obliques inverses. Vous pouvez remplacer chaque barre oblique inverse unique par deux barres obliques inverses ou une seule barre oblique. Pour les chemins longs, la solution la plus facile consiste à ajouter un r devant la chaine pour en faire une chaîne brute. Cela garantit que les barres obliques inverses ne sont pas lues comme des caractères d’échappement.
Vous allez maintenant tester votre code.
- Cliquez sur File (Fichier), puis sur Save (Enregistrer).
- Cliquez sur Run (Exécuter), puis sur Run Module (Exécuter le module).
La fenêtre IDLE Shell apparaît, avec un message qui indique que le shell a redémarré pour votre script. Le chemin d’accès et le nom de fichier du script sont affichés. Une pause de quelques secondes a lieu, puis l’invite IDLE Shell, >>> est renvoyée.
On peut avoir l’impression que rien ne s’est passé, car le script ne disposait d’aucune instruction pour afficher les données dans le shell. Par la suite, vous ajouterez des instructions d’affichage dans votre code pour renvoyer des informations au shell.
IDLE Shell est également un lieu où vous pouvez saisir des lignes de code et les exécuter immédiatement.
- Dans IDLE Shell, après l’invite >>>, saisissez print(arcpy.env.workspace) et appuyez sur Entrée.
Le chemin d’accès à l’espace de travail que vous avez configuré dans le script est affiché dans IDLE Shell. Le script a importé le module arcpy, défini la variable mypath comme étant égale à une chaîne contenant le chemin d’accès aux données du didacticiel et configuré l’espace de travail de arcpy sur ce chemin. En affichant la valeur arcpy.env.workspace dans le shell, vous avez démontré que le script fonctionnait.
- Fermez la fenêtre IDLE Shell.
Une fois l’espace de travail configuré, vous pouvez référencer un jeu de données en utilisant son nom de fichier sans le chemin complet.
Décrire un jeu de données avec Python
Maintenant que le script définit l’espace de travail, vous pouvez utiliser Python pour décrier les propriétés d’un jeu de données dans cet espace de travail.
Pour ce faire, vous allez utiliser la fonction da.Describe().
- Dans la fenêtre de l’éditeur IDLE, cliquez après la ligne arcpy.env.workspace = mypath et appuyez sur Entrée pour ajouter une nouvelle ligne.
- Saisissez le code suivant et appuyez sur Entrée :
desc = arcpy.da.Describe("bike_routes.shp")
La fonction da.Describe() provient du module arcpy.da, qui est utilisé pour les processus d’accès aux données. La fonction renvoie un dictionnaire Python. Un dictionnaire Python se compose de paires de clés et de leurs valeurs correspondantes. Les clés du dictionnaire renvoyé par da.Describe() sont les propriétés du jeu de données.
- Ajoutez une nouvelle ligne après la ligne desc = arcpy.da, ajoutez le code suivant et appuyez sur Entrée:
print(f'baseName: {desc["baseName"]}')
Une fois le script exécuté, la valeur de la propriété baseName est affichée. Dans la ligne de code ci-dessus, desc est le dictionnaire de propriétés et baseName est la clé, en tant que chaîne. L’expression desc["baseName"] renvoie la valeur associée à cette clé dans le dictionnaire.
Le style du format d’affichage utilisé ici est connu comme f-string. Les f-strings sont également appelés des littéraux de chaîne formatés. Il s’agit de chaînes avec la lettre f en préfixe et qui contiennent des variables entre accolades. Ces variables sont remplacées par leur valeur au moment de l’exécution. Dans le code d’exemple ci-dessus, des guillemets doubles sont utilisés autour de la valeur baseName pour en faire une chaîne. Comme les guillemets sont également utilisés pour les f-strings, des guillemets simples sont nécessaires pour les distinguer des guillemets doubles. Ces différents types de guillemets peuvent être utilisés indifféremment dans Python, à condition qu’ils soient cohérents.
La syntaxe suivante est également correcte :
print(f"baseName: {desc['baseName']}")
Le code complet jusque-là est le suivant :
import arcpy mypath = "C:/Lessons/PythonDesc" arcpy.env.workspace = mypath desc = arcpy.da.Describe("bike_routes.shp") print(f'baseName: {desc["baseName"]}')
Si vous avez stocké les données ailleurs, votre ligne mypath sera différente.
- Cliquez sur File (Fichier), puis sur Save (Enregistrer) pour enregistrer le script.
Vous pouvez également utiliser le raccourci clavier Ctrl+S.
- Cliquez sur Run (Exécuter), puis sur Run Module (Exécuter le module).
La fenêtre IDLE Shell apparaît avec le résultat :
baseName: bike_routes
Le nom de base des données est le nom de fichier sans l’extension de fichier.
Lors de l’apprentissage du code, il est courant de rencontrer des erreurs. L’étape suivante illustre une erreur classique susceptible de se produire à l’exécution de ce script.
- Modifiez la ligne desc = arcpy.da.Describe("bike_routes.shp") en supprimant le caractère de soulignement de bike_routes.
desc = arcpy.da.Describe("bikeroutes.shp")
- Enregistrez et exécutez le script.
IDLE Shell présente un message d’erreur :
ValueError: Object: Error in accessing describe
L’erreur suggère qu’un problème s’est produit avec la fonction da.Describe(). La raison de cette erreur est que le nom de la classe d’entités n’est pas correctement orthographié, de sorte qu’elle ne peut pas être localisée. Si vous rencontrez cette erreur, vérifiez l’exactitude du nom. Une autre erreur possible est la configuration incorrecte de l’espace de travail. Vérifiez également le chemin d’accès utilisé pour votre espace de travail.
Remarque :
Outre da.Describe(), vous pouvez aussi utiliser la fonction ArcPy standard Describe() pour examiner les propriétés des jeux de données SIG. La syntaxe est légèrement différente de da.Describe(). La fonction Describe() renvoie un objet Describe, que vous pouvez utiliser pour vérifier les propriétés. - Dans la fenêtre de l’éditeur IDLE, modifiez la ligne pour corriger le nom de la classe d’entités.
desc = arcpy.da.Describe("bike_routes.shp")
- Après la ligne print(f'baseName:, ajoutez les lignes suivantes :
print(f'extension: {desc["extension"]}') print(f'dataType: {desc["dataType"]}') print(f'shapeType: {desc["shapeType"]}')
- Enregistrez et exécutez le script.
Le nom de base, l’extension de fichier, le type de données et le type de géométrie du jeu de données en entrée sont affichés. Il est facile de voir dans la fenêtre Catalog (Catalogue) que bike_routes.shp est un shapefile de type polyligne, mais vous pouvez maintenant accéder à ces propriétés dans un script Python.
Il existe de nombreuses autres propriétés, mais cela constitue un bon départ pour comprendre chaque jeu de données. Vous trouverez la liste complète des propriétés dans la section de documentation ArcPy des pages d’aide ArcGIS Pro.
Il existe de nombreuses propriétés différentes, qui sont organisées par groupes dans les pages d’aide. Le groupe de propriétés Describe accessible via le lien ci-dessus comprend certaines propriétés générales à tous les jeux de données, notamment baseName, extension et datatype. On trouve ensuite des groupes de propriétés pour certains types de jeux de données. Par exemple, le groupe de propriétés FeatureClass inclut la propriété shapeType utilisée dans l’exemple de code précédent. Tous les jeux de données ne comportent pas cette propriété, s’ils ne contiennent aucune géométrie. Certaines propriétés peuvent être un peu difficiles à localiser en parcourant les pages d’aide. Par exemple, la propriété extent se trouve dans le groupe de propriétés Dataset. Les groupes de propriétés se rapportent uniquement à l’organisation des pages d’aide et n’ont aucun effet sur le code.
Vous allez ensuite remplacer la référence au jeu de données pour utiliser le script et explorer d’autres jeux de données.
Décrire d’autres jeux de données
Maintenant que vous disposez du script décrivant le jeu de données bike_routes.shp, vous allez le modifier pour décrire d’autres données.
- Modifiez la ligne desc = arcpy.da.Describe("bike_routes.shp") pour remplacer bike_routes.shp par watersheds.shp.
desc = arcpy.da.Describe("watersheds.shp")
- Enregistrez et exécutez le script.
- Modifiez la ligne desc = arcpy.da.Describe("bike_routes.shp") pour remplacer watersheds.shp par bike_racks.csv.
desc = arcpy.da.Describe("bike_racks.csv")
- Enregistrez et exécutez le script.
IDLE Shell présente un message d’erreur.
KeyError: 'shapeType'
Cela signifie qu’une erreur s’est produite lors de l’utilisation du dictionnaire, car la clé de dictionnaire shapeType n’existait pas. Si l’on considère la signification de shapeType, cela semble logique. Un fichier texte n’a pas de géométrie, il ne peut donc pas être classé comme point, polyligne ou polygone. La propriété est absente du dictionnaire, car elle n’est pas pertinente pour les fichiers CSV.
Le dictionnaire renvoyé par da.Describe() comprend uniquement les clés et valeurs qui sont pertinentes pour un type de données en particulier.
Vous pouvez éviter cette erreur en réalisant une vérification.
- Cliquez dans le script après la ligne print(f'dataType: {desc["dataType"]}') et appuyez sur Entrée pour ajouter une nouvelle ligne.
- Après la ligne print(f'dataType:, ajoutez la ligne suivante :
if "shapeType" in desc:
La ligne contient une instruction if. Les lignes d’instruction If comprennent un test. Dans ce cas, il s’agit de déterminer si la chaîne "shapeType" se trouve dans le dictionnaire desc. Après le test, les instructions if sont suivies d’un deux-points. La ligne suivante est la première ligne d’un bloc de code qui est exécuté de manière conditionnelle, si ce test est évalué comme étant vrai. Les lignes du bloc de code doivent être en retrait pour indiquer à Python qu’elles vont ensemble et qu’elles ne doivent être exécutées que si le test est vrai.
- Cliquez au début de la dernière ligne et ajoutez quatre espaces pour la mettre en retrait.
Les deux lignes de code finales sont les suivantes :
if "shapeType" in desc: print(f'shapeType: {desc["shapeType"]}')
- Enregistrez et exécutez le script.
Les résultats du fichier CSV s’affichent sans aucune erreur. Les trois premières propriétés sont affichées, puis l’instruction if test si le dictionnaire contient "shapeType". Comme ce n’est pas le cas, la dernière ligne n’est pas exécutée.
Comment voir quelles propriétés sont disponibles pour un jeu de données en particulier ?
Vous pouvez voir les propriétés en affichant l’ensemble du dictionnaire.
Ensuite, vous verrez comment afficher les propriétés.
Afficher toutes les propriétés d’un jeu de données
Vous avez vu comment afficher des clés et valeurs spécifiques pour un dictionnaire et comment tester si une clé en particulier se trouve dans le dictionnaire. Vous allez maintenant voir comment afficher le dictionnaire entier.
- Sélectionnez les cinq dernières lignes du script.
Cela inclut les lignes qui affichent les trois premières propriétés, plus l’instruction if et la ligne d’affichage finale.
- Une fois les lignes de code sélectionnées, cliquez sur Format, puis sur Comment Out Region (Ajouter des marques de commentaire dans la région).
Les lignes sélectionnées sont maintenant précédées de deux signes dièse. Un signe # au début convertit une ligne en commentaire pour Python, de sorte que ces lignes ne s’exécuteront pas à l’exécution du code.
Vous pouvez également saisir un signe dièse au début de chaque ligne, mais l’option de menu dans IDLE vous permet de le faire pour plusieurs lignes en même temps.
Vous pouvez annuler l’opération en sélectionnant les lignes et dans le menu Format, en choisissant Uncomment region (Supprimer les marques de commentaire de la région).
- Ajoutez une nouvelle ligne de code au bas du script et supprimez le retrait.
- Ajoutez les lignes suivantes :
for k, v in desc.items(): print(f"{k}: {v}")
La première des deux nouvelles lignes initie une boucle for. Les boucles For utilisent un ensemble d’entrées et un bloc de code en retrait et exécutent le bloc de code sur chacune des entrées. Dans ce cas, la boucle for effectue une itération sur les paires clé et valeur renvoyées en appelant la méthode items sur le dictionnaire desc. Consultez la documentation Python pour en savoir plus sur les boucles dans les dictionnaires.
La seconde des deux lignes est en retrait. C’est la seule ligne du bloc de code de la boucle for. À chaque exécution de la boucle, cette ligne affiche une chaîne formatée contenant les valeurs des variables k et v (clé et valeur), séparées par un deux-points.
- Enregistrez et exécutez le script.
Le code effectue une itération à travers tous les éléments du dictionnaire et affiche les clés et valeurs.
L’affichage du dictionnaire vous permet de voir les propriétés d’un type de données particulier.
Vous allez ensuite examiner certains des éléments à l’intérieur de la géodatabase.
Décrire les classes d’entités de géodatabase
Maintenant que vous avez vu comment examiner les propriétés des tables CSV et shapefiles basés sur des fichiers, vous allez utiliser Python pour examiner les propriétés des éléments dans une géodatabase. Vous allez utiliser l’ensemble des instructions d’affichage utilisées auparavant, au lieu de répertorier toutes les propriétés.
- Sélectionnez les cinq lignes de code qui ont été commentées précédemment, cliquez sur Format, puis sur Uncomment region (Supprimer les marques de commentaire de la région).
- Commentez les deux lignes de code finales qui ont permis d’effectuer l’itération sur le dictionnaire.
- Modifiez la ligne mypath = "C:/Lessons/PythonDesc" pour ajouter /DC.gdb.
mypath = "C:/Lessons/PythonDesc/DC.gdb"
- Modifiez la ligne desc = arcpy.da.Describe("bike_racks.csv") pour décrire la classe d’entités boundary.
desc = arcpy.da.Describe("boundary")
Les éléments à l’intérieur d’une géodatabase n’ayant pas d’extension de fichier, ils ne se distinguent que d’après leur type de données.
- Enregistrez et exécutez le script.
La seconde propriété est l’extension de fichier. Bien que cette propriété soit une clé valide dans le dictionnaire, la valeur est vide. Comme les extensions de fichiers vides sont communes pour les éléments de géodatabase, vous pouvez ajouter une autre instruction if de façon à uniquement afficher la ligne de l’extension, le cas échéant.
- Remplacez la ligne print(f'extension: {desc["extension"]}') par les deux lignes suivantes :
if desc["extension"] != "": print(f'extension: {desc["extension"]}')
L’opérateur de comparaison != signifie « différent de ». Les opérateurs de comparaison valides dans Python sont == (égal à), != (différent de), < (inférieur à), <= (inférieur ou égal à), > (supérieur à) et >= (supérieur ou égal à). Notez que même s’il semble que les opérateurs de comparaison =! et <> pourraient fonctionner, ils ne sont pas valides et entraîneront une erreur de syntaxe.
La première de ces deux lignes vérifie que la valeur associée à la clé « extension » n’est pas égale à une chaîne vide (deux guillemets sans rien à l’intérieur). Si le test est évalué comme vrai, la ligne visant à afficher la chaîne formatée avec le nom de clé de l’extension et la valeur associée à cette clé est exécutée.
- Enregistrez et exécutez le script.
Le code s’exécute et vérifie si la clé de l’extension n’a pas une valeur vide. Comme sa valeur est vide, le test est évalué comme faux. La ligne du bloc de code en retrait ne s’exécute pas et le code n’affiche pas cette ligne. Le code passe à la ligne suivante en dehors du bloc de code et poursuit en affichant le type de données et le type de forme.
Vous pouvez découvrir les autres éléments de la géodatabase d’une manière similaire en changeant le nom de l’élément dans la fonction da.Describe().
- Modifiez la ligne desc = arcpy.da.Describe("boundary") pour remplacer boundary par car_share_locations.
desc = arcpy.da.Describe("car_share_locations")
- Enregistrez et exécutez le script.
L’élément car_share_locations est une table de géodatabase. Il ne comporte aucune extension et aucune entrée pour shapeType, ces lignes ne s’affichent donc pas.
- Modifiez la ligne desc = arcpy.da.Describe("car_share_locations") pour décrire l’élément Transportation (Transports).
desc = arcpy.da.Describe("Transportation")
- Enregistrez et exécutez le script.
Transportation (Transports) est un jeu de classes d’entités dans la géodatabase. Un jeu de classes d’entités contient des éléments de données qui partagent un système de coordonnées commun. Un jeu de classes d’entités peut être utilisé comme espace de travail.
- Modifiez la ligne mypath = "C:/Lessons/PythonDesc/DC.gdb" pour ajouter /Transportation.
mypath = "C:/Lessons/PythonDesc/DC.gdb/Transportation"
Vous pouvez maintenant décrire les classes d’entités et d’autres éléments résidant à l’intérieur du jeu de classes d’entités.
- Modifiez la ligne desc = arcpy.da.Describe("Transportation") pour décrire l’élément Traffic (Trafic).
desc = arcpy.da.Describe("Traffic")
- Enregistrez et exécutez le script.
Traffic (Trafic) est un jeu de données réseau. Les jeux de données réseau permettent de modéliser les réseaux de transport. Ils sont créés à partir d'entités source, pouvant comprendre des entités simples (lignes et points) et des tournants, et stockent la connectivité des entités source. Lorsque vous réalisez une analyse du réseau, cela est toujours fait sur un jeu de données réseau.
D’autres types de données peuvent être utilisés dans da.Describe(), mais les éléments que vous avez décrits couvrent la plupart des types de jeux de données SIG les plus répandus. Il peut cependant être fastidieux de décrire individuellement chaque jeu de données. Il est utile d’être en mesure de créer une liste des différents jeux de données disponibles dans un espace de travail sans avoir à saisir leurs noms individuels.
Répertorier les fichiers d’un espace de travail
Dans les scripts Python, il est courant d’utiliser plusieurs jeux de données. Saisir le nom de chacun d’entre eux est fastidieux et prend du temps. ArcPy comporte plusieurs fonctions pour créer un inventaire des jeux de données. Ces fonctions renvoient généralement les jeux de données sous forme de liste Python, qui peut s’utiliser dans d’autres traitements.
- Vous allez commencer avec un nouveau script.
- Dans la fenêtre de l’éditeur IDLE, cliquez sur File (Fichier) et sur Save As (Enregistrer sous).
Le nom du fichier de script actuel est describe_data.py. Vous allez utiliser Save As (Enregistrer sous) pour créer un nouveau script et continuer votre travail, tout en conservant ce que vous avez réalisé jusqu’ici dans le fichier describe_data.py pour référence ultérieure.
- Dans la boîte de dialogue Save As (Enregistrer sous), saisissez list_data.py et cliquez sur Save (Enregistrer).
- Dans la fenêtre de script describe_data, sélectionnez tout sauf les trois premières lignes et appuyez sur la touche Suppr.
- Mettez à jour la ligne mypath = pour supprimer /DC.gdb/Transportation du chemin d’accès.
mypath = "C:/Lessons/PythonDesc"
Le chemin d’accès désignera toujours le dossier de base pour les données du didacticiel.
- Après la ligne arcpy.env.workspace, ajoutez les deux lignes suivantes :
files = arcpy.ListFiles() print(files)
La première de ces lignes crée une nouvelle variable nommée files et définit sa valeur comme égale au résultat de l’appel de la fonction ListFiles. Les fonctions sont suivies par une liste de paramètres entre parenthèses. Dans ce cas, la fonction ListFiles() n’exigeant aucun paramètre en entrée, les parenthèses sont vides.
La seconde ligne affiche la liste.
Le code doit se présenter comme suit :
import arcpy mypath = "C:/Lessons/PythonDesc" arcpy.env.workspace = mypath files = arcpy.ListFiles() print(files)
- Enregistrez et exécutez le script.
Il s’agit de la liste des fichiers du dossier PythonDesc. Les listes Python sont placées entre crochets.
La fonction ListFiles renvoie les fichiers de l’espace de travail courant. Cela signifie que si l’espace de travail n’a pas été configuré avec arcpy.env.workspace, le résultat est une liste vide et le script affiche None.
La fonction n’a aucun paramètre obligatoire et utilise automatiquement l’espace de travail courant. Les fichiers répertoriés sont très similaires à ceux visibles dans l’explorateur de fichiers. À une exception près. Une géodatabase est un dossier dans l’explorateur de fichiers, mais elle est incluse dans le résultat de ListFiles(). En conséquence, DC.gdb apparaît ici comme un fichier, bien qu’il s’agisse techniquement d’un dossier contenant des fichiers.
Vous limitez la recherche pour renvoyer uniquement certains types de fichiers.
- Mettez à jour la ligne files = arcpy.ListFiles() pour ajouter "*.csv" dans les parenthèses.
files = arcpy.ListFiles("*.csv")
La fonction ListFiles peut utiliser un paramètre facultatif, nommé wildcard, qui vous permet de spécifier une chaîne que les résultats de recherche doivent contenir. L’astérisque représentant zéro ou plusieurs caractères non spécifiés, cette recherche avec caractère générique renvoie tous les noms de fichiers qui incluent l’extension .csv.
- Enregistrez et exécutez le script.
Le script affiche la liste des résultats correspondants. Dans ce cas, c’est une liste à un seul élément.
['bike_racks.csv']
Cette technique fonctionne pour n’importe quel nombre de fichiers et est idéale pour obtenir tous les fichiers du même type qu’une liste et pour effectuer la même tâche sur chaque fichier.
Vous pouvez également répertorier d’autres types de fichiers, tels que .xlsx, .dbf, etc ou apparier d’autres parties de la chaîne de nom. Par exemple, la chaîne avec caractère générique "*bike*" renvoie la liste de tous les noms de fichiers qui incluent bike : ['bike_racks.csv', 'bike_routes.dbf', 'bike_routes.prj', 'bike_routes.sbn', 'bike_routes.sbx', 'bike_routes.shp', 'bike_routes.shx']
- Modifiez la ligne mypath = "C:/Lessons/PythonDesc" pour inclure DC.gdb
mypath = "C:/Lessons/PythonDesc/DC.gdb"
- Supprimez le paramètre "*.csv" de la fonction ListFiles.
files = arcpy.ListFiles()
- Enregistrez et exécutez le script.
Ce sont les mêmes fichiers que ceux que vous pouvez voir dans le dossier DC.gdb avec l’explorateur de fichiers. La fonction ListFiles() n’est pas pratique pour examiner le contenu d’une géodatabase, car les jeux de données ne correspondent pas aux fichiers individuels. Heureusement, une fonction existe pour répertorier les classes d’entités.
Répertorier les classes d’entités dans un espace de travail
Les classes d’entités font partie des types de jeux de données SIG les plus couramment utilisés. La fonction ListFeatureClasses() renvoie la liste des classes d’entités de l’espace de travail courant.
- Mettez à jour la ligne mypath = pour supprimer /DC.gdb du chemin d’accès.
mypath = "C:/Lessons/PythonDesc"
Le chemin d’accès désignera toujours le dossier de base pour les données du didacticiel.
- Mettez à jour la ligne files = arcpy.ListFiles() pour utiliser ListFeatureClasses.
files = arcpy.ListFeatureClasses()
Le code doit se présenter comme suit :
import arcpy mypath = "C:/Lessons/PythonDesc" arcpy.env.workspace = mypath files = arcpy.ListFeatureClasses() print(files)
- Enregistrez et exécutez le script.
Le script affiche une liste avec les deux classes d’entités.
['bike_routes.shp', 'watersheds.shp']
Les classes d’entités dans ce cas sont des shapefiles. Cela peut parfois prêter à confusion. Le terme de « classe d’entités » décrit un ensemble homogène d’entités, chacune avec la même représentation spatiale (comme des points, des lignes ou des polygones, par exemple) et un ensemble commun d’attributs. Les deux types les plus courants de classes d’entités dans ArcGIS Pro sont les shapefiles et les classes d’entités de géodatabase.
La fonction ListFeatureClasses() fonctionne à la fois pour les shapefiles et les classes d’entités de géodatabase, mais pour un espace de travail donné, elle ne renvoie que l’un d’entre eux. Lorsque l’espace de travail est un dossier, la fonction répertorie les shapefiles. Lorsque l’espace de travail est une géodatabase, la fonction répertorie les classes d’entités de géodatabase.
- Mettez à jour la ligne mypath = pour ajouter /DC.gdb au chemin d’accès.
mypath = "C:/Lessons/PythonDesc/DC.gdb"
Il s’agit du chemin d’accès à la géodatabase fichier.
- Enregistrez et exécutez le script.
Le script affiche une liste des trois classes d’entités.
['neighborhoods', 'boundary', 'public_schools']
La liste ne comprend pas les classes d’entités à l’intérieur du jeu de classes d’entités Transportation, puisqu’il s’agit d’un espace de travail différent.
Vous pouvez utiliser un caractère générique pour filtre les résultats de ListFeatureClasses(). Vous pouvez par exemple obtenir toutes les classes d’entités commençant par une lettre en particulier. La fonction vous permet également de filtrer en fonction du type d’entité. La syntaxe de la fonction ListFeatureClasses() est la suivante :
ListFeatureClasses ({wild_card}, {feature_type}, {feature_dataset})
Le paramètre feature_type de la fonction vous permet de limiter le résultat en fonction du type de classe d’entités.
- Mettez à jour la ligne files = arcpy.ListFeatureClasses() pour utiliser deux paramètres ("", "POINT").
files = arcpy.ListFeatureClasses("", "POINT")
Le premier paramètre, wild_card, n’est pas utilisé, mais comme les paramètres ont un ordre prescrit, ce paramètre doit être ignoré. La chaîne vide "" joue le rôle d’espace réservé pour indiquer que ce paramètre n’est pas utilisé. Vous pouvez aussi utiliser le mot-clé Python None.
Vous avez également la possibilité de fournir des paramètres référencés par nom, auquel cas il n’est pas nécessaire de respecter l’ordre initial. Ces deux méthodes d’écriture de la ligne sont également valides :
files = arcpy.ListFeatureClasses(None, "POINT")
files = arcpy.ListFeatureClasses(feature_type="POINT")
Vous pouvez aussi utiliser un signe dièse comme chaîne ("#") pour ignorer un paramètre d’outil. Cependant, cela ne fonctionne pas pour les fonctions non liées aux outils d’ArcPy.
Python est en majeure partie sensible à la casse, mais les chaînes utilisées dans les fonctions ArcPy ne respectent généralement pas la casse. En conséquence, vous pouvez également utiliser "Point" ou "point" dans le paramètre.
Le troisième paramètre que la fonction peut accepter, feature_dataset, n’est pas utilisé et peut être ignoré complètement, car il se trouve à la fin de la séquence de paramètres.
- Enregistrez et exécutez le script.
Le script affiche la seule classe d’entités points dans l’espace de travail.
['public_schools']
Répertorier les tables et les jeux de données
Vous avez répertorié les fichiers et classes d’entités. Vous allez maintenant répertorier les tables et jeux de classes d’entités.
- Mettez à jour la ligne mypath = pour supprimer /DC.gdb du chemin d’accès.
mypath = "C:/Lessons/PythonDesc"
Le chemin d’accès désignera toujours le dossier de base pour les données du didacticiel.
- Mettez à jour la ligne files = arcpy.ListFeatureClasses(feature_type="POINT") sur ListTables().
files = arcpy.ListTables()
Le code doit se présenter comme suit :
import arcpy mypath = "C:/Lessons/PythonDesc" arcpy.env.workspace = mypath files = arcpy.ListTables() print(files)
- Enregistrez et exécutez le script.
Le script affiche la liste des deux tables dans l’espace de travail.
['gardens.dbf', 'bike_racks.csv']
- Mettez à jour la ligne mypath = pour ajouter /DC.gdb au chemin d’accès.
mypath = "C:/Lessons/PythonDesc/DC.gdb"
Cette opération définit le chemin d’accès à la géodatabase.
import arcpy mypath = "C:/Lessons/PythonDesc/DC.gdb" arcpy.env.workspace = mypath files = arcpy.ListTables() print(files)
- Enregistrez et exécutez le script.
Le script affiche la liste avec la table unique dans la géodatabase.
['car_share_locations']
- Mettez à jour la ligne files = arcpy.ListTables() sur ListDatasets().
files = arcpy.ListDatasets()
import arcpy mypath = "C:/Lessons/PythonDesc/DC.gdb" arcpy.env.workspace = mypath files = arcpy.ListDatasets() print(files)
- Enregistrez et exécutez le script.
Le script affiche la liste avec le jeu de classes d’entités unique dans la géodatabase.
['Transportation']
- Mettez à jour la ligne mypath = pour ajouter /Transportation au chemin d’accès.
mypath = "C:/Lessons/PythonDesc/DC.gdb/Transportation"
Cette opération définit le chemin d’accès au jeu de classes d’entités Transportation (Transports).
import arcpy mypath = "C:/Lessons/PythonDesc/DC.gdb/Transportation" arcpy.env.workspace = mypath files = arcpy.ListDatasets() print(files)
- Enregistrez et exécutez le script.
Le script affiche la liste avec le jeu de données réseau unique dans le jeu de données Transportation (Transports).
['traffic']
La fonction ListDatasets() fonctionne avec différents éléments de données, notamment les jeux de classes d’entités, les réseaux géométriques, les réseaux, l’atelier parcellaire, les catalogues d’images, la topologie et plusieurs autres.
Maintenant que vous avez vu comment utiliser les fonctions de liste pour créer un inventaire des données, vous allez utiliser la liste générée pour décrire chacun de ses éléments.
Effectuer une itération sur une liste
La création d’une liste constitue généralement la première étape d’un processus de plus grande envergure. Dans la plupart des cas, vous souhaitez réaliser une tâche sur chaque jeu de données. Vous allez utiliser une boucle Python for pour effectuer une itération sur une liste.
Vous allez commencer avec un nouveau script.
- Cliquez sur File (Fichier) et sur Save As (Enregistrer sous).
- Donnez au nouveau fichier le nom iterate_data.py.
- Mettez à jour la ligne mypath = pour supprimer /Transportation du chemin d’accès.
mypath = "C:/Lessons/PythonDesc/DC.gdb"
- Mettez à jour la ligne files = arcpy.ListDatasets() pour utiliser la fonction ListFeatureClasses.
files = arcpy.ListFeatureClasses()
- Remplacez la ligne print(files) par for file in files: et appuyez sur la touche Entrée.
Le symbole deux-points à la fin de la ligne indique le début d’un bloc de code. La boucle for répète les éléments de la liste et le code en retrait dans le bloc de code est exécuté pour chaque élément. Lorsque vous appuyez sur Entrée après une ligne de code qui se termine par un symbole deux-points, la ligne de code suivante est automatiquement mise en retrait.
À chaque cycle, la variable temporaire file reçoit l’un des noms de la liste de fichiers dans la variable files.
- Sur la nouvelle ligne en retrait, ajoutez ce qui suit :
desc = arcpy.da.Describe(file)
La fonction da.Describe() reçoit un dictionnaire avec les propriétés des classes d’entités. Cette ligne de code s’exécutera pour chaque classe d’entités de la liste des classes d’entités.
- Appuyer sur Entrée et ajoutez ce qui suit :
print(desc["baseName"])
La ligne doit être en retrait de quatre espaces pour s’aligner sur la ligne précédente. Elle fait partie du bloc de code de la boucle for et s’exécutera pour chaque classe d’entités de la liste.
Cette ligne récupère et affiche la valeur stockée dans le dictionnaire desc à l’aide de la clé baseName.
Le code complet est le suivant :
import arcpy mypath = "C:/Lessons/PythonDesc/DC.gdb" arcpy.env.workspace = mypath files = arcpy.ListFeatureClasses() for file in files: desc = arcpy.da.Describe(file) print(desc["baseName"])
- Enregistrez et exécutez le script.
Le script affiche le nom des trois classes d’entités sur trois nouvelles lignes.
neighborhoods boundary public_schools
Vous allez modifier le code pour rendre les résultats plus révélateurs.
- Mettez à jour la ligne print(desc["baseName"]) sur name = desc["baseName"].
Au lieu d’afficher le nom, cette ligne le stocke dans la variable name.
La ligne doit toujours être en retrait pour s’aligner sur la ligne précédente du bloc de code afin de s’exécuter pour chaque cycle de la boucle.
- Ajoutez les trois lignes suivantes :
data = desc["dataType"] shape = desc["shapeType"] print(f"{name} is a {data} with {shape} geometry")
Ce code stocke le type de données et les valeurs géométriques dans les variables data et shape.
La ligne finale crée et affiche une chaîne formatée avec le contenu des trois variables remplacées à l’intérieur.
- Enregistrez et exécutez le script.
Le script affiche les trois chaînes formatées :
neighborhoods is a FeatureClass with Polygon geometry boundary is a FeatureClass with Polygon geometry public_schools is a FeatureClass with Point geometry
Vous avez répertorié les classes d’entités de la géodatabase, effectué une itération sur la liste et affiché les informations de chaque élément. Vous allez ensuite ajouter du code pour suivre le nombre de classes d’entités de chaque type.
Suivre le nombre des types de classes d’entités
Vous pouvez vérifier les propriétés de chaque classe d’entités et utiliser la logique conditionnelle pour savoir ce qui se passe. Dans cette section, vous allez utiliser des instructions if pour comptabiliser les classes d’entités par type géométrique.
- Insérez une nouvelle ligne avant la ligne for file in files:.
- Ajoutez les trois lignes suivantes avant la boucle for :
count_point = 0 count_line = 0 count_poly = 0
Ces lignes affectent des valeurs nulles aux trois nouvelles variables. Vous allez utiliser ces variables pour suivre le nombre de chaque classe d’entités.
Elles sont définies sur zéro avant la boucle for de sorte que dans la boucle for, vous pouvez les incrémenter, selon le type de la classe d’entités. Si vous les avez définies et configurées sur zéro à l’intérieur de la boucle for, à chaque exécution de la boucle, vous perdez les données du cycle précédent.
- À l’intérieur de la boucle for, supprimez les quatre dernières lignes.
- À l’intérieur de la boucle for, après desc = arcpy.da.Describe(file), ajoutez les lignes suivantes :
if desc["shapeType"] == "Point": count_point += 1
La ligne if doit être en retrait au même niveau que la ligne desc.
La ligne if tente de déterminer si la valeur du dictionnaire desc stockée à la clé shapeType est égale à la chaîne Point.
Dans Python, le signe d’égalité double, ==, permet de rechercher l’égalité, tandis que le signe d’égalité simple permet d’attribuer des valeurs aux variables.
La ligne est suivie par un symbole deux-points et la ligne suivante est en retrait, car il s’agit d’un nouveau bloc de code.
Si l’instruction est fausse, rien ne se produit. Si l’instruction est vraie, le bloc de code qui suit l’instruction if est exécuté.
Le bloc de code ajoute un à la valeur stockée dans la variable count_point. Lorsque la boucle s’exécute, elle vérifie chaque élément de la liste des classes d’entités pour savoir s’il s’agit d’une classe d’entités points. Si tel est le cas, elle ajoute un. Au terme de l’exécution de la boucle, la variable de compteur contient le nombre total de classes d’entités points.
Vous allez ajouter deux instructions if supplémentaires pour rechercher d’autres types géométriques.
- À la fin de la dernière ligne de code, appuyez sur Entrée.
La nouvelle ligne est alignée sur le retrait existant dans le bloc de code actuel. Cependant, vous voulez que la prochaine instruction if s’aligne au même niveau de retrait que l’instruction if précédente.
- Appuyez sur la touche Retour arrière.
Cela ajuste le retrait et aligne la nouvelle ligne sur l’instruction if précédente.
- Ajoutez les lignes de code suivantes :
if desc["shapeType"] == "Polyline": count_line += 1 if desc["shapeType"] == "Polygon": count_poly += 1
Vous pouvez supprimer le retrait à l’aide de la touche Retour arrière ou vous pouvez ajouter un retrait en insérant quatre espaces.
Désormais, chaque élément de la liste de fichiers sera décrit, le dictionnaire des résultats de description sera stocké dans la variable desc et les données stockées à la clé shapeType seront vérifiées pour savoir si elles correspondent aux chaînes Point, Polyline ou Polygon. Lorsqu’une correspondance a lieu, la valeur un est ajoutée à la variable de compteur pour cette forme.
Vous allez à présent ajouter des lignes pour afficher les informations.
- À la fin du script, ajoutez une ligne de code et appuyez sur la touche Retour arrière pour supprimer le retrait.
- Ajoutez les lignes de code suivantes :
print(f"Count of Point feature classes: {count_point}") print(f"Count of Polyline feature classes: {count_line}") print(f"Count of Polygon feature classes: {count_poly}")
Comme les trois dernières lignes ne sont pas en retrait, elles ne font pas partie du bloc de code de la boucle for. Elles s’exécutent uniquement une fois la boucle terminée et le nombre de chaque type de forme enregistré.
- Enregistrez et exécutez le script.
Le script affiche les trois lignes suivantes :
Count of Point feature classes: 1 Count of Polyline feature classes: 0 Count of Polygon feature classes: 2
Cela illustre une méthode de traitement des données avec Python. Commencez par obtenir une liste des données, puis utilisez ces informations pour faire quelque chose avec les données. Cet exemple comptabilise simplement les classes d’entités, mais vous pourriez utiliser un script semblable pour d’autres tâches, telles que la copie de toutes les classes d’entités surfaciques ou la vérification des attributs de toutes les classes d’entités points.
Vous avez affiché le nombre de classes d’entités des trois géométries. Vous allez maintenant voir une façon plus rapide d’obtenir le même résultat.
Comptabiliser avec un filtre par type d’entité
Pour obtenir le nombre total de classes d’entités dans un espace de travail, vous pouvez aussi utiliser la fonction ListFeatureClasses() avec un filtre par type d’entité.
- Cliquez sur File (Fichier) et sur Save As (Enregistrer sous).
- Donnez au nouveau fichier le nom filter_by_type.py.
- Sélectionnez les lignes entre les trois premières et les trois dernières lignes du script, cliquez sur Format, puis sur Comment Out Region (Ajouter des marques de commentaire dans la région).
- Ajoutez une nouvelle ligne après la section commentée, mais avant les lignes print.
- Ajoutez les lignes de code suivantes :
count_point = len(arcpy.ListFeatureClasses(feature_type="POINT")) count_line = len(arcpy.ListFeatureClasses(feature_type="POLYLINE")) count_poly = len(arcpy.ListFeatureClasses(feature_type="POLYGON"))
Ces trois lignes définissent les variables count_point, count_line et count_poly d’une nouvelle manière.
Au lieu de les définir sur zéro et d’incrémenter leurs valeurs, chaque ligne utilise ici la fonction ListFeatureClasses() avec le paramètre feature_type facultatif. Cette fonction crée une liste de classes d’entités correspondant au paramètre de filtrage. La fonction len détermine la longueur de la liste obtenue, qui est un décompte des classes d’entités de ce type.
- Enregistrez et exécutez le script.
Le script affiche les trois lignes suivantes :
Count of Point feature classes: 1 Count of Polyline feature classes: 0 Count of Polygon feature classes: 2
Cette solution de code, hormis les lignes commentées, est plus courte que la méthode précédente qui utilise da.Describe() pour déterminer le type géométrique. Cependant, da.Describe() vous permet d’examiner des propriétés autres que le type géométrique, par exemple le nombre de champs, l’étendue spatiale et le système de coordonnées.
- Fermez le script et la fenêtre IDLE Shell.
Vous avez vu deux techniques pour obtenir le nombre total de classes d’entités de différents types et afficher ces informations dans IDLE Shell. Vous allez ensuite voir un exemple d’utilisation de ces deux approches dans un script qui répertorie et décrit le contenu d’un espace de travail et écrit les résultats dans un fichier texte.
Écrire les informations d’inventaire dans un fichier texte
Même si l’affichage des résultats dans la fenêtre interactive est immédiat, les écrire dans un fichier texte peut parfois se révéler plus utile. Le script finalisé correspondant se trouve dans le dossier PythonDesc.
- Dans File Explorer, accédez au dossier PythonDesc dans lequel vous avez extrait les données.
- Cliquez avec le bouton droit sur write_inventory.py et sélectionnez Edit with IDLE (ArcGIS Pro) (Mettre à jour avec IDLE (ArcGIS Pro)).
Vous allez passer en revue le script, ajuster le chemin d’accès si nécessaire et l’exécuter pour voir son mode de fonctionnement. Le script inclut des commentaires ainsi que des lignes vides pour améliorer la lisibilité, mais cela n’a aucune influence sur le fonctionnement du code.
Le script commence par des commentaires indiquant notamment l’auteur, la date et l’objectif. Il est conseillé d’ajouter ce genre de note aux scripts comme rappel de leur objectif et de leur date de création. Si vous partagez le script, ces informations aideront les autres personnes à mieux le comprendre et leur permettra de savoir qui contacter en cas de questions.
Les premières lignes de code qui s’exécutent dans le script importent les modules arcpy et os.
import arcpy import os
Le module os vous donne accès aux fonctions du système d’exploitation via Python.
La section suivante configure certaines variables des chemins d’accès et de l’espace de travail.
#Variables for paths and workspace root = "C:/Lessons/PythonDesc" gdb = "DC.gdb" textfile = "inventory.txt" arcpy.env.workspace = os.path.join (root, gdb) output = os.path.join(root, textfile)
La section commence par un commentaire qui identifie l’action de cette partie du code. C’est une autre pratique utile pour écrire du code Python.
- Si vous avez extrait PythonDesc ailleurs que dans C:/Lessons/PythonDesc, mettez à jour le chemin d’accès sur la ligne root = "C:/Lessons/PythonDesc" pour désigner l’emplacement du dossier sur votre ordinateur.
Quel que soit le dossier racine, le nom de la géodatabase fichier et le nom du fichier texte peuvent rester les mêmes, ainsi que la ligne de code qui définit l’espace de travail arcpy.env.workspace. En utilisant une variable pour le chemin d’accès au dossier racine, il vous suffit de la mettre à jour dans un seul endroit du script. La fonction os.path.join() permet de créer des chemins complets à partir de la variable root et des variables gdb et textfile.
Ensuite, un nouveau fichier texte vide est créé en utilisant la fonction open() et en spécifiant un mode d’écriture avec "w". Si un fichier de ce nom existe déjà, il est remplacé.
#Create new textfile to write results f = open(output, "w")
La section suivante du script utilise la fonction ListFeatureClasses() pour obtenir des listes des trois types géométriques.
#Create list of feature classes by geometry type points = arcpy.ListFeatureClasses("", "POINT") lines = arcpy.ListFeatureClasses("", "POLYLINE") polygons = arcpy.ListFeatureClasses("", "POLYGON")
La section suivante du script écrit les informations contextuelles du fichier texte à l’aide de chaînes formatées. Le \n à la fin de chacune de ces lignes ajoute un caractère d’échappement qui encode une nouvelle ligne afin que les informations se présentent sous forme de trois lignes distinctes dans le fichier texte.
f.write(f"Workspace of interest: {arcpy.env.workspace}\n") f.write(f"This workspace contains the following feature classes:\n") f.write(f"Count of Point feature classes: {len(points)}\n")
La troisième de ces lignes utilise len(points) pour insérer la longueur de la liste de points, le nombre de classes d’entités points dans l’espace de travail, dans la chaîne.
La ligne suivante contient une instruction if qui vérifie si la liste des classes d’entités points contient des éléments. En l’absence de points, rien ne se produit jusqu’à la ligne f.write suivante. En revanche, si des classes d’entités points sont présentes, le bloc de code après la ligne s’exécute et le script écrit une nouvelle ligne formatée dans le fichier texte.
if len(points) != 0: f.write(f"The names of the Point feature classes are:\n") for point in points: desc = arcpy.da.Describe(point) f.write(f'\t{desc["baseName"]}\n') f.write(f"Count of Polyline feature classes: {len(lines)}\n")
Ensuite, une boucle for traite chacune des classes d’entités points dans la liste.
À l’intérieur de la boucle, la variable desc est configurée pour contenir le dictionnaire de la description arcpy.da.Describe de la classe d’entités.
La ligne suivante écrit une chaîne formatée avec le nom de la classe d’entités, extraite du dictionnaire à l’aide de la clé baseName. La ligne est en retrait de la longueur d’une tabulation à l’aide du caractère d’échappement \t, puis une nouvelle ligne est ajoutée avec le caractère \n. La boucle se répète ensuite pour toutes les autres classes d’entités points. Lorsqu’il n’y en a plus, la ligne f.write s’exécute et ajoute le texte décrivant le nombre de classes d’entités polylignes dans le fichier texte, puis commence une nouvelle ligne avec un \n.
Le reste de cette section livre les mêmes informations sur les classes d’entités polylignes et surfaciques.
if len(lines) != 0: f.write(f"The names of the Polyline feature classes are:\n") for line in lines: desc = arcpy.da.Describe(line) f.write(f'\t{desc["baseName"]}\n') f.write(f"Count of Polygon feature classes: {len(polygons)}\n") if len(polygons) != 0: f.write(f"The names of the Polygon feature classes are:\n") for polygon in polygons: desc = arcpy.da.Describe(polygon) f.write(f'\t{desc["baseName"]}\n')
Une fois la boucle de traitement des classes d’entités polylignes terminée, la ligne suivante ferme le fichier texte.
f.close()
La dernière section utilise la fonction os du module startfile pour ouvrir le fichier texte de rapport.
#Open the resulting output file os.startfile(output)
- Enregistrez et exécutez le script.
Le fichier texte s’ouvre dans Notepad.
Les résultats sont écrits dans le fichier texte avec la méthode write() du fichier. Le caractère de nouvelle ligne \n permet de s’assurer de la mise en forme de chaque résultat sur une nouvelle ligne. Le caractère de tabulation \t permet d’améliorer la lisibilité en mettant en retrait le nom des classes d’entités. Une barre oblique inverse est utilisée pour ces caractères spéciaux.
Au lieu d’écrire les résultats dans un fichier texte, vous pouvez les afficher dans la fenêtre interactive en remplaçant toutes les instances de f.write par print. Si vous voulez exécuter le script dans ArcGIS Pro en l’utilisant comme outil de script, vous pouvez écrire les informations dans les messages de l’outil de géotraitement en remplaçant f.write par arcpy.AddMessage.
Analyser
- Le code Python peut être utilisé pour décrire les propriétés des jeux de données SIG, telles que le type de fichier, l’extension de fichier et la géométrie.
- ArcPy comporte plusieurs fonctions pour créer des listes de jeux de données. Des fonctions spécifiques sont disponibles pour créer des listes de fichiers, des jeux de données, des tables et des classes d’entités.
- En répertoriant et décrivant les jeux de données avec du code Python, vous pouvez créer un inventaire détaillé des jeux de données SIG dans un espace de travail. Vous pouvez ensuite traiter chaque jeu de données différemment selon ses caractéristiques.
- Le code Python peut être utilisé pour écrire des informations dans des fichiers texte. Ceci est utile pour signaler et consigner les erreurs.
Les documentations Script 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.