Mots-clés Python

Dans Python, certains mots clés ne peuvent pas être utilisés comme noms variables ou de fonction. Les mots clés sont des mots réservés avec des fonctions / utilisations spécifiques. Le nombre total de mots clés peut changer en fonction de votre version Python. Par exemple, dans Python 3.7, il n'y avait que 33 mots clés. Dans Python 3.dix.4, il y a environ 35 mots clés. Dans ce tutoriel, nous apprendrons les mots clés Python.

Vérification des mots clés

Dans Python, vous pouvez utiliser le module de mots clés pour vérifier les mots clés. Mot-clé.KWList répertorie tous les mots clés de Python.

principal.py
Importer un mot-clé
# Cela imprime tous les mots clés
var = mot-clé.kwlist
imprimer (var)

Sortir:

[«False», «Aucun», «True», «et«, «comme», «Assert», «async», «Await», «Break», «Class», «Continuer», «Def», « del ',' elif ',' else ',' sauf ',' enfin ',' for ',' from ',' global ',' if ',' import ',' in ',' is ',' lambda ' , «non-local», «pas», ou «pass», «relance», «retour», «essai», «tandis», «avec», «rendement»]
Processus terminé avec le code de sortie 0

Si, en revanche, vous ne savez pas si un mot est un mot-clé, vous pouvez utiliser le mot-clé.ISKEYWORD (S) à découvrir:

principal.py
Importer un mot-clé
word_1 = "pause"
word_2 = "fonction"
word_3 = "variable"
# Ceci est utilisé pour vérifier si un mot est un mot-clé
var_1 = mot-clé.isKeyword (word_1)
imprimer (var_1)
var_2 = mot-clé.isKeyword (word_2)
imprimer (var_2)
var_3 = mot-clé.isKeyword (word_3)
Imprimer (var_3)

Sortir:

Vrai
FAUX
FAUX
Processus terminé avec le code de sortie 0

Alors maintenant, vérifions plusieurs mots clés!

Mot-clé: affirmer

Le affirmer Le mot-clé est utilisé dans Python pour déboguer. Ici, une condition est passé après le affirmer mot-clé. Si cette condition est vraie, tout va bien; Si, en revanche, la condition est fausse, une élan d'assurance est soulevée.

Voici deux exemples distincts. Lors du premier essai du bloc sauf, la condition est vraie, donc aucune erreur n'est augmentée. Dans le deuxième essai du bloc sauf, la condition (2 + 3 == 10) est fausse, et donc une élan d'assurance est augmentée.

principal.py
essayer:
affirmer 2 + 3 == 5
Print ("Affirmer 2 + 3 == 5 n'a pas soulevé d'assemblant")
Sauf assertionerror:
print ("Assert 2 + 3 == 5 a soulevé une assertionerror")
essayer:
affirmer 2 + 3 == 10
Imprimer ("Affirmer 2 + 3 == 10 n'a pas soulevé d'assemblage d'herbe")
Sauf assertionerror:
Imprimer ("Affirmer 2 + 3 == 10 a soulevé une assertionerror")

Sortir:

Affirmer 2 + 3 == 5 n'a pas soulevé de dorsion d'assurance
Affirmer 2 + 3 == 10 a soulevé une assertionerror
Processus terminé avec le code de sortie 0

Mots-clés: passer, continuer et casser

Le mot-clé de passe entraîne une opération nul; Il ne fait pratiquement rien. Il est généralement utilisé pour commencer à écrire du code comme espace réservé. Fondamentalement, il le contournera.

principal.py
classe de classe ():
passer

Sortir:

Processus terminé avec le code de sortie 0

D'un autre côté, le mot-clé continu est utilisé pour mettre fin à l'itération dans une boucle pour ou bien que, et passer par la suite à l'itération suivante. Donc, si le continuer Le mot-clé est utilisé, il sautera une itération.

principal.py
Nombres = [10, 15, 20, 25, 30, 35, 40]
pour engourdir les nombres:
Si Numb / 2 == 5:
continuer
Imprimer (engourdi)

Sortir:

15
20
25
30
35
40
Processus terminé avec le code de sortie 0

Dans cet exemple, nous disons que si un nombre divisé par 2 est égal à 5, alors continuez, et 10 divisé par 2 est égal à 5, donc il l'a sauté.

Le casser Le mot-clé est utilisé pour sortir d'une boucle

principal.py
i = 1
alors que je < 9:
i = i + 1
si je != 5:
Imprimer (i)
Si i == 5:
casser
imprimer ("en dehors des loo")

Sortir:

2
3
4
En dehors de la boucle
Processus terminé avec le code de sortie 0

Comme vous pouvez le voir, quand il frappe 5, il sort de la boucle.

Mots-clés: si, sinon et elif

Nous avons tous rencontré le sinon, et Elif affirmations. Ce sont les bases.

principal.py
nombres = [15, 20, 25]
pour engourdir les nombres:
Si engourdi> 20:
print ("% s est supérieur à 20"% (engourdie))
Elif Numb < 20:
print ("% s est inférieur à 20"% (engourdi))
autre:
print ("% s est égal à 20"% (engourdi))

Sortir:

15 est inférieur à 20
20 est égal à 20
25 est supérieur à 20
Processus terminé avec le code de sortie 0

Mots-clés: essayez, sauf et enfin

Essayer sauf Les déclarations sont utilisées pour assister aux erreurs. Alors, nous disons essayer ceci, et si cela échoue, nous pouvons attraper l'erreur dans le sauf déclaration.

principal.py
x = "2"
essayer:
Si x == "2":
print ("First Try Block a bien tourné")
sauf:
imprimer ("erreur s'est produite")
essayer:
Si x / 0 == 1:
Imprimer (x / 2)
sauf TypeError:
Imprimer ("Il y avait un type Eerror dans le deuxième bloc d'essai")

Sortir:

Essayez d'abord le bloc s'est bien passé
Il y avait une énergie type dans le deuxième bloc d'essai
Processus terminé avec le code de sortie 0

Comme vous pouvez le voir, dans le premier bloc, il n'y a eu aucune erreur, donc le essayer un bloc a été exécuté et le sauf Le bloc a été ignoré. Dans la seconde essayer bloc, il y a eu une erreur, et cette erreur a été prise par le sauf bloc.

Le enfin le bloc est exécuté après le essayer et sauf bloc. Il est toujours exécuté indépendamment de ce qui se passe.

principal.py
essayer:
i = 4
b = i / 0
Impression (b)
Sauf ZerodivisionError:
imprimer ("erreur")
enfin:
imprimer ("après le bloc d'essai sauf")

Sortir:

Erreur
Après le bloc d'essai sauf
Processus terminé avec le code de sortie 0

Mots-clés: est et dans

Le mot-clé IS est utilisé pour déterminer si deux objets sont identiques.

principal.py
x = ["voiture", "race", "accident"]
y = ["voiture", "race", "accident"]
imprimer (x est y)

Sortir:

FAUX
Processus terminé avec le code de sortie 0

Ce dernier est le cas parce que ces listes sont mutables et allouées séparément en mémoire.

Le dans Le mot clé est utilisé pour vérifier si une valeur est contenue dans une liste ou quelque chose de similaire.

Principal.py
x = [«voiture», «race», «accident»]
Si «voiture» dans x:
Imprimer («La voiture de mots est dans la liste X»)
autre:
Imprimer («La voiture de mots n'est pas dans la liste x»)

Sortir:

La voiture de mots est dans la liste x
Processus terminé avec le code de sortie 0

Mots-clés: vrai, faux et aucun

Vrai et FAUX sont des valeurs booléennes; Aucun est une valeur nulle.

Principal.py
Imprimer (aucun == 0)
imprimer (aucun == false)
imprimer (aucun == aucun)
Imprimer (2 + 3 == 5)
Imprimer (2 + 3 == 10)

Sortir:

FAUX
FAUX
Vrai
Vrai
FAUX
Processus terminé avec le code de sortie 0

Donc, cela signifie qu'aucun n'est pas égal à 0, pas égal à False, et est une valeur propre.

Mots-clés: et, ou non

Ce sont assez simples. Et est et, ou est ou, et pas est utilisé pour nier quelque chose.

principal.py
a = 3
b = 5
C = 30
Si un> 1 et un 6 ou B < 20:
print ("b est supérieur à 6 ou moins de 20")
autre:
imprimer ("b n'est ni supérieur à 6 ni moins de 20")
Imprimer (pas vrai)

Sortir:

A est compris entre 1 et 20
B est supérieur à 6 ou moins 20
FAUX
Processus terminé avec le code de sortie 0

N'oubliez pas cela pour «et», Les deux déclarations doivent être vraies pour renvoyer un vrai. Pour "ou", Vous en avez besoin pour être vrai.

Mots-clés: pour et pendant que

Les deux pour et alors que sont utilisés pour la boucle. Nous utilisons pour Quand nous savons combien de fois nous voulons faire boucle. Nous utilisons alors que Quand nous voulons que la boucle continue jusqu'à ce qu'elle atteigne une pause ou un point de résiliation prédéfini.

principal.py
# pour boucle
x = ["voiture", "race", "accident"]
Pour les membres de X:
Impression (membres)
# While Loop
i = 1
alors que je<3:
i = i + 1
Imprimer (i)

Sortir:

voiture
course
accident
2
3
Processus terminé avec le code de sortie 0

Mots-clés: import, de et comme

Nous connaissons et utilisons tous le mot-clé importer. Il est utilisé pour importer des modules. De plus, nous savons «depuis"Puisqu'il est utilisé dans l'instruction IMPORT. Le comme Le mot-clé est utilisé pour l'aliasing.

principal.py
à partir des mots clés importants kwlist
à partir de l'importation de mots clés est-ce que
imprimer (kwlist)
imprimer (clé ("race"))

Sortir:

[«False», «Aucun», «True», «et«, «comme», «Assert», «async», «Await», «Break», «Class», «Continuer», «Def», « del ',' elif ',' else ',' sauf ',' enfin ',' for ',' from ',' global ',' if ',' import ',' in ',' is ',' lambda ' , «non-local», «pas», ou «pass», «relance», «retour», «essai», «tandis», «avec», «rendement»]
FAUX
Processus terminé avec le code de sortie 0

Alors ici, le mot-clé tel qu'il est utilisé comme un alias pour le mot iskeyword.

Mots-clés: classe, DEF, retour et rendement

Le classe Le mot-clé est utilisé pour assembler les données et les fonctions. Le def Le mot-clé est utilisé pour définir une fonction. Et retour est utilisé pour renvoyer une valeur.

principal.py
Zone de classe:
# fonction
Def __init __ (soi, largeur, hauteur):
soi.largeur = largeur
soi.hauteur = hauteur
def rectarea (soi):
se retourner.largeur * soi.hauteur
var = zone (3, 4)
imprimer (var.rectarea ())

Sortir:

12
Processus terminé avec le code de sortie 0

Contrairement à retour qui donne une sortie et s'arrête par la suite, rendement fournira une sortie et continuera. Le rendement Le mot-clé est utilisé dans une fonction et renvoie un générateur.

principal.py
Fonction de retour
def returnfunc ():
pour I à portée (3):
print ("returnfunc:% s"% i)
retour i
returnfunc ()
Fonction de rendement
Def Contordefunc ():
pour I à portée (3):
rendement i
pour le membre de LEADEDFUNC ():
Imprimer ("Contactez-vous:% S"% membre)

Sortir:

returnfunc: 0
Contour de rendement: 0
Contrôlement: 1
Contour de rendement: 2
Processus terminé avec le code de sortie 0

Remarquez comment pour le rendement Scénario, il continue, tandis que pour le scénario de retour, il s'arrête une fois qu'il frappe le mot-clé de retour.

Mots-clés: global et non local

Le mondial Le mot-clé est accessible n'importe où. En règle générale, une variable à l'extérieur d'une fonction peut facilement être lue et imprimée à partir d'une fonction. Mais, quand il s'agit de le modifier, vous devez utiliser le mot-clé mondial, sinon vous obtiendrez une erreur.

principal.py
x = 8
essayer:
def add ():
x = x + 8
Imprimer (x)
ajouter()
Sauf Unboundlocalerror:
Imprimer ("Erreur soulevée parce que vous ne pouvez pas jouer avec une variable globale dans un contexte local")
essayer:
def moins ():
Global X
x = x-4
Imprimer (x)
moins()
Sauf Unboundlocalerror:
Imprimer ("Erreur soulevée")

Sortir:

Erreur soulevée parce que vous ne pouvez pas jouer avec une variable globale dans un contexte local
4
Processus terminé avec le code de sortie 0

Le non local Le mot-clé est utilisé avec des fonctions imbriquées.

principal.py
# sans utiliser non local
def exter_func ():
x = 2
def inner_func ():
x = 3
Imprimer ("inner_func:% s"% x)
inner_func ()
Print ("OUTER_FUNC:% S"% x)
outer_func ()
# maintenant en utilisant non local
def exter_func2 ():
x = 10
def inner_func2 ():
x non local
x = 20
Print ("inner_func2:% s"% x)
inner_func2 ()
Print ("OUTER_FUNC2:% S"% x)
outer_func2 ()

Sortir:

inner_func: 3
OUTER_FUNC: 2
inner_func2: 20
OUTER_FUNC2: 20
Processus terminé avec le code de sortie 0

Mot-clé: Del

Le del Le mot-clé est utilisé pour supprimer.

principal.py
x = ["race", "voiture", "accident"]
del x [2]
Imprimer (x)

Sortir:

['voiture de course']
Processus terminé avec le code de sortie 0

Mot-clé: avec

Le avec Le mot-clé simplifie le code.

principal.py
avec Open ('Fichier.txt ',' w ') comme fichier:
déposer.écrire ("Linuxhint")

Sortir:

Processus terminé avec le code de sortie 0

Mots-clés: asynchrones et attendez

Ici, la fonction fonctionnera avec un écart de cinq secondes entre la première déclaration d'impression et la seconde.

principal.py
importer asyncio
async def ayncfunc ():
imprimer («première déclaration»)
AWAIT ASYNCIO.sommeil (5)
imprimer («deuxième déclaration»)
asyncio.Run (ayncfunc ())

Sortir:

Première déclaration
Deuxième déclaration
Processus terminé avec le code de sortie 0

Mots-clés: augmenter

Le augmenter Le mot-clé est utilisé pour soulever une exception ou une erreur.

principal.py
x = [5, 10, 15, 20]
Pour les membres de X:
z = membres / 5
Si z == 1:
lever l'exception ("vous avez un 1")

Sortir:

lever l'exception ("vous avez un 1")
Exception: vous avez un 1
Processus terminé avec le code de sortie 1

Mot-clé: lambda

Le lambda Le mot-clé est utilisé pour créer une fonction sans nom.

principal.py
a = lambda x, y, z: x + y + z
imprimer (a (1,2,3))

Sortir:

6
Processus terminé avec le code de sortie 0

Conclusion

Les mots clés Python sont des mots cruciaux qui ne peuvent pas être utilisés comme noms de variables ou de fonction. Il y a 35 mots clés dans Python 3.dix.4, et chaque mot-clé est aussi important que le reste. Dans ce tutoriel, nous avons appris chacun de ces 35 mots clés. Alors, utilisez chacun efficacement!