Comment utiliser le Python ou l'opérateur – Real Python

Il y a trois opérateurs booléens en Python: et, ou, et ne pas. Avec eux, vous pouvez tester les conditions et décider du chemin d’exécution de vos programmes. Dans ce tutoriel, vous en apprendrez plus sur le langage Python. ou opérateur et comment l'utiliser.

À la fin de ce didacticiel, vous aurez appris:

• Comment le python ou opérateur fonctionne

• Comment utiliser le Python ou opérateur dans des contextes booléens et non booléens

• Quel genre de problèmes de programmation pouvez-vous résoudre en utilisant ou en python

• Comment lire et mieux comprendre le code des autres personnes qui utilisent certaines des fonctionnalités spéciales de Python ou opérateur

Vous allez apprendre à utiliser le Python ou opérateur en construisant quelques exemples pratiques. Même si vous n’utilisez pas vraiment toutes les possibilités offertes par le Python ou offre de l'opérateur, sa maîtrise vous permettra d'écrire un meilleur code.

Logique Booléenne

George Boole (1815-1864) développa ce qu'on appelle maintenant Algèbre de Boole, qui est le fondement de la logique numérique derrière le matériel informatique et les langages de programmation.

L'algèbre booléenne est construite autour de la valeur de vérité d'expressions et d'objets (qu'ils soient ou non vrai ou faux) et est basé dans les opérations booléennes ET, OU, et NE PAS. Ces opérations sont implémentées via des opérateurs logiques ou booléens vous permettant de créer Expressions booléennes, qui sont des expressions évaluées comme étant vraies ou fausses.

À l'aide de la logique booléenne, vous pouvez évaluer les conditions et décider des opérations que vos programmes exécuteront, en fonction de la valeur de vérité de ces conditions. C'est une pierre angulaire de la programmation qui vous fournit les outils nécessaires pour décider du déroulement de l'exécution de vos programmes.

Jetons un coup d’œil à quelques concepts de base liés à la logique booléenne en Python:

• Booléen est le type de valeur qui peut être soit Vrai ou Faux. En Python, le type booléen est bool, qui est un sous-type de int.

• Valeurs booléennes sont les valeurs Vrai ou Faux (avec une capitale T et F) en Python.

• UNE Variable booléenne est une variable qui peut être soit Vrai ou Faux. Les variables booléennes sont couramment utilisées comme drapeaux pour indiquer si des conditions spécifiques existent.

• UNE Expression booléenne est une expression qui retourne soit Vrai ou Faux.

• Contexte booléen peut être si conditions et tandis que boucles, où Python s'attend à ce qu'une expression soit évaluée à une valeur booléenne. Vous pouvez utiliser pratiquement n'importe quelle expression ou objet dans un contexte booléen, et Python tentera de déterminer sa valeur de vérité.

• Opérandes sont les sous-expressions ou objets impliqués dans une expression (booléenne ou non) et reliés par un opérateur.

• Opérateurs booléens ou logiques sont ET (logique ET ou conjonction), OU (logique OU ou disjonction), et NE PAS (logique NE PAS ou négation). Les mots-clés et, ou, et ne pas sont les opérateurs Python pour ces opérations.

Maintenant que vous avez un meilleur contexte sur la logique booléenne, passons à d’autres sujets spécifiques à Python.

Les opérateurs booléens Python

Python a trois opérateurs booléens qui sont dactylographiés en tant que mots anglais simples:

1. et
2. ou
3. ne pas

Ces opérateurs connectent des expressions booléennes (et des objets) pour créer des expressions booléennes composées.

Les opérateurs booléens Python prennent toujours deux expressions booléennes ou deux objets ou une combinaison d’eux, ils sont donc considérés opérateurs binaires.

Dans ce tutoriel, vous allez couvrir le monde Python ou opérateur, qui est l'opérateur qui implémente la logique OU opération en Python. Vous apprendrez comment cela fonctionne et comment l’utiliser.

Comment le python ou Travaux de l'opérateur

Avec le booléen OU opérateur, vous pouvez connecter deux expressions booléennes dans une expression composée. Au moins une sous-expression doit être vraie pour que l'expression composée soit considérée comme vraie, et cela importe peu. Si les deux sous-expressions sont fausses, l'expression est fausse.

C’est la logique générale de la OU opérateur. Cependant, le Python ou L’opérateur fait tout cela et plus encore, comme vous le verrez dans les sections suivantes.

En utilisant ou Avec des expressions booléennes

Vous aurez besoin de deux sous-expressions pour créer une expression booléenne à l'aide du langage Python. ou opérateur en tant que connecteur. La syntaxe de base d’une expression booléenne avec ou est comme suit:

# Syntaxe pour l'expression booléenne avec ou en Python
exp1 ou exp2

Si au moins une des sous-expressions (exp1 ou exp2) évalue à Vrai, alors l'expression est considérée comme étant Vrai. Si les deux sous-expressions évaluent à Faux, alors l'expression est Faux. Cette définition s'appelle inclusif ou, car il permet les deux possibilités aussi bien que non plus.

Voici un résumé de la Python ou comportement de l’opérateur:

Tableau 1. Python Logique ou Opérateur: Table de vérité

Ce tableau résume la valeur de vérité résultante d’une expression booléenne telle que exp1 ou exp2 en fonction des valeurs de vérité de ses sous-expressions.

Illustrons les valeurs de vérité résultantes montrées dans Tableau 1 en codant quelques exemples pratiques:

>>> exp1 = 1 == 2
>>> exp1
Faux
>>> exp2 = 7 > 3
>>> exp2
Vrai
>>> exp1 ou exp2  # Return True, car exp2 est True
Vrai
>>> exp2 ou exp1  # Retourne également True
Vrai
>>> exp3 = 3 < 1
>>> exp1 ou exp3  # Return False, car les deux sont False
Faux

Dans les exemples précédents, chaque fois qu'une sous-expression est évaluée à Vrai, le résultat global est Vrai. Par contre, si les deux sous-expressions sont évaluées à Faux, le résultat global est également Faux.

En utilisant ou Avec des objets communs

En général, les opérandes d’une expression impliquant une OU opération doit avoir des valeurs booléennes, comme indiqué dans Tableau 1 et renvoyer une valeur de vérité à la suite. En ce qui concerne les objets, Python n’est pas très strict en la matière et implémente en interne un ensemble de règles pour décider si un objet est considéré comme vrai ou faux:

Par défaut, un objet est considéré comme vrai à moins que sa classe ne définisse __bole __ () méthode qui retourne Faux ou un __len __ () méthode qui renvoie zéro lorsqu'elle est appelée avec l'objet. Voici la plupart des objets intégrés considérés comme faux:

• constantes définies comme étant fausses: Aucun et Faux.
• zéro de tout type numérique: 0, 0.0, 0j, Décimal (0), Fraction (0, 1)
• séquences vides et collections: '', (), [], , ensemble(), gamme (0)

(La source)

Si les opérandes impliqués dans un ou opération sont des objets au lieu d’expressions booléennes, alors le Python ou l'opérateur renvoie un objet vrai ou faux, pas les valeurs Vrai ou Faux comme on pouvait s'y attendre. La valeur de vérité de cet objet est déterminée selon les règles que vous avez vues auparavant.

Cela signifie que Python ne contraint pas le résultat d'un ou opération à un bool objet. Si vous testez deux objets en utilisant ou en Python, l'opérateur renvoie le premier objet évalué comme étant vrai ou le dernier objet de l'expression, quelle que soit sa valeur de vérité:

>>> 2 ou 3
2
>>> 5 ou 0.0
5
>>> [] ou 3
3
>>> 0 ou 

Dans les deux premiers exemples, les premiers opérandes (2 et 5) sont vrais (non nul), donc le Python ou l'opérateur renvoie toujours le premier.

Dans les deux derniers exemples, l'opérande gauche est false (un objet vide). Le python ou L'opérateur évalue les deux opérandes et renvoie l'objet à droite, ce qui peut donner la valeur true ou false.

Vous pouvez résumer le comportement affiché dans le code précédent comme suit:

Tableau 2. Python ou Comportement de l'opérateur lors du test d'objets au lieu d'expressions booléennes

En bref, le python ou L'opérateur renvoie le premier objet évalué comme étant vrai ou le dernier objet de l'expression, quelle que soit sa valeur de vérité.

Vous pouvez généraliser ce comportement en enchaînant plusieurs opérations dans une seule expression, comme ceci:

Dans cet exemple, le Python ou L'opérateur renvoie le premier vrai opérande trouvé ou le dernier. C’est la règle à suivre pour mémoriser ou fonctionne en Python.

Mélange d'expressions et d'objets booléens

Vous pouvez également combiner des expressions booléennes et des objets Python courants dans une ou opération. Dans ce cas, le Python ou l'opérateur retournera toujours le premier vrai opérande ou le dernier opérande, mais la valeur retournée pourrait être Vrai ou Faux ou l'objet que vous testez:

Tableau 3. Python ou Comportement de l'opérateur lors du test d'objets et d'expressions booléennes

Voyons comment cela fonctionne avec quelques exemples:

>>> 2 < 4 ou 2  # Cas 1
Vrai
>>> 2 < 4 ou []  # Cas 2
Vrai
>>> 5 > dix ou []  # Cas 3
[]
>>> 5 > dix ou 4  # Cas 4
4

Dans Cas 1 et Cas 2, la sous-expression 2 <4 a été évalué à Vraiet la valeur renvoyée était Vrai. D'autre part, dans Cas 3 et Cas 4, la sous-expression 5> 10 a été évalué à Faux, le dernier opérande a donc été renvoyé et vous avez obtenu une liste vide ([]) et un entier (4) au lieu de Vrai ou Faux.

En tant qu'exercice, vous pouvez essayer d'étendre Tableau 3 en inversant l'ordre des expressions dans la troisième colonne, c'est-à-dire, utilisez obj ou exp et essayez de prédire les résultats.

Évaluation de court-circuit

Python peut parfois déterminer la valeur de vérité d'une expression booléenne avant d'avoir évalué toutes les sous-expressions et tous les objets impliqués. Le python ou L’opérateur, par exemple, arrête d’évaluer les opérandes dès qu’il trouve quelque chose qui est considéré comme vrai. Par exemple, l'expression suivante est toujours Vrai:

>>> Vrai ou 4 < 3
Vrai

Si le premier opérande dans un ou expression est évaluée à true, quelle que soit la valeur du deuxième opérande (4 <3 est Faux), alors l'expression est considérée comme vraie et le second opérande n'est jamais évalué. C'est appelé évaluation de court-circuit (paresseux).

Prenons un autre exemple:

>>> def true_func():
...     impression('En cours d'exécution true_func ()')
...     revenir Vrai
...
>>> def false_func():
...     impression('Lancer false_func ()')
...     revenir Faux
...
>>> true_func() ou false_func()  # Cas 1
Exécution de true_func ()
Vrai
>>> false_func() ou true_func()  # Cas 2
Lancer false_func ()
Exécution de true_func ()
Vrai
>>> false_func() ou false_func()  # Cas 3
Lancer false_func ()
Lancer false_func ()
Faux
>>> true_func() ou true_func()  # Cas 4
Exécution de true_func ()
Vrai

Dans Cas 1, Python évalué true_func (). Depuis qu'il revient Vrai, le prochain opérande (false_func ()) n'est pas évalué. Notez que la phrase Lancer false_func () n'est jamais imprimé. Enfin, l'expression entière est considérée Vrai.

Cas 2 évalue les deux fonctions, car le premier opérande (false_func ()) est Faux. Ensuite, l’opérateur renvoie le deuxième résultat, c’est-à-dire la valeur renvoyée par true_func (), lequel est Vrai.

Cas 3 évalue les deux fonctions, car les deux retournent Faux. L’opération renvoie la valeur de retour de la dernière fonction, c’est-à-dire Faux, et l'expression est considérée comme Faux.

Dans Cas 4, Python n'évalue que la première fonction, qui est Vraiet l'expression est Vrai.

Dans évaluation de court-circuit (paresseux), le second opérande d'une expression booléenne n'est pas évalué si la valeur de l'expression peut être déterminée à partir du premier opérande uniquement. Python (comme d'autres langages) contourne cette seconde évaluation en faveur de la performance, car évaluer le second opérande représenterait une perte de temps inutile en temps processeur.

Enfin, en matière de performance, lorsque vous utilisez le logiciel Python ou opérateur, considérez ce qui suit:

• Les expressions à droite du Python ou L’opérateur peut appeler des fonctions qui effectuent un travail important ou important, ou avoir des effets secondaires qui ne se produiront pas si la règle de court-circuit prend effet.

• La condition la plus susceptible d'être vraie peut être la condition la plus à gauche. Cette approche peut réduire le temps d'exécution de vos programmes car Python est ainsi en mesure de déterminer si la condition est vraie en évaluant simplement le premier opérande.

Récapitulation de section

Vous avez appris comment le Python ou opérateur travaille et a vu certaines de ses caractéristiques et comportements principaux. Vous en savez maintenant suffisamment pour continuer à progresser en apprenant à utiliser l'opérateur pour résoudre des problèmes concrets.

Avant cela, récapitulons quelques points importants sur ou en Python:

• Il satisfait aux règles générales qu'un booléen OU l'opérateur devrait suivre. Si une sous-expression booléenne ou les deux sont vraies, le résultat est vrai. Sinon, si les deux sous-expressions sont fausses, le résultat est faux.

• Il retourne des objets au lieu de Vrai ou Faux valeurs lorsqu’il teste des objets Python. Cela signifie que l'expression x ou y résultats X si elle est évaluée comme vraie, et retourne sinon y (indépendamment de sa valeur de vérité).

• Il suit un ensemble prédéfini de règles internes Python pour déterminer la valeur de vérité d'un objet.

• Il arrête d’évaluer les opérandes dès qu’il trouve quelque chose qui est considéré comme vrai. C'est ce qu'on appelle l'évaluation par court-circuit ou paresseuse.

Il est maintenant temps de savoir où et comment utiliser cet opérateur à l’aide de quelques exemples.

Contextes Booléens

Dans cette section, vous verrez des exemples pratiques d’utilisation de Python. ou opérateur et apprenez à tirer parti de son comportement quelque peu inhabituel pour écrire un meilleur code Python.

Il existe deux situations principales dans lesquelles vous pouvez dire que vous travaillez dans un contexte booléen en Python:

1. si déclarations: exécution conditionnelle
2. tandis que boucles: répétition conditionnelle

Avec un si Vous pouvez choisir le chemin d’exécution de vos programmes en fonction de la valeur de vérité de certaines conditions.

D'autre part, tandis que Les boucles vous permettent de répéter un morceau de code tant qu'une condition donnée reste vraie.

Ces deux structures font partie de ce que vous appelez déclarations de flux de contrôle. Ils vous aident à choisir le chemin d’exécution de vos programmes.

Vous pouvez utiliser le Python ou opérateur pour construire des expressions booléennes adaptées à une utilisation à la fois si déclaration et tandis que boucles, comme vous le verrez dans les deux prochaines sections.

si Les déclarations

Disons que vous voulez vous assurer que l’une des deux conditions (ou les deux) est vraie avant de choisir un certain
chemin d'exécution. Dans ce cas, vous pouvez utiliser le code Python ou opérateur pour connecter les conditions dans une expression et utiliser cette expression dans un si déclaration.

Supposons que vous deviez obtenir une confirmation de l'utilisateur pour exécuter certaines actions en fonction de la réponse de l'utilisateur:

>>> def réponse():
...     ans = contribution('Le faites vous...? (Oui Non): ')
...     si ans.inférieur() == 'Oui' ou ans.inférieur() == 'y':
...         impression(F'Réponse positive: ans')
...     elif ans.inférieur() == 'non' ou ans.inférieur() == 'n':
...         impression(F'Réponse négative: ans')
...
>>> réponse()
Le faites vous...? (oui / non): y
Réponse positive: y
>>> réponse()
Le faites vous...? (oui / non): n
Réponse négative: n

Ici, vous obtenez la saisie de l’utilisateur et l’affectez à ans. Puis le si déclaration commence à vérifier les conditions de gauche à droite. Si au moins l'un d'entre eux est évalué à true, il exécute le si bloc de code. le elif déclaration fait la même chose.

Dans le premier appel à réponse(), la contribution de l’utilisateur était y, qui remplissait la première condition, et le si le bloc de code a été exécuté. Lors du deuxième appel, la saisie de l’utilisateur (n) satisfait à la deuxième condition, de sorte que elif bloc de code a couru. Si la saisie de l’utilisateur ne remplit aucune condition, aucun bloc de code n’est exécuté.

Un autre exemple pourrait être lorsque vous essayez de déterminer si un nombre est en dehors d’une plage. Dans ce cas, il est également possible d’utiliser le logiciel Python. ou opérateur. Le code suivant teste si X est en dehors de la gamme de 20 à travers 40:

>>> def ma_range(X):
...     si X < 20 ou X > 40:
...         impression('À l'extérieur')
...     autre:
...         impression('À l'intérieur')
...
>>> ma_range(25)
À l'intérieur
>>> ma_range(18)
À l'extérieur

Quand vous appelez mon_range () avec x = 25, la si tests de déclaration 25 <20, lequel est Faux. Ensuite, il teste x> 40, qui est aussi Faux. Le résultat final est Faux, alors le autre le bloc a été exécuté.

D'autre part, 18 <20 est évalué à Vrai. Puis le python ou l’opérateur effectue une évaluation de court-circuit, et la condition est considérée comme étant Vrai. Le bloc principal est exécuté et la valeur est en dehors de la plage.

tandis que Boucles

tandis que Les boucles sont un autre exemple de contexte booléen dans lequel vous pouvez utiliser le langage Python. ou opérateur. En utilisant ou dans l'en-tête de la boucle, vous pouvez tester plusieurs conditions et exécuter le corps jusqu'à ce que toutes les conditions soient évaluées comme étant fausses.

Supposons que vous deviez mesurer la température de fonctionnement de certains équipements industriels jusqu’à ce qu’elle atteigne une plage de températures allant de 100 ° F à 140 ° F. Pour ce faire, vous pouvez utiliser un tandis que boucle:

de temps importation dormir

temp = measure_temp()  # Mesure de température initiale

tandis que temp < 100 ou temp > 140:
    impression("Température en dehors de la plage recommandée")
    impression('Nouvelle mesure de température en 30 secondes')
    dormir(30)
    impression('Mesurer la température ...')
    temp = measure_temp()
    impression(F«La nouvelle température est temp    ºF ')

Ceci est un exemple jouet presque en pseudo-code, mais il illustre l'idée. Ici le tandis que la boucle est en cours d'exécution jusqu'à temp est entre 100 ºF et 140 ºF. Si la valeur de la température est en dehors de la plage, le corps de la boucle est exécuté et vous mesurerez à nouveau la température. Une fois que measure_temp () renvoie une valeur entre 100 ºF et 140 ºF, la boucle se termine. La mesure de la température est prise toutes les 30 secondes en utilisant dormir (30).

Contextes non booléens

Vous pouvez tirer parti des fonctionnalités spéciales du Python ou opérateur en dehors des contextes booléens. La règle de base est toujours que le résultat de vos expressions booléennes est le premier véritable opérande ou le dernier de la ligne.

Notez que les opérateurs logiques (ou inclus) sont évalués avant l'opérateur d'affectation (=), vous pouvez donc affecter le résultat d'une expression booléenne à une variable de la même façon que vous le faites avec une expression commune:

>>> une = 1
>>> b = 2
>>> var1 = une ou b
>>> var1
1
>>> une = Aucun
>>> b = 2
>>> var2 = une ou b
>>> var2
2
>>> une = []
>>> b = 
>>> var3 = une ou b
>>> var3

Ici le ou L'opérateur fonctionne comme prévu, renvoyant le premier opérande vrai ou le dernier opérande si les deux sont évalués à false.

Vous pouvez profiter de ce comportement quelque peu spécial de ou en Python pour implémenter une solution Pythonic à certains problèmes de programmation assez courants. Jetons un coup d’œil à quelques exemples concrets.

Valeurs par défaut pour les variables

Une façon courante d'utiliser le Python ou L'opérateur doit sélectionner un objet dans un ensemble d'objets en fonction de sa valeur de vérité. Vous pouvez le faire en utilisant une instruction d'affectation:

>>> X = une ou b ou Aucun

Ici, vous avez assigné à X le premier objet vrai dans l'expression. Si tous les objets (une et b dans ce cas) sont de faux objets, alors le python ou l'opérateur revient Aucun, qui est le dernier opérande. Cela fonctionne parce que le ou l'opérateur renvoie l'un de ses opérandes en fonction de leur valeur de vérité.

Vous pouvez également utiliser cette fonctionnalité pour attribuer une valeur par défaut à vos variables. Les exemples suivants définissent X à une si une est vrai, et à défaut autrement:

Dans le code précédent, vous affectez une à X seulement si une est évalué à vrai. Autrement, X est assigné défaut.

Défaut revenir Valeurs

Vous pouvez manipuler le revenir valeur de certaines fonctions intégrées au moment de l'appel. Fonctions comme max () et min (), qui prend un argument itérable et renvoie une valeur unique, pourrait être votre candidat idéal pour ce type de bidouille.

Si vous fournissez un iterable vide à max () ou min ()alors vous aurez un ValueError. Cependant, vous pouvez modifier ce comportement en utilisant le ou opérateur. Jetons un coup d’œil au code suivant:

>>> lst = []  # Liste vide pour tester max () et min ()
>>> max(lst)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
    max(lst)
ValueError: max () arg est une séquence vide
>>> min(lst)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
    min(lst)
ValueError: min () arg est une séquence vide
>>> # Utilisez Python ou opérateur pour modifier ce comportement
>>> max(lst ou [[[[0])  # Retourne 0
0
>>> min(lst ou [[[[0])  # Retourne 0
0

Le comportement par défaut de max () et min () est d'élever un ValueError si vous les appelez avec un itérable vide. Cependant, en utilisant le Python ou opérateur, vous fournissez un défaut revenir valeur pour ces fonctions et remplacer leur comportement par défaut.

Arguments par défaut mutables

Un problème courant auquel les programmeurs Python débutants sont confrontés consiste à essayer d’utiliser des objets mutables comme arguments par défaut des fonctions.

Les valeurs mutables des arguments par défaut peuvent conserver l'état entre les appels. C'est souvent inattendu. Cela se produit parce que les valeurs d'argument par défaut sont évaluées et enregistrées une seule fois, c'est-à-dire lorsque def L’instruction est exécutée et non à chaque appel de la fonction résultante. C’est pourquoi vous devez faire attention à la modification des valeurs par défaut modifiables dans les fonctions.

Prenons l'exemple suivant:

>>> def mutable_default(lst=[]):  # Essayez d'utiliser une valeur mutable par défaut
...     lst.ajouter(1)  # Changer le même objet à chaque fois
...     impression(lst)
...
>>> mutable_default(lst=[[[[3, 2])  # Par défaut non utilisé
[3, 2, 1]
>>> mutable_default()  # Utilisé par défaut
[1]
>>> mutable_default()  # La valeur par défaut augmente à chaque appel
[1, 1]
>>> mutable_default()
[1, 1, 1]

Ici, chaque appel à mutable_default () ajoute 1 à la fin de lst, parce que lst contient une référence au même objet (valeur par défaut []). Vous ne recevez pas de nouveau liste chaque fois que la fonction est appelée comme vous le souhaitiez.

Si ce n'est pas le comportement que vous souhaitez, la solution classique (et la plus sûre) consiste à déplacer le comportement par défaut vers le corps de la fonction:

>>> def mutable_default(lst=Aucun):  # Utiliser Aucun comme valeur formelle par défaut
...     si lst est Aucun:
...         lst = []  # Défaut utilisé? Ensuite, lst obtient une nouvelle liste vide.
...     lst.ajouter(1)
...     impression(lst)
...
>>> mutable_default(lst=[[[[3, 2])  # Par défaut non utilisé
[3, 2, 1]
>>> mutable_default()  # Utilisé par défaut
[1]
>>> mutable_default()
[1]

Avec cette implémentation, vous vous assurez que lst est mis à vide liste chaque fois que vous appelez mutable_default () sans argument, en s'appuyant sur la valeur par défaut pour lst.

le si déclaration dans cet exemple pourrait presque être remplacée par la cession lst = lst ou []. De cette façon, si aucun argument n'est passé à la fonction, alors lst serait par défaut à Aucun et le python ou L'opérateur retournerait la liste vide à droite:

>>> def mutable_default(lst=Aucun):  # Utiliser Aucun comme valeur formelle par défaut
...     lst = lst ou []  # Défaut utilisé? Puis lst obtient une liste vide.
...     lst.ajouter(1)
...     impression(lst)
...
>>> mutable_default(lst=[[[[3, 2])  # Par défaut non utilisé
[3, 2, 1]
>>> mutable_default()  # Utilisé par défaut
[1]
>>> mutable_default()
[1]

Cependant, ce n’est pas exactement la même chose. Par exemple, si un vide liste est passé, puis le ou opération entraînerait la fonction pour modifier et imprimer un nouveau créé liste, plutôt que de modifier et d’imprimer le fichier original transmis liste comme le si la version ferait l'affaire.

Si vous êtes certain de ne vous servir que de fichiers non vides liste objets, alors vous pouvez utiliser cette approche. Sinon, tenez-vous en au si version.

Division zéro

La division zéro peut être un problème courant lorsque vous traitez avec des calculs numériques. Pour éviter ce problème, il est probable que vous finissiez par vérifier si le dénominateur est égal à 0 ou non en utilisant un si déclaration.

Prenons un exemple:

>>> def diviser(une, b):
...     si ne pas b == 0:
...         revenir une / b
...
>>> diviser(15, 3)
5.0
>>> diviser(0, 3)
0.0
>>> diviser(15, 0)

Ici, vous avez testé si le dénominateur (b) n'était pas égal à 0et vous avez ensuite renvoyé le résultat de l'opération de division. Si b == 0 est évalué à Vrai, puis diviser() retourne implicitement Aucun. Voyons comment obtenir un résultat similaire, mais cette fois-ci en utilisant le langage Python. ou opérateur:

>>> def diviser(une, b):
...     revenir b == 0 ou une / b
...
>>> diviser(15, 3)
5.0
>>> diviser(0, 3)
0.0
>>> diviser(15, 0)
Vrai

Dans ce cas, le Python ou l'opérateur évalue la première sous-expression (b == 0). Seulement si cette sous-expression est Faux, la deuxième sous-expression (un B) est évaluée et le résultat final sera la division des une et b.

La différence avec l'exemple précédent est que, si b == 0 est évalué à Vrai, puis diviser() résultats Vrai au lieu de l'implicite Aucun.

Plusieurs expressions dans lambda

Python fournit lambda expressions, qui vous permettent de créer des fonctions anonymes simples. L'expression paramètres lambda: expression donne un objet fonction. Ce type de fonction peut être utile si vous souhaitez définir des fonctions de rappel et de touche simples.

Le modèle le plus courant pour vous d'écrire un lambda fonction est d'utiliser un seul expression comme valeur de retour. Cependant, vous pouvez changer cela et laisser lambda exécuter plusieurs expressions en utilisant le Python ou opérateur:

>>> lambda_func = lambda Bonjour, monde: impression(Bonjour, fin='') ou impression(monde)
>>> lambda_func('Bonjour', 'Monde!')
Bonjour le monde!

Avec cet exemple, vous avez forcé lambda exécuter deux expressions (print (bonjour, fin = '') et imprimer (monde)). Mais comment fonctionne ce code? Bien ici lambda exécute une expression booléenne où deux fonctions sont exécutées.

Quand ou évalue la première fonction, il reçoit Aucun, qui est la valeur de retour implicite pour impression(). Puisque Aucun est considéré comme faux, ou continue d'évaluer son deuxième opérande et le renvoie finalement comme résultat pour l'expression booléenne.

Dans ce cas, la valeur renvoyée par l'expression booléenne est également celle renvoyée par lambda:

>>> résultat = lambda_func('Bonjour', 'Monde!')
Bonjour le monde!
>>> impression(résultat)
Aucun

Ici, résultat contient une référence à la valeur renvoyée par lambda, qui est la même valeur renvoyée par l'expression booléenne.

Conclusion

Vous savez maintenant comment le Python ou L’opérateur fonctionne et comment l’utiliser pour résoudre certains problèmes de programmation courants en Python.

Maintenant que vous connaissez les bases du Python ou opérateur, vous pourrez:

• Utilisez le python ou opérateur dans des contextes booléens et non booléens

• Résoudre plusieurs types de problèmes de programmation en utilisant efficacement le Python ou opérateur

• Écrivez mieux et plus de code Pythonic en tirant parti des fonctionnalités quelque peu spéciales de ou en python

• Lisez et comprenez mieux le code des autres utilisateurs lorsqu'ils utilisent Python. ou opérateur

De plus, vous avez appris un peu plus sur la logique booléenne, ainsi que sur certains de ses concepts principaux en Python.