Suite

Configuration de la liste déroulante dans les paramètres de l'outil de script Python ?

Configuration de la liste déroulante dans les paramètres de l'outil de script Python ?


J'essaie de créer un outil à partir d'un script python que j'ai écrit qui prendra une liste que j'ai créée et l'utilisera comme menu déroulant dans l'outil fini comme l'une des entrées (voir l'image ci-jointe par exemple):

La liste que j'utilise est une grande liste qui comprend toutes les villes de l'état du Vermont, et je la génère dans le script à partir d'une table (voir le code ci-dessous). Je soupçonne que mon problème pour le moment est simplement de définir les propriétés de l'outil pour prendre cette liste et l'utiliser pour créer une liste déroulante pour l'utilisateur. Voici le bloc de code qui crée la liste à utiliser dans le paramètre - quelqu'un voit-il des problèmes avec cette fin de code de l'outil ?

import arcpy arcpy.env.workspace = "Z:OPSTechnicalServicesCulvertsGetCulvertsGetCulverts.gdb" towns = "Database ConnectionsGDB_GEN.sdeGDB_Gen.VTRANS_ADMIN.townindex" arcpy.MakeFeatureLayer_management (towns,"towns_lyr") NameList = [] NameListArray = set() rows = arcpy.SearchCursor("towns_lyr") pour la ligne dans les lignes : value = row.getValue("TOWNNAME") si la valeur n'est pas dans NameListArray : NameList.append (valeur) ville = NameList ville = arcpy.GetParameterAsText(0)

Voici également une image des propriétés de l'outil, avec le code de validation par défaut - dois-je modifier ce code de validation ?

J'ai cherché des informations sur la modification de ce code de validation, mais je n'ai pas pu trouver d'informations sur son utilisation pour le formatage des listes déroulantes.


Essayez de définir le code de classe du validateur d'outil sur ceci :

import arcpy class ToolValidator(object): """Classe pour valider les valeurs des paramètres d'un outil et contrôler le comportement de la boîte de dialogue de l'outil.""" def __init__(self): """Configurer arcpy et la liste des paramètres de l'outil."" " self.params = arcpy.GetParameterInfo() def initializeParameters(self): """Affiner les propriétés des paramètres d'un outil. Cette méthode est appelée lorsque l'outil est ouvert.""" return def updateParameters(self): """ Modifiez les valeurs et les propriétés des paramètres avant d'effectuer la validation interne. Cette méthode est appelée chaque fois qu'un paramètre a été modifié.""" towns = "Database ConnectionsGDB_GEN.sdeGDB_Gen.VTRANS_ADMIN.townindex" rows = arcpy.SearchCursor (towns) self.params[0].filter.list = sorted(list(set(r.getValue('TOWNNAME') for r in rows))) del rows return def updateMessages(self): """Modifier les messages créé par validation interne pour chaque paramètre d'outil. Cette méthode est appelée après validation interne.""" return

Exécution de scripts Python CGI à partir de Javascript et de l'interface utilisateur mobile JQuery

J'ai une interface utilisateur JQuery avec un tas de curseurs. Chaque code de curseur ressemble à ceci :

Il doit y avoir du JQuery d'accompagnement qui fait quelque chose comme ceci:

De toute évidence, deux choses majeures doivent changer à propos de la JS. Premièrement, il doit s'exécuter lorsque le curseur est relâché (pas au chargement de la page), et deuxièmement, il doit réellement transmettre la valeur du curseur au script Python d'une manière ou d'une autre. Je l'ai configuré comme ça juste pour tester. Lorsque je charge la page, ce script python de testeur est exécuté correctement et certains matériels connectés au Raspberry Pi sont correctement contrôlés. Je sais que je devrais utiliser l'événement slidestop, mais je n'arrive pas à le faire fonctionner. Je ne suis pas non plus sûr de la MEILLEURE façon d'envoyer des variables au script python.

Mon script python ressemble à ceci, en ce moment : #!/usr/bin/python

Ainsi, il ne recherche aucun type de données entrantes, il est simplement appelé et écrit des données série. Il devrait pouvoir recevoir des données de l'appel AJAX et ajuster la commande d'écriture série en fonction des informations qu'il reçoit. J'ai besoin d'aide pour obtenir ces informations dans des variables avec lesquelles je peux travailler. Je suppose que je devrais également renvoyer une sorte de message "J'ai terminé" à la fonction d'appel JavaScript.

J'attends avec impatience toute idée que les gens pourraient avoir sur des problèmes de haut niveau ou sur des moyens de résoudre des problèmes plus spécifiques que j'ai énumérés ici.


Créer des configurations d'exécution/débogage permanentes

PyCharm propose les méthodes suivantes pour créer une configuration d'exécution/débogage permanente :

Créez à partir d'un modèle ou copiez une configuration existante.

Enregistrer une configuration temporaire comme permanente

Sélectionnez une configuration temporaire dans le sélecteur de configuration d'exécution/débogage, puis cliquez sur Enregistrer la configuration .

Une fois que vous avez enregistré une configuration temporaire, elle devient permanente et est enregistrée dans un fichier XML distinct dans le répertoire <project>/.idea/. Par exemple, MonProjet/.idea/Voiture.xml .

Vous pouvez également sélectionner une configuration temporaire dans la boîte de dialogue Exécuter/déboguer les configurations et cliquer sur dans la barre d'outils.

PyCharm fournit des modèles de configuration d'exécution/débogage pour différents langages, outils et frameworks. La liste des modèles disponibles varie en fonction des plugins installés/regroupés.

Créer une configuration d'exécution/débogage à partir d'un modèle

Ouvrez la boîte de dialogue Exécuter/Déboguer la configuration de l'une des manières suivantes :

Sélectionnez Exécuter | Modifier les configurations à partir du menu principal.

La barre de navigation étant visible ( Affichage | Apparence | Barre de navigation ), choisissez Modifier les configurations dans le sélecteur de configuration d'exécution/débogage.

Appuyez sur Alt+Maj+F10 , puis appuyez sur 0 ou sélectionnez la configuration dans la fenêtre contextuelle et appuyez sur F4 .

Dans la boîte de dialogue Exécuter/Déboguer la configuration, cliquez sur dans la barre d'outils ou appuyez sur Alt+Inser . La liste affiche les modèles de configuration d'exécution/débogage.

Sélectionnez le modèle souhaité. Si vous n'êtes pas sûr du modèle à choisir, reportez-vous à la boîte de dialogue Configurations Exécuter/Déboguer pour plus d'informations sur des modèles particuliers.

Spécifiez le nom de la configuration d'exécution/de débogage dans le champ Nom. Ce nom sera affiché dans la liste des configurations d'exécution/de débogage disponibles.

Sélectionnez Autoriser l'exécution parallèle si vous souhaitez autoriser l'exécution simultanée de plusieurs instances de la configuration. Si cette option est désactivée, toute tentative de réexécution de la configuration mettra fin à la session active.

Dans la section Avant le lancement, définissez si vous souhaitez effectuer des actions spécifiques avant de lancer l'application, par exemple, exécuter certains outils ou scripts avant de lancer la configuration d'exécution/de débogage.

Pour plus d'informations sur les activités Avant le lancement particulières, reportez-vous à Avant le lancement

Appliquez les modifications et fermez la boîte de dialogue.


Configuration de la liste déroulante dans les paramètres de l'outil de script Python ? - Systèmes d'information géographique

Pour savoir à quoi servent les différents paramètres, laissez simplement le pointeur de votre souris une seconde sur la case d'édition/case à cocher. et une info-bulle utile apparaîtra.

Réglages généraux

Graphique 4.72. La boîte de dialogue Paramètres, page Général


Cette boîte de dialogue vous permet de spécifier votre langue préférée et les paramètres spécifiques à Subversion.

Sélectionne la langue de votre interface utilisateur. Bien sûr, vous devez d'abord installer le module linguistique correspondant pour obtenir une autre langue d'interface utilisateur que l'anglais par défaut.

TortoiseSVN contactera périodiquement son site de téléchargement pour voir si une version plus récente du programme est disponible. S'il y en a, il affichera un lien de notification dans la boîte de dialogue de validation. Utilisez Vérifier maintenant si vous voulez une réponse tout de suite. La nouvelle version ne sera pas téléchargée, vous recevrez simplement une boîte de dialogue d'information vous indiquant que la nouvelle version est disponible.

TortoiseSVN a trois sons personnalisés qui sont installés par défaut.

Vous pouvez sélectionner différents sons (ou désactiver complètement ces sons) à l'aide du Panneau de configuration de Windows. Configurer est un raccourci vers le Panneau de configuration.

Sur les systèmes Windows Vista et ultérieurs, cela contrôle si les boîtes de dialogue utilisent le style Aero.

Sous Windows 7, vous pouvez créer une bibliothèque dans laquelle regrouper les copies de travail dispersées à divers endroits de votre système.

Les modèles d'ignorer globaux sont utilisés pour empêcher l'affichage des fichiers non versionnés, par ex. dans la boîte de dialogue de validation. Les fichiers correspondant aux modèles sont également ignorés par une importation. Ignorez les fichiers ou les répertoires en saisissant les noms ou les extensions. Les motifs sont séparés par des espaces, par ex. bin obj *.bak *.

?? *.jar *.[Tt]mp . Ces modèles ne doivent pas inclure de séparateurs de chemin. Notez également qu'il n'y a aucun moyen de différencier les fichiers et les répertoires. Lisez la section intitulée « Correspondance de modèle dans les listes d'ignorer » pour plus d'informations sur la syntaxe de correspondance de modèle.

Notez que les modèles d'ignorer que vous spécifiez ici affecteront également les autres clients Subversion exécutés sur votre PC, y compris le client en ligne de commande.

Avertir

Si vous utilisez le fichier de configuration de Subversion pour définir un modèle global-ignores, il remplacera les paramètres que vous définissez ici. Le fichier de configuration de Subversion est accessible à l'aide de l'outil Modifier comme décrit ci-dessous.

Ce modèle d'ignorer affectera tous vos projets. Il n'est pas versionné, il n'affectera donc pas les autres utilisateurs. En revanche, vous pouvez également utiliser la propriété versionnée svn:ignore ou svn:global-ignores pour exclure des fichiers ou des répertoires du contrôle de version. Lisez la section intitulée « Ignorer les fichiers et les répertoires » pour plus d'informations.

Définissez les dates des fichiers sur la « dernière date de validation »

Cette option indique à TortoiseSVN de définir les dates des fichiers sur la dernière date de validation lors d'une extraction ou d'une mise à jour. Sinon TortoiseSVN utilisera la date actuelle. Si vous développez un logiciel, il est généralement préférable d'utiliser la date actuelle, car les systèmes de construction examinent normalement les horodatages pour décider quels fichiers doivent être compilés. Si vous utilisez « last commit time » et revenez à une ancienne révision de fichier, votre projet risque de ne pas se compiler comme vous l'attendiez.

Fichier de configuration Subversion

Utilisez Modifier pour modifier directement le fichier de configuration de Subversion. Certains paramètres ne peuvent pas être modifiés directement par TortoiseSVN et doivent être définis ici à la place. Pour plus d'informations sur le fichier de configuration de Subversion, consultez le Zone de configuration d'exécution . La rubrique sur Paramétrage automatique des propriétés est d'un intérêt particulier, et qui est configuré ici. Notez que Subversion peut lire les informations de configuration à plusieurs endroits, et vous devez savoir lequel est prioritaire. Faire référence à Configuration et registre Windows pour en savoir plus.

Appliquer les modifications locales à svn:externals lors de la mise à jour

Cette option indique à TortoiseSVN de toujours appliquer les modifications locales à la propriété svn:externals lors de la mise à jour de la copie de travail.

Paramètres du menu contextuel

Graphique 4.73. La boîte de dialogue Paramètres, page du menu contextuel


Cette page vous permet de spécifier quelles entrées du menu contextuel de TortoiseSVN apparaîtront dans le menu contextuel principal et lesquelles apparaîtront dans le sous-menu de TortoiseSVN. Par défaut, la plupart des éléments ne sont pas cochés et apparaissent dans le sous-menu.

Il existe un cas particulier pour Get Lock . Vous pouvez bien sûr le promouvoir au niveau supérieur en utilisant la liste ci-dessus, mais comme la plupart des fichiers n'ont pas besoin de verrouillage, cela ne fait qu'ajouter de l'encombrement. Cependant, un fichier avec la propriété svn:needs-lock a besoin de cette action à chaque fois qu'il est modifié, donc dans ce cas, il est très utile de l'avoir au niveau supérieur. Cocher la case ici signifie que lorsqu'un fichier est sélectionné avec la propriété svn:needs-lock définie, Get Lock apparaîtra toujours au niveau supérieur.

La plupart du temps, vous n'aurez pas besoin du menu contextuel de TortoiseSVN, à part pour les dossiers qui sont sous contrôle de version par Subversion. Pour les dossiers non versionnés, vous n'avez vraiment besoin du menu contextuel que lorsque vous souhaitez effectuer une extraction. Si vous cochez l'option Masquer les menus pour les chemins non versionnés , TortoiseSVN n'ajoutera pas ses entrées au menu contextuel pour les dossiers non versionnés. Mais les entrées sont ajoutées pour tous les éléments et chemins dans un dossier versionné. Et vous pouvez récupérer les entrées des dossiers non versionnés en maintenant la touche Changement touche enfoncée tout en affichant le menu contextuel.

S'il y a des chemins sur votre ordinateur où vous ne voulez tout simplement pas que le menu contextuel de TortoiseSVN apparaisse, vous pouvez les lister dans la case en bas.

Paramètres de la boîte de dialogue TortoiseSVN 1

Graphique 4.74. La boîte de dialogue Paramètres, page Boîtes de dialogue 1


Cette boîte de dialogue vous permet de configurer certaines des boîtes de dialogue de TortoiseSVN comme vous les aimez.

Limite le nombre de messages de journal que TortoiseSVN récupère lorsque vous sélectionnez pour la première fois TortoiseSVN → Afficher le journal utile pour les connexions serveur lentes. Vous pouvez toujours utiliser Afficher tout ou Suivant 100 pour recevoir plus de messages.

Sélectionne la police et la taille utilisées pour afficher le message de journal lui-même dans le volet central de la boîte de dialogue Journal de révision et lors de la composition des messages de journal dans la boîte de dialogue Valider.

Format date/heure court dans les messages de journal

Si les messages longs standard occupent trop d'espace sur votre écran, utilisez le format court.

Peut double-cliquer dans la liste des journaux pour comparer avec la révision précédente

Si vous vous retrouvez fréquemment à comparer des révisions dans le volet supérieur de la boîte de dialogue du journal, vous pouvez utiliser cette option pour autoriser cette action lors d'un double-clic. Elle n'est pas activée par défaut car la récupération du diff est souvent un long processus, et de nombreuses personnes préfèrent éviter l'attente après un double-clic accidentel, c'est pourquoi cette option n'est pas activée par défaut.

TortoiseSVN peut fermer automatiquement toutes les boîtes de dialogue de progression lorsque l'action est terminée sans erreur. Ce paramètre vous permet de sélectionner les conditions de fermeture des boîtes de dialogue. Le paramètre par défaut (recommandé) est Fermer manuellement, ce qui vous permet de consulter tous les messages et de vérifier ce qui s'est passé. Cependant, vous pouvez décider d'ignorer certains types de messages et de fermer automatiquement la boîte de dialogue s'il n'y a pas de changements critiques.

La fermeture automatique si aucune fusion, ajout ou suppression signifie que la boîte de dialogue de progression se fermera s'il y avait des mises à jour simples, mais si les modifications du référentiel ont été fusionnées avec le vôtre, ou si des fichiers ont été ajoutés ou supprimés, la boîte de dialogue restera ouverte. Il restera également ouvert s'il y a eu des conflits ou des erreurs pendant l'opération.

La fermeture automatique si aucun conflit assouplit davantage les critères et fermera la boîte de dialogue même s'il y a eu des fusions, des ajouts ou des suppressions. Cependant, en cas de conflits ou d'erreurs, la boîte de dialogue reste ouverte.

La fermeture automatique si aucune erreur ferme toujours la boîte de dialogue même s'il y a eu des conflits. La seule condition qui maintient la boîte de dialogue ouverte est une condition d'erreur, qui se produit lorsque Subversion est incapable de terminer la tâche. Par exemple, une mise à jour échoue car le serveur est inaccessible, ou une validation échoue car la copie de travail est obsolète.

Fermez toujours les boîtes de dialogue pour les opérations locales

Les opérations locales telles que l'ajout de fichiers ou l'annulation des modifications n'ont pas besoin de contacter le référentiel et se terminent rapidement, de sorte que la boîte de dialogue de progression est souvent de peu d'intérêt. Sélectionnez cette option si vous souhaitez que la boîte de dialogue de progression se ferme automatiquement après ces opérations, sauf en cas d'erreurs.

Utiliser la corbeille lors du retour

Lorsque vous annulez des modifications locales, vos modifications sont ignorées. TortoiseSVN vous offre un filet de sécurité supplémentaire en envoyant le fichier modifié dans la corbeille avant de rapporter la copie vierge. Si vous préférez ignorer la corbeille, décochez cette option.

Utilisez l'URL de WC comme URL par défaut « De : »

Dans la boîte de dialogue de fusion, le comportement par défaut consiste à mémoriser l'URL De : entre les fusions. Cependant, certaines personnes aiment effectuer des fusions à partir de nombreux points différents de leur hiérarchie et trouvent plus facile de commencer avec l'URL de la copie de travail actuelle. Cela peut ensuite être modifié pour faire référence à un chemin parallèle sur une autre branche.

Vous pouvez spécifier le chemin par défaut pour les extractions. Si vous conservez toutes vos extractions au même endroit, il est utile d'avoir le lecteur et le dossier pré-remplis afin que vous n'ayez qu'à ajouter le nouveau nom de dossier à la fin.

Vous pouvez également spécifier l'URL par défaut pour les paiements. Si vous extrayez souvent les sous-projets d'un très gros projet, il peut être utile d'avoir l'URL pré-remplie afin que vous n'ayez qu'à ajouter le nom du sous-projet à la fin.


Vous pouvez le faire en utilisant l'opérateur splat :

Cela amène la fonction à recevoir chaque élément de liste en tant que paramètre distinct. Il y a une description ici : http://docs.python.org/tutorial/controlflow.html#unpacking-argument-lists

Cela a déjà été parfaitement répondu, mais comme je viens d'arriver sur cette page et que je n'ai pas compris tout de suite, je vais juste ajouter un exemple simple mais complet.


Cliquez sur

Avec Click, vous pouvez facilement créer une CLI par rapport à Argparse. Click résout le même problème que argparse résout, mais utilise une approche légèrement différente pour le faire. Il utilise le concept de décorateurs. Cela nécessite que les commandes soient des fonctions pouvant être encapsulées à l'aide de décorateurs.

Vous pouvez ajouter un argument et une option comme ci-dessous :

Si vous exécutez les scripts ci-dessus, vous devriez obtenir :

En rassemblant le tout, j'ai pu créer une interface de ligne de commande simple pour interroger des livres sur Google Books.

Pour plus d'informations, vous pouvez creuser en profondeur sur Click à partir de la documentation officielle


Édition et navigation¶

Fenêtres de l'éditeur¶

IDLE peut ouvrir des fenêtres d'éditeur au démarrage, en fonction des paramètres et de la manière dont vous démarrez IDLE. Ensuite, utilisez le menu Fichier. Il ne peut y avoir qu'une seule fenêtre d'éditeur ouverte pour un fichier donné.

La barre de titre contient le nom du fichier, le chemin complet et la version de Python et IDLE exécutant la fenêtre. La barre d'état contient le numéro de ligne (« Ln ») et le numéro de colonne (« Col »). Les numéros de ligne commencent par 1 et les numéros de colonne par 0.

IDLE suppose que les fichiers avec une extension .py* connue contiennent du code Python et que les autres fichiers n'en contiennent pas. Exécutez le code Python avec le menu Exécuter.

Raccourcis clavier¶

Dans cette section, « C » fait référence à la touche Contrôle sous Windows et Unix et à la touche Commande sous macOS.

Retour arrière supprime à gauche Suppr supprime à droite

C-Retour arrière supprimer le mot à gauche C-Supprimer le mot à droite

Touches fléchées et Page Up / Page Down pour se déplacer

C-LeftArrow et C-RightArrow se déplacent par mots

Accueil / Fin aller au début/à la fin de la ligne

C-Home / C-End aller au début/à la fin du fichier

Certaines liaisons Emacs utiles sont héritées de Tcl/Tk :

  • C-un début de ligne

  • C-e fin de ligne

  • C-k kill line (mais ne le met pas dans le presse-papiers)

  • C-l fenêtre centrale autour du point d'insertion

  • C-b recule d'un caractère sans supprimer (généralement, vous pouvez également utiliser la touche curseur pour cela)

  • C-f avance d'un caractère sans supprimer (généralement, vous pouvez également utiliser la touche curseur pour cela)

  • C-p remonte d'une ligne (généralement, vous pouvez également utiliser la touche curseur pour cela)

  • C-d supprimer le caractère suivant

Les raccourcis clavier standard (comme C-c pour copier et C-v pour coller) peuvent fonctionner. Les raccourcis clavier sont sélectionnés dans la boîte de dialogue Configure IDLE.

Indentation automatique¶

Après une instruction d'ouverture de bloc, la ligne suivante est indentée de 4 espaces (dans la fenêtre Python Shell d'un onglet). Après certains mots-clés (break, return etc.) la ligne suivante est en retrait. En indentation de début, Backspace supprime jusqu'à 4 espaces s'ils sont là. Tab insère des espaces (dans la fenêtre Python Shell un onglet), le nombre dépend de la largeur du retrait. Actuellement, les onglets sont limités à quatre espaces en raison des limitations Tcl/Tk.

Voir aussi les commandes de retrait/région de retrait dans le menu Format .

Achèvements¶

Des complétions sont fournies, lorsqu'elles sont demandées et disponibles, pour les noms de modules, les attributs de classes ou de fonctions, ou les noms de fichiers. Chaque méthode de demande affiche une zone de complétion avec les noms existants. (Voir les complétions de tabulation ci-dessous pour une exception.) Pour n'importe quelle case, modifiez le nom en cours de remplissage et l'élément mis en surbrillance dans la case en tapant et en supprimant des caractères en appuyant sur les touches Haut , Bas , PageUp , PageDown , Home et End et par un seul cliquez dans la case. Fermez la boîte à l'aide des touches Échap , Entrée et Tabulation double ou des clics à l'extérieur de la boîte. Un double clic dans la boîte sélectionne et ferme.

Une façon d'ouvrir une boîte est de taper un caractère clé et d'attendre un intervalle prédéfini. La valeur par défaut est de 2 secondes, personnalisez-le dans la boîte de dialogue des paramètres. (Pour éviter les popups automatiques, définissez le délai sur un grand nombre de millisecondes, tel que 100000000.) Pour les noms de modules importés ou les attributs de classe ou de fonction, tapez « . ». Pour les noms de fichiers dans le répertoire racine, saisissez os.sep ou os.altsep immédiatement après un guillemet d'ouverture. (Sous Windows, on peut d'abord spécifier un lecteur.) Déplacez-vous dans les sous-répertoires en tapant un nom de répertoire et un séparateur.

Au lieu d'attendre ou après la fermeture d'une boîte, ouvrez une boîte de complétion immédiatement avec Afficher les complétions dans le menu Edition. La touche de raccourci par défaut est C-space . Si l'on tape un préfixe pour le nom souhaité avant d'ouvrir la boîte, le premier match ou quasi-accident est rendu visible. Le résultat est le même que si l'on saisit un préfixe après l'affichage de la case. Afficher les complétions après qu'un devis complète les noms de fichiers dans le répertoire actuel au lieu d'un répertoire racine.

Appuyer sur Tab après un préfixe a généralement le même effet que Afficher les achèvements. (Sans préfixe, il indente.) Cependant, s'il n'y a qu'une seule correspondance avec le préfixe, cette correspondance est immédiatement ajoutée au texte de l'éditeur sans ouvrir de boîte.

L'appel de « Afficher les complétions » ou la touche Tab après un préfixe, en dehors d'une chaîne et sans « . » précédent, ouvre une boîte avec des mots-clés, des noms intégrés et des noms de niveau de module disponibles.

Lors de l'édition de code dans un éditeur (par opposition à Shell), augmentez les noms de niveau de module disponibles en exécutant votre code et en ne redémarrant pas le Shell par la suite. Ceci est particulièrement utile après avoir ajouté des importations en haut d'un fichier. Cela augmente également les complétions d'attributs possibles.

Les zones de complétion excluent initialement les noms commençant par « _ » ou, pour les modules, non inclus dans « __tous__ ». Les noms cachés sont accessibles en tapant « _ » après « . », avant ou après l'ouverture de la boîte.

Conseils d'appel¶

Une info-bulle s'affiche automatiquement lorsqu'on tape ( après le nom d'un accessible une fonction. Une expression de nom de fonction peut inclure des points et des indices. Une info-bulle reste jusqu'à ce qu'on clique dessus, que le curseur soit déplacé hors de la zone d'argument ou que ) soit tapé. Chaque fois que le curseur se trouve dans la partie argument d'une définition, sélectionnez Modifier et "Afficher l'info-bulle" dans le menu ou entrez son raccourci pour afficher une info-bulle.

L'info-bulle se compose de la signature et de la docstring de la fonction jusqu'à la première ligne vierge de cette dernière ou la cinquième ligne non vierge. (Certaines fonctions intégrées n'ont pas de signature accessible.) Un '/' ou '*' dans la signature indique que les arguments précédents ou suivants sont transmis par position ou nom (mot-clé) uniquement. Les détails sont sujets à changement.

Dans Shell, les fonctions accessibles dépendent des modules qui ont été importés dans le processus utilisateur, y compris ceux importés par Idle lui-même, et des définitions qui ont été exécutées, le tout depuis le dernier redémarrage.

Par exemple, redémarrez le Shell et entrez itertools.count( . Une info-bulle apparaît car Idle importe itertools dans le processus utilisateur pour son propre usage. (Cela pourrait changer.) Entrez Turtle.write( et rien n'apparaît. Idle n'importe pas lui-même tortue . L'entrée de menu et le raccourci ne font rien non plus. Entrez import turtle . Ensuite, turtle.write( affichera une info-bulle.

Dans un éditeur, les instructions d'importation n'ont aucun effet tant que l'on n'exécute pas le fichier. On peut vouloir exécuter un fichier après avoir écrit des instructions d'importation, après avoir ajouté des définitions de fonction ou après avoir ouvert un fichier existant.

Contexte du code¶

Dans une fenêtre d'éditeur contenant du code Python, le contexte du code peut être basculé afin d'afficher ou de masquer un volet en haut de la fenêtre. Lorsqu'il est affiché, ce volet gèle les lignes d'ouverture pour le code de bloc, telles que celles commençant par class , def ou si les mots-clés, qui auraient autrement défilé hors de vue. La taille du volet sera agrandie et réduite selon les besoins pour afficher tous les niveaux de contexte actuels, jusqu'au nombre maximum de lignes défini dans la boîte de dialogue Configure IDLE (qui est par défaut à 15). S'il n'y a pas de lignes de contexte actuelles et que la fonctionnalité est activée, une seule ligne vierge s'affiche. Cliquer sur une ligne dans le volet contextuel déplacera cette ligne vers le haut de l'éditeur.

Les couleurs du texte et de l'arrière-plan du volet contextuel peuvent être configurées sous l'onglet Highlights de la boîte de dialogue Configure IDLE.

Fenêtre Shell Python¶

Avec IDLE's Shell, on saisit, édite et rappelle des déclarations complètes. La plupart des consoles et des terminaux ne fonctionnent qu'avec une seule ligne physique à la fois.

Lorsque l'on colle du code dans Shell, il n'est pas compilé et éventuellement exécuté jusqu'à ce que l'on appuie sur Return . On peut d'abord éditer le code collé. Si l'on colle plus d'une instruction dans Shell, le résultat sera une SyntaxError lorsque plusieurs instructions sont compilées comme si elles n'en faisaient qu'une.

Les fonctionnalités d'édition décrites dans les sous-sections précédentes fonctionnent lors de la saisie de code de manière interactive. La fenêtre Shell d'IDLE répond également aux touches suivantes.

C-c interrompt l'exécution de la commande

C-d envoie la fin du fichier ferme la fenêtre si tapé à une invite >>>

Alt-/ (Développer le mot) est également utile pour réduire la saisie

Alt-p récupère la commande précédente correspondant à ce que vous avez tapé. Sur macOS, utilisez C-p .

Alt-n récupère ensuite. Sur macOS, utilisez C-n .

Retour pendant que sur n'importe quelle commande précédente récupère cette commande

Couleurs du texte¶

Idle affiche par défaut le texte noir sur blanc, mais colore le texte avec des significations spéciales. Pour le shell, il s'agit de la sortie du shell, de l'erreur du shell, de la sortie utilisateur et de l'erreur utilisateur. Pour le code Python, à l'invite du shell ou dans un éditeur, il s'agit des mots-clés, des noms de classe et de fonction intégrés, des noms suivant class et def , des chaînes et des commentaires. Pour toute fenêtre de texte, il s'agit du curseur (si présent), du texte trouvé (si possible) et du texte sélectionné.

La coloration du texte est effectuée en arrière-plan, de sorte que le texte non coloré est parfois visible. Pour modifier le schéma de couleurs, utilisez l'onglet Mise en surbrillance de la boîte de dialogue Configurer IDLE. Le marquage des lignes de point d'arrêt du débogueur dans l'éditeur et du texte dans les fenêtres contextuelles et les boîtes de dialogue n'est pas configurable par l'utilisateur.


Créer une interface graphique rapide

Quand PySimpleGUI est-il utile ? Immédiatement, chaque fois que vous avez besoin d'une interface graphique. Il faut moins de cinq minutes pour créer et essayer une interface graphique. Le moyen le plus rapide de créer une interface graphique consiste à en copier une à partir du livre de recettes PySimpleGUI. Suivez ces étapes:

  • Trouvez une interface graphique qui ressemble à ce que vous voulez créer
  • Copier le code du livre de recettes
  • Collez-le dans votre IDE et exécutez-le

Regardons la première recette du livre.

C'est un formulaire de taille raisonnable.


Allez au-delà de l'outil de pente standard d'ArcGIS avec la personnalisation Python

Les modèles altimétriques numériques sont une partie importante de nombreux jeux de données et études du système d'information géographique. De plus, la distribution et la caractérisation des attributs topographiques à travers un paysage peuvent être des informations vitales pour les applications géomorphologiques, hydrologiques et biologiques (Moore et al. 1991). Les paramètres calculés à partir des DEM sont tout aussi importants. La pente est peut-être la plus courante. Cependant, l'outil de pente standard dans ArcGIS (10.4.1) n'examine qu'un voisinage 3x3 et n'inclut pas la cellule centrale. [Pour une discussion plus complète des calculs de pente, voir Hickey et al (1994) et Dunn et Hickey (1998).] Bien que cela soit acceptable pour un examen à plus grande échelle de la pente, la personnalisation des outils de traitement de terrain ArcGIS avec le code Python peut aider nous calculons la pente selon des directions spécifiques aux besoins d'un chercheur. Les applications théoriques d'un outil de pente directionnelle peuvent inclure la recherche de la pente le long du chemin naturel d'un cours d'eau, l'anticipation de la direction de l'eau s'écoulant sur une surface, l'étude de la direction du mouvement des incendies de forêt sur divers terrains ou la mesure de la direction relative de la pente le long d'un sentier de randonnée.

Cet article traite d'une méthode de calcul de la pente le long d'une grille de direction d'écoulement. Dans l'exemple hydrologique, cela équivaudrait à calculer l'angle de pente maximum en descente. Si l'utilisateur s'intéresse à la pente dans une autre direction, par exemple dans la direction d'un feu, d'un ruisseau ou d'un sentier en mouvement, une grille FD doit être créée pour représenter la direction du mouvement le long de l'entité étudiée.

Codage

L'objectif de ce projet est de calculer l'angle de pente sur la base d'une combinaison d'un DEM et de la sortie d'un calcul FD. L'entrée de FD est généralement un DEM, et la sortie identifie l'une des huit cellules environnantes avec la direction de l'inclinaison de pente la plus raide. La sortie est codée comme le montre la figure 1.

Figure 1 : sortie FLOWDIRECTION

Alternativement, FD peut être calculé à partir de n'importe quelle autre couche raster. Par exemple, un utilisateur peut créer un jeu de données raster qui décrit le mouvement du feu, puis FD peut être calculé à partir de ces données plus un DEM.

Quelle que soit l'application prévue, le code présenté ici prend les rasters de sortie DEM et de direction de flux et calcule la pente directionnelle en calculant la pente (montée/course) de la cellule centrale du noyau à la seule cellule adjacente le long du raster FD suivant.

Pour les curieux, le workflow est présenté ci-dessous dans le code AML hérité (Hickey et al, 1994). FLOW est la grille FD (voir Figure 1), DEM est le DEM rempli, SIZE est la taille du pixel, DIAG est la taille de 1,4 * pixel (ou la distance diagonale entre deux pixels adjacents) et ANGLE est la pente calculée :

Pour implémenter cette approche à l'aide de Python, nous avons converti le raster en un tableau NumPy. NumPy est un module Python spécial pour travailler avec les mathématiques et les nombres. Un tableau NumPy peut stocker des valeurs qui représentent des lignes et des colonnes dans une grille. Un programmeur peut ensuite obtenir la valeur de n'importe quelle cellule du raster en référençant la ligne et la colonne de la cellule. Cela permet d'effectuer des calculs personnalisés à l'aide des valeurs des cellules de grille adjacentes, ce qui est non seulement utile pour personnaliser la pente, mais également pour tout type de statistique de voisinage.

Convertissez les rasters DEM et de direction de flux en tableaux NumPy comme ceci :

Plus loin dans le code, nous avons configuré quelques tuples Python de directions de flux, en utilisant le terme rook pour les cellules adjacentes et diag pour les cellules diagonales.

Ensuite, après avoir trouvé la différence d'élévation entre les pixels le long de la FD, nous pouvons appliquer le calcul de pente correct en fonction de la direction du flux. Notez que le code Python ci-dessous montre la pente en pourcentage, alors que l'AML ci-dessus utilisait des degrés. Vous pouvez appliquer l'approche que vous voulez en modifiant le calcul :

Pour que cela fonctionne correctement, toutes les entrées doivent se trouver dans une géodatabase fichier. N'oubliez pas non plus que, pour toute opération de voisinage raster, les lignes/colonnes extérieures sont toujours inexactes et l'utilisateur doit travailler sur une zone d'étude qui est plus grande que nécessaire - et ne couper la zone finale qu'une fois toutes les analyses terminées.

Un lien vers le code complet est fourni à la fin de cet article.

Exemple de procédure pas à pas de projet

Le site d'étude se trouve à proximité d'un sentier de randonnée populaire à l'extérieur d'Ellensburg, Washington (Figure 2). Il a été choisi en raison de la topographie relativement simple, du manque de couverture végétale (écosystème de steppe arbustive) et de la familiarité des auteurs. Nos objectifs étaient d'abord de calculer l'angle de pente descendant maximal (pente dans la direction de l'écoulement de l'eau), puis de calculer la pente dans la direction qu'un incendie simulé pourrait se propager. Un DEM de 10 mètres couvrant l'étendue de la zone d'étude a été téléchargé à partir de la bibliothèque de données en ligne de l'USGS, Earth Explorer, stocké au format .dem et importé dans une géodatabase de fichier ArcGIS. Toutes les données ont été référencées spatialement en utilisant NAD27 - UTM zone 10N. Toutes les données ont été découpées dans une zone un peu plus grande que la zone d'intérêt. Nous avons ensuite exécuté l'outil de remplissage sur le DEM pour supprimer les récepteurs et les petits problèmes de données. [Note de l'auteur : exécutez toujours Fill it pour résoudre les problèmes mineurs qui semblent prévaloir dans n'importe quel DEM que vous pourriez télécharger.]

Figure 2. Vue oblique de la zone d'étude, vers le sud. La zone brûlée est surlignée en rouge le feu a commencé à l'extrême droite (ouest).

Après le découpage des données de la zone d'étude et l'opération de remplissage DEM, FlowDirection a été utilisé pour créer un raster FD. Enfin, le script de pente directionnelle présenté a été exécuté sur les données. La sortie est l'angle de pente de descente maximal (Figure 3).

Figure 3. En haut à gauche, DEM de la zone d'étude avec zone d'incendie pour référence. En haut à droite, ombrage. En bas à gauche, sortie dans le sens du flux. En bas à droite, angle de pente maximal en descente.

To examine the slope along which a simulated fire would travel, we digitized a series of fire lines, assuming these represented the location of the fire line at different times. We also created a polygon file representing the total area burned. It’s important that these vector files be in the same datum/coordinate system as the DEM.

We then assigned “elevations” to the fire. The numbers themselves don’t really matter as long as the highest values are where the fire started and the lowest, where it finished. We then ran the Topo to Raster tool on the fire lines. When doing this, make sure to use the clipped DEM as the input to the “output cell size” and “output extent” (Figure 4). This will ensure that the DEM and your new fire raster overlay exactly. Run Fill on this fire raster, then FlowDirection. This FD layer will represent the direction the ‘fire’ is moving (Figure 5).

Figure 4: DEM created from the fire lines. Fire lines (with labels, 100 was where the fire started it finished at 30) and fire AOI for reference. This is the same AOI as is shown in Figure 3.

Figure 5: FLOWDIRECTION output based on the fire dem in Figure 4.

We then ran our script using the DEM and the fire FD layers as inputs. The output is the slope of the land according to the direction of the moving fire (Figure 6).

Figure 6: Slope angle along the direction of fire movement. Note, negative values represent areas where the fire is moving uphill green is downhill.

Debugging List

Are you getting odd results? Very high or low values? Or even large areas with a 0 slope? Here are some suggestions for things to check:

  • Is everything in the same datum/coordinate system? Never use geographic (lat/long) coordinates when working with raster data.
  • Did you remember to run Fill on your DEM?
  • Ensure that all the raster layers overlay perfectly and have the same number of rows, columns, and cell size.
  • Ensure that the vertical units are the same as the horizontal units (meters or feet).
  • All your input files should be within a file geodatabase.

Conclusion

If you need to go beyond the out-of-the-box functionality of the ArcGIS raster analysis tools, you can use the ArcPy site package to write custom tools. A particularly powerful way to work with DEMs is to use NumPy arrays to iterate through each cell and apply your own formulas. We’ve demonstrated this by implementing a calculation to find directional slope. The walkthrough project describes how such a tool can be applied toward either modeling the path of a wildfire or of water flowing downhill. The code is available at http://www.onlinegeographer.com/slope/slope.html.

Dunn, M. and R. Hickey, 1998, The Effect of Slope Algorithms on Slope Estimates within a GIS. Cartography. V. 27, no. 1, pp. 9–15.

Hickey, R, A. Smith, and P. Jankowski, 1994, Slope length Calculations from a DEM with in ARC/INFO GRID. Computers, Environment and Urban Systems, v. 18, no. 5, pp. 365 - 380.

Moore, I. D., Grayson, R. B., & Ladson, A. R. (1991). Digital terrain modelling: a review of hydrological, geomorphological, and biological applications. Hydrological processes, 5(1), 3-30.


Description du projet

Geolocation is a simple and clever application which uses google maps api.

  1. Geocode Module allows you to easily and quickly get information about given location.
  • country,
  • country short form,
  • city,
  • route/street,
  • street number,
  • postal code,
  • formatted address,
  • administrative areas,
  • lat,
  • lng.
  1. Distance Module allows you to get information about travel distance and time for a matrix of origins and destinations.
  • origin address,
  • destination address,
  • duration,
  • distance: kilometers, meters, miles.

20 CONTROLLING THE KEYBOARD AND MOUSE WITH GUI AUTOMATION

Knowing various Python modules for editing spreadsheets, downloading files, and launching programs is useful, but sometimes there just aren’t any modules for the applications you need to work with. The ultimate tools for automating tasks on your computer are pro­grams you write that directly control the keyboard and mouse. These programs can control other applications by sending them virtual keystrokes and mouse clicks, just as if you were sitting at your computer and interacting with the applications yourself.

This technique is known as graphical user interface automation, ou alors GUI automation for short. With GUI automation, your programs can do anything that a human user sitting at the computer can do, except spill coffee on the keyboard. Think of GUI automation as programming a robotic arm. You can program the robotic arm to type at your keyboard and move your mouse for you. This technique is particularly useful for tasks that involve a lot of mindless clicking or filling out of forms.

Some companies sell innovative (and pricey) “automation solutions,” usually marketed as robotic process automation (RPA). These products are effectively no different than the Python scripts you can make yourself with the pyautogui module, which has functions for simulating mouse movements, button clicks, and mouse wheel scrolls. This chapter covers only a subset of PyAutoGUI’s features you can find the full documentation at https://pyautogui.readthedocs.io/.

Installing the pyautogui Module

The pyautogui module can send virtual keypresses and mouse clicks to Windows, macOS, and Linux. Windows and macOS users can simply use pip to install PyAutoGUI. However, Linux users will first have to install some software that PyAutoGUI depends on. Open a terminal window and enter the following commands:

  • sudo apt-get install scrot
  • sudo apt-get install python3-tk
  • sudo apt-get install python3-dev

To install PyAutoGUI, run pip install --user pyautogui . Don’t use sudo with pip you may install modules to the Python installation that the operating system uses, causing conflicts with any scripts that rely on its original configuration. However, you should use the sudo command when installing applications with apt-get .

Appendix A has complete information on installing third-party modules. To test whether PyAutoGUI has been installed correctly, run import pyautogui from the interactive shell and check for any error messages.

Don’t save your program as pyautogui.py. When you run import pyautogui , Python will import your program instead of the PyAutoGUI and you’ll get error messages like AttributeError: module 'pyautogui' has no attribute 'click' .

Setting Up Accessibility Apps on macOS

As a security measure, macOS doesn’t normally let programs control the mouse or keyboard. To make PyAutoGUI work on macOS, you must set the program running your Python script to be an accessibility application. Without this step, your PyAutoGUI function calls will have no effect.

Whether you run your Python programs from Mu, IDLE, or the Terminal, have that application open. Then open the System Preferences and go to the Accessibility tab. The currently open applications will appear under the “Allow the apps below to control your computer” label. Check Mu, IDLE, Terminal, or whichever app you use to run your Python scripts. You’ll be prompted to enter your password to confirm these changes.

Staying on Track

Before you jump into a GUI automation, you should know how to escape problems that may arise. Python can move your mouse and type keystrokes at an incredible speed. In fact, it might be too fast for other programs to keep up with. Also, if something goes wrong but your program keeps moving the mouse around, it will be hard to tell what exactly the program is doing or how to recover from the problem. Like the enchanted brooms from Disney’s The Sorcerer’s Apprentice, which kept filling&mdashand then overfilling&mdashMickey’s tub with water, your program could get out of control even though it’s following your instructions perfectly. Stopping the program can be difficult if the mouse is moving around on its own, preventing you from clicking the Mu Editor window to close it. Fortunately, there are several ways to prevent or recover from GUI automation problems.

Pauses and Fail-Safes

If your program has a bug and you’re unable to use the keyboard and mouse to shut it down, you can use PyAutoGUI’s fail-safe feature. Quickly slide the mouse to one of the four corners of the screen. Every PyAutoGUI function call has a 10th-of-a-second delay after performing its action to give you enough time to move the mouse to a corner. If PyAutoGUI then finds that the mouse cursor is in a corner, it raises the pyautogui.FailSafeException exception. Non-PyAutoGUI instructions will not have this 10th-of-a-second delay.

If you find yourself in a situation where you need to stop your PyAutoGUI program, just slam the mouse toward a corner to stop it.

Shutting Down Everything by Logging Out

Perhaps the simplest way to stop an out-of-control GUI automation program is to log out, which will shut down all running programs. On Windows and Linux, the logout hotkey is CTRL-ALT-DEL. On macOS, it is -SHIFT-OPTION-Q. By logging out, you’ll lose any unsaved work, but at least you won’t have to wait for a full reboot of the computer.

Controlling Mouse Movement

In this section, you’ll learn how to move the mouse and track its position on the screen using PyAutoGUI, but first you need to understand how PyAutoGUI works with coordinates.

The mouse functions of PyAutoGUI use x- and y-coordinates. Figure 20-1 shows the coordinate system for the computer screen it’s similar to the coordinate system used for images, discussed in Chapter 19. The origine, où X et oui are both zero, is at the upper-left corner of the screen. The x-coordinates increase going to the right, and the y-coordinates increase going down. All coordinates are positive integers there are no negative coordinates.

Figure 20-1: The coordinates of a computer screen with 1920×1080 resolution

Ton resolution is how many pixels wide and tall your screen is. If your screen’s resolution is set to 1920×1080, then the coordinate for the upper-left corner will be (0, 0), and the coordinate for the bottom-right corner will be (1919, 1079).

The pyautogui.size() function returns a two-integer tuple of the screen’s width and height in pixels. Enter the following into the interactive shell:

>>> import pyautogui
>>> wh = pyautogui.size() # Obtain the screen resolution.
>>> wh
Size(width=1920, height=1080)
>>> wh[0]
1920
>>> wh.width
1920

The pyautogui.size() function returns (1920, 1080) on a computer with a 1920×1080 resolution depending on your screen’s resolution, your return value may be different. The Size object returned by size() is a named tuple. Named tuples have numeric indexes, like regular tuples, and attribute names, like objects: both wh[0] and wh.width evaluate to the width of the screen. (Named tuples are beyond the scope of this book. Just remember that you can use them the same way you use tuples.)

Moving the Mouse

Now that you understand screen coordinates, let’s move the mouse. The pyautogui.moveTo() function will instantly move the mouse cursor to a specified position on the screen. Integer values for the x- and y-coordinates make up the function’s first and second arguments, respectively. An optional duration integer or float keyword argument specifies the number of seconds it should take to move the mouse to the destination. If you leave it out, the default is 0 for instantaneous movement. (All of the duration keyword arguments in PyAutoGUI functions are optional.) Enter the following into the interactive shell:

>>> import pyautogui
>>> for i in range(10): # Move mouse in a square.
. pyautogui.moveTo(100, 100, duration=0.25)
. pyautogui.moveTo(200, 100, duration=0.25)
. pyautogui.moveTo(200, 200, duration=0.25)
. pyautogui.moveTo(100, 200, duration=0.25)

This example moves the mouse cursor clockwise in a square pattern among the four coordinates provided a total of 10 times. Each movement takes a quarter of a second, as specified by the duration=0.25 keyword argument. If you hadn’t passed a third argument to any of the pyautogui.moveTo() calls, the mouse cursor would have instantly teleported from point to point.

The pyautogui.move() function moves the mouse cursor relative to its current position. The following example moves the mouse in the same square pattern, except it begins the square from wherever the mouse happens to be on the screen when the code starts running:

>>> import pyautogui
>>> for i in range(10):
. pyautogui.move(100, 0, duration=0.25) # right
. pyautogui.move(0, 100, duration=0.25) # down
. pyautogui.move(-100, 0, duration=0.25) # left
. pyautogui.move(0, -100, duration=0.25) # up

The pyautogui.move() function also takes three arguments: how many pixels to move horizontally to the right, how many pixels to move vertically downward, and (optionally) how long it should take to complete the movement. A negative integer for the first or second argument will cause the mouse to move left or upward, respectively.

Getting the Mouse Position

You can determine the mouse’s current position by calling the pyautogui.position() function, which will return a Point named tuple of the mouse cursor’s X et oui positions at the time of the function call. Enter the following into the interactive shell, moving the mouse around after each call:

>>> pyautogui.position() # Get current mouse position.
Point(x=311, y=622)
>>> pyautogui.position() # Get current mouse position again.
Point(x=377, y=481)
>>> p = pyautogui.position() # And again.
>>> p
Point(x=1536, y=637)
>>> p[0] # The x-coordinate is at index 0.
1536
>>> p.x # The x-coordinate is also in the x attribute.
1536

Of course, your return values will vary depending on where your mouse cursor is.

Controlling Mouse Interaction

Now that you know how to move the mouse and figure out where it is on the screen, you’re ready to start clicking, dragging, and scrolling.

Clicking the Mouse

To send a virtual mouse click to your computer, call the pyautogui.click() method. By default, this click uses the left mouse button and takes place wherever the mouse cursor is currently located. You can pass x- and y-coordinates of the click as optional first and second arguments if you want it to take place somewhere other than the mouse’s current position.

If you want to specify which mouse button to use, include the button keyword argument, with a value of 'left' , 'middle' , or 'right' . For example, pyautogui.click(100, 150, button='left') will click the left mouse button at the coordinates (100, 150), while pyautogui.click(200, 250, button='right') will perform a right-click at (200, 250).

Enter the following into the interactive shell:

>>> import pyautogui
>>> pyautogui.click(10, 5) # Move mouse to (10, 5) and click.

You should see the mouse pointer move to near the top-left corner of your screen and click once. A full “click” is defined as pushing a mouse button down and then releasing it back up without moving the cursor. You can also perform a click by calling pyautogui.mouseDown() , which only pushes the mouse button down, and pyautogui.mouseUp() , which only releases the button. These functions have the same arguments as click() , and in fact, the click() function is just a convenient wrapper around these two function calls.

As a further convenience, the pyautogui.doubleClick() function will perform two clicks with the left mouse button, while the pyautogui.rightClick() and pyautogui.middleClick() functions will perform a click with the right and middle mouse buttons, respectively.

Dragging the Mouse

Dragging means moving the mouse while holding down one of the mouse buttons. For example, you can move files between folders by dragging the folder icons, or you can move appointments around in a calendar app.

PyAutoGUI provides the pyautogui.dragTo() and pyautogui.drag() functions to drag the mouse cursor to a new location or a location relative to its current one. The arguments for dragTo() and drag() are the same as moveTo() and move() : the x-coordinate/horizontal movement, the y-coordinate/vertical movement, and an optional duration of time. (macOS does not drag correctly when the mouse moves too quickly, so passing a duration keyword argument is recommended.)

To try these functions, open a graphics-drawing application such as MS Paint on Windows, Paintbrush on macOS, or GNU Paint on Linux. (If you don’t have a drawing application, you can use the online one at https://sumopaint.com/.) I will use PyAutoGUI to draw in these applications.

With the mouse cursor over the drawing application’s canvas and the Pencil or Brush tool selected, enter the following into a new file editor window and save it as spiralDraw.py:

import pyautogui, time
? time.sleep(5)
? pyautogui.click() # Click to make the window active.
distance = 300
change = 20
while distance > 0:
? pyautogui.drag(distance, 0, duration=0.2) # Move right.
? distance = distance &ndash change
? pyautogui.drag(0, distance, duration=0.2) # Move down.
? pyautogui.drag(-distance, 0, duration=0.2) # Move left.
distance = distance &ndash change
pyautogui.drag(0, -distance, duration=0.2) # Move up.

When you run this program, there will be a five-second delay ? for you to move the mouse cursor over the drawing program’s window with the Pencil or Brush tool selected. Puis spiralDraw.py will take control of the mouse and click to make the drawing program’s window active ? . Le active window is the window that currently accepts keyboard input, and the actions you take&mdashlike typing or, in this case, dragging the mouse&mdashwill affect that window. The active window is also known as the concentré ou alors foreground window. Once the drawing program is active, spiralDraw.py draws a square spiral pattern like the one on the left of Figure 20-2. While you can also create a square spiral image by using the Pillow module discussed in Chapter 19, creating the image by controlling the mouse to draw it in MS Paint lets you make use of this program’s various brush styles, like in Figure 20-2 on the right, as well as other advanced features, like gradients or the fill bucket. You can preselect the brush settings yourself (or have your Python code select these settings) and then run the spiral-drawing program.

Figure 20-2: The results from the pyautogui.drag() example, drawn with MS Paint’s different brushes

The distance variable starts at 200 , so on the first iteration of the while loop, the first drag() call drags the cursor 200 pixels to the right, taking 0.2 seconds ? . distance is then decreased to 195 ? , and the second drag() call drags the cursor 195 pixels down ? . The third drag() call drags the cursor &ndash195 horizontally (195 to the left) ? , distance is decreased to 190, and the last drag() call drags the cursor 190 pixels up. On each iteration, the mouse is dragged right, down, left, and up, and distance is slightly smaller than it was in the previous iteration. By looping over this code, you can move the mouse cursor to draw a square spiral.

You could draw this spiral by hand (or rather, by mouse), but you’d have to work slowly to be so precise. PyAutoGUI can do it in a few seconds!

At the time of this writing, PyAutoGUI can’t send mouse clicks or keystrokes to certain programs, such as antivirus software (to prevent viruses from disabling the software) or video games on Windows (which use a different method of receiving mouse and keyboard input). You can check the online documentation at https://pyautogui.readthedocs.io/ to see if these features have been added.

Scrolling the Mouse

The final PyAutoGUI mouse function is scroll() , which you pass an integer argument for how many units you want to scroll the mouse up or down. The size of a unit varies for each operating system and application, so you’ll have to experiment to see exactly how far it scrolls in your particular situation. The scrolling takes place at the mouse cursor’s current position. Passing a positive integer scrolls up, and passing a negative integer scrolls down. Run the following in Mu Editor’s interactive shell while the mouse cursor is over the Mu Editor window:

You’ll see Mu scroll upward if the mouse cursor is over a text field that can be scrolled up.

Planning Your Mouse Movements

One of the difficulties of writing a program that will automate clicking the screen is finding the x- and y-coordinates of the things you’d like to click. The pyautogui.mouseInfo() function can help you with this.

The pyautogui.mouseInfo() function is meant to be called from the interactive shell, rather than as part of your program. It launches a small application named MouseInfo that’s included with PyAutoGUI. The window for the application looks like Figure 20-3.

Figure 20-3: The MouseInfo application’s window

Enter the following into the interactive shell:

>>> import pyautogui
>>> pyautogui.mouseInfo()

This makes the MouseInfo window appear. This window gives you information about the mouse’s cursor current position, as well the color of the pixel underneath the mouse cursor, as a three-integer RGB tuple and as a hex value. The color itself appears in the color box in the window.

To help you record this coordinate or pixel information, you can click one of the eight Copy or Log buttons. The Copy All, Copy XY, Copy RGB, and Copy RGB Hex buttons will copy their respective information to the clipboard. The Log All, Log XY, Log RGB, and Log RGB Hex buttons will write their respective information to the large text field in the window. You can save the text in this log text field by clicking the Save Log button.

By default, the 3 Sec. Button Delay checkbox is checked, causing a three-second delay between clicking a Copy or Log button and the copying or logging taking place. This gives you a short amount of time in which to click the button and then move the mouse into your desired position. It may be easier to uncheck this box, move the mouse into position, and press the F1 to F8 keys to copy or log the mouse position. You can look at the Copy and Log menus at the top of the MouseInfo window to find out which key maps to which buttons.

For example, uncheck the 3 Sec. Button Delay, then move the mouse around the screen while pressing the F6 button, and notice how the x- and y-coordinates of the mouse are recorded in the large text field in the middle of the window. You can later use these coordinates in your PyAutoGUI scripts.

For more information on MouseInfo, review the complete documentation at https://mouseinfo.readthedocs.io/.

Working with the Screen

Your GUI automation programs don’t have to click and type blindly. PyAutoGUI has screenshot features that can create an image file based on the current contents of the screen. These functions can also return a Pillow Image object of the current screen’s appearance. If you’ve been skipping around in this book, you’ll want to read Chapter 17 and install the pillow module before continuing with this section.

On Linux computers, the scrot program needs to be installed to use the screenshot functions in PyAutoGUI. In a Terminal window, run sudo apt-get install scrot to install this program. If you’re on Windows or macOS, skip this step and continue with the section.

Getting a Screenshot

To take screenshots in Python, call the pyautogui.screenshot() function. Enter the following into the interactive shell:

>>> import pyautogui
>>> im = pyautogui.screenshot()

The im variable will contain the Image object of the screenshot. You can now call methods on the Image object in the im variable, just like any other Image object. Chapter 19 has more information about Image objects.

Analyzing the Screenshot

Say that one of the steps in your GUI automation program is to click a gray button. Before calling the click() method, you could take a screenshot and look at the pixel where the script is about to click. If it’s not the same gray as the gray button, then your program knows something is wrong. Maybe the window moved unexpectedly, or maybe a pop-up dialog has blocked the button. At this point, instead of continuing&mdashand possibly wreaking havoc by clicking the wrong thing&mdashyour program can “see” that it isn’t clicking the right thing and stop itself.

You can obtain the RGB color value of a particular pixel on the screen with the pixel() function. Enter the following into the interactive shell:

>>> import pyautogui
>>> pyautogui.pixel((0, 0))
(176, 176, 175)
>>> pyautogui.pixel((50, 200))
(130, 135, 144)

Pass pixel() a tuple of coordinates, like (0, 0) or (50, 200), and it’ll tell you the color of the pixel at those coordinates in your image. The return value from pixel() is an RGB tuple of three integers for the amount of red, green, and blue in the pixel. (There is no fourth value for alpha, because screenshot images are fully opaque.)

PyAutoGUI’s pixelMatchesColor() function will return True if the pixel at the given x- and y-coordinates on the screen matches the given color. The first and second arguments are integers for the x- and y-coordinates, and the third argument is a tuple of three integers for the RGB color the screen pixel must match. Enter the following into the interactive shell:

>>> import pyautogui
? >>> pyautogui.pixel((50, 200))
(130, 135, 144)
? >>> pyautogui.pixelMatchesColor(50, 200, (130, 135, 144))
Vrai
? >>> pyautogui.pixelMatchesColor(50, 200, (255, 135, 144))
Faux

After using pixel() to get an RGB tuple for the color of a pixel at specific coordinates ? , pass the same coordinates and RGB tuple to pixelMatchesColor() ? , which should return True . Then change a value in the RGB tuple and call pixelMatchesColor() again for the same coordinates ? . This should return false . This method can be useful to call whenever your GUI automation programs are about to call click() . Note that the color at the given coordinates must exactly correspondre. If it is even slightly different&mdashfor example, (255, 255, 254) instead of (255, 255, 255) &mdashthen pixelMatchesColor() will return False .

Image Recognition

But what if you do not know beforehand where PyAutoGUI should click? You can use image recognition instead. Give PyAutoGUI an image of what you want to click, and let it figure out the coordinates.

For example, if you have previously taken a screenshot to capture the image of a Submit button in submit.png, the locateOnScreen() function will return the coordinates where that image is found. To see how locateOnScreen() works, try taking a screenshot of a small area on your screen then save the image and enter the following into the interactive shell, replacing 'submit.png' with the filename of your screenshot:

>>> import pyautogui
>>> b = pyautogui.locateOnScreen('submit.png')
>>> b
Box(left=643, top=745, width=70, height=29)
>>> b[0]
643
>>> b.left
643

The Box object is a named tuple that locateOnScreen() returns and has the x-coordinate of the left edge, the y-coordinate of the top edge, the width, and the height for the first place on the screen the image was found. If you’re trying this on your computer with your own screenshot, your return value will be different from the one shown here.

If the image cannot be found on the screen, locateOnScreen() returns None . Note that the image on the screen must match the provided image perfectly in order to be recognized. If the image is even a pixel off, locateOnScreen() raises an ImageNotFoundException exception. If you’ve changed your screen resolution, images from previous screenshots might not match the images on your current screen. You can change the scaling in the display settings of your operating system, as shown in Figure 20-4.

Figure 20-4: The scale display settings in Windows 10 (left) and macOS (right)

If the image can be found in several places on the screen, locateAllOnScreen() will return a Generator object. Generators are beyond the scope of this book, but you can pass them to list() to return a list of four-integer tuples. There will be one four-integer tuple for each location where the image is found on the screen. Continue the interactive shell example by entering the following (and replacing 'submit.png' with your own image filename):

>>> list(pyautogui.locateAllOnScreen('submit.png'))
[(643, 745, 70, 29), (1007, 801, 70, 29)]

Each of the four-integer tuples represents an area on the screen. In the example above, the image appears in two locations. If your image is only found in one area, then using list() and locateAllOnScreen() returns a list containing just one tuple.

Once you have the four-integer tuple for the specific image you want to select, you can click the center of this area by passing the tuple to click() . Enter the following into the interactive shell:

>>> pyautogui.click((643, 745, 70, 29))

As a shortcut, you can also pass the image filename directly to the click() function:

The moveTo() and dragTo() functions also accept image filename arguments. Remember locateOnScreen() raises an exception if it can’t find the image on the screen, so you should call it from inside a try statement:

try:
location = pyautogui.locateOnScreen('submit.png')
except:
print('Image could not be found.')

Without the try and except statements, the uncaught exception would crash your program. Since you can’t be sure that your program will always find the image, it’s a good idea to use the try and except statements when calling locateOnScreen() .

Getting Window Information

Image recognition is a fragile way to find things on the screen if a single pixel is a different color, then pyautogui.locateOnScreen() won’t find the image. If you need to find where a particular window is on the screen, it’s faster and more reliable to use PyAutoGUI’s window features.

As of version 0.9.46, PyAutoGUI’s window features work only on Windows, not on macOS or Linux. These features come from PyAutoGUI’s inclusion of the PyGetWindow module.

Obtaining the Active Window

The active window on your screen is the window currently in the foreground and accepting keyboard input. If you’re currently writing code in the Mu Editor, the Mu Editor’s window is the active window. Of all the windows on your screen, only one will be active at a time.

In the interactive shell, call the pyautogui.getActiveWindow() function to get a Window object (technically a Win32Window object when run on Windows).

Once you have that Window object, you can retrieve any of the object’s attributes, which describe its size, position, and title:

left, right, top, bottom A single integer for the x- or y-coordinate of the window’s side

topleft, topright, bottomleft, bottomright A named tuple of two integers for the (x, y) coordinates of the window’s corner

midleft, midright, midleft, midright A named tuple of two integers for the (x, y) coordinate of the middle of the window’s side

width, height A single integer for one of the window’s dimensions, in pixels

size A named tuple of two integers for the (width, height) of the window

area A single integer representing the area of the window, in pixels

center A named tuple of two integers for the (x, y) coordinate of the window’s center

centerx, centery A single integer for the x- or y-coordinate of the window’s center

box A named tuple of four integers for the (left, top, width, height) measurements of the window

title A string of the text in the title bar at the top of the window

To get the window’s position, size, and title information from the window object, for example, enter the following into the interactive shell:

>>> import pyautogui
>>> fw = pyautogui.getActiveWindow()
>>> fw
Win32Window(hWnd=2034368)
>>> str(fw)
'<Win32Window left="500", top="300",,, title="Mu 1.0.1 &ndash test1.py">'
>>> fw.title
'Mu 1.0.1 &ndash test1.py'
>>> fw.size
(2070, 1208)
>>> fw.left, fw.top, fw.right, fw.bottom
(500, 300, 2070, 1208)
>>> fw.topleft
(256, 144)
>>> fw.area
2500560
>>> pyautogui.click(fw.left + 10, fw.top + 20)

You can now use these attributes to calculate precise coordinates within a window. If you know that a button you want to click is always 10 pixels to the right of and 20 pixels down from the window’s top-left corner, and the window’s top-left corner is at screen coordinates (300, 500), then calling pyautogui.click(310, 520) (or pyautogui.click(fw.left + 10, fw.top + 20) if fw contains the Window object for the window) will click the button. This way, you won’t have to rely on the slower, less reliable locateOnScreen() function to find the button for you.

Other Ways of Obtaining Windows

While getActiveWindow() is useful for obtaining the window that is active at the time of the function call, you’ll need to use some other function to obtain Window objects for the other windows on the screen.

The following four functions return a list of Window objects. If they’re unable to find any windows, they return an empty list:

pyautogui.getAllWindows() Returns a list of Window objects for every visible window on the screen.

pyautogui.getWindowsAt(x, y) Returns a list of Window objects for every visible window that includes the point (x, y).

pyautogui.getWindowsWithTitle(title) Returns a list of Window objects for every visible window that includes the string title in its title bar.

pyautogui.getActiveWindow() Returns the Window object for the window that is currently receiving keyboard focus.

PyAutoGUI also has a pyautogui.getAllTitles() function, which returns a list of strings of every visible window.

Manipulating Windows

Windows attributes can do more than just tell you the size and position of the window. You can also set their values in order to resize or move the window. For example, enter the following into the interactive shell:

>>> import pyautogui
>>> fw = pyautogui.getActiveWindow()
? >>> fw.width # Gets the current width of the window.
1669
? >>> fw.topleft # Gets the current position of the window.
(174, 153)
? >>> fw.width = 1000 # Resizes the width.
? >>> fw.topleft = (800, 400) # Moves the window.

First, we use the Window object’s attributes to find out information about the window’s size ? and position ? . After calling these functions in Mu Editor, the window should move ? and become narrower ? , as in Figure 20-5.

Figure 20-5: The Mu Editor window before (top) and after (bottom) using the Window object attributes to move and resize it

You can also find out and change the window’s minimized, maximized, and activated states. Try entering the following into the interactive shell:

>>> import pyautogui
>>> fw = pyautogui.getActiveWindow()
? >>> fw.isMaximized # Returns True if window is maximized.
Faux
? >>> fw.isMinimized # Returns True if window is minimized.
Faux
? >>> fw.isActive # Returns True if window is the active window.
Vrai
? >>> fw.maximize() # Maximizes the window.
>>> fw.isMaximized
Vrai
? >>> fw.restore() # Undoes a minimize/maximize action.
? >>> fw.minimize() # Minimizes the window.
>>> import time
>>> # Wait 5 seconds while you activate a different window:
? >>> time.sleep(5) fw.activate()
? >>> fw.close() # This will close the window you're typing in.

The isMaximized ? , isMinimized ? , and isActive ? attributes contain Boolean values that indicate whether the window is currently in that state. The maximize() ? , minimize() ? , activate() ? , and restore() ? methods change the window’s state. After you maximize or minimize the window with maximize() or minimize() , the restore() method will restore the window to its former size and position.

The close() method ? will close a window. Be careful with this method, as it may bypass any message dialogs asking you to save your work before quitting the application.

The complete documentation for PyAutoGUI’s window-controlling feature can be found at https://pyautogui.readthedocs.io/. You can also use these features separately from PyAutoGUI with the PyGetWindow module, documented at https://pygetwindow.readthedocs.io/.

Controlling the Keyboard

PyAutoGUI also has functions for sending virtual keypresses to your computer, which enables you to fill out forms or enter text into applications.

Sending a String from the Keyboard

The pyautogui.write() function sends virtual keypresses to the computer. What these keypresses do depends on what window is active and what text field has focus. You may want to first send a mouse click to the text field you want in order to ensure that it has focus.

As a simple example, let’s use Python to automatically type the words Hello, world! into a file editor window. First, open a new file editor window and position it in the upper-left corner of your screen so that PyAutoGUI will click in the right place to bring it into focus. Next, enter the following into the interactive shell:

>>> pyautogui.click(100, 200) pyautogui.write('Hello, world!')

Notice how placing two commands on the same line, separated by a semicolon, keeps the interactive shell from prompting you for input between running the two instructions. This prevents you from accidentally bringing a new window into focus between the click() and write() calls, which would mess up the example.

Python will first send a virtual mouse click to the coordinates (100, 200), which should click the file editor window and put it in focus. The write() call will send the text Hello, world! to the window, making it look like Figure 20-6. You now have code that can type for you!

Figure 20-6: Using PyAutogGUI to click the file editor window and type Hello, world! into it

By default, the write() function will type the full string instantly. However, you can pass an optional second argument to add a short pause between each character. This second argument is an integer or float value of the number of seconds to pause. For example, pyautogui.write('Hello, world!', 0.25) will wait a quarter-second after typing H, another quarter-second after e, etc. This gradual typewriter effect may be useful for slower applications that can’t process keystrokes fast enough to keep up with PyAutoGUI.

For characters such as UNE ou alors !, PyAutoGUI will automatically simulate holding down the SHIFT key as well.

Key Names

Not all keys are easy to represent with single text characters. For example, how do you represent SHIFT or the left arrow key as a single character? In PyAutoGUI, these keyboard keys are represented by short string values instead: 'esc' for the ESC key or 'enter' for the ENTER clé.

Instead of a single string argument, a list of these keyboard key strings can be passed to write() . For example, the following call presses the A key, then the B key, then the left arrow key twice, and finally the X and Y keys:

Because pressing the left arrow key moves the keyboard cursor, this will output XYab. Table 20-1 lists the PyAutoGUI keyboard key strings that you can pass to write() to simulate pressing any combination of keys.

You can also examine the pyautogui.KEYBOARD_KEYS list to see all possible keyboard key strings that PyAutoGUI will accept. The 'shift' string refers to the left SHIFT key and is equivalent to 'shiftleft' . The same applies for 'ctrl' , 'alt' , and 'win' strings they all refer to the left-side key.

Table 20-1: PyKeyboard Attributes

Keyboard key string

'a' , 'b' , 'c' , 'A' , 'B' , 'C' , '1' , '2' , '3' , '!' , '@' , '#' , and so on