Table des matières
Dans le processus d'apprentissage de la programmation, il est souvent nécessaire de créer des programmes qui ne sont pas si faciles à appliquer dans la vie réelle. Après tout, de temps en temps, vous ne devez suivre les instructions que sous certaines conditions. Pour pouvoir implémenter cela dans le programme, tous les langages ont des instructions de contrôle. Avec leur aide, vous pouvez contrôler le flux d'exécution du code, créer des boucles ou effectuer certaines actions uniquement lorsqu'une certaine condition est vraie.
Aujourd'hui, nous allons parler de l'instruction if, qui vérifie la situation actuelle pour une certaine condition et, sur la base de ces informations, prend des décisions sur les actions futures.
Types d'instructions de contrôle
En général, if n'est pas la seule instruction qui contrôle le déroulement d'un programme. De même que lui-même peut faire partie d'une plus grande chaîne d'opérateurs.
Il existe également des boucles et des instructions qui contrôlent le processus de son exécution. Aujourd'hui, nous ne parlerons que de l'opérateur conditionnel et des chaînes auxquelles il peut participer.
En programmation, il existe une chose telle que la création de branches. C'est précisément cela qui signifie une séquence de commandes qui n'est exécutée que si une certaine condition est vraie. Les critères eux-mêmes peuvent être différents :
- Égalité d'une variable à une certaine valeur.
- Exécution d'une action spécifique.
- État de l'application (réduite ou non).
Le spectre peut être beaucoup plus large. Les instructions conditionnelles sont de plusieurs types :
- Avec une branche. Autrement dit, une seule vérification est effectuée, à la suite de laquelle certaines actions sont effectuées.
- Avec deux succursales ou plus. Si le critère 1 est vrai, alors vérifiez le critère 2. S'il est vrai, alors vérifiez le 3. Et ainsi, effectuez autant de vérifications que nécessaire.
- Avec plusieurs conditions. Tout est simple ici. L'interprète vérifie plusieurs conditions ou l'une d'entre elles.
if
La structure de l'instruction if est similaire dans toutes les langues. Cependant, en Python, sa syntaxe est quelque peu différente de toutes les autres :
si état :
<входящее выражение 1>
<входящее выражение 2>
<nе входящее выражение>
Tout d'abord, l'opérateur lui-même est déclaré, après quoi la condition sous laquelle il commence à fonctionner est écrite. La condition peut être vraie ou fausse.
Ceci est suivi d'un bloc avec des commandes. S'il suit immédiatement un critère à respecter, la séquence de commandes correspondante est appelée un bloc if. Vous pouvez y utiliser n'importe quel nombre de commandes.
Attention! L'indentation dans toutes les commandes de bloc if doit avoir la même taille. Les limites des blocs sont déterminées par les retraits.
Selon la documentation du langage, l'indentation est de 4 espaces.
Comment fonctionne cet opérateur ? Lorsque l'interpréteur voit le mot if, il vérifie immédiatement l'expression par rapport aux critères spécifiés par l'utilisateur. Si tel est le cas, alors il commence à chercher des instructions et à les suivre. Sinon, toutes les commandes de ce bloc sont ignorées.
Si une instruction après la condition n'est pas indentée, elle n'est pas traitée comme un bloc if. Dans notre situation, cette ligne est
Voici un extrait de code pour un exemple du fonctionnement de cet opérateur.
nombre = int(input("Entrez un nombre :"))
si nombre > 10 :
print("Le nombre est supérieur à 10")
Ce programme invite l'utilisateur à entrer un nombre et vérifie s'il est supérieur à 10. Si tel est le cas, il renvoie les informations appropriées. Par exemple, si l'utilisateur entre le chiffre 5, le programme se terminera simplement, et c'est tout.
Mais si vous spécifiez le nombre 100, l'interprète comprendra qu'il est supérieur à dix et le signalera.
Attention! Dans notre cas, si la condition est fausse, le programme s'arrête, car aucune commande n'est donnée après l'instruction.
Il n'y a qu'une seule commande dans le code ci-dessus. Mais il y en a beaucoup plus. La seule exigence est d'indenter.
Analysons maintenant cette séquence de commandes.
nombre = int(input("Ecrire un nombre : "))
si nombre > 10 :
print("première ligne")
print("deuxième ligne")
print("troisième ligne")
print("La ligne qui est exécutée, quel que soit le nombre saisi")
print("Fin de l'application")
Essayez de deviner quelle sera la sortie si vous entrez les valeurs 2, 5, 10, 15, 50.
Comme vous pouvez le voir, si le nombre saisi par l'utilisateur est supérieur à dix, trois lignes sont générées + une avec le texte "Exécuter à chaque fois ..." et une "Fin", et si moins de dix, alors une seule, avec un texte différent. Seules les lignes 3,4,5 seront exécutées si vrai. Cependant, les deux dernières lignes seront écrites quel que soit le nombre spécifié par l'utilisateur.
Si vous utilisez les instructions directement dans la console, le résultat sera différent. L'interprète active immédiatement le mode multiligne si, après avoir spécifié le critère de vérification, appuyez sur Entrée.
Supposons que nous ayons écrit la séquence de commandes suivante.
>>>
>>> n = 100
>>> si n > 10 :
...
Après cela, nous verrons que >>> a été remplacé par des points de suspension. Cela signifie que le mode d'entrée multiligne est activé. En termes simples, si vous appuyez sur Entrée, vous serez transféré à l'entrée de la deuxième étape de l'instruction.
Et pour sortir de ce bloc, vous devez ajouter une autre construction au bloc if.
>>>
>>> n = 100
>>> si n > 10 :
… imprimer(«nv 10»)
...
Si la condition n'est pas vraie, le programme se termine. Ceci est un problème, car l'utilisateur peut percevoir un tel programme comme s'étant fermé en raison d'un échec. Par conséquent, il est nécessaire de donner un retour à l'utilisateur. Pour cela, un lien est utilisé sinon.
opérateur d'expression sinon
Cet opérateur permet de mettre en place un lien : si l'expression correspond à une certaine règle, effectuer ces actions, sinon, d'autres. C'est-à-dire qu'il vous permet de diviser le flux du programme en deux routes. La syntaxe est intuitive :
si état :
# si bloc
relevé 1
relevé 2
etc
autre:
# autre bloc
relevé 3
relevé 4
et ainsi de suite:
Expliquons le fonctionnement de cet opérateur. Tout d'abord, l'instruction standard est exécutée dans le thread if, vérifier s'il correspond condition "vrai ou faux". Les actions ultérieures dépendent des résultats de la vérification. Si vrai, l'instruction qui se trouve dans la séquence d'instructions suivant la condition est exécutée directement. if, si c'est faux, alors d'autre.
De cette façon, vous pouvez gérer les erreurs. Par exemple, l'utilisateur doit entrer un rayon. Évidemment, il ne peut s'agir que d'un nombre avec un signe plus, ou c'est une valeur nulle. S'il est inférieur à 0, vous devez émettre un message vous demandant d'entrer un nombre positif.
Voici le code qui implémente cette tâche. Mais il y a une erreur ici. Essayez de deviner lequel.
rayon = int(input("Entrez le rayon : "))
si rayon >= 0 :
print("Circonférence = ", 2 * 3.14 * rayon)
print("Aire = ", 3.14 * rayon ** 2)
autre:
print("Veuillez entrer un nombre positif")
Erreur de non-concordance d'indentation. Si è Sinon doivent se trouver sans eux ou avec le même nombre d'entre eux (selon qu'ils sont imbriqués ou non).
Donnons un autre cas d'utilisation (où tout sera correct avec l'alignement de l'opérateur) - un élément d'application qui vérifie un mot de passe.
mot de passe = entrée ("Entrez le mot de passe : ")
si mot de passe == « sshh » :
print("Bienvenue")
autre:
print("Accès refusé")
Cette instruction ignore la personne plus loin si le mot de passe est sshh. S'il existe une autre combinaison de lettres et de chiffres, le message « Accès refusé » s'affiche.
expression-instruction if-elif-else
Ce n'est que si plusieurs conditions ne sont pas vraies que l'instruction qui se trouve dans le bloc est exécutée. d'autre. Cette expression fonctionne comme ceci.
si condition_1 :
# si bloc
déclaration
déclaration
plus de déclaration
condition elif_2 :
# premier bloc elif
déclaration
déclaration
plus de déclaration
condition elif_3 :
# deuxième bloc elif
déclaration
déclaration
plus de déclaration
...
d'autre
déclaration
déclaration
plus de déclaration
Vous pouvez spécifier n'importe quel nombre de conditions supplémentaires.
Déclarations imbriquées
Une autre façon d'implémenter plusieurs conditions consiste à insérer des vérifications de condition supplémentaires dans le bloc if.
Opérateur if à l'intérieur d'un autre bloc de condition
gre_score = int(input("Entrez votre limite de crédit actuelle"))
per_grad = int(input("Entrez votre cote de solvabilité :"))
si per_grad > 70 :
# extérieur si bloc
si gre_score > 150 :
# interne si bloc
print("Félicitations, vous avez reçu un prêt")
autre:
print("Désolé, vous n'êtes pas éligible pour un prêt")
Ce programme effectue une vérification de la cote de crédit. S'il est inférieur à 70, le programme signale que l'utilisateur n'est pas éligible au crédit. Si elle est supérieure, une deuxième vérification est effectuée pour voir si la limite de crédit actuelle est supérieure à 150. Si oui, un message s'affiche indiquant que le prêt a été émis.
Si les deux valeurs sont fausses, un message s'affiche indiquant que l'utilisateur n'a pas la possibilité d'obtenir un prêt.
Maintenant, retravaillons un peu ce programme.
gre_score = int(input("Entrez la limite actuelle : "))
per_grad = int(input("Entrez le pointage de crédit : "))
si per_grad > 70 :
si gre_score > 150 :
print("Félicitations, vous avez reçu un prêt")
autre:
print("Votre limite de crédit est faible")
autre:
print("Désolé, vous n'êtes pas éligible au crédit")
Le code lui-même est très similaire, mais imbriqué if fournit également un algorithme au cas où la condition de celui-ci s'avère fausse. C'est-à-dire que la limite de la carte est insuffisante, mais que l'historique de crédit est bon, le message "Vous avez une cote de crédit faible" s'affiche.
instruction if-else dans une condition d'autre
Créons un autre programme qui détermine la note d'un élève en fonction des résultats des tests.
score = int(input("Entrez votre score :"))
si note >= 90 :
print("Génial ! Votre note est A")
autre:
si note >= 80 :
print("Génial ! Votre note est B")
autre:
si note >= 70 :
print("Bien ! Votre note est C")
autre:
si note >= 60 :
print("Votre note est D. Cela vaut la peine de répéter le matériel.")
autre:
print("Vous avez échoué à l'examen")
L'application vérifie d'abord si le score est supérieur ou égal à 90. Si oui, elle renvoie une note A. Si cette condition est fausse, des vérifications ultérieures sont effectuées. On voit que l'algorithme est quasiment le même à première vue. Donc au lieu de vérifier à l'intérieur d'autre mieux vaut utiliser une combinaison si-elif-else.
Alors l'opérateur if remplit une fonction très importante - il s'assure que certains morceaux de code ne sont exécutés que si cela est nécessaire. Il est impossible d'imaginer programmer sans lui, car même les algorithmes les plus simples nécessitent des fourches du type "si vous allez à gauche, vous le trouverez, et si vous allez à droite, alors vous devez faire ceci et cela".