Summary  
This chapter explains how logical operators (`and`, `or`, `not`) combine and invert Boolean expressions, covering their precedence, short-circuit evaluation, and the fact that `and`/`or` can return operand values.  

General domain of usage  
Control flow and conditional decision making

On dit **oui et oui**, **oui ou non**, **absolument pas**. En Python, les opérateurs logiques **`and`**, **`or`** et **`not`** expriment formellement ces idées et produisent des booléens (`True`/`False`) utilisés avec les comparaisons dans `if`/`while`.

Watch this video for a clear explanation of logical operators in Python. You'll see how `and`, `or`, and `not` work in real code, how short-circuiting happens, and how to use these operators to control program flow. The video includes practical examples and visualizations to help you master logical expressions and their results.

**generation rule: make video with duration of 120-180 seconds**

Vrai uniquement si **les deux** `X` et `Y` sont True.

Vrai si **au moins un** parmi `X`, `Y` est True.

Négation : **inverse** True en False et inversement.

### Priorité
`not` a une priorité plus élevée que `and`, qui a lui-même une priorité plus élevée que `or` (`not > and > or`). Utiliser des parenthèses en cas de doute.

Par exemple, `age >= 18 and has_id` est `True` uniquement si les deux conditions sont remplies :

age = 21
has_id = True
print(age >= 18 and has_id)   # True

## Table de vérité

Une **table de vérité** répertorie toutes les valeurs de vérité possibles des entrées et affiche le résultat d'une expression logique. Il s'agit d'un moyen compact de raisonner sur la logique sans exécuter de code.


### Utilisation de la table
Si `X` est `False` et `Y` est `True`, alors `X and Y` est `False`, `X or Y` est `True`, et `not X` est `True`.


## Valeurs de retour et court-circuitage

`and` et `or` ne renvoient pas toujours les valeurs booléennes `True` ou `False`. À la place, ils retournent **l'un de leurs opérandes**, et Python arrête l'évaluation dès que le résultat final est garanti (court-circuitage).

* `A and B` :
  * Si `A` est falsy, le résultat est garanti comme étant falsy, donc Python court-circuite et retourne `A` (sans évaluer `B`).
* Si `A` est truthy, le résultat dépend entièrement de `B`, donc Python évalue et retourne `B`.

* `A or B` :
  * Si `A` est truthy, le résultat est garanti comme étant truthy, donc Python court-circuite et retourne `A` (sans évaluer `B`).
* Si `A` est falsy, le résultat dépend entièrement de `B`, donc Python évalue et retourne `B`.

* `not X` retourne toujours une valeur booléenne réelle : `True` ou `False`.

# Choosing a display name for a user profile
username = ""             # user didn't set a custom name
print(username or "Guest")   # "Guest" → fallback to default name

username = "Alice"
print(username or "Guest")   # "Alice" → custom name is used

# Checking login attempts and access permissions
login_attempts = 0
access_level = 123
print(login_attempts and access_level)  # 0 → login not yet attempted

login_attempts = 5
print(login_attempts and access_level)  # 123 → user has access after attempts

# Checking empty and non-empty values
print(not 0, not "Hello")  # True False → 0 is falsey, non-empty string is truthy

Quelle affirmation correspond à la logique classique pour « ni X ni Y » ?

Acquérir une compréhension solide des principaux types de données de Python et apprendre à les manipuler efficacement. Explorer les nombres, les booléens et les chaînes de caractères à travers des exercices pratiques et des exemples concrets. Développer la confiance dans l'exécution des opérations de base et acquérir les compétences fondamentales nécessaires pour écrire un code Python propre et efficace.

Découvrez les principes fondamentaux des types de données numériques en Python et apprenez à manipuler les entiers et les nombres à virgule flottante. Maîtrise des opérations arithmétiques de base, exploration du concept d'immuabilité et mise en pratique avec les fonctions et outils intégrés de Python pour gérer efficacement les nombres dans des situations réelles.

Acquérir une compréhension claire du type de données booléen, un sous-type spécialisé des données numériques qui représente les valeurs de vérité. Bien qu'il puisse sembler difficile au début, la maîtrise des booléens est essentielle pour écrire des programmes logiques et efficaces. Cette section vous aidera à appliquer avec assurance la logique booléenne à des scénarios de programmation réels.

Les chaînes de caractères permettent de travailler avec du texte en Python, qu'il s'agisse d'afficher des messages ou de traiter des entrées utilisateur. Vous étudierez comment créer, modifier et manipuler efficacement les chaînes de caractères. La compréhension des chaînes de caractères est essentielle pour écrire des programmes interactifs et transmettre clairement des informations à travers votre code.

Apprenez à gérer efficacement les types de données afin d'assurer l'exactitude et la cohérence dans vos programmes. Convertissez les valeurs au type approprié, nettoyez le texte avant toute comparaison et séparez les opérations numériques du formatage du texte. Découvrez également comment gérer de manière délibérée les données manquantes et traiter différemment le texte lisible par l'humain des entrées brutes, pour obtenir des résultats fiables, cohérents et faciles à lire.

Opérateurs Logiques

Signification de chaque opérateur

Priorité

Table de vérité

Utilisation de la table

Valeurs de retour et court-circuitage

1. Complétez les blancs avec `True` ou `False`. Soit `X = True`, `Y = False`.

2. Quelle affirmation correspond à la logique classique pour « ni X ni Y » ?

3. Que retourne l'expression ?