Cinq vrais favoris de Python – Real Python

By | juillet 22, 2020

Expert Python

Python dispose d'un vaste écosystème de packages, de modules et de bibliothèques que vous pouvez utiliser pour créer votre application. Certains de ces packages et modules sont inclus avec votre installation Python et sont collectivement connus sous le nom de bibliothèque standard.

La bibliothèque standard se compose de modules qui fournissent des solutions standardisées aux problèmes de programmation courants. Ce sont d'excellents éléments constitutifs pour les applications dans de nombreuses disciplines. Cependant, de nombreux développeurs préfèrent utiliser des packages alternatifs, ou extensions, cela peut améliorer la convivialité et l'utilité des éléments de la bibliothèque standard.

Dans ce didacticiel, vous rencontrerez certains des auteurs à Vrai Python et découvrez les packages qu'ils aiment utiliser à la place des packages les plus courants dans la bibliothèque standard.

Les packages que vous découvrirez dans ce didacticiel sont les suivants:

  • pudb: Un débogueur visuel avancé basé sur du texte
  • demandes: Une belle API pour faire des requêtes HTTP
  • analyser: Un correcteur de texte intuitif et lisible
  • dateutil: Une extension pour le populaire datetime bibliothèque
  • dactylo: Un analyseur d'interface de ligne de commande intuitif

Vous allez commencer par examiner une alternative visuelle et puissante à PDB.

pudb pour le débogage visuel

Christophe Trudeau

Christophe Trudeau est un auteur et créateur de cours chez Real Python. Au travail, c'est un consultant qui aide les organisations à améliorer leurs équipes techniques. À la maison, il passe son temps avec les jeux de société et la photographie.

Je passe beaucoup de temps à travailler SSH sur des machines distantes, donc je ne peux pas profiter de la plupart des IDE. Mon débogueur de choix est pudb, qui a une interface utilisateur basée sur du texte. Je trouve son interface intuitive et simple d'utilisation.

Python est livré avec PDB, qui a été inspiré par gdb, qui lui-même a été inspiré par dbx. Tandis que PDB fait le travail, la meilleure chose à faire est qu'il est livré avec Python. Comme il est basé sur la ligne de commande, vous devez vous souvenir d'un grand nombre de touches de raccourci et ne pouvez voir que de petites quantités de code source à la fois.

Un autre package Python pour le débogage est pudb. Il affiche un plein écran du code source ainsi que des informations de débogage utiles. Cela a l'avantage supplémentaire de me rendre nostalgique de l'ancien temps lorsque je codais en Turbo Pascal:

Interface Pudb

L'interface est divisée en deux parties principales. Le panneau de gauche est pour le code source et le panneau de droite pour les informations de contexte. Le côté droit est subdivisé en trois sections:

  1. Variables
  2. Empiler
  3. Points d'arrêt

Tout ce dont vous avez besoin dans un débogueur est disponible sur un seul écran.

Interagir avec pudb

Vous pouvez installer pudb à travers pépin:

$ python -m pip installer pudb

Si vous utilisez Python 3.7 ou supérieur, vous pouvez profiter de point d'arrêt () en définissant le PYTHONBREAKPOINT variable d'environnement à pudb.set_trace. Si vous utilisez un système d'exploitation basé sur Unix tel que Linux ou macOS, vous définissez la variable comme suit:

$ exportation PYTHONBREAKPOINT=pudb.set_trace

Si vous êtes basé sous Windows, la commande est différente:

C: > ensemble PYTHONBREAKPOINT=pudb.set_trace

Vous pouvez également insérer import pudb; pudb.set_trace () directement dans votre code.

Lorsque votre code en cours d'exécution atteint un point d'arrêt, pudb interrompt l'exécution et affiche son interface:

Utilisation de base de Pudb

Vous pouvez naviguer et exécuter le code source avec le clavier:

Clé action
Vers le haut ou K Déplacer le code d'une ligne
Vers le bas ou J Déplacer le code d'une ligne vers le bas
Haut de page ou Ctrl+B Faire défiler la page de codes vers le haut
Bas de page ou Ctrl+F Faire défiler la page de codes vers le bas
N Exécuter la ligne courante
S Entrez dans la ligne actuelle s'il s'agit d'une fonction
C Poursuivre l'exécution jusqu'au prochain point d'arrêt

Si vous redémarrez votre code, alors pudb se souvient des points d'arrêt de la session précédente. Droite et La gauche vous permettent de vous déplacer entre le code source et la zone de contrôle sur le côté droit.

À l'intérieur de Variables , vous voyez toutes les variables actuellement dans la portée:

Panneau des variables Pudb

Par défaut, la vue d'une variable est raccourcie, mais vous pouvez voir le contenu complet en appuyant sur . Le développement de la vue vous montrera les éléments dans un tuple ou une liste, ou il affichera le contenu complet d'une variable binaire. T et R basculer entre repro et type modes d'affichage.

Utilisation d'expressions de surveillance et accès au REPL

Tandis que le Variables zone sur le côté droit est focalisée, vous pouvez également ajouter un regarder l'expression. Une montre peut être n'importe quelle expression Python. Il est utile pour examiner les données enfouies profondément dans un objet alors que l’objet est encore dans sa forme abrégée ou pour évaluer des relations complexes entre des variables.

Pressage ! vous échappe vers une REPL dans le contexte de votre programme en cours d'exécution. Ce mode affiche également toute sortie envoyée à l'écran avant le déclenchement du débogueur. En naviguant dans l'interface ou en utilisant des touches de raccourci, vous pouvez également modifier les points d'arrêt, changer où vous vous trouvez dans le cadre de la pile et charger d'autres fichiers de code source.

Pourquoi pudb Est génial

le pudb l'interface nécessite moins de mémorisation des touches de raccourci que PDB et est conçu pour afficher autant de code que possible. Il possède la plupart des fonctionnalités des débogueurs trouvés dans les IDE mais peut être utilisé dans un terminal. Comme l'installation de ce package Python n'est qu'un bref appel à pépin loin, vous pouvez l'importer rapidement dans n'importe quel environnement. La prochaine fois que vous serez bloqué sur la ligne de commande, vérifiez-le!

demandes pour interagir avec le Web

Martin Breuss

Martin Breuss est un auteur et créateur de cours chez Real Python. Il travaille en tant qu'éducateur en programmation chez CodingNomads, où il enseigne des bootcamps et des cours en ligne. En dehors du travail, il aime prendre des sièges, marcher et enregistrer des sons aléatoires.

Mon choix numéro un pour un package Python en dehors de la bibliothèque standard est le populaire demandes paquet. Il a un statut spécial sur mon ordinateur car il est le seulement package externe que j'ai installé à l'échelle du système. Tous les autres packages vivent dans leurs environnements virtuels dédiés.

Je ne suis pas le seul à favoriser demandes comme principal outil pour les interactions Web Python: selon le demandes documentation, le package compte environ 1,6 million de téléchargements par jour!

Ce nombre est si élevé car les interactions programmatiques avec Internet offrent de nombreuses possibilités, qu'il s'agisse de publier vos écrits via une API Web ou de récupérer des données via le web scraping. Mais la bibliothèque standard de Python inclut déjà le urllib package pour vous aider à accomplir ces tâches. Alors pourquoi utiliser un package externe? Ce qui rend demandes un choix si populaire?

demandes Est lisible

le demandes Library présente une API bien développée qui suit de près l'objectif de Python d'être aussi lisible qu'en anglais ordinaire. le demandes les développeurs ont résumé cette idée dans leur slogan «HTTP for Humans».

Vous pouvez utiliser pépin à installer demandes sur ton ordinateur:

$ demandes d'installation python -m pip

Voyons comment demandes résiste en termes de lisibilité en l'utilisant pour accéder au texte d'un site Web. Lorsque vous vous attaquez à cette tâche avec votre navigateur fiable, vous devez suivre les étapes suivantes:

  1. Ouvrez le navigateur.
  2. Saisissez l'URL.
  3. Regardez le texte du site Web.

Comment pourriez-vous obtenir le même résultat avec du code? Tout d'abord, vous définissez les étapes nécessaires pseudocode:

  1. Importez l'outillage dont vous avez besoin.
  2. Obtenez les données du site Web.
  3. Imprimez le texte du site Web.

Après avoir clarifié la logique, vous traduisez le pseudocode en Python à l'aide du demandes bibliothèque:

>>>

>>> importer demandes
>>> réponse = demandes.avoir("http://www.example.com")
>>> réponse.texte

Le code se lit presque comme l'anglais et est concis et clair. Bien que cet exemple de base ne soit pas beaucoup plus difficile à construire avec la bibliothèque standard urllib paquet, demandes conserve sa syntaxe simple et centrée sur l'humain, même dans des scénarios plus complexes.

Dans l'exemple suivant, vous verrez que vous pouvez réaliser beaucoup de choses avec seulement quelques lignes de code Python.

demandes Est puissant

Intensifions le jeu et défions demandes avec une tâche plus complexe:

  1. Connectez-vous à votre compte GitHub.
  2. Conservez ces informations de connexion pour gérer plusieurs demandes.
  3. Créez un nouveau référentiel.
  4. Créez un nouveau fichier avec du contenu.
  5. Exécutez la deuxième requête uniquement si la première réussit.

Défi accepté et accompli! L'extrait de code ci-dessous effectue toutes les tâches ci-dessus. Tout ce que vous avez à faire est de remplacer les deux chaînes "VOTRE_GITHUB_USERNAME" et "VOTRE_GITHUB_TOKEN" avec votre nom d'utilisateur GitHub et votre jeton d'accès personnel, respectivement.

Lisez l'extrait de code ci-dessous, copiez-le et enregistrez-le dans votre propre script Python, remplissez vos informations d'identification et exécutez-le pour voir demandes en action:

importer demandes

session = demandes.Session()
session.auth = ("VOTRE_GITHUB_USERNAME", "VOTRE_GITHUB_TOKEN")
charge utile = 
    "Nom": "demandes de test",
    "la description": "Créé avec la bibliothèque de requêtes"

api_url ="https://api.github.com/user/repos"
response_1 = session.Publier(api_url, json=charge utile)
si response_1:
    Les données = 
            "message": "Ajouter README via l'API",
            # Le 'contenu' doit être une chaîne encodée en base64
            # La bibliothèque standard de Python peut vous aider
            # Vous pouvez découvrir le secret de cette chaîne déformée
            # en le téléchargeant sur GitHub avec ce script :)
            "contenu": "UmVxdWVzdHMgaXMgYXdlc29tZSE ="
    
    repo_url = response_1.json()[[[["url"]
    readme_url = F"repo_url/contents/README.md "
    response_2 = session.mettre(readme_url, json=Les données)
autre:
    impression(response_1.status_code, response_1.json())

html_url = response_2.json()[[[["contenu"][[[["html_url"]
impression(F"Consultez votre repo en direct sur: html_url")
session.proche()

Après avoir exécuté le code, continuez et accédez au lien qu'il imprime à la fin. Vous verrez qu'un nouveau dépôt a été créé sur votre compte GitHub. Le nouveau référentiel contient un README.md fichier contenant du texte, le tout généré avec ce script.

Comme vous pouvez le voir, l'extrait de code court ci-dessus accomplit beaucoup et reste compréhensible.

Pourquoi demandes Est génial

Python demande La bibliothèque est l’une des bibliothèques externes Python les plus utilisées, car c’est un outil lisible, accessible et puissant pour interagir avec le Web.
Pour en savoir plus sur les nombreuses possibilités de travailler avec demandes, consultez Faire des requêtes HTTP avec Python.

analyser pour les chaînes correspondantes

Geir Arne Hjelle

Geir Arne Hjelle est auteur et réviseur chez Real Python. Il travaille comme consultant en science des données à Oslo, en Norvège, et est particulièrement heureux lorsque son analyse implique des cartes et des images. Loin du clavier, Geir Arne aime les jeux de société, les hamacs et se promener sans but dans la forêt.

J'aime le pouvoir de expressions régulières. Avec une expression régulière, ou regex, vous pouvez rechercher virtuellement tout motif dans une chaîne donnée. Cependant, une grande puissance s'accompagne d'une grande complexité! Construire une regex peut prendre beaucoup d'essais et d'erreurs, et comprendre les subtilités d'une regex donnée est peut-être encore plus difficile.

analyser est une bibliothèque qui contient une grande partie de la puissance des expressions régulières mais utilise une syntaxe plus claire et peut-être plus familière. En bref, analyser est f-strings à l'envers. Vous pouvez utiliser essentiellement les mêmes expressions pour rechercher et analyser les chaînes que vous utilisez pour les mettre en forme. Voyons comment cela fonctionne dans la pratique!

Rechercher des chaînes qui correspondent à un modèle donné

Vous avez besoin d'un texte que vous souhaitez analyser. Dans ces exemples, nous utiliserons PEP 498, la spécification d'origine des chaînes f. pepdocs est un petit utilitaire qui peut télécharger le texte des documents de proposition d'amélioration Python (PEP).

Installer analyser et pepdocs de PyPI:

$ python -m pip installer analyser pepdocs

Pour commencer, téléchargez PEP 498:

>>>

>>> importer pepdocs
>>> pep498 = pepdocs.avoir(498)

En utilisant analyser vous pouvez, par exemple, trouver l'auteur de PEP 498:

>>>

>>> importer analyser
>>> analyser.chercher("Auteur:  n", pep498)
<Résultat ('Eric V. Smith ',) >

parse.search () recherche un motif, dans ce cas "Auteur: n", nulle part dans la chaîne donnée. Vous pouvez aussi utiliser parse.parse (), qui fait correspondre le motif au Achevée chaîne. De la même manière que pour les chaînes F, vous utilisez des accolades () pour indiquer les variables que vous souhaitez analyser.

Bien que vous puissiez utiliser des accolades vides, la plupart du temps, vous souhaitez ajouter des noms à vos modèles de recherche. Vous pouvez séparer le nom et l'adresse e-mail de l'auteur de PEP 498 Eric V. Smith comme ceci:

>>>

>>> analyser.chercher("Auteur: Nom    <email> ", pep498)

Cela renvoie un Résultat objet avec des informations sur le match. Vous pouvez accéder à tous les résultats de votre recherche avec .fixé, .nommé, et .spans. Vous pouvez aussi utiliser [] pour obtenir une valeur unique:

>>>

>>> résultat = analyser.chercher("Auteur: Nom    <email> ", pep498)
>>> résultat.nommé
'name': 'Eric V. Smith', 'email': 'eric@trueblade.com'

>>> résultat[[[["Nom"]
«Eric V. Smith»

>>> résultat.travées
'name': (95, 108), 'email': (110, 128)

>>> pep498[[[[110:128]
«eric@trueblade.com»

.spans vous donne les indices de votre chaîne qui correspondent à votre modèle.

Utiliser des spécificateurs de format

Vous pouvez trouver toutes les correspondances d'un motif avec parse.findall (). Essayez de trouver les autres PEP mentionnés dans PEP 498:

>>>

>>> [[[[résultat[[[["num"] pour résultat dans analyser.Trouver tout("DYNAMISME num", pep498)]
['p', 'd', '2', '2', '3', 'i', '3', 'r', ..., 't', '4', 'i', '4', '4']

Hmm, cela ne semble pas très utile. Les PEP sont référencés à l'aide de nombres. Vous pouvez donc utiliser la syntaxe de format pour indiquer que vous recherchez des nombres:

>>>

>>> [[[[résultat[[[["num"] pour résultat dans analyser.Trouver tout("DYNAMISME num: d", pep498)]
[215, 215, 3101, 3101, 461, 414, 461]

Ajouter :ré raconte analyser que vous recherchez un entier. En prime, les résultats sont même convertis à partir de chaînes en nombres. En plus de :ré, vous pouvez utiliser la plupart des spécificateurs de format utilisés par les chaînes f.

Vous pouvez également analyser les dates à l'aide de spécifications spéciales à deux caractères:

>>>

>>> analyser.chercher("Créé: created: tg n", pep498)

: tg recherche les dates écrites comme jour mois année. Vous pouvez utiliser : ti et : ta, ainsi que plusieurs autres options, si l'ordre ou le format est différent.

Accéder aux expressions rationnelles sous-jacentes

analyser repose sur la bibliothèque d'expressions régulières de Python, . Chaque fois que vous faites une recherche, analyser construit le regex correspondant sous le capot. Si vous devez faire la même recherche plusieurs fois, vous pouvez créer une fois l'expression régulière avec parse.compile.

L'exemple suivant imprime toutes les descriptions des références à d'autres documents dans PEP 498:

>>>

>>> references_pattern = analyser.compiler(".. [#] référence")
>>> pour ligne dans pep498.lignes de division():
...     si résultat : = references_pattern.analyser(ligne):
...         impression(résultat[[[["référence"])
...
%-mise en page
str.format
[ ... ]
PEP 461 rejette bytes.format ()

La boucle utilise l'opérateur morse, disponible dans Python 3.8 et versions ultérieures, pour tester chaque ligne par rapport au modèle fourni. Vous pouvez consulter le modèle compilé pour voir l'expression régulière cachée derrière vos nouvelles capacités d'analyse:

>>>

>>> references_pattern._expression
'\. \. \[#\] (? P. +?) '

L'original analyser modèle, ".. [#] référence", est plus simple à lire et à écrire.

Pourquoi analyser Est génial

Les expressions régulières sont clairement utiles. Cependant, des livres épais ont été écrits pour expliquer les subtilités des regex. analyser est une petite bibliothèque qui fournit la plupart des capacités des expressions régulières mais avec une syntaxe beaucoup plus conviviale.

Si vous comparez ".. [#] référence" et "\. \. \[#\] (? P. +?) "alors tu verras pourquoi j'aime analyser encore plus que j'aime la puissance des expressions régulières.

dateutil pour travailler avec des dates et des heures

Bryan Weber

Bryan Weber est auteur et critique pour Real Python et professeur en génie mécanique. Lorsqu'il n'écrit pas Python ou n'enseigne pas, il peut très probablement être trouvé en train de cuisiner, de jouer avec sa famille ou de faire une randonnée, et les bons jours, les trois.

Si vous avez déjà eu à faire de la programmation avec le temps, vous connaissez les nœuds alambiqués dans lesquels cela peut vous lier. Tout d'abord, vous devez gérer les fuseaux horaires, dans lesquels deux points différents sur Terre auront une heure différente à un instant donné. Ensuite, vous avez l'heure d'été, un événement deux fois par an au cours duquel une heure se produit deux fois ou ne se produit pas du tout, mais uniquement dans certains pays.

Vous devez également tenir compte des années bissextiles et des secondes intercalaires pour garder les horloges humaines synchronisées avec les révolutions de la Terre autour du Soleil. Vous devez programmer autour des bogues Y2K et Y2038. La liste se rallonge de plus en plus.

Heureusement, Python inclut un module vraiment utile dans la bibliothèque standard appelé datetime. Python datetime est un bon moyen de stocker et d'accéder aux informations sur les dates et heures. cependant, datetime a quelques endroits où l'interface n'est pas aussi agréable.

En réponse, la formidable communauté de Python a développé plusieurs bibliothèques et API différentes pour gérer les dates et les heures de manière judicieuse. Certains d'entre eux étendent la fonction intégrée datetime, et certains sont des remplacements complets. Ma bibliothèque préférée de tous est dateutil.

Pour suivre les exemples ci-dessous, installez dateutil comme ça :

$ python -m pip installer python-dateutil

Maintenant que tu as dateutil installé, les exemples des prochaines sections vous montreront à quel point il est puissant. Vous verrez également comment dateutil interagit avec datetime.

Définir un fuseau horaire

dateutil a plusieurs choses à faire. Tout d'abord, il est recommandé dans la documentation Python en complément de datetime pour la gestion des fuseaux horaires et de l'heure d'été:

>>>

>>> de dateutil importer tz
>>> de datetime importer datetime
>>> london_now = datetime.maintenant(tz=tz.gettz("Europe / Londres"))
>>> london_now.tzname()  # 'BST' en été et 'GMT' en hiver
«BST»

Mais dateutil peut faire bien plus que fournir un béton tzinfo exemple. C'est vraiment une chance, car après Python 3.9, la bibliothèque standard Python aura sa propre capacité à accéder à la base de données IANA.

Analyser les chaînes de date et d'heure

dateutil rend beaucoup plus simple l'analyse des chaînes en datetime instances utilisant le analyseur module:

>>>

>>> de dateutil importer analyseur
>>> analyseur.analyser("Lundi 4 mai à 8h")  # Que le 4 soit avec vous!
datetime.datetime (2020, 5, 4, 8, 0)

Remarquerez que dateutil déduit automatiquement l'année pour cette date même si vous ne la spécifiez pas! Vous pouvez également contrôler la façon dont les fuseaux horaires sont interprétés ou ajoutés à l'aide de analyseur ou travaillez avec des dates au format ISO-8601. Cela vous donne beaucoup plus de flexibilité que vous n'en trouverez dans datetime.

Calculer les écarts de temps

Une autre excellente caractéristique de dateutil est sa capacité à gérer l'arithmétique du temps avec le relativedelta module. Vous pouvez ajouter ou soustraire des unités de temps arbitraires d'un datetime instance ou trouvez la différence entre deux datetime les instances:

>>>

>>> de dateutil.relativedelta importer relativedelta
>>> de dateutil importer analyseur
>>> mai_4e = analyseur.analyser("Lundi 4 mai à 8h00")
>>> mai_4e + relativedelta(journées= +1, années= +5, mois= -2)
datetime.datetime (2025, 3, 5, 8, 0)
>>> jour de la sortie = analyseur.analyser("25 mai 1977 à 8h00")
>>> relativedelta(mai_4e, jour de la sortie)
relativedelta (années = + 42, mois = + 11, jours = + 9)

C'est plus flexible et puissant que datetime.timedelta car vous pouvez spécifier des intervalles de temps supérieurs à un jour, comme un mois ou une année.

Calculer les événements récurrents

Dernier point mais non le moindre, dateutil a un module puissant appelé règle pour le calcul des dates dans le futur selon la RFC iCalendar. Supposons que vous souhaitiez générer un programme de stand-up régulier pour le mois de juin, à 10 h 00 les lundis et vendredis:

>>>

>>> de dateutil importer règle
>>> de dateutil importer analyseur
>>> liste(
...     règle.règle(
...         règle.HEBDOMADAIRE,
...         par semaine=(règle.MO, règle.FR),
...         dtstart=analyseur.analyser("1er juin 2020 à 10 h"),
...         jusqu'à ce que=analyseur.analyser("30 juin 2020"),
...     )
... )
[datetime.datetime(2020, 6, 1, 10, 0), ..., datetime.datetime(2020, 6, 29, 10, 0)]

Notez que vous n'avez pas besoin de savoir si les dates de début ou de fin sont le lundi ou le vendredi.dateutil comprend cela pour vous. Une autre façon d'utiliser règle est de trouver la prochaine fois qu'une date particulière se produira. Découvrons la prochaine fois que le jour bissextile, le 29 février, se produira un samedi comme il l'a fait en 2020:

>>>

>>> liste(
...     règle.règle(
...         règle.ANNUEL,
...         compter=1,
...         par semaine=règle.SA,
...         parmonthday=29,
...         par mois=2,
...     )
... )
[datetime.datetime(2048, 2, 29, 22, 5, 5)]

Le prochain jour bissextile d'un samedi aura lieu en 2048. Il y a une tonne d'autres exemples dans le dateutil documentation ainsi qu'une série d'exercices à essayer.

Pourquoi dateutil Est génial

Vous venez de voir quatre fonctionnalités de dateutil qui vous facilitent la vie lorsque vous faites face au temps:

  1. Un moyen pratique de réglage fuseaux horaires compatible avec datetime objets
  2. Une méthode utile pour analyse des chaînes en dates
  3. Une interface puissante pour faire arithmétique du temps
  4. Une excellente façon de calculer récurrent ou futur Rendez-vous.

La prochaine fois que vous allez devenir gris en essayant de programmer avec le temps, donnez dateutil un coup de feu!

dactylo pour l'analyse de l'interface de ligne de commande

Dane Hillard

Dane Hillard est un auteur de livres et de blogs sur Python et l'un des principaux développeurs d'applications Web chez ITHAKA, une organisation à but non lucratif qui soutient l'enseignement supérieur. Dans son temps libre, il fait à peu près tout, mais aime la cuisine, la musique, les jeux de société et la danse de salon en particulier.

Les développeurs Python commencent souvent à analyser l’interface de ligne de commande (CLI) à l’aide de sys module. Tu peux lire sys.argv pour obtenir la liste des arguments qu'un utilisateur fournit à votre script:

# command.py

importer sys

si __Nom__ == "__principale__":
    impression(sys.argv)

Le nom du script et tous les arguments fournis par un utilisateur se retrouvent sous forme de valeurs de chaîne dans sys.argv:

$ python command.py un deux trois
["command.py", "one", "two", "three"]
$ python command.py 1 2 3
["command.py", "1", "2", "3"]

Cependant, à mesure que vous ajoutez des fonctionnalités à votre script, vous souhaiterez peut-être analyser les arguments de votre script de manière plus éclairée. Vous devrez peut-être gérer les arguments de plusieurs types de données différents ou indiquer plus clairement aux utilisateurs les options disponibles.

argparse Est maladroit

Intégré à Python argparse module vous aide à créer des arguments nommés, à convertir les valeurs fournies par l'utilisateur en types de données appropriés et à créer automatiquement un menu d'aide pour votre script. Si vous n'avez pas utilisé argparse avant, puis consultez Comment créer des interfaces de ligne de commande en Python avec argparse.

L'un des grands avantages de argparse est que vous pouvez spécifier les arguments de votre CLI d'une manière plus déclarative, en réduisant ce qui serait autrement une bonne quantité de code procédural et conditionnel.

Prenons l'exemple suivant, qui utilise sys.argv pour imprimer une chaîne fournie par l'utilisateur un nombre de fois spécifié par l'utilisateur avec une gestion minimale des cas de bord:

# string_echo_sys.py

importer sys

USAGE = "" "
USAGE:

python string_echo_sys.py  [--fois[--fois[--times[--times]
"" "

si __Nom__ == "__principale__":
    si len(sys.argv) == 1 ou (len(sys.argv) == 2 et sys.argv[[[[1] == "--Aidez-moi"):
        sys.sortie(USAGE)
    elif len(sys.argv) == 2:
        chaîne = sys.argv[[[[1]  # Premier argument après le nom du script
        impression(chaîne)
    elif len(sys.argv) == 4 et sys.argv[[[[2] == "--fois":
        chaîne = sys.argv[[[[1]  # Premier argument après le nom du script

        essayer:
            fois = int(sys.argv[[[[3])  # Argument après --times
        sauf ValueError:
            sys.sortie(F"Valeur non valide pour --times! USAGE")

        impression(" n".joindre([[[[chaîne] * fois))
    autre:
        sys.sortie(USAGE)

Ce code permet aux utilisateurs de consulter une documentation utile sur l'utilisation du script:

$ python string_echo_sys.py --help

USAGE:

python string_echo_sys.py  [--fois[--fois[--times[--times]

Les utilisateurs peuvent fournir une chaîne et un nombre facultatif de fois pour imprimer la chaîne:

$ python string_echo_sys.py BONJOUR! --fois 5
SALUT!
SALUT!
SALUT!
SALUT!
SALUT!

Pour obtenir une interface similaire avec argparse, vous pouvez écrire quelque chose comme ceci:

# string_echo_argparse.py

importer argparse

analyseur = argparse.ArgumentParser(
    la description="Faites écho à une chaîne aussi longtemps que vous le souhaitez"
)
analyseur.add_argument("chaîne", Aidez-moi="La chaîne à faire écho")
analyseur.add_argument(
    "--fois",
    Aidez-moi="Le nombre de répétitions de la chaîne",
    type=int,
    défaut=1,
)

si __Nom__ == "__principale__":
    args = analyseur.parse_args()
    impression(" n".joindre([[[[args.chaîne] * args.fois))

le argparse le code est plus descriptif, et argparse fournit également une analyse complète des arguments et un --Aidez-moi option expliquant l'utilisation de votre script, le tout gratuitement.

Bien que argparse est une grande amélioration par rapport à sys.argv directement, cela vous oblige toujours à réfléchir un peu à l'analyse CLI. Vous essayez généralement d'écrire un script qui fait quelque chose d'utile, donc l'énergie dépensée pour l'analyse CLI est une énergie gaspillée!

Pourquoi dactylo Est génial

dactylo fournit plusieurs des mêmes fonctionnalités que argparse mais utilise un paradigme de développement très différent. Au lieu d'écrire une logique déclarative, procédurale ou conditionnelle pour analyser l'entrée utilisateur, dactylo exploite indication de type pour introspecter votre code et générer une CLI afin que vous n'ayez pas à dépenser beaucoup d'efforts pour réfléchir à la gestion des entrées utilisateur.

Commencez par installer dactylo de PyPI:

$ python -m pip install typer

Maintenant que tu as dactylo à votre disposition, voici comment rédiger un script qui donne un résultat similaire à celui argparse exemple:

# string_echo_typer.py

importer dactylo

def écho(
    chaîne: str,
    fois: int = dactylo.Option(1, Aidez-moi="Le nombre de répétitions de la chaîne"),
):
    "" "Écho une chaîne aussi longtemps que vous le souhaitez" ""

    dactylo.écho(" n".joindre([[[[chaîne] * fois))

si __Nom__ == "__principale__":
    dactylo.courir(écho)

Cette approche utilise encore moins de lignes fonctionnelles, et ces lignes sont principalement axées sur les fonctionnalités de votre script. Le fait que le script répète une chaîne un certain nombre de fois est plus évident.

dactylo offre même aux utilisateurs la possibilité de générer Languette achèvement pour leurs shells, afin qu’ils puissent utiliser la CLI de votre script beaucoup plus rapidement.

Vous pouvez consulter Comparaison des bibliothèques d'analyse de ligne de commande Python – Argparse, Docopt et Click pour voir si l'une de celles-ci vous convient, mais j'adore dactylo pour sa brièveté et sa puissance.

Conclusion: cinq packages Python utiles

La communauté Python a construit tellement de packages géniaux. Tout au long de ce didacticiel, vous avez découvert plusieurs packages utiles qui sont des alternatives, ou extensions, aux packages courants de la bibliothèque standard de Python.

Dans ce didacticiel, vous avez appris:

  • Pourquoi pudb pourrait vous aider à déboguer votre code
  • Comment demandes peut améliorer la façon dont vous communiquez avec les serveurs Web
  • Comment vous pouvez utiliser analyser pour simplifier votre correspondance de chaîne
  • Quelles fonctionnalités dateutil offres pour travailler avec des dates et des heures
  • Pourquoi devriez-vous utiliser dactylo pour analyser les arguments de ligne de commande

Nous avons rédigé des didacticiels dédiés et des sections de didacticiels pour certains de ces packages pour en savoir plus. Nous vous encourageons à approfondir et à partager certaines de vos alternatives de bibliothèque standard préférées avec nous dans les commentaires!

Lectures complémentaires

Voici quelques didacticiels et cours vidéo que vous pouvez consulter pour en savoir plus sur les packages traités dans ce didacticiel: