La programmation et les algorithmes

Un algorithme est une séquence finie et non ambiguë d'instructions et d'opérations permettant de résoudre un problème ou d'obtenir un résultat donné. Imagine une recette de cuisine : elle contient des étapes précises pour arriver à un plat. Un algorithme, c'est pareil, mais pour un ordinateur.

Key Concepts:

• Définition d'un algorithme : Une suite d'étapes claires pour atteindre un but.
• Séquence d'instructions : Les étapes sont ordonnées et doivent être suivies dans un ordre précis.
• Résolution de problèmes : Le but principal est de trouver une solution à une question posée.
• Exemples concrets :
  • Recette de cuisine : Mélanger, cuire, assaisonner...
  • Instructions de montage de meubles : Étape 1, Étape 2...
  • Calcul de la moyenne de notes : Additionner toutes les notes, diviser par le nombre de notes.

Un bon algorithme doit toujours :

1. Être fini : il doit se terminer après un nombre fini d'étapes.
2. Être non ambigu : chaque instruction doit être claire et interprétable d'une seule manière.
3. Être efficace : il doit résoudre le problème avec le moins de ressources possible (temps, mémoire).

Pour concevoir et communiquer un algorithme, il existe différentes manières de le représenter. Le choix dépend souvent de la complexité de l'algorithme et du public visé.

Key Concepts:

• Langage naturel : Décrire l'algorithme avec des phrases courantes. C'est simple à comprendre pour un humain, mais souvent trop ambigu pour un ordinateur.
  • Exemple : "Demander l'âge de la personne. Si l'âge est supérieur ou égal à 18, afficher "Majeur". Sinon, afficher "Mineur"."
• Pseudo-code : Une description de l'algorithme qui ressemble à un langage de programmation mais sans respecter une syntaxe stricte. C'est un bon compromis entre le langage naturel et le code. Il utilise des mots-clés comme DEBUT, FIN, LIRE, ECRIRE, SI, ALORS, SINON, TANT QUE. C'est la méthode la plus courante en algorithmique.
  • Exemple :

    DEBUT Algorithme MajeurOuMineur
        LIRE age
        SI age >= 18 ALORS
            ECRIRE "Majeur"
        SINON
            ECRIRE "Mineur"
        FIN SI
    FIN Algorithme
    

• Organigrammes (flowcharts) : Des diagrammes graphiques utilisant des symboles standardisés pour représenter les étapes et le flux de contrôle de l'algorithme. Très visuels, ils sont utiles pour les algorithmes plus complexes.
  • Symboles courants :
    • Ovale : Début/Fin
    • Parallélogramme : Entrée/Sortie de données
    • Rectangle : Traitement/Opération
    • Losange : Décision (condition)
    • Flèche : Sens du flux
• Importance de la clarté : Quelle que soit la représentation choisie, l'objectif est de rendre l'algorithme compréhensible par quiconque le lira, et de s'assurer qu'il ne contient aucune ambiguïté.

Pour qu'un algorithme puisse manipuler des informations, il a besoin de les stocker temporairement. C'est le rôle des variables.

Key Concepts:

• Définition d'une variable : Une variable est un emplacement nommé en mémoire qui peut stocker une valeur. Cette valeur peut changer (varier) pendant l'exécution de l'algorithme. C'est comme une boîte étiquetée où l'on peut ranger différentes choses.
  • Exemple : age, nom, prixTotal.
• Types de données : Pour chaque variable, il est important de savoir quel type de données elle va contenir. Cela permet à l'ordinateur de savoir comment interpréter et manipuler cette donnée.
  • Entier (Integer) : Nombres entiers (positifs, négatifs ou zéro). Ex: 5, -10, 0, 1000.
  • Flottant (Float) : Nombres décimaux, avec une partie fractionnaire. Ex: 3.14, -0.5, 99.99.
  • Chaîne de caractères (String) : Séquence de caractères (lettres, chiffres, symboles). Utilisé pour le texte. Ex: "Bonjour", "Python", "123".
  • Booléen (Boolean) : Représente une valeur de vérité. Peut être VRAI (True) ou FAUX (False). Souvent utilisé pour les conditions.
• Déclaration et affectation :
  • Déclaration : Créer la variable et lui donner un nom. Dans certains langages, il faut aussi spécifier son type.
  • Affectation : Attribuer une valeur à la variable. On utilise souvent le symbole ← ou = en pseudo-code.
  • Exemple en pseudo-code :

    DEBUT
        DECLARE age : ENTIER       // Déclaration de la variable 'age' de type ENTIER
        age ← 25                   // Affectation de la valeur 25 à la variable 'age'
        DECLARE nom : CHAINE
        nom ← "Alice"
        DECLARE estMajeur : BOOLEEN
        estMajeur ← VRAI
    FIN
    

• Portée des variables : C'est l'endroit du programme où une variable est "visible" et peut être utilisée. Nous y reviendrons plus tard avec les fonctions, mais sache que toutes les variables ne sont pas accessibles partout.

Les opérateurs sont des symboles qui nous permettent de manipuler des valeurs et des variables pour créer de nouvelles valeurs ou prendre des décisions. Une expression est une combinaison de variables, de valeurs et d'opérateurs qui, une fois évaluée, produit une nouvelle valeur.

Key Concepts:

• Opérateurs arithmétiques : Pour les calculs mathématiques.

  • + : Addition (Ex: 5 + 3 donne 8)
  • - : Soustraction (Ex: 10 - 4 donne 6)
  • * : Multiplication (Ex: 2 * 6 donne 12)
  • / : Division (Ex: 15 / 3 donne 5)
  • % : Modulo (reste de la division entière) (Ex: 10 % 3 donne 1)
  • ^ ou ** : Puissance (Ex: 2^3 ou 2**3 donne 8)

• Opérateurs de comparaison : Pour comparer des valeurs. Ils renvoient toujours un booléen (VRAI ou FAUX).

  • = ou <mark> : Égal à (Ex: 5 </mark> 5 donne VRAI, 5 == 3 donne FAUX)
  • != ou <> : Différent de (Ex: 5 != 3 donne VRAI)
  • < : Inférieur à (Ex: 5 < 8 donne VRAI)
  • > : Supérieur à (Ex: 10 > 7 donne VRAI)
  • <= : Inférieur ou égal à (Ex: 5 <= 5 donne VRAI)
  • >= : Supérieur ou égal à (Ex: 10 >= 12 donne FAUX)

• Opérateurs logiques : Pour combiner des expressions booléennes.

  • ET (AND) : VRAI si toutes les conditions sont VRAIES.
    • Ex: (age > 18) ET (genre <mark> "homme")
  • OU (OR) : VRAI si au moins une des conditions est VRAIE.
    • Ex: (jour </mark> "samedi") OU (jour <mark> "dimanche")
  • NON (NOT) : Inverse la valeur de vérité.
    • Ex: NON (estConnecte)

• Priorité des opérateurs : Comme en mathématiques, certains opérateurs sont évalués avant d'autres.

  1. Parenthèses ()
  2. Puissances ** ou ^
  3. Multiplication *, Division /, Modulo %
  4. Addition +, Soustraction -
  5. Opérateurs de comparaison </mark>, !=, <, >, <=, >=
  6. Opérateurs logiques NON, ET, OU (dans cet ordre)

  Exemple : 5 + 3 * 2 donne 11 (3 * 2 est évalué en premier), alors que (5 + 3) * 2 donne 16.

La structure la plus simple est la séquence. C'est le comportement par défaut d'un algorithme : les instructions sont exécutées l'une après l'autre, dans l'ordre où elles sont écrites.

Key Concepts:

• Exécution linéaire : Les instructions sont traitées de haut en bas, une par une.
• Ordre des opérations : L'ordre est crucial. Changer l'ordre peut changer le résultat ou provoquer des erreurs.
  • Exemple :

    DEBUT
        AFFICHER "Bonjour"
        AFFICHER "Comment ça va ?"
    FIN
    

    Le programme affichera toujours "Bonjour" puis "Comment ça va ?".
• Blocs d'instructions : Une séquence peut être vue comme un bloc d'instructions. Parfois, ces blocs sont regroupés, par exemple, à l'intérieur d'une condition ou d'une boucle.

Les structures conditionnelles permettent à un algorithme de prendre des décisions. C'est ce qui rend un programme "intelligent" : il peut réagir différemment en fonction de certaines conditions.

Key Concepts:

• Tests logiques : L'algorithme évalue une expression booléenne (une condition). Si la condition est VRAIE, un bloc d'instructions est exécuté. Si elle est FAUSSE, un autre bloc (ou aucun) peut être exécuté.

• Branchement conditionnel : Le programme "choisit" un chemin parmi plusieurs possibles.

• Syntaxe générale en pseudo-code :

  SI (condition) ALORS
      // Instructions à exécuter si la condition est VRAIE
  SINON
      // Instructions à exécuter si la condition est FAUSSE
  FIN SI
  

  Le bloc SINON est optionnel. Si tu n'as rien à faire quand la condition est fausse, tu peux l'omettre.

• Conditions imbriquées : Il est possible de placer une structure conditionnelle à l'intérieur d'une autre.

  • Exemple :

    SI (age >= 18) ALORS
        SI (aPermisConduire == VRAI) ALORS
            ECRIRE "Vous pouvez louer une voiture."
        SINON
            ECRIRE "Vous êtes majeur mais n'avez pas le permis."
        FIN SI
    SINON
        ECRIRE "Vous êtes mineur."
    FIN SI
    

• Opérateurs booléens : Pour des conditions plus complexes, on utilise les opérateurs ET, OU, NON vus précédemment.

  • Exemple : SI (age >= 18 ET aPermisConduire == VRAI) ALORS ...

Les boucles permettent d'exécuter un bloc d'instructions plusieurs fois. C'est l'un des concepts les plus puissants en programmation car il permet d'automatiser des tâches répétitives sans écrire le même code encore et encore.

Key Concepts:

• Boucle Tant que (While) : Répète un bloc d'instructions tant qu'une condition est VRAIE. La condition est testée avant chaque itération. Si la condition est fausse dès le début, le bloc ne sera jamais exécuté.

  TANT QUE (condition) FAIRE
      // Instructions à répéter
  FIN TANT QUE
  

  • Exemple : Compter jusqu'à 5

    DEBUT
        compteur ← 1
        TANT QUE (compteur <= 5) FAIRE
            ECRIRE compteur
            compteur ← compteur + 1 // Très important : modifier la condition pour qu'elle devienne fausse à un moment donné !
        FIN TANT QUE
    FIN
    

    Attention : si la condition ne devient jamais fausse, la boucle ne s'arrêtera jamais ! C'est une boucle infinie.

• Boucle Pour (For) : Répète un bloc d'instructions un nombre de fois déterminé à l'avance ou pour chaque élément d'une collection.

  POUR (variable DE debut À fin AVEC PAS increment) FAIRE
      // Instructions à répéter
  FIN POUR
  

  • Exemple : Compter jusqu'à 5

    DEBUT
        POUR i DE 1 À 5 FAIRE
            ECRIRE i
        FIN POUR
    FIN
    

  • En Python, la boucle for est souvent utilisée pour parcourir des collections (listes, chaînes de caractères, etc.).

• Condition d'arrêt : C'est la condition qui, lorsqu'elle devient fausse (pour TANT QUE) ou que le parcours est terminé (pour POUR), met fin à la boucle.

• Itération : Chaque exécution du bloc d'instructions à l'intérieur d'une boucle est appelée une itération.

Pour qu'un programme soit utile, il doit pouvoir interagir avec l'utilisateur ou avec l'environnement. C'est le rôle des fonctions d'entrée/sortie.

Key Concepts:

• Fonctions d'entrée (lire) : Permettent au programme de recevoir des données de l'extérieur, généralement via le clavier de l'utilisateur.
  • Exemple en pseudo-code : LIRE nomUtilisateur
  • L'algorithme met en pause son exécution et attend que l'utilisateur tape quelque chose et valide (souvent avec la touche Entrée). La valeur tapée est ensuite stockée dans la variable spécifiée.
• Fonctions de sortie (écrire, afficher) : Permettent au programme d'afficher des informations à l'utilisateur, généralement sur l'écran.
  • Exemple en pseudo-code : ECRIRE "Bienvenue, " + nomUtilisateur
  • Ces fonctions affichent du texte, des valeurs de variables ou le résultat d'expressions.
• Interaction utilisateur : L'ensemble des opérations d'entrée et de sortie constitue l'interaction entre le programme et son utilisateur. Un bon programme doit être clair dans ce qu'il demande et ce qu'il affiche.
• Affichage de résultats : La sortie est essentielle pour présenter les résultats des calculs ou des traitements effectués par l'algorithme.

Pour écrire et exécuter du code Python, tu as besoin de quelques outils.

Key Concepts:

• Interpréteur Python : C'est le programme qui lit ton code Python et l'exécute instruction par instruction. Sans lui, ton ordinateur ne comprendrait pas ce que tu as écrit. Python est un langage interprété, pas compilé.
• Éditeurs de code (IDLE, VS Code) :
  • IDLE : C'est l'environnement de développement intégré (IDE) qui est souvent livré avec Python. Il est simple et suffisant pour commencer. Il propose un shell Python (où tu peux taper des commandes Python et voir les résultats immédiatement) et un éditeur de texte pour écrire et sauvegarder tes scripts.
  • VS Code (Visual Studio Code) : Un éditeur de code très populaire et puissant, développé par Microsoft. Il est gratuit, open-source, et très extensible grâce à des extensions. C'est un excellent choix pour des projets plus importants.
  • D'autres options existent comme PyCharm, Sublime Text, etc.
• Exécution d'un script :
  1. Écris ton code Python dans un fichier texte et sauvegarde-le avec l'extension .py (ex: mon_programme.py).
  2. Ouvre un terminal ou une invite de commande.
  3. Navigue jusqu'au dossier où tu as enregistré ton fichier.
  4. Tape python mon_programme.py et appuie sur Entrée. L'interpréteur Python exécutera ton code.
• Syntaxe de base : La syntaxe est l'ensemble des règles qui régissent la manière dont tu dois écrire ton code. Python est connu pour sa syntaxe propre et l'utilisation de l'indentation (les espaces au début des lignes) pour définir les blocs de code, là où d'autres langages utilisent des accolades.

En Python, tu n'as pas besoin de déclarer explicitement le type d'une variable. L'interpréteur Python devine le type en fonction de la valeur que tu lui donnes. C'est ce qu'on appelle le typage dynamique.

Key Concepts:

• Déclaration implicite : Tu crées une variable simplement en lui affectant une valeur.

  age = 20          # age est un entier (int)
  nom = "Sophie"    # nom est une chaîne de caractères (str)
  taille = 1.75     # taille est un nombre flottant (float)
  est_etudiant = True # est_etudiant est un booléen (bool)
  

• Types numériques (int, float) :
  • int (integer) : Pour les nombres entiers. Ex: 10, -5.
  • float (floating-point number) : Pour les nombres décimaux. Ex: 3.14, 0.001.
• Chaînes de caractères (str) : Pour le texte. Elles sont délimitées par des guillemets simples (') ou doubles (").
  • Ex: 'Bonjour', "Python c'est cool".
• Booléens (bool) : Pour les valeurs de vérité. True (Vrai) ou False (Faux). Note la majuscule !

Python est sensible à la casse : Age n'est pas la même variable que age.

Les opérateurs en Python sont très similaires à ceux que nous avons vus en pseudo-code.

Key Concepts:

• Opérateurs arithmétiques :
  • +, -, *, / (division flottante)
  • // : Division entière (le quotient, sans la partie décimale). Ex: 10 // 3 donne 3.
  • % : Modulo (reste de la division entière). Ex: 10 % 3 donne 1.
  • ** : Puissance. Ex: 2 ** 3 donne 8.
• Opérateurs de comparaison :
  • == (égal à), != (différent de)
  • <, >, <=, >=
  • Ces opérateurs renvoient True ou False.
• Opérateurs logiques (and, or, not) :
  • and (ET) : True si les deux opérandes sont True.
  • or (OU) : True si au moins un des opérandes est True.
  • not (NON) : Inverse la valeur de vérité de l'opérande.
• Priorité des opérateurs : La même logique s'applique qu'en mathématiques et en pseudo-code. Les parenthèses () peuvent être utilisées pour forcer un ordre d'évaluation.
  • Ex: resultat = 5 + 3 * 2 (resultat sera 11)
  • Ex: resultat = (5 + 3) * 2 (resultat sera 16)

Les conditions en Python utilisent les mots-clés if, elif (else if), et else. L'indentation est cruciale pour définir les blocs de code.

Key Concepts:

• Instruction if :

  age = 20
  if age >= 18:
      print("Vous êtes majeur.")
  

  Notez le : après la condition et l'indentation (généralement 4 espaces) pour le bloc d'instructions.
• if, else :

  temperature = 15
  if temperature > 25:
      print("Il fait chaud.")
  else:
      print("Il fait frais.")
  

• if, elif, else : Pour gérer plusieurs conditions mutuellement exclusives.

  note = 12
  if note >= 16:
      print("Très bien")
  elif note >= 12: # Si la première condition était fausse (note < 16)
      print("Bien")
  elif note >= 10: # Si les deux premières étaient fausses (note < 12)
      print("Passable")
  else:            # Si toutes les conditions précédentes étaient fausses (note < 10)
      print("Insuffisant")
  

• Indentation : C'est la règle d'or en Python. Les instructions qui font partie d'un bloc (if, else, elif, boucles, fonctions) doivent être indentées au même niveau. Une erreur d'indentation (IndentationError) arrêtera l'exécution de ton programme.

Python propose des boucles while et for pour la répétition d'instructions.

Key Concepts:

• Boucle while : Répète un bloc de code tant qu'une condition est True.

  compteur = 1
  while compteur <= 5:
      print(compteur)
      compteur = compteur + 1 # ou compteur += 1
  print("Fin de la boucle while.")
  

  N'oublie pas de modifier la variable de la condition à l'intérieur de la boucle pour éviter une boucle infinie !
• Boucle for (avec range, listes) :
  • Avec range() : range(n) génère une séquence de nombres de 0 à n-1. range(a, b) génère de a à b-1. range(a, b, step) génère de a à b-1 avec un pas.

    # Répète 5 fois (i prend les valeurs 0, 1, 2, 3, 4)
    for i in range(5):
        print(f"Itération {i}") # f-string pour affichage formaté, très pratique
    
    # Compte de 1 à 5 (i prend les valeurs 1, 2, 3, 4, 5)
    for i in range(1, 6):
        print(i)
    
    # Compte de 0 à 10 par pas de 2 (0, 2, 4, 6, 8, 10)
    for i in range(0, 11, 2):
        print(i)
    

  • Itération sur des séquences : La boucle for est très efficace pour parcourir les éléments d'une liste, d'une chaîne de caractères, etc.

    fruits = ["pomme", "banane", "cerise"]
    for fruit in fruits:
        print(f"J'aime la {fruit}.")
    
    phrase = "Python"
    for lettre in phrase:
        print(lettre)
    

• Instructions break et continue :
  • break : Permet de sortir immédiatement de la boucle en cours, même si la condition de la boucle est toujours vraie.

    for i in range(10):
        if i <mark> 5:
            break # Arrête la boucle quand i atteint 5
        print(i) # Affichera 0, 1, 2, 3, 4
    

  • continue : Permet de passer à l'itération suivante de la boucle, en ignorant les instructions restantes du bloc pour l'itération actuelle.

    for i in range(5):
        if i </mark> 2:
            continue # Passe l'itération où i est 2
        print(i) # Affichera 0, 1, 3, 4
    

Une fonction est un bloc de code nommé qui effectue une tâche spécifique.

Key Concepts:

• Rôle d'une fonction :
  • Réutilisabilité du code : Évite de copier-coller le même code plusieurs fois. Tu écris la logique une seule fois et tu l'appelles quand tu en as besoin.
  • Modularité : Découpe un gros problème en petits sous-problèmes gérables. Chaque fonction s'occupe d'une petite tâche.
  • Lisibilité : Rend le code plus facile à lire et à comprendre.
• Définition (def) : En Python, on utilise le mot-clé def pour définir une fonction.

  def saluer(): # saluer est le nom de la fonction
      print("Bonjour !")
      print("Bienvenue dans mon programme.")
  

  Comme pour les conditions et les boucles, l'indentation est utilisée pour définir le corps de la fonction.
• Appel de fonction : Pour exécuter le code d'une fonction, il faut l'appeler par son nom, suivi de parenthèses.

  saluer() # Ceci exécute les instructions à l'intérieur de la fonction saluer
  saluer() # On peut l'appeler plusieurs fois
  

Les fonctions peuvent échanger des informations avec le reste du programme.

Key Concepts:

• Arguments et paramètres :
  • Les paramètres sont les variables listées entre les parenthèses lors de la définition de la fonction. Ce sont des "placeholders" pour les données que la fonction attend.
  • Les arguments sont les valeurs que tu passes à la fonction lorsque tu l'appelles. Ces valeurs sont affectées aux paramètres.

  def afficher_salutation(nom): # 'nom' est un paramètre
      print(f"Bonjour, {nom} !")
  
  afficher_salutation("Alice")   # "Alice" est un argument
  afficher_salutation("Bob")     # "Bob" est un autre argument
  

  Une fonction peut prendre plusieurs paramètres, séparés par des virgules.

  def additionner(a, b):
      somme = a + b
      print(f"La somme de {a} et {b} est {somme}")
  
  additionner(5, 3) # a=5, b=3
  

• Valeur de retour (return) : Une fonction peut calculer un résultat et le renvoyer au programme qui l'a appelée. On utilise le mot-clé return.

  def calculer_carre(nombre):
      carre = nombre * nombre
      return carre # La fonction renvoie la valeur de 'carre'
  
  resultat = calculer_carre(7) # 'resultat' vaudra 49
  print(f"Le carré est : {resultat}")
  print(f"Le carré de 10 est : {calculer_carre(10)}") # On peut utiliser la valeur directement
  

  Quand return est exécuté, la fonction s'arrête immédiatement et renvoie la valeur spécifiée.
• Fonctions sans retour : Toutes les fonctions ne renvoient pas explicitement une valeur. Si une fonction n'a pas d'instruction return, elle renvoie implicitement None (qui représente l'absence de valeur).
• Passage par valeur/référence (simplifié) : En Python, les arguments sont passés "par référence d'objet". Pour les types immuables (nombres, chaînes, tuples), cela se comporte comme un passage par valeur : modifier le paramètre à l'intérieur de la fonction ne modifie pas l'argument d'origine. Pour les types mutables (listes, dictionnaires), cela se comporte comme un passage par référence : modifier l'objet via le paramètre à l'intérieur de la fonction modifie l'objet original. C'est un concept plus avancé, mais bon à savoir.

La portée (scope) d'une variable détermine où elle peut être accédée et modifiée dans ton programme.

Key Concepts:

• Variables locales : Une variable définie à l'intérieur d'une fonction est une variable locale. Elle n'est accessible que depuis l'intérieur de cette fonction. Elle est créée lorsque la fonction est appelée et détruite lorsque la fonction se termine.

  def ma_fonction():
      x = 10 # x est une variable locale à ma_fonction
      print(x)
  
  ma_fonction() # Affiche 10
  # print(x) # Erreur : NameError, x n'est pas défini en dehors de la fonction
  

• Variables globales : Une variable définie en dehors de toute fonction (au niveau principal du script) est une variable globale. Elle peut être lue depuis n'importe où dans le script, y compris à l'intérieur des fonctions.

  y = 20 # y est une variable globale
  
  def autre_fonction():
      print(y) # Peut accéder à y
  
  autre_fonction() # Affiche 20
  print(y) # Affiche 20
  

  Attention : pour modifier une variable globale depuis l'intérieur d'une fonction, il faut utiliser le mot-clé global. C'est une pratique à utiliser avec parcimonie pour éviter de rendre le code difficile à suivre.

  compteur_global = 0
  
  def incrementer():
      global compteur_global # Indique que nous voulons modifier la variable globale
      compteur_global += 1
  
  incrementer()
  incrementer()
  print(compteur_global) # Affiche 2
  

• Impact sur le comportement : Comprendre la portée est essentiel pour éviter des erreurs et pour écrire du code prévisible. Les variables locales sont préférables car elles évitent les effets de bord inattendus.
• Bonnes pratiques : Privilégie l'utilisation de paramètres pour passer des données aux fonctions et de return pour renvoyer des résultats, plutôt que de manipuler des variables globales. Cela rend les fonctions plus indépendantes et plus faciles à tester.

La modularité consiste à diviser un programme en fichiers plus petits et plus gérables, appelés modules.

Key Concepts:

• Découpage en modules : Plutôt que de tout mettre dans un seul fichier, on regroupe les fonctions liées dans des fichiers .py séparés. Chaque fichier .py est un module.
  • Ex: calculs.py pourrait contenir des fonctions d'addition, soustraction, etc.
  • Ex: affichage.py pourrait contenir des fonctions pour afficher des messages formatés.
• Importation de modules : Pour utiliser les fonctions ou variables définies dans un autre module, tu dois l'importer.

  # Dans ton fichier principal (ex: main.py)
  # Imaginons que 'calculs.py' contient une fonction 'additionner(a, b)'
  
  import calculs # Importe tout le module
  
  resultat = calculs.additionner(10, 5)
  print(resultat)
  
  from calculs import additionner # Importe seulement une fonction spécifique
  
  resultat2 = additionner(20, 2)
  print(resultat2)
  

• Utilisation de bibliothèques standards (math, random) : Python est fourni avec une vaste bibliothèque standard de modules qui offrent de nombreuses fonctionnalités prêtes à l'emploi.
  • math : Fonctions mathématiques (racine carrée, trigonométrie, etc.).

    import math
    print(math.sqrt(25)) # Affiche 5.0
    print(math.pi)       # Affiche la valeur de pi
    

  • random : Génération de nombres aléatoires.

    import random
    print(random.randint(1, 10)) # Génère un entier aléatoire entre 1 et 10 inclus
    

• Organisation du code : La modularité est essentielle pour les projets de grande envergure. Elle facilite la maintenance, le débogage et le travail en équipe.

Une liste est une collection ordonnée et modifiable d'éléments. C'est l'une des structures de données les plus utilisées en Python.

Key Concepts:

• Définition d'une liste : Une liste est créée en plaçant tous les éléments (séparés par des virgules) entre crochets []. Une liste peut contenir des éléments de différents types.

  ma_liste = [1, 2, 3, "quatre", True, 5.0]
  fruits = ["pomme", "banane", "cerise"]
  nombres = [10, 20, 30, 40]
  

• Accès aux éléments (indices) : Chaque élément d'une liste a un indice (un numéro de position) qui commence à 0 pour le premier élément.

  print(fruits[0]) # Affiche "pomme"
  print(fruits[2]) # Affiche "cerise"
  print(fruits[-1]) # Accès au dernier élément : "cerise"
  

  Tu peux aussi accéder à des sous-parties de la liste (tranches ou "slices") :

  print(nombres[1:3]) # Affiche [20, 30] (du 2ème élément jusqu'à l'élément avant l'indice 3)
  print(nombres[:2])  # Affiche [10, 20] (du début jusqu'à l'élément avant l'indice 2)
  print(nombres[2:])  # Affiche [30, 40] (de l'indice 2 jusqu'à la fin)
  

• Opérations (ajout, suppression, modification) : Les listes sont mutables, ce qui signifie que tu peux les modifier après leur création.
  • Modification :

    fruits[1] = "orange" # Remplace "banane" par "orange"
    print(fruits) # Affiche ["pomme", "orange", "cerise"]
    

  • Ajout :
    • append() : Ajoute un élément à la fin de la liste.

      fruits.append("mangue") # Ajoute "mangue" à la fin
      

    • insert(indice, element) : Insère un élément à un indice spécifique.

      fruits.insert(1, "kiwi") # Insère "kiwi" à l'indice 1
      

  • Suppression :
    • del liste[indice] : Supprime l'élément à un indice donné.

      del fruits[0] # Supprime "pomme"
      

    • remove(element) : Supprime la première occurrence d'une valeur spécifique.

      fruits.remove("orange") # Supprime "orange"
      

    • pop(indice) : Supprime l'élément à un indice et le renvoie (utile si tu veux récupérer l'élément supprimé). Si aucun indice n'est spécifié, supprime et renvoie le dernier élément.

      dernier_fruit = fruits.pop()
      

• Parcours de liste : Tu peux parcourir tous les éléments d'une liste avec une boucle for.

  for fruit in fruits:
      print(fruit)
  
  # Si tu as besoin de l'indice et de l'élément :
  for index, fruit in enumerate(fruits):
      print(f"L'élément à l'indice {index} est {fruit}")
  

Un tuple est une collection ordonnée et immuable d'éléments. Une fois créé, un tuple ne peut plus être modifié.

Key Concepts:

• Définition d'un tuple : Créé en plaçant les éléments (séparés par des virgules) entre parenthèses ().

  mon_tuple = (1, 2, "trois", False)
  coordonnees = (10.5, 20.3)
  

  Un tuple d'un seul élément doit avoir une virgule : (42,).
• Différences avec les listes :
  • Mutabilité : La différence principale. Les listes sont modifiables, les tuples ne le sont pas.
  • Syntaxe : Crochets [] pour les listes, parenthèses () pour les tuples.
• Cas d'utilisation :
  • Quand tu as besoin d'une collection d'éléments qui ne doit pas changer (par exemple, des coordonnées géographiques, des dates).
  • Pour retourner plusieurs valeurs d'une fonction (Python les renvoie sous forme de tuple).
  • Quand tu veux utiliser la collection comme une clé dans un dictionnaire (les listes ne peuvent pas être des clés car elles sont mutables).
• Immuabilité : Tu ne peux pas ajouter, supprimer ou modifier des éléments d'un tuple. Tenter de le faire entraînera une erreur.

  # coordonnees[0] = 15.0 # Erreur : TypeError: 'tuple' object does not support item assignment
  

  Tu peux cependant accéder aux éléments d'un tuple de la même manière qu'une liste (par indice ou tranche).

Une chaîne de caractères (str) est une séquence ordonnée de caractères. Comme les tuples, les chaînes sont immuables en Python.

Key Concepts:

• Définition d'une chaîne : Délimitée par des guillemets simples ('), doubles (") ou triples (''' ou """) pour les chaînes multilignes.

  message = "Bonjour le monde !"
  prenom = 'Alice'
  citation = """Ceci est une
  citation sur
  plusieurs lignes."""
  

• Opérations (concaténation, découpage) :
  • Concaténation (+) : Joindre deux chaînes.

    salutation = "Salut" + " " + prenom # "Salut Alice"
    

  • Répétition (*) : Répéter une chaîne plusieurs fois.

    etoiles = "*" * 5 # "*****"
    

  • Découpage (slicing) : Similaire aux listes et tuples, pour extraire une sous-chaîne.

    print(message[0])   # 'B'
    print(message[0:7]) # 'Bonjour'
    print(message[8:])  # 'le monde !'
    

• Méthodes de chaînes : Les chaînes ont de nombreuses méthodes intégrées pour les manipuler.
  • len(chaine) : Renvoie la longueur de la chaîne.
  • chaine.upper() : Renvoie la chaîne en majuscules.
  • chaine.lower() : Renvoie la chaîne en minuscules.
  • chaine.strip() : Supprime les espaces blancs au début et à la fin.
  • chaine.replace(old, new) : Remplace toutes les occurrences d'une sous-chaîne par une autre.
  • chaine.split(separateur) : Divise la chaîne en une liste de sous-chaînes en utilisant un séparateur.
  • separateur.join(liste_de_chaines) : Joint les éléments d'une liste en une seule chaîne.
• Immuabilité des chaînes : Tu ne peux pas modifier un caractère individuel dans une chaîne.

  # message[0] = 'b' # Erreur : TypeError: 'str' object does not support item assignment
  

  Pour "modifier" une chaîne, tu dois en créer une nouvelle à partir de l'ancienne.

  nouveau_message = "b" + message[1:] # Crée "bonjour le monde !"
  

Un dictionnaire est une collection non ordonnée et modifiable d'éléments, stockés sous forme de paires clé-valeur. C'est comme un annuaire téléphonique où chaque nom (clé) est associé à un numéro (valeur).

Key Concepts:

• Définition d'un dictionnaire : Créé en plaçant les paires clé-valeur (séparées par : ) entre accolades {}. Les clés doivent être uniques et immuables (nombres, chaînes, tuples). Les valeurs peuvent être de n'importe quel type.

  personne = {
      "nom": "Dupont",
      "prenom": "Jean",
      "age": 30,
      "ville": "Paris"
  }
  notes = {"Maths": 15, "Physique": 12, "Anglais": 18}
  

• Accès et modification :
  • Accès : Utilise la clé entre crochets pour accéder à la valeur associée.

    print(personne["nom"])   # Affiche "Dupont"
    print(notes["Physique"]) # Affiche 12
    

    Si la clé n'existe pas, cela provoque une erreur (KeyError). Tu peux utiliser dictionnaire.get(cle, valeur_par_defaut) pour éviter l'erreur et obtenir une valeur par défaut si la clé est absente.

    print(personne.get("profession", "Non spécifié")) # Affiche "Non spécifié"
    

  • Modification :

    personne["age"] = 31 # Modifie la valeur associée à la clé "age"
    print(personne)
    

  • Ajout : Si la clé n'existe pas, elle est ajoutée avec sa valeur.

    personne["profession"] = "Ingénieur"
    print(personne)
    

  • Suppression :
    • del dictionnaire[cle] : Supprime la paire clé-valeur.

      del personne["ville"]
      

    • dictionnaire.pop(cle) : Supprime la paire clé-valeur et renvoie la valeur.

      age_supprime = personne.pop("age")
      

• Cas d'utilisation :
  • Quand tu as besoin de stocker des données qui ont une relation clé-valeur (par exemple, les propriétés d'un objet, un registre de mots).
  • Pour une recherche rapide de valeurs (les dictionnaires sont très efficaces pour cela).
  • Représenter des données structurées, comme des objets JSON.