Understanding Programming Language Concepts

# Understanding Programming Language Concepts ## Objectifs et prérequis **Objectifs** : À la fin de ce chapitre, l'étudiant sera capable de : - Expliquer les concepts fondamentaux des langages de programmation (syntaxe, sémantique, niveaux). - Identifier et comparer les paradigmes de programmation (impératif, procédural, orienté objet, fonctionnel, logique). - Décrire le rôle des traducteurs de langage (compilateurs, interpréteurs, assembleurs) et leurs étapes. - Classer les erreurs de programme (syntaxiques, sémantiques, logiques, d'exécution) et appliquer des techniques de débogage. - Écrire, compiler/interpréter, exécuter et déboguer des programmes simples en C et Python. - Utiliser les opérateurs, expressions, structures de sélection et itératives dans les deux langages. - Développer et déboguer un projet de programme Python en deux parties, en appliquant les bonnes pratiques de conception et de test. **Prérequis** : Connaissances de base en informatique (matériel, logiciel, système d'exploitation), familiarité avec l'utilisation d'un ordinateur, notions élémentaires de logique et de résolution de problèmes. Aucune expérience préalable en programmation n'est requise, mais une logique structurée est attendue. --- ## I. Programming Language Basics ### Définition et niveaux de langages Un langage de programmation est un langage formel composé d'instructions qui produisent divers types de sortie. Il sert d'interface entre l'humain et la machine. > **À retenir** : Un langage de programmation doit avoir une syntaxe précise (règles de formation des symboles) et une sémantique bien définie (signification des constructions). Les langages sont classés par niveau d'abstraction : - **Langage machine** : binaire (0 et 1), directement exécutable par le CPU. Exemple : `10110000 01100001`. - **Langage d'assemblage** : mnémoniques représentant des instructions machine. Exemple : `MOV AL, 61h`. - **Langage de haut niveau** : proche du langage humain, indépendant du matériel. Exemples : C, Python, Java. ### Syntaxe vs Sémantique - **Syntaxe** : règles gouvernant la structure correcte d'un programme (comme la grammaire en langue naturelle). - **Sémantique** : signification des constructions syntaxiques (ce que le programme fait lorsqu'il est exécuté). **Exemple résolu** : En Python : `x = 5 + 3` - Syntaxe correcte : variable, opérateur d'affectation, expression arithmétique. - Sémantique : évalue `5 + 3` → `8`, puis assigne `8` à `x`. En C : `int x = 5 + 3;` - Syntaxe : type, nom variable, opérateur d'affectation, expression, point-virgule. - Sémantique : même résultat que ci-dessus. **Exercice d'application** : Identifier l'erreur syntaxique dans : `print("Hello World` **Correction** : Parenthèse fermante manquante → `print("Hello World")` **Exercice d'application** : Quel est le résultat sémantique de `7 * 2 + 3` en Python ? **Correction** : Priorité des opérateurs → `(7 * 2) + 3 = 14 + 3 = 17` --- ## II. Programming Paradigms 1 ### Paradigme impératif Décrit le calcul comme une séquence d'états qui changent. Le programme spécifie *comment* atteindre un résultat. > **À retenir** : Dans le paradigme impératif, l'état du programme est modifié par des affectations et des instructions de contrôle. **Caractéristiques** : variables mutables, boucles, instructions conditionnelles, séquence explicite. **Exemple** (C) : ```c int sum = 0; for (int i = 1; i <= 5; i++) { sum = sum + i; } ``` - État initial : `sum = 0`, `i = 1` - Après chaque itération : `sum` est mis à jour - État final : `sum = 15` ### Paradigme procédural Sous-ensemble de l'impératif où le programme est organisé en procédures ou fonctions réutilisables. > **À retenir** : La programmation procédurale décompose un problème en sous-tâches (fonctions) qui peuvent être appelées plusieurs fois. **Avantages** : modularité, réutilisabilité, lisibilité, facilité de débogage. **Exemple** (Python) : ```python def factorial(n): if n == 0: return 1 else: return n * factorial(n - 1) result = factorial(5) # Résultat : 120 ``` - La fonction `factoriel` encapsule la logique de calcul. - Elle est appelée avec `n=5` pour produire `120`. **Exercice d'application** : Écrire une fonction procédurale en C qui calcule la moyenne de trois nombres. **Correction** : ```c #include <stdio.h> float moyenne(float a, float b, float c) { return (a + b + c) / 3.0; } int main() { printf("%f\n", moyenne(4.0, 6.0, 8.0)); // Affiche 6.000000 return 0; } ``` --- ## III. Programming Paradigms 2 ### Paradigme orienté objet (POO) Organise le code autour d'objets qui encapsulent des données (attributs) et des comportements (méthodes). > **À retenir** : Les quatre piliers du POO sont l'encapsulation, l'héritage, le polymorphisme et l'abstraction. **Exemple** (Python) : ```python class Rectangle: def __init__(self, length, width): self.length = length self.width = width def area(self): return self.length * self.width r = Rectangle(5, 3) print(r.area()) # Résultat : 15 ``` - Encapsulation : données (`length`, `width`) et méthode (`area`) regroupées. - Abstraction : l'utilisateur n'a besoin de connaître que l'interface (`area()`). **Exemple** (C++) : ```cpp class Rectangle { private: double length, width; public: Rectangle(double l, double w) : length(l), width(w) {} double area() { return length * width; } }; ``` *Note : Le C pur ne supporte pas le POO ; C++ en est une extension.* ### Paradigme fonctionnel Considère le calcul comme l'évaluation de fonctions mathématiques, évitant l'état mutable et les effets de bord. > **À retenir** : En programmation fonctionnelle, les fonctions sont des citoyens de première ordre et l'immutabilité est privilégiée. **Caractéristiques** : fonctions pures (même entrée → même sortie, aucun effet de bord), récursivité, fonctions d'ordre supérieur. **Exemple** (Python) : ```python def square(x): return x * x numbers = [1, 2, 3, 4] squared = list(map(square, numbers)) # Résultat : [1, 4, 9, 16] ``` - `square` est une fonction pure. - `map` applique `square` à chaque élément sans modifier `numbers`. **Exercice d'application** : Écrire une fonction pure en Python qui retourne la longueur d'une chaîne sans utiliser `len()`. **Correction** : ```python def string_length(s): count = 0 for _ in s: count += 1 return count print(string_length("hello")) # Résultat : 5 ``` --- ## IV. Language Translators ### Rôle des traducteurs Convertissent le code source (langage de haut niveau) en code cible (langage machine ou intermédiaire) exécutable par l'ordinateur. > **À retenir** : Un traducteur doit préserver la sémantique du programme source tout en produisant un code cible efficace. ### Types de traducteurs 1. **Assembleur** : traduit le langage d'assemblage en langage machine. - Un à un : chaque mnémonique → une instruction machine. - Exemple : `NASM`, `MASM`. 2. **Compilateur** : traduit tout le programme source en code machine avant l'exécution. - Étapes : analyse lexicale → syntaxique → sémantique → génération de code → optimisation. - Exemple : `gcc` (C), `g++` (C++). - Avantages : exécution rapide. - Inconvénients : temps de compilation long, moins flexible pour le débogage. 3. **Interpréteur** : traduit et exécute le code source ligne par ligne, sans produire de fichier exécutable intermédiaire. - Exemple : `python3`, `bash`. - Avantages : débogage facile, portabilité. - Inconvénients : exécution plus lente. ### Étapes de la compilation (exemple avec gcc) 1. **Préprocessing** : suppression des commentaires, expansion des macros (`#include`, `#define`). - Commande : `gcc -E file.c -o file.i` 2. **Compilation** : traduction du code préprocessé en assembleur. - Commande : `gcc -S file.i -o file.s` 3. **Assemblage** : traduction de l'assembleur en code objet (binaire relocatable). - Commande : `gcc -c file.s -o file.o` 4. **Édition des liens** : combinaison du code objet avec les bibliothèques pour produire l'exécutable. - Commande : `gcc file.o -o file` **Exemple résolu** : Compilation de `hello.c` : ```c #include <stdio.h> int main() { printf("Hello, World!\n"); return 0; } ``` Étapes : ```bash gcc -E hello.c -o hello.i # Préprocessing gcc -S hello.i -o hello.s # Compilation gcc -c hello.s -o hello.o # Assemblage gcc hello.o -o hello # Édition des liens ./hello # Exécution → affiche "Hello, World!" ``` **Exercice d'application** : Quelle étape de la compilation produit un fichier `.o` ? **Correction** : L'assemblage. **Exercice d'application** : Pourquoi un interprète est-il préféré pour l'apprentissage de la programmation ? **Correction** : Parce qu'il permet une exécution immédiate ligne par ligne, facilitant le débogage et la compréhension du flux d'exécution. --- ## V. Program Errors and Debugging ### Types d'erreurs 1. **Erreur de syntaxe** : violation des règles de grammaire du langage. Détectée à la compilation/interprétation. - Exemple (Python) : `if x = 5:` → devrait être `if x == 5:` - Exemple (C) : `printf("Hello")` → manque le point-virgule. 2. **Erreur sémantique** : code syntaxiquement correct mais sans sens logique. Détectée à l'exécution ou lors de la revue de code. - Exemple : utiliser une variable non initialisée. - En C : `int x; printf("%d", x);` → comportement indéfini. 3. **Erreur logique** : le programme s'exécute mais produit un résultat incorrect en raison d'une faute dans l'algorithme. - Exemple : calculer la moyenne comme `(a + b) / 2` au lieu de `(a + b + c) / 3` pour trois nombres. 4. **Erreur d'exécution (runtime)** : survient pendant l'exécution, souvent due à des conditions imprévues. - Exemple : division par zéro, accès à un indice hors limites d'un tableau. > **À retenir** : Le débogage est le processus systématique d'identification, de localisation et de correction des erreurs dans un programme. ### Techniques de débogage - **Lecture attentive du code** : relire ligne par ligne. - **Affichage intermédiaire** : utiliser `print` (Python) ou `printf` (C) pour suivre les valeurs des variables. - **Utilisation d'un débogueur** : outils comme `gdb` (C/C++) ou `pdb` (Python) permettant d'exécuter pas à pas, d'inspecter les variables, de poser des points d'arrêt. - **Test par cas** : vérifier le comportement avec des entrées connues (cas limites, cas typiques). - **Méthode des hypothèses** : formuler une hypothèse sur la cause de l'erreur, tester, puis confirmer ou infirmer. **Exemple résolu (débogage en Python)** : Programme : ```python def moyenne(a, b, c): return a + b + c / 3 # Erreur logique : manque de parenthèses print(moyenne(3, 6, 9)) # Affiche 12.0 au lieu de 6.0 ``` - **Hypothèse** : l'erreur vient de la priorité des opérateurs. - **Test** : `c / 3` est évalué en premier → `9 / 3 = 3`, puis `3 + 6 + 3 = 12`. - **Correction** : `return (a + b + c) / 3` - **Vérification** : `(3 + 6 + 9) / 3 = 18 / 3 = 6.0` → correct. **Exercice d'application** : Identifier le type d'erreur dans : `int arr[5]; printf("%d", arr[10]);` en C. **Correction** : Erreur d'exécution (accès hors limites du tableau). Peut provoquer un segmentation fault. **Exercice d'application** : Corriger l'erreur sémantique suivante en Python : `x = "5"; y = 3; print(x + y)` **Correction** : Type mismatch → concaténation de chaîne et entier impossible. Solution : `print(int(x) + y)` → `8` ou `print(x + str(y))` → `"53"` selon l'intention. --- ## VI. Integration Activity Cette activité vise à synthétiser les notions vues jusqu'ici : bases des langages, paradigmes, traducteurs et erreurs. **Consigne** : Écrire un algorithme (en pseudocode ou dans un langage de haut niveau) qui : 1. Lit trois nombres entiers depuis l'entrée. 2. Détermine le plus grand des trois. 3. Affiche le résultat. 4. Utilise une fonction pour encapsuler la logique de comparaison. **Solution en Python** : ```python def max_of_three(a, b, c): if a >= b and a >= c: return a elif b >= a and b >= c: return b else: return c # Lecture des entrées x = int(input("Entrez le premier nombre : ")) y = int(input("Entrez le deuxième nombre : ")) z = int(input("Entrez le troisième nombre : ")) resultat = max_of_three(x, y, z) print("Le plus grand nombre est :", resultat) ``` **Solution en C** : ```c #include <stdio.h> int max_of_three(int a, int b, int c) { if (a >= b && a >= c) { return a; } else if (b >= a && b >= c) { return b; } else { return c; } } int main() { int x, y, z; printf("Entrez le premier nombre : "); scanf("%d", &x); printf("Entrez le deuxième nombre : "); scanf("%d", &y); printf("Entrez le troisième nombre : "); scanf("%d", &z); int resultat = max_of_three(x, y, z); printf("Le plus grand nombre est : %d\n", resultat); return 0; } ``` **Points d'intégration** : - Utilisation de fonctions (paradigme procédural). - Structures de sélection (`if-elif-else`). - Gestion des entrées/sorties. - Possibilité d'erreurs sémantiques (ex. : oubli de `&` dans `scanf` en C). - Nécessité d'un traducteur (interpréteur Python ou compilateur C) pour exécuter. **Exercice d'application** : Modifier le programme Python pour qu'il gère le cas où l'utilisateur entre une valeur non entière (ex. : "abc"). **Correction** : Utiliser une boucle avec `try-except` pour valider l'entrée. ```python def get_integer(prompt): while True: try: return int(input(prompt)) except ValueError: print("Entrée invalide. Veuillez entrer un entier.") x = get_integer("Entrez le premier nombre : ") y = get_integer("Entrez le deuxième nombre : ") z = get_integer("Entrez le troisième nombre : ") # ... reste identique ``` --- ## VII. Introduction to C & Python Programming 1 ### Structure d'un programme C Un programme C commence par la fonction `main()`. Il peut inclure des bibliothèques standards via `#include`. > **À retenir** : Toute instruction en C doit se terminer par un point-virgule (`;`), sauf les blocs de contrôle et les définitions de fonctions. **Exemple minimal** : ```c #include <stdio.h> int main() { printf("Hello, OnBuch!\n"); return 0; } ``` - `#include <stdio.h>` : inclut la bibliothèque pour les entrées/sorties. - `int main()` : point d'entrée du programme. - `printf(...)` : affiche une chaîne suivie d'un saut de ligne (`\n`). - `return 0;` : indique une terminaison normale. ### Structure d'un programme Python Un programme Python est une séquence d'instructions exécutées de haut en bas. Aucune déclaration de fonction principale n'est requise, mais c'est une bonne pratique. > **À retenir** : En Python, l'indentation définit les blocs de code (au lieu des accolades `{}`). **Exemple minimal** : ```python print("Hello, OnBuch!") ``` - Pas de point-virgule nécessaire. - Pas d'accolades : l'indentation (ici, aucune car une seule ligne) définit le bloc. **Exemple avec fonction** : ```python def main(): print("Hello, OnBuch!") if __name__ == "__main__": main() ``` - `if __name__ == "__main__":` : garantit que `main()` n'est exécuté que si le script est lancé directement, pas importé. ### Comparaison C vs Python : Hello World | Aspect | C | Python | |-------|---|--------| | Bibliothèque nécessaire | `#include <stdio.h>` | Aucune | | Fonction principale | `int main()` requise | Optionnelle | | Terminateur d'instruction | Point-virgule (`;`) | Aucun | | Délimiteur de bloc | Accolades `{}` | Indentation | | Compilation nécessaire | Oui (ex. : `gcc`) | Non (interprété) | | Exécution | `./a.out` | `python3 script.py` | **Exercice d'application** : Écrire un programme C qui affiche votre nom et votre âge sur deux lignes différentes. **Correction** : ```c #include <stdio.h> int main() { printf("Jean Dupont\n"); printf("16 ans\n"); return 0; } ``` **Exercice d'application** : Écrire un programme Python qui demande le nom de l'utilisateur et l'accueille. **Correction** : ```python nom = input("Quel est votre nom ? ") print("Bonjour,", nom + "!") ``` *Note : La virgule dans `print` ajoute un espace automatiquement.* --- ## VIII. Introduction to C & Python Programming 2 ### Variables et types de données en C Les variables doivent être déclarées avec leur type avant utilisation. > **À retenir** : En C, le type d'une variable détermine la taille de mémoire allouée et les opérations autorisées. **Types de base** : - `int` : entier (généralement 4 bytes) - `float` : nombre à virgule flottante simple précision (4 bytes) - `double` : nombre à virgule flottante double précision (8 bytes) - `char` : caractère simple (1 byte) - `void` : absence de type **Exemple** : ```c int age = 16; float hauteur = 1.75; double precision = 3.141592653589793; char initiale = 'J'; ``` ### Variables et types de données en Python Les variables sont dynamiquement typées : leur type est déterminé à l'affectation. > **À retenir** : En Python, une variable peut changer de type au cours de l'exécution (typage dynamique). **Types de base** : - `int` : entier de précision illimitée - `float` : nombre à virgule flottante (double précision interne) - `str` : chaîne de caractères Unicode - `bool` : valeur de vérité (`True` ou `False`) - `None` : absence de valeur **Exemple** : ```python age = 16 # int hauteur = 1.75 # float nom = "Jean" # str est_etudiant = True # bool rien = None # NoneType ``` ### Affectation et mise à jour Dans les deux langages, l'opérateur d'affectation est `=`. **Exemple résolu (mise à jour)** : En C : ```c int compteur = 0; compteur = compteur + 1; // compteur vaut maintenant 1 ``` En Python : ```python compteur = 0 compteur = compteur + 1 # compteur vaut maintenant 1 ``` Raccourci : `compteur += 1` dans les deux langages. **Exercice d'application** : Déclarer et initialiser en C une variable pour stocker le prix d'un livre à 2500 francs CFA. **Correction** : ```c int prix_livre = 2500; // en francs CFA ``` **Exercice d'application** : Quel est le type de la variable `x` après `x = 3.0 * 2` en Python ? **Correction** : `float` → `6.0` (même si le résultat est entier, la présence d'un flottant force le résultat en flottant). --- ## IX. Introduction to C & Python Programming 3 ### Entrées/sorties de base en C - **Sortie** : `printf()` pour afficher formaté. - Syntaxe : `printf(format, arg1, arg2, ...);` - Spécificateurs : `%d` (entier), `%f` (flottant), `%s` (chaîne), `%c` (caractère). - Exemple : `printf("Age: %d, Height: %.2f\n", age, hauteur);` - **Entrée** : `scanf()` pour lire formaté. - Syntaxe : `scanf(format, &arg1, &arg2, ...);` - **Important** : utiliser `&` pour passer l'adresse de la variable. - Exemple : `scanf("%d", &age);` - Attention : `scanf` peut laisser des caractères dans le tampon (ex. : `\n` après un entier). > **À retenir** : En C, oublier le `&` dans `scanf` entraîne un comportement indéfini (souvent un crash). **Exemple résolu** : Lire un âge et l'afficher avec un message. ```c #include <stdio.h> int main() { int age; printf("Entrez votre âge : "); scanf("%d", &age); // & obligatoire printf("Vous avez %d ans.\n", age); return 0; } ``` Si l'utilisateur entre `16`, l'affichage est : `Vous avez 16 ans.` ### Entrées/sorties de base en Python - **Sortie** : `print()` pour afficher. - Syntaxe : `print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)` - Par défaut : sépare les arguments par un espace, termine par un saut de ligne. - Exemple : `print("Age:", age, "ans")` → `Age: 16 ans` - **Entrée** : `input()` pour lire une chaîne depuis l'entrée standard. - Toujours retourne une `str` ; conversion nécessaire pour d'autres types. - Exemple : `age = int(input("Entrez votre âge : "))` > **À retenir** : En Python, `input()` retourne toujours une chaîne de caractères ; il faut convertir explicitement pour obtenir un entier ou un flottant. **Exemple résolu** : Lire un âge et l'afficher avec un message. ```python age = int(input("Entrez votre âge : ")) print("Vous avez", age, "ans.") ``` Si l'utilisateur entre `16`, l'affichage est : `Vous avez 16 ans.` **Exercice d'application** : Écrire un programme C qui lit deux entiers et affiche leur somme. **Correction** : ```c #include <stdio.h> int main() { int a, b; printf("Entrez le premier entier : "); scanf("%d", &a); printf("Entrez le deuxième entier : "); scanf("%d", &b); printf("La somme est : %d\n", a + b); return 0; } ``` **Exercice d'application** : Écrire un programme Python qui lit un flottant et affiche son double. **Correction** : ```python valeur = float(input("Entrez un nombre : ")) print("Le double est :", valeur * 2) ``` --- ## X. Python/C Operators and Expressions 1 ### Opérateurs arithmétiques Communs aux deux langages : `+` (addition), `-` (soustraction), `*` (multiplication), `/` (division), `%` (modulo), `**` (exponentiation, Python uniquement), `//` (division entière). > **À retenir** : En C, la division entre deux entiers effectue une division entière (troncature vers zéro). En Python, `/` retourne toujours un flottant ; `//` retourne un entier. **Tableau de priorité** (du plus haut au plus bas) : 1. Parenthèses `()` 2. Exponentiation `**` (Python) 3. Multiplication `*`, division `/`, division entière `//`, modulo `%` 4. Addition `+`, soustraction `-` 5. Affectation `=`, `+=`, `-=`, etc. **Exemple résolu** : Évaluer `3 + 4 * 2 ** 2` en Python. - Étape 1 : `2 ** 2 = 4` - Étape 2 : `4 * 4 = 16` - Étape 3 : `3 + 16 = 19` Résultat : `19` En C : `3 + 4 * 2 * 2` (pas d'opérateur `**`) - Étape 1 : `4 * 2 = 8` - Étape 2 : `8 * 2 = 16` - Étape 3 : `3 + 16 = 19` Résultat : `19` ### Opérateurs de comparaison Retournent une valeur de vérité (`True`/`False` en Python, `1`/`0` en C). - Égalité : `==` - Inégalité : `!=` - Inférieur : `<` - Inférieur ou égal : `<=` - Supérieur : `>` - Supérieur ou égal : `>=` > **À retenir** : En C, toute valeur non nulle est considérée comme `vrai` (`True`), zéro comme `faux` (`False`). En Python, `bool` est un type distinct. **Exemple résolu** : Évaluer `5 > 3 and not (2 == 2)` en Python. - `5 > 3` → `True` - `2 == 2` → `True` - `not True` → `False` - `True and False` → `False` Résultat : `False` En C : équivalent logique : `(5 > 3) && !(2 == 2)` - `5 > 3` → `1` (vrai) - `2 == 2` → `1` - `!1` → `0` - `1 && 0` → `0` (faux) Résultat : `0` ### Opérateurs logiques - Conjonction (ET) : `&&` en C, `and` en Python - Disjonction (OU) : `||` en C, `or` en Python - Négation (NON) : `!` en C, `not` en Python **Exercice d'application** : Évaluer en Python : `not (4 < 5) or (7 >= 7 and 0)` **Correction** : - `4 < 5` → `True` → `not True` → `False` - `7 >= 7` → `True` - `True and 0` → `False` (en Python, `0` est falsy) - `False or False` → `False` Résultat : `False` **Exercice d'application** : Écrire une expression C qui est vraie si et seulement si `x` est compris entre 10 et 20 (inclus). **Correction** : ```c (x >= 10) && (x <= 20) ``` --- ## XI. Python/C Operators and Expressions 2 ### Opérateurs d'affectation composés Combinaison d'un opérateur et de l'affectation pour simplifier le code. > **À retenir** : Les opérateurs composés améliorent la lisibilité et évitent les répétitions. | Opérateur | Équivalent en C | Équivalent en Python | Exemple (x = 5) | |----------|-----------------|----------------------|-----------------| | `+=` | `x = x + y` | `x = x + y` | `x += 3` → `x = 8` | | `-=` | `x = x - y` | `x = x - y` | `x -= 2` → `x = 3` | | `*=` | `x = x * y` | `x = x * y` | `x *= 4` → `x = 20` | | `/=` | `x = x / y` | `x = x / y` | `x /= 2` → `x = 2.5` (C : si x est int, troncature ; Python : flottant) | | `%=` | `x = x % y` | `x = x % y` | `x %= 3` → `x = 2` (si x=5) | | `//=` | N/A | `x = x // y` | `x //= 2` → `x = 2` (si x=5) | | `**=` | N/A | `x = x ** y` | `x **= 2` → `x = 25` (si x=5) | **Exemple résolu** : Partant de `x = 10`, quelle est la valeur de `x` après `x *= 2 + 3` ? - D'abord, évaluer `2 + 3 = 5` - Ensuite, `x *= 5` → `x = x * 5` → `10 * 5 = 50` Résultat : `x = 50` **Exercice d'application** : En Python, partir de `x = 7`. Appliquer successivement : `x += 4`, `x *= 2`, `x -= 3`. Quel est le résultat final ? **Correction** : - Après `x += 4` : `7 + 4 = 11` - Après `x *= 2` : `11 * 2 = 22` - Après `x -= 3` : `22 - 3 = 19` Résultat : `19` **Exercice d'application** : En C, partir de `int x = 15;`. Appliquer : `x /= 4;`. Quelle est la valeur de `x` ? **Correction** : Division entière → `15 / 4 = 3` (troncature vers zéro) → `x = 3` --- ## XII. Python/C Selection Structures 1 ### Structure conditionnelle simple : `if` Permet d'exécuter un bloc de code uniquement si une condition est vraie. > **À retenir** : La condition dans une structure `if` doit être une expression booléenne. **Syntaxe en C** : ```c if (condition) { // bloc à exécuter si condition est vraie } ``` **Syntaxe en Python** : ```python if condition: # bloc à exécuter si condition est vraie ``` **Exemple résolu** : Afficher "Adulte" si l'âge est ≥ 18. En C : ```c if (age >= 18) { printf("Adulte\n"); } ``` En Python : ```python if age >= 18: print("Adulte") ``` Si `age = 20` → affiche ; si `age = 15` → rien. ### Structure conditionnelle double : `if-else` Exécute un bloc si la condition est vraie, un autre sinon. > **À retenir** : Les deux branches de `if-else` sont mutuellement exclusives : une seule est exécutée. **Syntaxe en C** : ```c if (condition) { // bloc si vrai } else { // bloc si faux } ``` **Syntaxe en Python** : ```python if condition: # bloc si vrai else: # bloc si faux ``` **Exemple résolu** : Déterminer si un nombre est pair ou impair. En C : ```c if (nombre % 2 == 0) { printf("Pair\n"); } else { printf("Impair\n"); } ``` En Python : ```python if nombre % 2 == 0: print("Pair") else: print("Impair") ``` Si `nombre = 4` → `4 % 2 = 0` → vrai → "Pair" Si `nombre = 7` → `7 % 2 = 1` → faux → "Impair" **Exercice d'application** : Écrire un programme C qui lit un entier et affiche "Positif" s'il est > 0, "Nul" s'il est 0, sinon "Négatif". **Correction** : Nécessite `if-else if-else` (voir prochaine section). *Solution anticipée* : ```c if (n > 0) { printf("Positif\n"); } else if (n == 0) { printf("Nul\n"); } else { printf("Négatif\n"); } ``` **Exercice d'application** : Écrire un programme Python qui lit un âge et affiche "Mineur" si < 18, sinon "Majeur". **Correction** : ```python age = int(input("Entrez votre âge : ")) if age < 18: print("Mineur") else: print("Majeur") ``` ---