Syntaxe, types et structures de contrôle

Syntaxe, types et structures de contrôle

1. Variables et types

   Python est à typage dynamique : le type est déduit à la volée, il n'y a pas de déclaration de type. L'annotation (nom: str) est une aide à la lecture et aux outils, pas une contrainte d'exécution.

   entier = 42
   flottant = 3.14
   texte = "Python"
   booleen = True          # True / False, avec une majuscule
   rien = None             # absence de valeur, ce n'est pas 0 ni ""
   
   print(type(entier))     # <class 'int'>
   print(type(rien))       # <class 'NoneType'>

   Les types de base

   • int, float, complex — numériques
   • str — texte, immuable
   • bool — vrai ou faux
   • list, tuple, set, dict — collections
   • NoneType — la valeur None

   Le piège du booléen

   En Python, 0, "", [], {} et None sont faux. Une liste vide est donc fausse, ce qui surprend au premier abord mais évite les tests de longueur everywhere.

   if valeurs:        # faux si la liste est vide
       print("il y a des valeurs")
   
   # explicite et plus lisible quand le type compte
   if len(valeurs) > 0:
       print("il y a des valeurs")

   Chaînes

   nom = "Alice"
   print(nom.upper())      # ALICE  (renvoie une nouvelle chaîne)
   print(nom[0])           # A
   print(nom[-1])          # e
   print(nom[0:3])         # Ali  (découpage)
   print(nom.upper() == "ALICE")  # True

2. Conditions et boucles

   Conditions

   if note >= 16:
       mention = "Très bien"
   elif note >= 14:
       mention = "Bien"
   elif note >= 10:
       mention = "Passable"
   else:
       mention = "Insuffisant"

   Le test d'appartenance

   Python n'a pas de switch : on utilise match (disponible depuis 3.10) quand on compare une même valeur à plusieurs cas, sinon des if/elif.

   def Notes(note: int) -> str:
       match note:
           case 20:
               return "Parfait"
           case 19 | 18:
               return "Excellent"
           case n if n < 10:
               return "Insuffisant"
           case _:
               return "Correct"

   Boucles

   for lettre in "Python":
       print(lettre)
   
   for index, valeur in enumerate(["a", "b", "c"]):
       print(index, valeur)
   
   compteur = 0
   while compteur < 3:
       print(compteur)
       compteur += 1

   break sort de la boucle, continue passe à l'itération suivante. else après une boucle s'exécute si aucun break n'a eu lieu — une particularité qui surprend les débutants mais qui exprime bien l'intention « si tout s'est terminé normalement ».

3. Compréhensions

   La compréhension de liste construit une liste à partir d'un itérable. C'est l'idiomate dominant en Python : plus court, et souvent plus rapide qu'une boucle avec append.

   nombres = [1, 2, 3, 4, 5]
   
   carres = [n * n for n in nombres]              # [1, 4, 9, 16, 25]
   pairs = [n for n in nombres if n % 2 == 0]     # [2, 4]
   
   # avec transformation et condition
   etiquettes = [f"#{n}" for n in nombres if n > 3]   # ['#4', '#5']

   Dictionnaire et ensemble

   longueurs = {mot: len(mot) for mot in ["chat", "chien"]}
   # {'chat': 4, 'chien': 5}
   
   initiales = {mot[0] for mot in ["chat", "chien", "cheval"]}  # {'c'}

   Générateur : la variante paresseuse

   Si vous n'avez besoin que de parcourir la valeur sans la stocker, utilisez une expression génératrice : elle ne construit rien en mémoire.

   carres = (n * n for n in nombres)   # pas de crochets : paresseux
   for c in carres:
       print(c)

   Quand ne pas en utiliser

   Si la logique dépasse une ligne, ou si elle contient une boucle for imbriquée, la compréhension devient illisible : une boucle explicite est alors plus claire.

4. Exercices

   1. FizzBuzz : afficher les nombres de 1 à 100, en écrivant « Fizz » pour les multiples de 3, « Buzz » pour les multiples de 5, et « FizzBuzz » pour les multiples des deux.
   2. Palindrome : écrire une fonction qui indique si une chaîne est un palindrome, en ignorant la casse et les espaces. Comparer les deux méthodes.
   3. Dictionnaire d'âge : à partir d'une liste de prénoms, construire un dictionnaire prénom → âge, puis afficher les prénoms triés du plus âgé au plus jeune.
   4. Compréhension : réécrivez cette boucle en compréhension.

      mots = ["Python", "est", "simple", "et", "puissant"]
      resultat = []
      for m in mots:
          if len(m) > 3:
              resultat.append(m.upper())