# Expressions > [!video] Vidéo explicative > <iframe width="560" height="315" src="https://www.youtube.com/embed/bRBKEYtLkfo?si=Av0t0fgXcM9aUftf" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe> ## Introduction En programmation et en algorithmique, une **expression** est une combinaison de valeurs, de variables, d'opérateurs et d'appels de fonctions qui s'évalue pour produire une unique valeur. Comprendre les expressions est fondamental car elles constituent la base de tout calcul et de toute prise de décision dans un algorithme. > [!definition] Expression > Une expression est une construction syntaxique qui produit une valeur lorsqu'elle est évaluée. ## 1. Composants fondamentaux des expressions Les expressions sont construites à partir de plusieurs éléments : - **Littéraux** : Valeurs constantes (ex: `10`, `3.14`, `"bonjour"`, `vrai`). - **Variables** : Noms qui font référence à des emplacements mémoire contenant des valeurs (ex: `x`, `compteur`). - **Opérateurs** : Symboles qui effectuent des opérations sur une ou plusieurs valeurs (ex: `+`, `-`, `*`, `/`, `ET`, `OU`, `==`). - **Appels de fonctions** : Exécutions de blocs de code nommés qui retournent une valeur (ex: `calculerSomme(a, b)`). - **Parenthèses** : Utilisées pour modifier l'ordre d'évaluation. ## 2. Types d'expressions Les expressions peuvent être classées selon le type de valeur qu'elles produisent. ### 2.1. Expressions arithmétiques Elles produisent une valeur numérique. Elles utilisent des opérateurs arithmétiques. > [!note] Opérateurs Arithmétiques courants > - `+` : Addition > - `-` : Soustraction > - `*` : Multiplication > - `/` : Division (peut être entière ou flottante selon le contexte) > - `%` : Modulo (reste de la division entière) > - `^` ou `**` : Puissance (notation varie) > [!example] Exemple d'expression arithmétique > ``` > (5 + 3) * 2 - 10 / 2 > ``` > Évaluation : $(8) * 2 - 5 = 16 - 5 = 11$ ### 2.2. Expressions relationnelles (ou de comparaison) Elles comparent deux valeurs et produisent une valeur booléenne (`vrai` ou `faux`). > [!note] Opérateurs Relationnels courants > - `==` : Égal à > - `!=` : Différent de > - `<` : Inférieur à > - `>` : Supérieur à > - `<=` : Inférieur ou égal à > - `>=` : Supérieur ou égal à > [!example] Exemple d'expression relationnelle > ``` > 10 > 5 ET (x + 2) == y > ``` > Si `x = 3` et `y = 5`, l'expression `(3 + 2) == 5` est `vrai`. > L'expression complète `10 > 5 ET vrai` est `vrai ET vrai`, ce qui donne `vrai`. ### 2.3. Expressions logiques (ou booléennes) Elles opèrent sur des valeurs booléennes et produisent une valeur booléenne. Elles sont directement liées aux concepts de la Logique Combinatoire. > [!note] Opérateurs Logiques courants > - `ET` (AND) : Vrai si toutes les opérandes sont vraies. > - `OU` (OR) : Vrai si au moins une opérande est vraie. > - `NON` (NOT) : Inverse la valeur de vérité de l'opérande. > [!example] Exemple d'expression logique > ``` > (âge >= 18) ET (possèdePermis == vrai) > ``` > Si `âge = 20` et `possèdePermis = faux`, l'expression s'évalue à : > `(vrai) ET (faux)` qui donne `faux`. ### 2.4. Expressions d'appel de fonction Elles invoquent une fonction et utilisent la valeur qu'elle retourne. > [!example] Exemple d'expression d'appel de fonction > ``` > resultat = RacineCarrée(25) + 5 > ``` > Ici, `RacineCarrée(25)` est une expression qui s'évalue à `5`. L'expression complète s'évalue à `5 + 5 = 10`. ## 3. Ordre d'évaluation des expressions L'ordre dans lequel les opérations sont effectuées est crucial pour obtenir le bon résultat. Cet ordre est déterminé par la **priorité des opérateurs** et l'**associativité**. > [!note] Priorité des opérateurs (général) > 1. Parenthèses `()` > 2. Opérateurs unaires (ex: `NON`, `-` unaire) > 3. Puissance `^` ou `**` > 4. Multiplication `*`, Division `/`, Modulo `%` (de gauche à droite) > 5. Addition `+`, Soustraction `-` (de gauche à droite) > 6. Opérateurs relationnels `==`, `!=`, `<`, `>`, `<=`, `>=` (de gauche à droite) > 7. Opérateurs logiques `ET` (de gauche à droite) > 8. Opérateurs logiques `OU` (de gauche à droite) > [!warning] Attention > La priorité exacte des opérateurs peut varier légèrement d'un langage de programmation à l'autre. Il est toujours préférable d'utiliser des parenthèses pour clarifier l'ordre d'évaluation et éviter toute ambiguïté. > [!example] Évaluation avec priorité > ``` > 5 + 3 * 2 > ``` > Sans parenthèses, la multiplication est effectuée avant l'addition : $5 + (3 \times 2) = 5 + 6 = 11$. > Avec parenthèses : $(5 + 3) * 2 = 8 * 2 = 16$. ## 4. Expressions et affectation Bien que l'affectation (`=`) soit une instruction et non une expression en soi dans de nombreux contextes algorithmiques (elle ne produit pas de valeur directement utilisée), elle utilise des expressions pour déterminer la valeur à assigner. > [!example] Utilisation d'expressions dans une affectation > ```pseudo > DEBUT > nombre_a ENTIER = 10 > nombre_b ENTIER = 5 > resultat ENTIER > > resultat = (nombre_a + nombre_b) * 2 // (nombre_a + nombre_b) * 2 est une expression > > AFFICHER resultat // Affiche 30 > FIN > ``` > L'expression `(nombre_a + nombre_b) * 2` est évaluée à `30`, puis cette valeur est affectée à la variable `resultat`. ## Résumé Les expressions sont des éléments fondamentaux en algorithmique, permettant de calculer des valeurs, de prendre des décisions et de manipuler des données. Elles combinent littéraux, variables, opérateurs et appels de fonctions, et leur évaluation respecte un ordre de priorité précis. La maîtrise des expressions est un prérequis essentiel pour la programmation dans n'importe quel langage, y compris Python. ## 🗓️ Historique > **Dernière mise à jour :** `26 octobre 2025` > **Rédigé par :** [[Julien DUQUENNOY]]