Une introduction – Real Python

le Vrai et Faux Mots clés

le Vrai Le mot-clé est utilisé comme valeur booléenne vraie dans le code Python. Le mot-clé Python Faux est similaire à la Vrai , mais avec la valeur booléenne opposée false. Dans d'autres langages de programmation, vous verrez ces mots clés écrits en minuscules (vrai et faux), mais en Python, ils sont toujours écrits en majuscules.

Les mots-clés Python Vrai et Faux peut être assigné à des variables et comparé à directement:

>>> X = Vrai
>>> X est Vrai
Vrai

>>> y = Faux
>>> y est Faux
Vrai

La plupart des valeurs en Python seront évaluées à Vrai lorsqu'il est passé à bool (). Il n'y a que quelques valeurs en Python qui évalueront Faux lorsqu'il est passé à bool (): 0, "", [], et pour n'en nommer que quelques-uns. Passer une valeur à bool () indique la véracité de la valeur ou la valeur booléenne équivalente. Vous pouvez comparer la véracité d'une valeur à Vrai ou Faux en passant la valeur à bool ():

>>> X = "c'est une valeur vraie"
>>> X est Vrai
Faux
>>> bool(X) est Vrai
Vrai

>>> y = ""  # C'est de la fausse
>>> y est Faux
Faux
>>> bool(y) est Faux
Vrai

Notez que la comparaison d'une valeur véridique directement à Vrai ou Faux en utilisant est ne fonctionne pas. Vous devez directement comparer une valeur à Vrai ou Faux seulement si vous voulez savoir si c'est réellement les valeurs Vrai ou Faux.

Lorsque vous écrivez des déclarations conditionnelles basées sur la véracité d'une valeur, vous devez ne pas comparer directement à Vrai ou Faux. Vous pouvez compter sur Python pour effectuer la vérification de la véracité des conditions à votre place:

>>> X = "c'est une valeur vraie"
>>> si X est Vrai:  # Ne fais pas ça
...     impression("x est vrai")
...
>>> si X:  # Faites ceci
...     impression("x est véridique")
...
x est véridique

En Python, vous n'avez généralement pas besoin de convertir les valeurs pour être explicitement Vrai ou Faux. Python déterminera implicitement la véracité de la valeur pour vous.

le Aucun Mot-clé

Le mot-clé Python Aucun ne représente aucune valeur. Dans d'autres langages de programmation, Aucun est représenté comme nul, néant, aucun, undef, ou indéfini.

Aucun est également la valeur par défaut renvoyée par une fonction si elle n'a pas de revenir déclaration:

>>> def func():
...     impression("Bonjour")
...
>>> X = func()
Bonjour
>>> impression(X)
Aucun

Pour approfondir ce mot clé Python très important et utile, consultez Null en Python: comprendre l'objet NoneType de Python.

le et Mot-clé

Le mot-clé Python et est utilisé pour déterminer si les opérandes gauche et droit sont vrais ou faux. Si les deux opérandes sont véridiques, le résultat sera véridique. Si l'on est faux, alors le résultat sera faux:

Notez que les résultats d'un et déclaration ne sera pas nécessairement Vrai ou Faux. Cela est dû au comportement original de et. Plutôt que d'évaluer les opérandes à leurs valeurs booléennes, et renvoie simplement s'il est faux ou s'il revient . Les résultats d'un et pourrait être transmise à bool () pour obtenir l'explicite Vrai ou Faux valeur, ou ils pourraient être utilisés dans une conditionnelle si déclaration.

Si vous vouliez définir une expression qui faisait la même chose qu'un et expression, mais sans utiliser le et , alors vous pouvez utiliser l'opérateur ternaire Python:

la gauche si ne pas la gauche autre droite

La déclaration ci-dessus produira le même résultat que gauche et droite.

Parce que et renvoie le premier opérande s'il est faux et renvoie le dernier opérande, vous pouvez également utiliser et dans une mission:

Si y est faux, cela entraînerait X se voir attribuer la valeur de y. Autrement, X se verrait attribuer la valeur de z. Cependant, cela rend le code confus. Une alternative plus verbeuse et plus claire serait:

Ce code est plus long, mais il indique plus clairement ce que vous essayez d'accomplir.

le ou Mot-clé

Python ou Le mot-clé est utilisé pour déterminer si au moins l'un des opérandes est véridique. Une ou retourne le premier opérande s'il est véridique et renvoie sinon le deuxième opérande:

Tout comme le et mot-clé, ou ne convertit pas ses opérandes en leurs valeurs booléennes. Au lieu de cela, il s'appuie sur leur véracité pour déterminer les résultats.

Si vous vouliez écrire quelque chose comme un ou expression sans l'utilisation de ou, alors vous pouvez le faire avec une expression ternaire:

Cette expression produira le même résultat que gauche ou droite. Pour profiter de ce comportement, vous verrez également parfois ou utilisé dans les affectations. Ceci est généralement découragé en faveur d'une affectation plus explicite.

Pour un regard plus approfondi sur ou et comment l'utiliser, consultez Comment utiliser le Python ou l'opérateur.

le ne pas Mot-clé

Python ne pas Le mot clé est utilisé pour obtenir la valeur booléenne opposée d'une variable:

>>> val = ""  # La valeur de vérité est «Faux»
>>> ne pas val
Vrai

>>> val = 5  # La valeur de vérité est "Vrai"
>>> ne pas val
Faux

le ne pas Le mot-clé est utilisé dans les instructions conditionnelles ou d'autres expressions booléennes pour retourner le sens ou le résultat booléen. contrairement à et et ou, ne pas déterminera la valeur booléenne explicite, Vrai ou Faux, puis retournez le contraire.

Si vous vouliez obtenir le même comportement sans utiliser ne pas, vous pouvez le faire avec l'expression ternaire suivante:

Vrai si bool(<expr>) est Faux autre Faux

Cette déclaration retournerait le même résultat que ne pas .

le dans Mot-clé

Python dans le mot clé est un puissant contrôle de confinement, ou opérateur d'adhésion. Étant donné un élément à rechercher et un conteneur ou une séquence à rechercher, dans reviendra Vrai ou Faux indiquant si l'élément a été trouvé dans le conteneur:

Un bon exemple d'utilisation du dans Le mot clé recherche une lettre spécifique dans une chaîne:

>>> Nom = "Tchad"
>>> "c" dans Nom
Faux
>>> "C" dans Nom
Vrai

le dans Le mot-clé fonctionne avec tous les types de conteneurs: listes, dict, ensembles, chaînes et tout ce qui définit __contient __ () ou peut être répété.

le est Mot-clé

Python est mot-clé est un contrôle d'identité. Ceci est différent du == , qui vérifie l'égalité. Parfois, deux choses peuvent être considérées comme égales mais ne pas être exactement le même objet en mémoire. le est Le mot clé détermine si deux objets sont exactement le même objet:

Cela reviendra Vrai si est exactement le même objet en mémoire que , sinon il reviendra Faux.

La plupart du temps, vous verrez est utilisé pour vérifier si un objet est Aucun. Depuis Aucun est un singleton, une seule instance de Aucun qui peut exister, donc tous Aucun les valeurs sont exactement le même objet en mémoire.

Si ces concepts sont nouveaux pour vous, vous pouvez obtenir une explication plus approfondie en consultant Python ‘! =’ Is Not ‘is not’: Comparaison d'objets en Python. Pour une plongée plus approfondie dans la façon dont est fonctionne, consultez Opérateurs et Expressions en Python.

le si Mot-clé

le si Le mot clé est utilisé pour démarrer une instruction conditionnelle. Une si vous permet d'écrire un bloc de code qui n'est exécuté que si l'expression après si est véridique.

La syntaxe d'un si commence par le mot clé si au début de la ligne, suivie d'une expression valide qui sera évaluée pour sa valeur de véracité:

le si déclaration est un élément crucial de la plupart des programmes. Pour plus d'informations sur le si , consultez les instructions conditionnelles en Python.

Une autre utilisation du si Le mot clé fait partie de l'opérateur ternaire de Python:

<var> = <expr1> si <expr2> autre <expr3>

Il s'agit d'une version en ligne du sinon déclaration ci-dessous:

si <expr2>:
    <var> = <expr1>
autre:
    <var> = <expr3>

Si vos expressions sont des instructions simples, alors l'utilisation de l'expression ternaire fournit un bon moyen de simplifier un peu votre code. Une fois que les conditions deviennent un peu complexes, il est souvent préférable de se fier à la norme si déclaration.

le elif Mot-clé

le elif ressemble et fonctionne comme l'instruction si déclaration, avec deux différences majeures:

1. En utilisant elif n'est valable qu'après si déclaration ou autre elif.
2. Vous pouvez en utiliser autant elif déclarations que vous avez besoin.

Dans d'autres langages de programmation, elif est soit sinon si (deux mots séparés) ou elseif (les deux mots écrasés ensemble). Quand tu vois elif en Python, pensez sinon si:

si <expr1>:
    <déclarations>
elif <expr2>:
    <déclarations>
elif <expr3>:
    <déclarations>

Python n'a pas de commutateur déclaration. Une façon d'obtenir les mêmes fonctionnalités que les autres langages de programmation offrent commutateur instructions est en utilisant si et elif. Pour d'autres façons de reproduire le commutateur en Python, consultez Émulation des instructions switch / case en Python.

le autre Mot-clé

le autre , en conjonction avec les mots clés Python si et elif, désigne un bloc de code qui ne doit être exécuté que si les autres blocs conditionnels, si et elif, sont toutes fausses:

si <expr>:
    <déclarations>
autre:
    <déclarations>

Notez que le autre ne prend pas d’expression conditionnelle. Connaissance du elif et autre mots-clés et leur bonne utilisation est essentielle pour les programmeurs Python. Ensemble avec si, ils constituent certains des composants les plus fréquemment utilisés dans n'importe quel programme Python.

le pour Mot-clé

La boucle la plus courante en Python est la pour boucle. Il est construit en combinant les mots clés Python pour et dans expliqué plus tôt. La syntaxe de base pour un pour boucle est la suivante:

pour <élément> dans <récipient>:
    <déclarations>

Un exemple courant consiste à boucler les chiffres de un à cinq et à les imprimer à l'écran:

>>> pour num dans gamme(1, 6):
...     impression(num)
...
1
2
3
4
5

Dans d'autres langages de programmation, la syntaxe d'un pour la boucle sera un peu différente. Vous devrez souvent spécifier la variable, la condition pour continuer et la façon d'incrémenter cette variable (pour (int i = 0; i <5; i ++)).

En Python, le pour loop est comme une boucle for-each dans d'autres langages de programmation. Étant donné l'objet sur lequel itérer, il attribue la valeur de chaque itération à la variable:

>>> gens = [[[["Kevin", "Credo", "Jim"]
>>> pour la personne dans gens:
...     impression(F"la personne    était au bureau. ")
...
Kevin était au bureau.
Creed était dans The Office.
Jim était au bureau.

Dans cet exemple, vous commencez avec la liste (conteneur) des noms des personnes. le pour la boucle commence par le pour au début de la ligne, suivi de la variable à laquelle assigner chaque élément de la liste, puis du dans mot-clé, et enfin le conteneur (gens).

Python pour la boucle est un autre ingrédient majeur de tout programme Python. En apprendre davantage sur pour boucles, consultez Python "for" Loops (Definite Iteration).

le tandis que Mot-clé

Python tandis que boucle utilise le mot clé tandis que et fonctionne comme un tandis que boucle dans d'autres langages de programmation. Tant que la condition qui suit la tandis que mot-clé est véridique, le bloc suivant le tandis que continuera d'être exécutée encore et encore:

tandis que <expr>:
    <déclarations>

La façon la plus simple de spécifier une boucle infinie en Python est d'utiliser le tandis que mot-clé avec une expression toujours véridique:

>>> tandis que Vrai:
...     impression("travail...")
...

Pour plus d'exemples de boucles infinies en action, consultez Socket Programming in Python (Guide). En apprendre davantage sur tandis que boucles, consultez les boucles Python «while» (itération indéfinie).

le Pause Mot-clé

Si vous devez quitter une boucle plus tôt, vous pouvez utiliser le Pause mot-clé. Ce mot-clé fonctionnera dans les deux pour et tandis que boucles:

pour <élément> dans <récipient>:
    si <expr>:
        Pause

Un exemple d'utilisation du Pause serait si vous additionniez les nombres entiers dans une liste de nombres et vouliez quitter lorsque le total dépassait une valeur donnée:

>>> nums = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, dix]
>>> somme = 0
>>> pour num dans nums:
...     somme + = num
...     si somme > dix:
...         Pause
...
>>> somme
15

Les deux mots clés Python Pause et continuer peut être un outil utile lorsque vous travaillez avec des boucles. Pour une discussion plus approfondie de leurs utilisations, consultez les boucles «while» Python (itération indéfinie).

le continuer Mot-clé

Python a également un continuer mot-clé pour quand vous voulez passer à l'itération de boucle suivante. Comme dans la plupart des autres langages de programmation, le continuer Le mot-clé vous permet d'arrêter l'exécution de l'itération de boucle actuelle et de passer à l'itération suivante:

pour <élément> dans <récipient>:
    si <expr>:
        continuer

le continuer le mot clé fonctionne également dans tandis que boucles. Si la continuer Le mot clé est atteint dans une boucle, puis l'itération en cours est arrêtée et l'itération suivante de la boucle est lancée.

le autre Mot-clé utilisé avec les boucles

En plus d’utiliser le autre mot-clé avec conditionnel si , vous pouvez également l'utiliser dans le cadre d'une boucle. Lorsqu'il est utilisé avec une boucle, le autre Le mot clé spécifie le code qui doit être exécuté si la boucle se termine normalement, ce qui signifie Pause n'a pas été appelé pour quitter la boucle plus tôt.

La syntaxe d'utilisation autre avec un pour la boucle ressemble à ceci:

pour <élément> dans <récipient>:
    <déclarations>
autre:
    <déclarations>

Ceci est très similaire à l'utilisation autre avec un si déclaration. En utilisant autre avec un tandis que boucle ressemble:

tandis que <expr>:
    <déclarations>
autre:
    <déclarations>

La documentation standard de Python contient une section sur l'utilisation Pause et autre avec un pour boucle que vous devriez vraiment vérifier. Il utilise un excellent exemple pour illustrer l’utilité du autre bloquer.

La tâche qu'il montre consiste à parcourir les nombres de deux à neuf pour trouver les nombres premiers. Vous pouvez le faire avec une norme pour boucle avec un variable indicateur:

>>> pour n dans gamme(2, dix):
...     premier = Vrai
...     pour X dans gamme(2, n):
...         si n % X == 0:
...             premier = Faux
...             impression(F"n    n'est pas premier ")
...             Pause
...     si premier:
...         impression(F"n    est premier! ")
...
2 est premier!
3 est premier!
4 n'est pas premier
5 est premier!
6 n'est pas premier
7 est premier!
8 n'est pas premier
9 n'est pas premier

Vous pouvez utiliser le premier pour indiquer comment la boucle a été quittée. S'il est sorti normalement, le premier séjours de drapeau Vrai. S'il est sorti avec Pause, puis le premier le drapeau sera défini sur Faux. Une fois en dehors de l'intérieur pour boucle, vous pouvez vérifier le drapeau pour déterminer si premier est Vrai et, si c'est le cas, imprimez que le nombre est premier.

le autre bloc fournit une syntaxe plus simple. Si vous devez définir un indicateur dans une boucle, considérez l'exemple suivant comme un moyen de simplifier potentiellement votre code:

>>> pour n dans gamme(2, dix):
...     pour X dans gamme(2, n):
...         si n % X == 0:
...             impression(F"n    n'est pas premier ")
...             Pause
...     autre:
...         impression(F"n    est premier! ")
...
2 est premier!
3 est premier!
4 n'est pas premier
5 est premier!
6 n'est pas premier
7 est premier!
8 n'est pas premier
9 n'est pas premier

La seule chose que vous devez faire pour utiliser le autre bloc dans cet exemple est de supprimer le premier signaler et remplacer la finale si déclaration avec le autre bloquer. Cela finit par produire le même résultat que l'exemple précédent, uniquement avec un code plus clair.

Parfois, en utilisant un autre Le mot-clé avec une boucle peut sembler un peu étrange, mais une fois que vous comprenez qu'il vous permet d'éviter d'utiliser des indicateurs dans vos boucles, il peut être un outil puissant.

le def Mot-clé

Mot clé de Python def est utilisé pour définir une fonction ou une méthode d'une classe. Cela équivaut à une fonction en JavaScript et PHP. La syntaxe de base pour définir une fonction avec def ressemble à ça:

def <une fonction>(<params>):
    <corps>

Les fonctions et méthodes peuvent être des structures très utiles dans n'importe quel programme Python. Pour en savoir plus sur leur définition et tous leurs tenants et aboutissants, consultez Définir votre propre fonction Python.

le classe Mot-clé

Pour définir une classe en Python, vous utilisez le classe mot-clé. La syntaxe générale pour définir une classe avec classe est comme suit:

classe Ma classe(<étend>):
    <corps>

Les classes sont de puissants outils de programmation orientée objet, et vous devez les connaître et savoir comment les définir. Pour en savoir plus, consultez la programmation orientée objet (POO) dans Python 3.

le avec Mot-clé

Les gestionnaires de contexte sont une structure vraiment utile en Python. Chaque gestionnaire de contexte exécute un code spécifique avant et après les instructions que vous spécifiez. Pour en utiliser un, vous utilisez le avec mot-clé:

avec <le contexte directeur> comme <var>:
    <déclarations>

En utilisant avec vous permet de définir le code à exécuter dans la portée du gestionnaire de contexte. L'exemple le plus élémentaire de ceci est lorsque vous travaillez avec des E / S de fichiers en Python.

Si vous vouliez ouvrir un fichier, faire quelque chose avec ce fichier, puis vous assurer que le fichier était correctement fermé, vous utiliseriez un gestionnaire de contexte. Considérez cet exemple dans lequel names.txt contient une liste de noms, un par ligne:

>>> avec ouvert("names.txt") comme fichier_entrée:
...    pour Nom dans fichier_entrée:
...        impression(Nom.bande())
...
Jim
Pam
Cece
Philippe

Le gestionnaire de contexte d'E / S de fichiers fourni par ouvert() et initié avec le avec Le mot-clé ouvre le fichier en lecture, attribue le pointeur de fichier ouvert à fichier_entrée, puis exécute le code que vous spécifiez dans le avec bloquer. Ensuite, après l'exécution du bloc, le pointeur de fichier se ferme. Même si votre code dans le avec bloc lève une exception, le pointeur de fichier serait toujours fermé.

Pour un excellent exemple d'utilisation avec et les gestionnaires de contexte, consultez les fonctions de minuterie Python: trois façons de surveiller votre code.

le comme Mot-clé utilisé avec avec

Si vous souhaitez accéder aux résultats de l'expression ou du gestionnaire de contexte transmis à avec, vous devrez l'aliaser en utilisant comme. Vous avez peut-être aussi vu comme utilisé pour alias les importations et les exceptions, et ce n'est pas différent. L'alias est disponible dans le avec bloquer:

avec <expr> comme <alias>:
    <déclarations>

La plupart du temps, vous verrez ces deux mots clés Python, avec et comme, utilisé ensemble.

le passer Mot-clé

Étant donné que Python n'a pas d'indicateurs de bloc pour spécifier la fin d'un bloc, le passer Le mot-clé est utilisé pour spécifier que le bloc est intentionnellement laissé vide. C'est l'équivalent d'un sans opération, ou pas d'opération. Voici quelques exemples d'utilisation passer pour spécifier que le bloc est vide:

def ma_fonction():
    passer

classe Ma classe:
    passer

si Vrai:
    passer

Pour en savoir plus passer, consultez les instructions conditionnelles en Python.

le lambda Mot-clé

le lambda Le mot clé est utilisé pour définir une fonction qui n'a pas de nom et n'a qu'une seule instruction, dont les résultats sont renvoyés. Fonctions définies avec lambda sont appelés fonctions lambda:

lambda <args>: <déclaration>

Un exemple de base d'un lambda fonction qui calcule l'argument soulevé à la puissance de dix ressemblerait à ceci:

Cela revient à définir une fonction avec def:

Une utilisation courante pour un lambda spécifie un comportement différent pour une autre fonction. Par exemple, imaginez que vous vouliez trier une liste de chaînes par leurs valeurs entières. Le comportement par défaut de trié () trierait les chaînes par ordre alphabétique. Mais avec trié (), vous pouvez spécifier sur quelle clé la liste doit être triée.

Une fonction lambda fournit un bon moyen de le faire:

>>> ids = [[[["id1", "id2", "id30", "id3", "id20", "id10"]
>>> trié(ids)
['id1', 'id10', 'id2', 'id20', 'id3', 'id30']

>>> trié(ids, clé=lambda X: int(X[[[[2:]))
['id1', 'id2', 'id3', 'id10', 'id20', 'id30']

Cet exemple trie la liste en fonction non pas de l'ordre alphabétique mais de l'ordre numérique des derniers caractères des chaînes après les avoir convertis en entiers. Sans pour autant lambda, vous auriez dû définir une fonction, lui donner un nom, puis la transmettre à trié (). lambda fait ce code plus propre.

À titre de comparaison, voici à quoi ressemblerait l'exemple ci-dessus sans utiliser lambda:

>>> def sort_by_int(X):
...     revenir int(X[[[[2:])
...
>>> ids = [[[["id1", "id2", "id30", "id3", "id20", "id10"]
>>> trié(ids, clé=sort_by_int)
['id1', 'id2', 'id3', 'id10', 'id20', 'id30']

Ce code produit le même résultat que le lambda exemple, mais vous devez définir la fonction avant de l'utiliser.

Pour plus d'informations sur lambda, consultez Comment utiliser les fonctions Python Lambda.

le revenir Mot-clé

Python revenir Le mot clé n'est valide que dans le cadre d'une fonction définie avec def. Lorsque Python rencontre ce mot-clé, il quitte la fonction à ce stade et renvoie les résultats de tout ce qui vient après la revenir mot-clé:

def <une fonction>():
    revenir <expr>

Sans expression, revenir reviendra Aucun par défaut:

>>> def return_none():
...     revenir
...
>>> return_none()
>>> r = return_none()
>>> impression(r)
Aucun

Cependant, la plupart du temps, vous souhaitez renvoyer les résultats d'une expression ou d'une valeur spécifique:

>>> def plus_1(num):
...    revenir num + 1
...
>>> plus_1(9)
dix
>>> r = plus_1(9)
>>> impression(r)
dix

Vous pouvez même utiliser le revenir mot-clé plusieurs fois dans une fonction. Cela vous permet d'avoir plusieurs points de sortie dans votre fonction. Un exemple classique de cas où vous voudriez avoir plusieurs instructions de retour est la solution récursive suivante pour calculer la factorielle:

def factorielle(n):
    si n == 1:
        revenir 1
    autre:
        revenir n * factorielle(n - 1)

Dans la fonction factorielle ci-dessus, il y a deux cas dans lesquels vous voudriez revenir de la fonction. Le premier est le cas de base, lorsque le nombre est 1, et le second est le cas normal, lorsque vous souhaitez multiplier le nombre actuel par la valeur factorielle du nombre suivant.

Pour en savoir plus sur le revenir , consultez Définir votre propre fonction Python.

le rendement Mot-clé

Python rendement mot-clé est un peu comme le revenir mot-clé en ce qu'il spécifie ce qui est renvoyé par une fonction. Cependant, lorsqu'une fonction a un rendement déclaration, ce qui est retourné est un Générateur. Le générateur peut ensuite être transmis au module intégré de Python suivant() pour obtenir la prochaine valeur renvoyée par la fonction.

Lorsque vous appelez une fonction avec rendement , Python exécute la fonction jusqu'à ce qu'elle atteigne la première rendement et renvoie ensuite un générateur. Ce sont des fonctions de générateur:

def <une fonction>():
    rendement <expr>

L'exemple le plus simple serait une fonction de générateur qui renvoie le même ensemble de valeurs:

>>> def famille():
...     rendement "Pam"
...     rendement "Jim"
...     rendement "Cece"
...     rendement "Philippe"
...
>>> noms = famille()
>>> noms

>>> suivant(noms)
«Pam»
>>> suivant(noms)
«Jim»
>>> suivant(noms)
«Cece»
>>> suivant(noms)
'Philippe'
>>> suivant(noms)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
StopIteration

Une fois la StopIteration exception est levée, le générateur a fini de renvoyer des valeurs. Pour parcourir à nouveau les noms, vous devez appeler famille() et obtenez un nouveau générateur. La plupart du temps, une fonction de générateur sera appelée dans le cadre d'un pour boucle, qui fait le suivant() vous appelle.

Pour en savoir plus sur le rendement et en utilisant des générateurs et des fonctions de générateur, consultez Comment utiliser les générateurs et produire en Python.

le importation Mot-clé

Python importation Le mot clé est utilisé pour importer ou inclure un module à utiliser dans votre programme Python. La syntaxe d'utilisation de base ressemble à ceci:

Une fois cette instruction exécutée, le sera disponible pour votre programme.

Par exemple, si vous souhaitez utiliser le Compteur classe du collections dans la bibliothèque standard, vous pouvez utiliser le code suivant:

>>> importation collections
>>> collections.Compteur()
Compteur()

Importation collections de cette façon rend l'ensemble collections module, y compris le Compteur classe, disponible pour votre programme. En utilisant le nom du module, vous avez accès à tous les outils disponibles dans ce module. Pour accéder à Compteur, vous le référencez depuis le module: collections..

le de Mot-clé

le de mot-clé est utilisé avec importation pour importer quelque chose de spécifique à partir d'un module:

de <module> importation <chose>

Cela importera tout Est à l'intérieur à utiliser dans votre programme. Ces deux mots clés Python, de et importation, sont utilisés ensemble.

Si vous souhaitez utiliser Compteur du collections module in the standard library, then you can import it specifically:

>>> de collections importation Counter
>>> Counter()
Counter()

Importing Counter like this makes the Counter class available, but nothing else from the collections module is available. Counter is now available without you having to reference it from the collections module.

le comme Mot-clé

le comme keyword is used to alias an imported module or tool. It’s used together with the Python keywords importation et de to change the name of the thing being imported:

importation <module> comme <alias>
de <module> importation <thing> comme <alias>

For modules that have really long names or a commonly used import alias, comme can be helpful in creating the alias.

If you want to import the Counter class from the collections module but name it something different, you can alias it by using comme:

>>> de collections importation Counter comme C
>>> C()
Counter()

Maintenant Counter is available to be used in your program, but it’s referenced by C au lieu. A more common use of comme import aliases is with NumPy or Pandas packages. These are commonly imported with standard aliases:

importation numpy comme np
importation pandas comme pd

This is a better alternative to just importing everything from a module, and it allows you to shorten the name of the module being imported.

le essayer Mot-clé

Any exception-handling block begins with Python’s essayer keyword. This is the same in most other programming languages that have exception handling.

The code in the essayer block is code that might raise an exception. Several other Python keywords are associated with essayer and are used to define what should be done if different exceptions are raised or in different situations. These are sauf, autre, et finally:

essayer:
    <statements>
<sauf|autre|finally>:
    <statements>

UNE essayer block isn’t valid unless it has at least one of the other Python keywords used for exception handling as part of the overall essayer statement.

If you wanted to calculate and return the miles per gallon of gas (mpg) given the miles driven and the gallons of gas used, then you could write a function like the following:

def mpg(miles, gallons):
    revenir miles / gallons

The first problem you might see is that your code could raise a ZeroDivisionError si la gallons parameter is passed in as 0. le essayer keyword allows you to modify the code above to handle that situation appropriately:

def mpg(miles, gallons):
    essayer:
        mpg = miles / gallons
    sauf ZeroDivisionError:
        mpg = Aucun
    revenir mpg

Now if gallons = 0, then mpg() won’t raise an exception and will return Aucun au lieu. This might be better, or you might decide that you want to raise a different type of exception or handle this situation differently. You’ll see an expanded version of this example below to illustrate the other keywords used for exception handling.

le sauf Mot-clé

Python’s sauf keyword is used with essayer to define what to do when specific exceptions are raised. You can have one or more sauf blocks with a single essayer. The basic usage looks like this:

essayer:
    <statements>
sauf <exception>:
    <statements>

Taking the mpg() example from before, you could also do something specific in the event that someone passes types that won’t work with the / operator. Having defined mpg() in a previous example, now try to call it with strings instead of numbers:

>>> mpg("lots", "many")
Traceback (most recent call last):
  Fichier "", line 1, dans 
  
  
  
  Fichier "", line 3, dans mpg
TypeError: unsupported operand type(s) for /: 'str' and 'str'

You could revise mpg() and use multiple sauf blocks to handle this situation, too:

def mpg(miles, gallons):
    essayer:
        mpg = miles / gallons
    sauf ZeroDivisionError:
        mpg = Aucun
    sauf TypeError comme ex:
        impression("you need to provide numbers")
        raise ex
    revenir mpg

Here, you modify mpg() to raise the TypeError exception only after you’ve printed a helpful reminder to the screen.

Notice that the sauf keyword can also be used in conjunction with the comme keyword. This has the same effect as the other uses of comme, giving the raised exception an alias so you can work with it in the sauf bloquer.

Even though it’s syntactically allowed, try not to use sauf statements as implicit catchalls. It’s better practice to always explicitly catch something, even if it’s just Exception:

essayer:
    1 / 0
sauf:  # Don't do this
    pass

essayer:
    1 / 0
sauf Exception:  # This is better
    pass

essayer:
    1 / 0
sauf ZeroDivisionError:  # This is best
    pass

If you really do want to catch a broad range of exceptions, then specify the parent Exception. This is more explicitly a catchall, and it won’t also catch exceptions you probably don’t want to catch, like RuntimeError ou KeyboardInterrupt.

le raise Mot-clé

le raise keyword raises an exception. If you find you need to raise an exception, then you can use raise followed by the exception to be raised:

You used raise previously, in the mpg() example. When you catch the TypeError, you re-raise the exception after printing a message to the screen.

le finally Mot-clé

Python’s finally keyword is helpful for specifying code that should be run no matter what happens in the essayer, sauf, ou autre blocks. To use finally, use it as part of a essayer block and specify the statements that should be run no matter what:

essayer:
    <statements>
finally:
    <statements>

Using the example from before, it might be helpful to specify that, no matter what happens, you want to know what arguments the function was called with. You could modify mpg() to include a finally block that does just that:

def mpg(miles, gallons):
    essayer:
        mpg = miles / gallons
    sauf ZeroDivisionError:
        mpg = Aucun
    sauf TypeError comme ex:
        impression("you need to provide numbers")
        raise ex
    finally:
        impression(F"mpg(miles, gallons) ")
    revenir mpg

Now, no matter how mpg() is called or what the result is, you print the arguments supplied by the user:

>>> mpg(dix, 1)
mpg(10, 1)
10,0

>>> mpg("lots", "many")
you need to provide numbers
mpg(lots, many)
Traceback (most recent call last):
  Fichier "", line 1, dans 
  
  
  
  Fichier "", line 8, dans mpg
  Fichier "", line 3, dans mpg
TypeError: unsupported operand type(s) for /: 'str' and 'str'

le finally keyword can be a very useful part of your exception-handling code.

le autre Keyword Used With essayer et sauf

You’ve learned that the autre keyword can be used with both the si keyword and loops in Python, but it has one more use. It can be combined with the essayer et sauf Python keywords. Vous pouvez utiliser autre in this way only if you also use at least one sauf block:

essayer:
    <statements>
sauf <exception>:
    <statements>
autre:
    <statements>

In this context, the code in the autre block is executed only if an exception was ne pas raised in the essayer bloquer. In other words, if the essayer block executed all the code successfully, then the autre block code would be executed.

dans le mpg() example, imagine you want to make sure that the mpg result is always returned as a flotte no matter what number combination is passed in. One of the ways you could do this is to use an autre bloquer. If the essayer block calculation of mpg is successful, then you convert the result to a flotte dans le autre block before returning:

def mpg(miles, gallons):
    essayer:
        mpg = miles / gallons
    sauf ZeroDivisionError:
        mpg = Aucun
    sauf TypeError comme ex:
        impression("you need to provide numbers")
        raise ex
    autre:
        mpg = flotte(mpg) si mpg est ne pas Aucun autre mpg
    finally:
        impression(F"mpg(miles, gallons) ")
    revenir mpg

Now the results of a call to mpg(), if successful, will always be a flotte.

For more on using the autre block as part of a essayer et sauf block, check out Python Exceptions: An Introduction.

le assert Mot-clé

le assert keyword in Python is used to specify an assert statement, or an assertion about an expression. Une assert statement will result in a no-op if the expression () is truthy, and it will raise an AssertionError if the expression is falsy. To define an assertion, use assert followed by an expression:

Generally, assert statements will be used to make sure something that needs to be true is. You shouldn’t rely on them, however, as they can be ignored depending on how your Python program is executed.

le async Mot-clé

le async keyword is used with def to define an asynchronous function, or coroutine. The syntax is just like defining a function, with the addition of async at the beginning:

async def <une fonction>(<params>):
    <statements>

You can make a function asynchronous by adding the async keyword before the function’s regular definition.

le await Mot-clé

Python’s await keyword is used in asynchronous functions to specify a point in the function where control is given back to the event loop for other functions to run. You can use it by placing the await keyword in front of a call to any async function:

await <certains async une fonction call>
# OR
<var> = await <certains async une fonction call>

When using await, you can either call the asynchronous function and ignore the results, or you can store the results in a variable when the function eventually returns.

le del Mot-clé

del is used in Python to unset a variable or name. You can use it on variable names, but a more common use is to remove indexes from a list or dictionary. To unset a variable, use del followed by the variable you want to unset:

Let’s assume you want to clean up a dictionary that you got from an API response by throwing out keys you know you won’t use. You can do so with the del keyword:

>>> del réponse[[[["headers"]
>>> del réponse[[[["errors"]

This will remove the "headers" et "errors" keys from the dictionary réponse.

le global Mot-clé

If you need to modify a variable that isn’t defined in a function but is defined in the global scope, then you’ll need to use the global keyword. This works by specifying in the function which variables need to be pulled into the function from the global scope:

A basic example is incrementing a global variable with a function call. You can do that with the global keyword:

>>> X = 0
>>> def inc():
...     global X
...     X + = 1
...
>>> inc()
>>> X
1
>>> inc()
>>> X
2

This is generally not considered good practice, but it does have its uses. To learn much more on the global keyword, check out Python Scope & the LEGB Rule: Resolving Names in Your Code.

le nonlocal Mot-clé

le nonlocal keyword is similar to global in that it allows you to modify variables from a different scope. Avec global, the scope you’re pulling from is the global scope. Avec nonlocal, the scope you’re pulling from is the parent scope. The syntax is similar to global:

This keyword isn’t used very often, but it can be handy at times. For more on scoping and the nonlocal keyword, check out Python Scope & the LEGB Rule: Resolving Names in Your Code.