Liste des mots-clés en Python et exemples

Ce tutoriel fournit des informations brèves sur tous les mots-clés utilisés en Python.

Les mots-clés sont des mots réservés en Python. Nous ne pouvons pas utiliser les mots-clés comme noms de variables, noms de fonctions ou tout autre identificateur.

C'est la liste de tous les mots-clés utilisés dans le langage de programmation Python

Les mots-clés mentionnés peuvent changer dans différentes versions de Python. Il peut y avoir des ajouts supplémentaires ou des suppressions de certains contenus. Vous pouvez toujours obtenir la liste des mots-clés de la version actuelle en utilisant la méthode suivante.

>>> import keyword
>>> print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally',
　'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'

Exemple de déclaration de mots-clés en Python

True, False

True et False sont des valeurs vraies et fausses en Python. Ils sont les résultats des opérations de comparaison ou des opérations logiques (booléennes) en Python. Par exemple :

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

Ici, nous pouvons voir que les trois premières instructions sont correctes, donc l'interpréteur retourne True, tandis que les trois autres instructions retournent False. True et False en Python sont équivalents à1et 0 sont identiques. Cela peut être prouvé par les exemples suivants :

>>> True ==　1
True
>>> False == 0
True
>>> True　+　True
2

None

None est une constante spéciale en Python, qui représente une valeur inexistante ou une valeur vide.

C'est un objet de type NoneType propre à lui-même. Nous ne pouvons pas créer plusieurs objets None, mais nous pouvons les assigner à des variables. Ces variables sont égales.

Nous devons特别注意，None ne signifie pas False, 0 ou toute liste, dictionnaire, chaîne de caractères vide, etc. Par exemple :

>>> None == 0
False
>>> None == []
False
>>> None == False
False
>>> x = None
>>> y = None
>>> x == y
True

Les fonctions vides qui ne retournent rien retournent automatiquement un objet None. Les fonctions qui n'ont pas rencontré de instruction return retournent également None. Par exemple :

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

Output results

None

Bien que ce programme exécute certaines opérations à l'intérieur, sa fonction ne retourne aucune valeur. Par conséquent, lorsque nous imprimons x, nous obtenons automatiquement (implicitement) None. De même, voici un autre exemple :

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

Output results

None

Bien que cette fonction ait une déclaration return, elle n'est pas toujours exécutable dans toutes les situations. La fonction retourne True uniquement si l'entrée est pair.

Si nous passons un nombre impair à la fonction, elle retourne implicitement None.

and, or, not

and, or, not sont des opérateurs logiques en Python. Et le résultat est True uniquement si les deux opérateurs sont True. Le tableau de vérité de and est le suivant :

or si l'un des opérateurs est True, le résultat est True. Le tableau de vérité de or est le suivant :

L'opérateur not est utilisé pour inverser la valeur de vérité. Le tableau de vérité de not est le suivant :

Voici quelques exemples d'utilisation

>>> True and False
False
>>> True or False
True
>>> not False
True

as

as est utilisé pour créer un alias lors de l'importation du module. Cela signifie que nous attribuons un nom différent (défini par l'utilisateur) au module lors de l'importation.

Par exemple, Python a un module standard appelé math. Supposons que nous voulions utiliser un alias pour calculer le cos(pi). Nous pouvons le faire de la manière suivante :

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

Ici, nous importons le module via l'attribution de nom au module myAlias. Maintenant, nous pouvons utiliser ce nom pour appeler le module. En utilisant ce nom, nous avons calculé cos(pi) et obtenu-1.0 pour obtenir la réponse.

assert

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

En programmation, parfois nous voulons comprendre l'état interne ou vérifier si nos hypothèses sont correctes. assert nous aide à cela et facilite la découverte des erreurs. assert suit une condition.

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

>>>　a　=　4
>>>　assert　a　<　5
>>>　assert　a　>　5
Traceback (appel le plus récent en dernier):
　　Fichier "<string>", ligne　301, dans runcode
　　Fichier "<interactive input>", ligne　1, dans <module>
AssertionError

Pour nous aider à mieux comprendre, nous pouvons fournir un message qui sera imprimé avec l'AssertionError.

>>>　a　=　4
>>>　assert　a　>　5,　"The　value　of　a　is　too　small"
Traceback (appel le plus récent en dernier):
　　Fichier "<string>", ligne　301, dans runcode
　　Fichier "<interactive input>", ligne　1, dans <module>
AssertionError:　The　value　of　a　is　too　small

À ce point, nous pouvons noter que,

assert　condition,　message

est équivalent à

if　not　condition:
　　　　raise　AssertionError(message)

async, await

La bibliothèque asyncio en Python fournit les mots-clés async et await. Ils sont utilisés pour écrire du code concurrent en Python. Par exemple,

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

Pour exécuter le programme, nous utilisons

asyncio.run(main())

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

Ici, d'abord imprimez Hello. La clé await fait que le programme attend1secondes. Ensuite, imprimez world.

break, continue

break et continue sont utilisés dans les boucles for et while pour modifier leur comportement normal.

break termine le plus petit cycle dans lequel il se trouve, et le flux de contrôle est directement dirigé vers les instructions sous la boucle. continue termine l'itération actuelle de la boucle, mais pas la boucle entière.

Cela peut être expliqué par les deux exemples suivants :

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

Output results

1
2
3
4

Ici, la boucle for est destinée à imprimer à partir de1à10sont imprimées. Mais si lorsque i vaut5 alors les conditions sont remplies, nous avons interrompu la boucle. Par conséquent, seules les valeurs de la plage sont imprimées.1à4.

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

Output results

1
2
3
4
6
7
8
9
10

Ici, nous utilisons le même programme que continue. Par conséquent, lorsque les conditions sont remplies, l'itération actuelle est sautée. Mais nous ne quittons pas la boucle. Par conséquent, les éléments sautés seront imprimés.5toutes les autres valeurs.

En savoir plus surInstructions break et continue PythonPlus d'informations.

class

class est utilisé pour définir de nouvelles classes utilisateur en Python.

Une classe est une collection de propriétés et de méthodes qui tentent de représenter des situations réelles. L'idée de placer des données et des fonctions dans une classe est essentielle pour le concept de programmation orientée objet (OOP).

Les classes peuvent être définies à tout moment dans le programme. Cependant, il est une bonne habitude de définir une seule classe dans un module. Voici un exemple d'utilisation :

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

En savoir plus surObjets et classes PythonPlus d'informations.

def

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

Une fonction est un ensemble de statements liées qui exécutent ensemble certaines tâches spécifiques. Elle aide à organiser le code en blocs gérables et à accomplir des tâches répétitives.

L'utilisation de def est indiquée ci-dessous :

def function_name(parameters):
　　　　...

En savoir plus surFonctions des fonctions PythonPlus d'informations.

del

del est utilisé pour supprimer les références à des objets. Tout est un objet en Python. Nous pouvons utiliser del pour supprimer des variables, par référence.

>>> a = b =　5
>>> del a
>>> a
Traceback (appel le plus récent en dernier):
　　Fichier "<string>", ligne　301, dans runcode
　　Fichier "<interactive input>", ligne　1, dans <module>
NameError: le nom 'a' n'est pas défini
>>> b
5

Ici, nous pouvons voir que la référence à la variable a a été supprimée. Par conséquent, 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 = ['x','y','z']
>>> del a[1]
>>> a
['x', 'z']

if, else, elif

if, else, elif sont utilisés pour les branches conditionnelles ou les décisions.

Lorsque nous devons tester une condition et exécuter le bloc uniquement si la condition est vraie, nous utilisons if et elif. Elif est l'abréviation de else if. Else est le bloc exécuté lorsque la condition est fausse. Un exemple clair est fourni ci-dessous :

def if_example(a):
　　　　if a ==　1:
　　　　　　　　print('Un')
　　　　elif a ==　2:
　　　　　　　　print('Deux')
　　　　else:
　　　　　　　　print('Autre chose')
if_example(2)
if_example(4)
if_example(1)

Output results

Deux
Autre chose
One

Dans ce cas, la fonction vérifie le nombre entré (si1ou2），et affichez le résultat. Sinon, toute entrée entraînera l'exécution du code de la partie else.

En savoir plus surLes instructions if et if ... else en PythonPlus d'informations.

except, raise, try

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

Les exceptions sont essentiellement des erreurs qui indiquent que des problèmes se sont produits pendant l'exécution de notre programme. Parmi les plusieurs exemples d'exceptions Python, IOError, ValueError, ZeroDivisionError, ImportError, NameError, TypeError, etc. Le bloc try...except est utilisé pour capturer les exceptions en Python.

Nous pouvons utiliser la clause raise pour lever explicitement une exception. Voici un exemple :

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

Output results

0.1
Exception　caught
None

Dans ce cas, la fonction reciprocal() renvoie le nombre réciproque de l'entrée.

Entrée10Lorsque, la sortie normale est 0.1. Mais lorsque nous entrons 0, une exception ZeroDivisionError est automatiquement levée.

Cela est capturé par notre bloc try...except, nous renvoyons None. Nous pouvons également explicitement lever ZeroDivisionError en vérifiant l'entrée et en le traitant comme suit :

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

finally

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

Utilisez finally pour vous assurer que le bloc de code à l'intérieur peut être exécuté même s'il y a des exceptions non traitées. Par exemple :

try:
　　　　Try-block
except　exception1:
　　　　Exception1-block
except　exception2:
　　　　Exception2-block
else:
　　　　Else-block
finally:
　　　　Finally-block

Dans ce cas, s'il y a une exception dans Try-block, il est traité dans le bloc except ou else. Mais peu importe l'ordre d'exécution, même en cas d'erreur, nous pouvons exécuter Finally en toute sécurité.-block. Cela est utile pour libérer les ressources.

En savoir plus surLe traitement des exceptions en programmation PythonPlus d'informations.

for

for est utilisé pour la boucle. Souvent, nous utilisons for lorsque nous connaissons le nombre de fois à boucler.

En Python, nous pouvons l'utiliser avec n'importe quel type de séquence (par exemple, une liste ou une chaîne de caractères). Voici un exemple de boucle for pour parcourir la liste names :

names = ['John','Monica','Steven','Robin']
for i in names:
　　　　print('Bonjour '+i)

Output results

Bonjour John
Bonjour Monica
Bonjour Steven
Bonjour Robin

En savoir plus surLe boucle for en PythonPlus d'informations.

from, import

La clé import est utilisée pour importer un module dans l'espace de noms courant. from…import est utilisé pour importer une propriété ou une fonction spécifique dans l'espace de noms courant. Par exemple :

import math

Importe le module math. Nous pouvons maintenant utiliser la fonction cos() comme math.cos(). Mais si nous ne voulons importer que la fonction cos(), nous pouvons utiliser from pour

from math import cos

Nous pouvons maintenant utiliser simplement la fonction cos() sans écrire math.cos().

En savoir plus surPlus d'informations sur les modules Python et les instructions import.

global

global est utilisé pour déclarer une variable comme globale à l'intérieur d'une fonction (extérieure à la fonction).

Si nous devons lire la valeur d'une variable globale, nous n'avons pas besoin de la définir comme global. C'est là que cela est nécessaire.

Si vous devez modifier la valeur d'une variable globale à l'intérieur d'une fonction, vous devez utiliser la déclaration global. Sinon, une variable locale portant ce nom sera créée.

L'exemple suivant nous aidera à clarifier cela.

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

Output results

10
5
5

Ici, read1() fonction ne lit que la valeur de globvar. Par conséquent, nous n'avons pas besoin de la déclarer comme global. Mais write1() fonction modifie la valeur, donc nous devons déclarer la variable comme global.

Nous pouvons voir dans la sortie que la modification a été effectuée (la valeur10est modifiée en5）。write2() essaie également de modifier cette valeur. Mais nous ne l'avons pas déclarée comme global.

Par conséquent, créons une nouvelle variable locale, globvar, qui n'est pas visible en dehors de cette fonction. Bien que nous modifiions cette variable locale pour15， mais les variables globales restent inchangées. Cela est clairement visible dans notre sortie.

in

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

>>> a = [1,　2,　3,　4,　5]
]　5　>>>
True
]　10　>>>
False

in a

L'utilisation secondaire de in est de parcourir une séquence dans le cycle for.
　　　　print(i)

Output results

for i in 'hello':
e
l
l
o

is

is est utilisé en Python pour tester l'identité des objets. L'opérateur == est utilisé pour tester si deux variables sont égales, tandis que l'opérateur is est utilisé pour tester si deux variables référencent le même objet.

Retourne True si les objets sont identiques, sinon retourne False.

>>> True is True
True
>>> False is False
True
>>> None is None
True

Nous savons qu'il n'y a qu'un seul exemple 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 à une autre liste ou dictionnaire vide. Mais ils ne sont pas les mêmes objets, car ils se trouvent chacun dans la mémoire. Cela est dû au fait que les listes et les dictionnaires sont mutables (les valeurs peuvent être modifiées).

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

Contrairement aux listes et aux dictionnaires, les chaînes et les tuples sont immuables (les valeurs ne peuvent pas être modifiées une fois définies). Par conséquent, deux chaînes ou tuples égaux sont également identiques. Ils référencent la même position de stockage.

lambda

lambda est utilisé pour créer une fonction anonyme (fonction sans nom). C'est une fonction en ligne qui ne contient pas de commande return. Elle se compose d'une expression évaluée et retournée. Par exemple :

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

Output results

2
4
6
8
10

Ici, nous créons une fonction en ligne, en utilisant l'instruction lambda pour doubler les valeurs. Nous l'utilisons pour doubler les valeurs de1à5les valeurs de la liste sont doublées.

En savoir plus surLa fonction lamda de PythonPlus d'informations.

nonlocal

L'utilisation de la clé nonlocal est très similaire à celle de la clé global. nonlocal est utilisé pour déclarer les variables dans les fonctions imbriquées (les fonctions à l'intérieur des fonctions) qui ne sont pas des variables locales, ce qui signifie qu'elles se trouvent dans la fonction fermée externe. Si vous devez modifier la valeur d'une variable non locale dans une fonction imbriquée, vous devez utiliser la déclaration nonlocal. Sinon, une variable locale portant ce nom sera créée à l'intérieur de la fonction imbriquée. L'exemple suivant nous aidera à clarifier cela.

def outer_function():
　　　　a =　5
　　　　def inner_function():
　　　　　　　　nonlocal a
　　　　　　　　a =　10
　　　　　　　　print("Fonction interne: ", a)
　　　　inner_function()
　　　　print("Fonction externe: ", a)
outer_function()

Output results

Fonction interne:　　10
Fonction externe:　　10

Ici, la fonction inner_function() est imbriquée dans la fonction outer_function.

La variable a se trouve dans la fonction outer_function(). Par conséquent, si vous souhaitez modifier a dans la fonction inner_function(), vous devez la déclarer comme nonlocal. Notez que cette a n'est pas une variable globale.

Donc, nous voyons dans la sortie que la variable a a été modifiée avec succès à l'intérieur de la fonction imbriquée inner_function(). Voici le résultat sans utiliser la directive nonlocal:

def outer_function():
　　　　a =　5
　　　　def inner_function():
　　　　　　　　a =　10
　　　　　　　　print("Fonction interne: ", a)
　　　　inner_function()
　　　　print("Fonction externe: ", a)
outer_function()

Output results

Fonction interne:　　10
Fonction externe:　　5

Ici, nous ne déclarons pas que la variable a dans la fonction imbriquée n'est pas locale. Par conséquent, une nouvelle variable locale portant le même nom sera créée, mais la variable non locale a ne sera pas modifiée, comme notre sortie le montre.

pass

La directive pass est une instruction vide en Python. Quand elle est exécutée, rien ne se passe. Elle est utilisée comme une marqueur.

Supposons que nous ayons une fonction non implémentée que nous voulons implémenter à l'avenir. Simplement,

def function(args):

Nous recevons un IndentationError au milieu du programme. À la place, nous utilisons la directive pass pour construire un corps vide.

def function(args):
　　　　pass

Nous pouvons également faire la même chose avec une class vide.

class example:
　　　　pass

return

La directive return est utilisée à l'intérieur des fonctions pour quitter et retourner une valeur.

Si nous ne retournons pas explicitement une valeur, None sera retourné automatiquement. Le prochain exemple le vérifie.

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

Output results

10
None

while

while est utilisé pour les boucles en Python.

Les instructions à l'intérieur du boucle while s'exécutent jusqu'à ce que la condition de boucle while évalue à False ou qu'une instruction break soit rencontrée. Le programme suivant en donne une illustration.

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

Output results

5
4
3
2
1

Veuillez noter que 0 est égal à False.

En savoir plus surLe boucle while en PythonPlus d'informations.

with

La syntaxe with est utilisée pour envelopper l'exécution d'un bloc de code dans une méthode de gestionnaire de contexte.

Le gestionnaire de contexte est une classe qui implémente les méthodes __enter__ et __exit__. L'utilisation de la syntaxe with assure l'appel de la méthode __exit__ à la fin du bloc imbriqué. Ce concept est similaire à l'utilisation de blocs try...finally. Voici un exemple.

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

This example writes the text Hello world! to the example.txt file. The file object defines the __enter__ and __exit__ methods, so they act as their own context managers.

First, the method __enter__ is called, then the code in the with statement is executed, and finally, the method __exit__ is called. __exit__ will call the method even if there is an error. It will basically close the file stream.

yield

yield is used in functions like return statements. However, yield returns a generator.

A generator is an iterator that generates one item at a time. A large number of values will occupy a large amount of memory. Generators are very useful in this case because they generate one value at a time, rather than storing all values in memory. For example,

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

A generator g will be created, generating a2to the power, until the sum is generated to99to the2to the power. We can use next() as shown in the following function to generate these numbers.

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

And so on...This type of generator is returned by the statement of the yield function. Here is an example.

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

Output results

0
1
4
9
16
25

Here, the function generator() returns a generator that generates from 0 to5the square of the number. Print it in the for loop.