Comment vérifier si une valeur est True en Python

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une valeur est True en Python. Nous commencerons par explorer les valeurs booléennes fondamentales True et False, en comprenant leur rôle dans la prise de décision et le flux du programme.

Ensuite, vous apprendrez à utiliser une comparaison directe avec True en utilisant l'opérateur d'égalité == pour vérifier si une condition est remplie. Enfin, vous comprendrez les valeurs « truthy » (valeurs considérées comme vraies) en Python.

Apprendre à propos de True et False

Dans cette étape, nous allons explorer les valeurs booléennes fondamentales en Python : True et False. Ces valeurs sont essentielles pour prendre des décisions et contrôler le flux de vos programmes.

En Python, True et False sont des mots-clés qui représentent des valeurs booléennes. Ils sont utilisés pour représenter la véracité ou la fausseté d'une condition. Commençons par examiner directement ces valeurs dans un script Python.

Ouvrez votre éditeur VS Code.
Créez un nouveau fichier nommé boolean_values.py dans votre répertoire ~/project.
```
cd ~/project
```

Ajoutez le contenu suivant au fichier boolean_values.py :

## Assign True and False to variables
is_true = True
is_false = False

## Print the values and their types
print("Value of is_true:", is_true)
print("Type of is_true:", type(is_true))

print("Value of is_false:", is_false)
print("Type of is_false:", type(is_false))

Ce script assigne les valeurs booléennes True et False aux variables is_true et is_false respectivement. Il affiche ensuite les valeurs et leurs types correspondants à l'aide de la fonction print().

Exécutez le script en utilisant la commande python :
```
python boolean_values.py
```
Vous devriez voir la sortie suivante :
```
Value of is_true: True
Type of is_true: <class 'bool'>
Value of is_false: False
Type of is_false: <class 'bool'>
```
Cette sortie confirme que True et False sont des valeurs booléennes en Python et que leur type est <class 'bool'>.

Utiliser la comparaison directe avec True

Dans cette étape, nous apprendrons à utiliser des comparaisons directes avec la valeur booléenne True. La comparaison directe est un concept fondamental en programmation qui vous permet de vérifier si une condition est vraie ou fausse.

En Python, vous pouvez utiliser l'opérateur d'égalité == pour comparer directement une variable ou une expression avec True. C'est une méthode courante pour vérifier si une condition est remplie. Créons un script pour illustrer cela.

Ouvrez votre éditeur VS Code.
Créez un nouveau fichier nommé compare_with_true.py dans votre répertoire ~/project.
```
cd ~/project
```
Ajoutez le contenu suivant au fichier compare_with_true.py :
```
## Assign a boolean value to a variable
is_valid = True

## Compare the variable directly with True
if is_valid == True:
    print("The condition is True.")
else:
    print("The condition is False.")

## Another example with a different variable
is_active = False

if is_active == True:
    print("The condition is True.")
else:
    print("The condition is False.")
```
Dans ce script, nous assignons d'abord la valeur booléenne True à la variable is_valid. Ensuite, nous utilisons une instruction if pour vérifier si is_valid est égal à True. Si c'est le cas, le script affiche "The condition is True.". Sinon, il affiche "The condition is False.". Nous répétons ensuite ce processus avec une variable is_active définie sur False.
Exécutez le script en utilisant la commande python :
```
python compare_with_true.py
```
Vous devriez voir la sortie suivante :
```
The condition is True.
The condition is False.
```
Cette sortie montre que le script identifie correctement quand une variable est égale à True et quand elle ne l'est pas.

Comprendre les valeurs vraies (truthy)

Dans cette étape, nous allons explorer le concept de valeurs "truthy" en Python. En Python, tout n'est pas explicitement True ou False, mais certaines valeurs sont considérées comme True dans un contexte booléen, tandis que d'autres sont considérées comme False. Comprendre les valeurs "truthy" est essentiel pour écrire des instructions conditionnelles concises et efficaces.

En Python, les valeurs suivantes sont considérées comme "falsy" (elles sont traitées comme False dans un contexte booléen) :

False
None
0 (zéro)
"" (chaîne de caractères vide)
[] (liste vide)
{} (dictionnaire vide)
() (tuple vide)

Toutes les autres valeurs sont considérées comme "truthy" (elles sont traitées comme True dans un contexte booléen). Créons un script pour illustrer cela.

Ouvrez votre éditeur VS Code.
Créez un nouveau fichier nommé truthy_values.py dans votre répertoire ~/project.
```
cd ~/project
```

Ajoutez le contenu suivant au fichier truthy_values.py :

## Examples of truthy and falsy values

## Falsy values
falsy_bool = False
falsy_none = None
falsy_int = 0
falsy_string = ""
falsy_list = []
falsy_dict = {}
falsy_tuple = ()

## Truthy values
truthy_int = 1
truthy_string = "Hello"
truthy_list = [1, 2, 3]
truthy_dict = {"key": "value"}

## Check truthiness in if statements
if falsy_bool:
    print("falsy_bool is True")
else:
    print("falsy_bool is False")

if falsy_none:
    print("falsy_none is True")
else:
    print("falsy_none is False")

if falsy_int:
    print("falsy_int is True")
else:
    print("falsy_int is False")

if truthy_int:
    print("truthy_int is True")
else:
    print("truthy_int is False")

Ce script définit plusieurs variables avec différentes valeurs, certaines étant "falsy" et d'autres "truthy". Il utilise ensuite des instructions if pour vérifier la "truthiness" de chaque variable et affiche un message en conséquence.

Exécutez le script en utilisant la commande python :
```
python truthy_values.py
```
Vous devriez voir la sortie suivante :
```
falsy_bool is False
falsy_none is False
falsy_int is False
truthy_int is True
```
Cette sortie montre comment différentes valeurs sont traitées comme True ou False dans un contexte booléen. Comprendre les valeurs "truthy" vous permet d'écrire un code plus concis et plus lisible en vérifiant implicitement des conditions sans les comparer explicitement à True ou False.

Résumé

Dans ce laboratoire (lab), nous avons commencé par explorer les valeurs booléennes fondamentales True et False en Python. Nous avons appris que ce sont des mots-clés représentant la véracité ou la fausseté d'une condition et que leur type est <class 'bool'>. Nous avons assigné ces valeurs à des variables et imprimé leurs valeurs et types pour confirmer leur nature.

Ensuite, nous avons commencé à apprendre à effectuer des comparaisons directes avec la valeur booléenne True en utilisant l'opérateur d'égalité ==. Cela nous permet de vérifier si une condition est remplie.