Les mots-clés sont les mots réservés en Python. Nous ne pouvons pas utiliser un mot-clé comme nom de variable, nom de fonction ou tout autre identifiant.

Voici une liste de tous les mots-clés en programmation Python

.

.

Les mots-clés ci-dessus peuvent être modifiés dans différentes versions de Python. Certains supplémentaires pourraient être ajoutés ou certains pourraient être supprimés. Vous pouvez toujours obtenir la liste des mots-clés dans votre version actuelle en tapant ce qui suit dans l’invite.

>>> import keyword>>> print(keyword.kwlist)

Description des mots-clés en Python avec exemples

True, False

True et False sont des valeurs de vérité en Python. Elles sont les résultats d’opérations de comparaison ou d’opérations logiques (booléennes) en Python. Par exemple :

>>> 1 == 1True>>> 5 > 3True>>> True or FalseTrue>>> 10 <= 1False>>> 3 > 7False>>> True and FalseFalse

Ici, nous pouvons voir que les trois premières déclarations sont vraies donc l’interpréteur renvoie True et renvoie False pour les trois autres déclarations. True et False en python sont les mêmes que 1 et 0. On peut le justifier avec l’exemple suivant :

>>> True == 1True>>> False == 0True>>> True + True2

None

None est une constante spéciale en Python qui représente l’absence d’une valeur ou une valeur nulle.

C’est un objet de son propre type de données, le NoneType. Nous ne pouvons pas créer plusieurs objets None mais nous pouvons l’affecter à des variables. Ces variables seront égales entre elles.

Nous devons faire particulièrement attention à ce que None n’implique pas False, 0 ou toute liste, dictionnaire, chaîne de caractères vide, etc. Par exemple:

>>> None == 0False>>> None == False>>> None == FalseFalse>>> x = None>>> y = None>>> x == yTrue

Les fonctions vides qui ne retournent rien retourneront automatiquement un objet None. None est également retourné par les fonctions dans lesquelles le déroulement du programme ne rencontre pas d’instruction de retour. Par exemple:

def a_void_function(): a = 1 b = 2 c = a + bx = a_void_function()print(x)

Sortie

None

Ce programme a une fonction qui ne renvoie pas de valeur, bien qu’elle fasse quelques opérations à l’intérieur. Ainsi, lorsque nous imprimons x, nous obtenons None qui est retournée automatiquement (implicitement). De même, voici un autre exemple:

def improper_return_function(a): if (a % 2) == 0: return Truex = improper_return_function(3)print(x)

Sortie

None

Bien que cette fonction ait une instruction return, elle n’est pas atteinte dans tous les cas. La fonction renvoie True uniquement lorsque l’entrée est paire.

Si nous donnons à la fonction un nombre impair, None est renvoyé implicitement.

et, ou , pas

and, or, not sont les opérateurs logiques en Python. and ne donnera True que si les deux opérandes sont True. La table de vérité de and est donnée ci-dessous :

.

or aura pour résultat True si l’un des opérandes est True. La table de vérité pour or est donnée ci-dessous :

.

not opérateur est utilisé pour inverser la valeur de vérité. La table de vérité pour not est donnée ci-dessous :

.

quelques exemples de leur utilisation sont donnés ci-dessous

>>> True and FalseFalse>>> True or FalseTrue>>> not FalseTrue

as

as est utilisé pour créer un alias lors de l’importation d’un module. Cela signifie donner un nom différent (défini par l’utilisateur) à un module tout en l’important.

Comme par exemple, Python a un module standard appelé math. Supposons que nous voulions calculer quel est le cosinus de pi en utilisant un alias. Nous pouvons le faire comme suit en utilisant as:

>>> import math as myAlias>>>myAlias.cos(myAlias.pi)-1.0

Nous avons ici importé le module math en lui donnant le nom myAlias. Maintenant, nous pouvons faire référence au module math avec ce nom. En utilisant ce nom, nous avons calculé cos(pi) et obtenu -1.0 comme réponse.

assert

assert est utilisé à des fins de débogage.

Pendant la programmation, nous souhaitons parfois connaître l’état interne ou vérifier si nos hypothèses sont vraies. assert nous aide à le faire et à trouver les bogues plus commodément. assert est suivi d’une condition.

Si la condition est vraie, rien ne se passe. Mais si la condition est fausse, AssertionError est soulevée. Par exemple:

>>> a = 4>>> assert a < 5>>> assert a > 5Traceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>AssertionError

Pour notre meilleure compréhension, nous pouvons également fournir un message à imprimer avec le AssertionError.

>>> a = 4>>> assert a > 5, "The value of a is too small"Traceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>AssertionError: The value of a is too small

À ce stade, nous pouvons noter que,

assert condition, message

est équivalent à,

if not condition: raise AssertionError(message)

async, await

Les mots-clés async et await sont fournis par la bibliothèque asyncio de Python. Ils sont utilisés pour écrire du code concurrent en Python. Par exemple,

import asyncioasync def main(): print('Hello') await asyncio.sleep(1) print('world')

Pour exécuter le programme, on utilise

asyncio.run(main())

Dans le programme ci-dessus, le mot-clé async spécifie que la fonction sera exécutée de manière asynchrone.

Ici, le premier Bonjour est imprimé. Le mot-clé awaitfait en sorte que le programme attende pendant 1 seconde. Et ensuite le monde est imprimé.

Briser, continuer

break et continue sont utilisés à l’intérieur des boucles for et while pour modifier leur comportement normal.

break fait terminer la plus petite boucle dans laquelle elle se trouve et le contrôle passe à l’instruction immédiatement inférieure à la boucle. continue entraîne la fin de l’itération actuelle de la boucle, mais pas de la boucle entière.

Cela peut être illustré avec les deux exemples suivants:

for i in range(1,11): if i == 5: break print(i)

Sortie

1234

Ici, la boucle for a l’intention d’imprimer les nombres de 1 à 10. Mais la condition if est remplie lorsque i est égal à 5 et nous sortons de la boucle. Ainsi, seule la plage 1 à 4 est imprimée.

for i in range(1,11): if i == 5: continue print(i)

Sortie

1234678910

Ici, nous utilisons continue pour le même programme. Ainsi, lorsque la condition est remplie, on saute cette itération. Mais nous ne sortons pas de la boucle. Par conséquent, toutes les valeurs sauf 5 sont imprimées.

En savoir plus sur l’instruction break et continue de Python.

class

class est utilisé pour définir une nouvelle classe définie par l’utilisateur en Python.

La classe est une collection d’attributs et de méthodes connexes qui tentent de représenter une situation du monde réel. Cette idée de rassembler des données et des fonctions dans une classe est centrale au concept de programmation orientée objet (POO).

Les classes peuvent être définies n’importe où dans un programme. Mais c’est une bonne pratique de définir une seule classe dans un module. Voici un exemple d’utilisation:

class ExampleClass: def function1(parameters): … def function2(parameters): …

Learn more about Python Objects and Class.

def

def est utilisé pour définir une fonction définie par l’utilisateur.

La fonction est un bloc d’instructions liées, qui ensemble font une tâche spécifique. Il nous aide à organiser le code en morceaux gérables et aussi à faire certaines tâches répétitives.

L’utilisation de def est montrée ci-dessous:

def function_name(parameters): …

Learn more about Python functions.

del

del est utilisé pour supprimer la référence à un objet. Tout est objet en Python. Nous pouvons supprimer la référence d’une variable en utilisant del

>>> a = b = 5>>> del a>>> aTraceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>NameError: name 'a' is not defined>>> b5

On peut voir ici que la référence de la variable a a été supprimée. Donc, elle n’est plus définie. Mais b existe toujours.

del est également utilisé pour supprimer des éléments d’une liste ou d’un dictionnaire:

>>> a = >>> del a>>> a

if, else, elif

if, else, elif sont utilisés pour le branchement conditionnel ou la prise de décision.

Lorsque nous voulons tester une certaine condition et exécuter un bloc uniquement si la condition est vraie, alors nous utilisons if et elif. elif est l’abréviation de else if. else est le bloc qui est exécuté si la condition est fausse. Cela sera clair avec l’exemple suivant:

def if_example(a): if a == 1: print('One') elif a == 2: print('Two') else: print('Something else')if_example(2)if_example(4)if_example(1)

Sortie

TwoSomething elseOne

Ici, la fonction vérifie le nombre d’entrée et imprime le résultat si c’est 1 ou 2. Toute entrée autre que cela entraînera l’exécution de la partie else du code.

Apprenez-en davantage sur les énoncés Python if et if…else.

except, raise, try

except, raise, try sont utilisés avec les exceptions en Python.

Les exceptions sont essentiellement des erreurs qui suggèrent que quelque chose s’est mal passé lors de l’exécution de notre programme. IOError, ValueError, ZeroDivisionError, ImportError, NameError, TypeError etc. sont quelques exemples d’exception en Python. Les blocs try...except sont utilisés pour attraper les exceptions en Python.

Nous pouvons lever une exception explicitement avec le mot-clé raise. Voici un exemple:

def reciprocal(num): try: r = 1/num except: print('Exception caught') return return rprint(reciprocal(10))print(reciprocal(0))

Sortie

0.1Exception caughtNone

Ici, la fonction reciprocal() renvoie la réciproque du nombre entré.

Lorsque nous entrons 10, nous obtenons la sortie normale de 0,1. Mais lorsque nous entrons 0, un ZeroDivisionError est levé automatiquement.

Ceci est attrapé par notre bloc try…except et nous retournons None. Nous aurions également pu lever le ZeroDivisionError explicitement en vérifiant l’entrée et le gérer ailleurs comme suit:

if num == 0: raise ZeroDivisionError('cannot divide')

finally

finally est utilisé avec le bloc try…except pour fermer les ressources ou les flux de fichiers.

L’utilisation de finally garantit que le bloc de code à l’intérieur est exécuté même s’il y a une exception non gérée. Par exemple:

try: Try-blockexcept exception1: Exception1-blockexcept exception2: Exception2-blockelse: Else-blockfinally: Finally-block

Ici, s’il y a une exception dans le Try-block, elle est traitée dans le bloc except ou else. Mais peu importe l’ordre d’exécution, nous pouvons être assurés que le bloc Finally-block est exécuté même s’il y a une erreur. Cela est utile pour nettoyer les ressources.

En savoir plus sur la gestion des exceptions en programmation Python.

for

for est utilisé pour le bouclage. Généralement, nous utilisons for lorsque nous connaissons le nombre de fois que nous voulons boucler.

En Python, nous pouvons l’utiliser avec n’importe quel type de séquences comme une liste ou une chaîne. Voici un exemple dans lequel for est utilisé pour parcourir une liste de noms:

names = for i in names: print('Hello '+i)

Sortie

Hello JohnHello MonicaHello StevenHello Robin

En savoir plus sur Python pour la boucle.

de, import

importLe mot-clé est utilisé pour importer des modules dans l’espace de nom courant. from…import est utilisé pour importer des attributs ou des fonctions spécifiques dans l’espace de noms actuel. Par exemple:

import math

importera le module math. Maintenant, nous pouvons utiliser la fonction cos() à l’intérieur de celui-ci comme math.cos(). Mais si nous voulions importer seulement la fonction cos(), cela peut être fait en utilisant from as

from math import cos

maintenant nous pouvons utiliser la fonction simplement comme cos(), pas besoin d’écrire math.cos().

En savoir plus sur les modules Python et l’instruction import.

global

global est utilisée pour déclarer qu’une variable à l’intérieur de la fonction est globale (en dehors de la fonction).

Si nous avons besoin de lire la valeur d’une variable globale, il n’est pas nécessaire de la définir comme global. Ceci est compris.

Si nous avons besoin de modifier la valeur d’une variable globale à l’intérieur d’une fonction, alors nous devons la déclarer avec global. Sinon, une variable locale portant ce nom est créée.

L’exemple suivant nous aidera à clarifier cela.

globvar = 10def read1(): print(globvar)def write1(): global globvar globvar = 5def write2(): globvar = 15read1()write1()read1()write2()read1()

Sortie

1055

Ici, la fonction read1() ne fait que lire la valeur de globvar. Donc, nous n’avons pas besoin de la déclarer comme global. Mais la fonction write1() modifie la valeur, donc nous devons déclarer la variable comme global.

Nous pouvons voir dans notre sortie que la modification a bien eu lieu (10 est changé en 5). Le write2() tente également de modifier cette valeur. Mais nous ne l’avons pas déclaré comme global.

Donc, une nouvelle variable locale globvar est créée qui n’est pas visible en dehors de cette fonction. Bien que nous modifions cette variable locale en 15, la variable globale reste inchangée. Ceci est clairement visible dans notre sortie.

in

in est utilisée pour tester si une séquence (liste, tuple, chaîne de caractères, etc.) contient une valeur. Elle renvoie True si la valeur est présente, sinon elle renvoie False. Par exemple :

>>> a = >>> 5 in aTrue>>> 10 in aFalse

L’utilisation secondaire de in est de parcourir une séquence dans une for boucle.

for i in 'hello': print(i)

Sortie

hello

est

is est utilisé en Python pour tester l’identité des objets. Alors que l’opérateur == est utilisé pour tester si deux variables sont égales ou non, is est utilisé pour tester si les deux variables font référence au même objet.

Il renvoie True si les objets sont identiques et False dans le cas contraire.

>>> True is TrueTrue>>> False is FalseTrue>>> None is NoneTrue

Nous savons qu’il n’y a qu’une seule instance de True, False et None en Python, donc ils sont identiques.

>>> == True>>> is False>>> {} == {}True>>> {} is {}False

Une liste ou un dictionnaire vide est égal à un autre vide. Mais ce ne sont pas des objets identiques car ils sont situés séparément en mémoire. Cela est dû au fait que la liste et le dictionnaire sont mutables (la valeur peut être modifiée).

>>> '' == ''True>>> '' is ''True>>> () == ()True>>> () is ()True

Contrairement à la liste et au dictionnaire, la chaîne de caractères et le tuple sont immuables (la valeur ne peut pas être modifiée une fois définie). Par conséquent, deux chaînes ou tuple égaux sont également identiques. Ils font référence au même emplacement mémoire.

lambda

lambda est utilisé pour créer une fonction anonyme (fonction sans nom). C’est une fonction inline qui ne contient pas d’instruction return. Elle consiste en une expression qui est évaluée et retournée. Par exemple:

a = lambda x: x*2for i in range(1,6): print(a(i))

Sortie

246810

Ici, nous avons créé une fonction inline qui double la valeur, en utilisant l’instruction lambda. Nous l’avons utilisée pour doubler les valeurs dans une liste contenant 1 à 5.

En savoir plus sur la fonction lamda de Python.

nonlocal

L’utilisation du mot-clé nonlocal est très similaire au mot-clé global. nonlocal est utilisé pour déclarer qu’une variable à l’intérieur d’une fonction imbriquée (fonction à l’intérieur d’une fonction) ne lui est pas locale, ce qui signifie qu’elle se trouve dans la fonction extérieure incluse. Si nous devons modifier la valeur d’une variable non locale à l’intérieur d’une fonction imbriquée, alors nous devons la déclarer avec nonlocal. Sinon, une variable locale portant ce nom est créée à l’intérieur de la fonction imbriquée. L’exemple suivant nous aidera à clarifier ceci.

def outer_function(): a = 5 def inner_function(): nonlocal a a = 10 print("Inner function: ",a) inner_function() print("Outer function: ",a)outer_function()

Sortie

Inner function: 10Outer function: 10

Ici, le inner_function() est imbriqué dans le outer_function.

La variable a est dans le outer_function(). Donc, si nous voulons la modifier dans le inner_function(), nous devons la déclarer comme nonlocal. Remarquez que a n’est pas une variable globale.

Ainsi, nous voyons dans la sortie que la variable a été modifiée avec succès à l’intérieur du inner_function() imbriqué. Le résultat de la non-utilisation du mot-clé nonlocal est le suivant :

def outer_function(): a = 5 def inner_function(): a = 10 print("Inner function: ",a) inner_function() print("Outer function: ",a)outer_function()

Sortie

Inner function: 10Outer function: 5

Ici, nous ne déclarons pas que la variable a à l’intérieur de la fonction imbriquée est nonlocal. Par conséquent, une nouvelle variable locale avec le même nom est créée, mais la non-locale a n’est pas modifiée comme on le voit dans notre sortie.

pass

pass est une déclaration nulle en Python. Il ne se passe rien lorsqu’elle est exécutée. Elle est utilisée comme placeholder.

Supposons que nous avons une fonction qui n’est pas encore implémentée, mais nous voulons l’implémenter dans le futur. Le simple fait d’écrire,

def function(args):

au milieu d’un programme nous donnera IndentationError. Au lieu de cela, nous construisons un corps vide avec l’instruction pass.

def function(args): pass

Nous pouvons également faire la même chose dans un classvide.

class example: pass

return

return instruction est utilisée à l’intérieur d’une fonction pour la quitter et retourner une valeur.

Si nous ne retournons pas une valeur explicitement, None est retournée automatiquement. Ceci est vérifié à l’aide de l’exemple suivant.

def func_return(): a = 10 return adef no_return(): a = 10print(func_return())print(no_return())

Sortie

10None

while

while est utilisé pour le bouclage en Python.

Les instructions à l’intérieur d’une boucle while continuent à s’exécuter jusqu’à ce que la condition de la boucle while évalue False ou qu’une instruction break soit rencontrée. Le programme suivant illustre cela.

i = 5while(i): print(i) i = i – 1

Sortie

54321

Notez que 0 est égal à False.

En savoir plus sur la boucle while de Python.L’instruction

with

with est utilisée pour envelopper l’exécution d’un bloc de code dans des méthodes définies par le gestionnaire de contexte.

Le gestionnaire de contexte est une classe qui implémente les méthodes __enter__ et __exit__. L’utilisation de l’instruction with garantit que la méthode __exit__ est appelée à la fin du bloc imbriqué. Ce concept est similaire à l’utilisation du bloc try…finally. Voici un exemple.

with open('example.txt', 'w') as my_file: my_file.write('Hello world!')

Cet exemple écrit le texte Hello world! dans le fichier example.txt. Les objets fichiers ont la méthode __enter__ et __exit__ définie en leur sein, ils agissent donc comme leur propre gestionnaire de contexte.

D’abord la méthode __enter__ est appelée, puis le code dans l’instruction with est exécuté et enfin la méthode __exit__ est appelée. La méthode __exit__ est appelée même s’il y a une erreur. Elle ferme essentiellement le flux de fichiers.

yield

yield est utilisée à l’intérieur d’une fonction comme une instruction return. Mais yield renvoie un générateur.

Le générateur est un itérateur qui génère un élément à la fois. Une grande liste de valeurs occupera beaucoup de mémoire. Les générateurs sont utiles dans cette situation car ils génèrent une seule valeur à la fois au lieu de stocker toutes les valeurs en mémoire. Par exemple,

>>> g = (2**x for x in range(100))

créera un générateur g qui génère des puissances de 2 jusqu’au nombre deux élevé à la puissance 99. Nous pouvons générer les nombres en utilisant la fonction next() comme indiqué ci-dessous.

>>> next(g)1>>> next(g)2>>> next(g)4>>> next(g)8>>> next(g)16

Et ainsi de suite… Ce type de générateur est renvoyé par l’instruction yield d’une fonction. Voici un exemple.

def generator(): for i in range(6): yield i*ig = generator()for i in g: print(i)

Sortie