Les concepts de `truthy` et `falsy` en Python

Cet article explique les concepts de truthy et falsy en Python.

YouTube Video

Les concepts de truthy et falsy en Python

Définition des concepts de truthy et falsy

En Python, les objets évalués dans des expressions conditionnelles sont considérés soit comme 'True' soit comme 'False'. Truthy fait référence aux objets évalués comme 'True', et falsy à ceux évalués comme 'False'. Ces évaluations sont souvent utilisées dans des branches conditionnelles comme les instructions if ou les boucles while. De plus, la fonction bool() prend n'importe quel objet et retourne sa valeur booléenne.

Falsy (Objets évalués comme False)

En Python, les objets suivants sont considérés comme falsy :.

• False

• None

• Valeurs numériques nulles

  • Exemple : 0, 0.0

• Types de séquences vides (comme les listes, tuples ou chaînes de caractères vides)

  • Exemple : [], (), ""

• Dictionnaire vide

  • Exemple : {}

• Ensemble vide

  • Exemple : set()

Ces objets sont évalués comme 'falsy' lorsqu'ils sont utilisés dans la condition d'une instruction if. Par exemple, vous pouvez écrire du code comme ceci.

1if not []:
2    print("The list is falsy.")

• Dans ce code, la liste [] est vide, elle est donc évaluée comme falsy, et l'instruction print est exécutée.

Truthy (Objets évalués comme True)

Les objets qui ne sont pas considérés comme falsy sont appelés truthy.

• Nombres non nuls (entiers, nombres à virgule flottante)

  • Exemples : 1, 3.14, -100

• Types de séquences non vides (listes, tuples, chaînes de caractères, etc.)

  • Exemples : [1, 2, 3], (1, 2), "Hello"

• Dictionnaires non vides

  • Exemple : {"key": "value"}

• Ensembles non vides

  • Exemple : {1, 2, 3}

Les objets considérés comme truthy seront évalués à 'True' lorsqu'ils sont utilisés dans la condition d'une instruction if. Par exemple, vous pouvez écrire du code comme ceci.

1if [1, 2, 3]:
2    print("The list is truthy.")

• Dans le code ci-dessus, puisque la liste [1, 2, 3] n'est pas vide, elle est évaluée comme truthy et l'instruction print est exécutée.

Évaluation de la valeur booléenne avec la fonction bool()

Vous pouvez évaluer la valeur booléenne des objets en utilisant la fonction bool().

 1# Examples of falsy values
 2print("False is", "truthy" if bool(False) else "falsy")
 3print("0 is", "truthy" if bool(0) else "falsy")
 4print('"" is', "truthy" if bool("") else "falsy")
 5print("None is", "truthy" if bool(None) else "falsy")
 6print("[] is", "truthy" if bool([]) else "falsy")
 7
 8# Examples of truthy values
 9print("1 is", "truthy" if bool(1) else "falsy")
10print('"hello" is', "truthy" if bool("hello") else "falsy")
11print('" " (space) is', "truthy" if bool(" ") else "falsy")
12print('"0" is', "truthy" if bool("0") else "falsy")

• Ce code montre comment la valeur de vérité de différentes valeurs est évaluée. Par exemple, la valeur numérique 0 et une chaîne vide sont considérées comme False, tandis qu’un espace ou la chaîne "0" sont considérés comme True.

Utilisation de truthy et falsy

En utilisant truthy et falsy, le code peut être écrit de manière plus concise et intuitive. En particulier, les instructions if peuvent souvent être évaluées sans comparaisons explicites pour les raccourcir. Par exemple, les deux extraits de code suivants se comportent de manière similaire, mais le premier est plus concis.

1my_list = [1]
2
3# Explicit comparison
4if my_list != []:
5    print("The list is not empty.")
6
7# Using truthy/falsy
8if my_list:
9    print("The list is not empty.")

Dans l'exemple ci-dessus, vous pouvez voir que my_list est évalué comme truthy tant qu'il ne s'agit pas d'une liste vide, ce qui élimine le besoin de comparaison explicite.

Conception avec truthy et falsy

En utilisant efficacement les concepts de truthy et falsy, vous pouvez améliorer la lisibilité et l'efficacité du code. Ils sont particulièrement utiles pour définir des valeurs par défaut, vérifier la validité des variables et valider les entrées. Par exemple, si vous vous attendez à ce que None ou une liste vide soient passés comme arguments, vous pouvez écrire du code comme ceci.

1def process_data(data=None):
2    data = data or []
3    print(data)
4
5process_data()  # An empty list is used by default.

• Dans ce code, si data vaut None, une liste vide [] est définie comme valeur par défaut. De cette manière, l'utilisation de truthy et falsy vous permet de définir des valeurs par défaut de manière concise.

Points à noter pour éviter un comportement inattendu

Cependant, bien que le code qui utilise les valeurs truthy et falsy puisse être concis et pratique, il peut entraîner un comportement inattendu. Par exemple, dans ce code, non seulement lorsque data vaut None, mais aussi lorsqu'il s'agit de toute valeur évaluée comme False, telle qu'une chaîne vide ou 0, elle sera remplacée par la liste vide par défaut []. Pour cette raison, lorsqu'une condition plus stricte est requise, comme initialiser uniquement lorsque la valeur est None, il est conseillé d'utiliser une condition explicite telle que value is None:. Selon la situation, il est important de concevoir avec un équilibre entre concision et rigueur.

1def process_data(data=None):
2    if data is None:
3        data = []
4    print(data)
5
6process_data()   # An empty list is used by default.
7process_data(0)  # 0 is printed because it's not None.

• Dans ce code, data est initialisé à une liste vide seulement si elle vaut None, tandis que les autres valeurs fausses comme 0 sont laissées intactes.

Contrôle de la valeur booléenne dans les objets personnalisés

Même dans vos propres classes, vous pouvez contrôler la valeur booléenne d'une instance en définissant __bool__() ou __len__().

 1class MyContainer:
 2    def __init__(self, items):
 3        self.items = items
 4
 5    def __len__(self):
 6        return len(self.items)
 7
 8box = MyContainer([])
 9print(bool(box))  # False
10
11box.items.append("item")
12print(bool(box))  # True

• Dans ce code, la méthode __len__() fait que le conteneur est évalué à False lorsqu'il est vide et à True lorsqu'il contient des éléments.

Conclusion

Les concepts de truthy et falsy en Python sont très importants pour écrire des expressions conditionnelles concises et rendre le code plus intuitif. Comprendre et utiliser correctement ces concepts peut grandement améliorer la lisibilité et l'efficacité du code.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video