Cinq vrais favoris de Python – Real Python

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:

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

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:

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 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.

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, ré. 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.

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!

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.