Langages et paradigmes de programmation

Un langage de programmation est un système de communication structuré qui permet à un humain de donner des instructions à une machine, généralement un ordinateur. Imaginez que vous voulez expliquer à quelqu'un comment faire un gâteau : vous utilisez des mots, des phrases, et un ordre précis. Pour un ordinateur, c'est la même chose, mais les "mots" et les "phrases" sont des instructions spécifiques que seule la machine peut comprendre.

Key Concepts:

• Définition d'un langage : C'est un ensemble de règles et de symboles utilisés pour écrire des programmes informatiques. Ces programmes sont ensuite exécutés par l'ordinateur pour réaliser des tâches spécifiques.
• Communication avec la machine : Les langages de programmation servent de pont entre la pensée humaine (ce que l'on veut faire) et l'exécution par la machine (comment elle doit le faire). Sans eux, il serait impossible de donner des ordres complexes à un ordinateur.
• Syntaxe et sémantique :
  • La syntaxe est l'ensemble des règles qui définissent la structure correcte d'un programme. C'est comme la grammaire d'une langue : elle vous dit comment arranger les mots pour former des phrases valides. Par exemple, en Python, print("Bonjour") est syntaxiquement correct, mais Print "Bonjour" ne l'est pas.
  • La sémantique est le sens des instructions. Même si une instruction est syntaxiquement correcte, elle peut ne pas avoir de sens ou ne pas faire ce que l'on attend. Par exemple, x = 1 / 0 est syntaxiquement correct, mais sémantiquement, cela conduit à une erreur car la division par zéro est impossible. Un programme doit être à la fois syntaxiquement correct et sémantiquement cohérent pour fonctionner comme prévu.

L'histoire des langages de programmation est une évolution constante, allant de la manipulation directe des composants de la machine à des abstractions de plus en plus élevées pour faciliter le travail des développeurs.

Key Concepts:

• Langages de bas niveau (machine, assembleur) :
  • Langage machine : C'est le niveau le plus bas, composé de suites de 0 et de 1 (code binaire) que le processeur de l'ordinateur peut exécuter directement. Chaque instruction correspond à une opération élémentaire du processeur. Programmer directement en langage machine est extrêmement fastidieux et source d'erreurs.
  • Langage assembleur : Une légère amélioration du langage machine. Il remplace les séquences de 0 et 1 par des mnémoniques (des codes courts et faciles à retenir) pour les instructions (ex: ADD pour additionner, MOV pour déplacer). Un programme appelé "assembleur" traduit ensuite ce code en langage machine. Bien que plus lisible, il reste très proche de l'architecture matérielle et est réservé à des tâches spécifiques (pilotes de périphériques, systèmes embarqués).
• Langages de haut niveau : Ces langages sont conçus pour être plus compréhensibles par les humains. Ils utilisent des mots clés proches du langage naturel (anglais) et des structures logiques. Un seul énoncé dans un langage de haut niveau peut correspondre à des dizaines, voire des centaines, d'instructions en langage machine. Ils permettent de développer plus rapidement et avec moins d'erreurs.
• Générations de langages :
  • 1ère génération : Langage machine.
  • 2ème génération : Langage assembleur.
  • 3ème génération : Premiers langages de haut niveau comme FORTRAN, COBOL, LISP, C, Pascal. Ils sont orientés vers la résolution de problèmes spécifiques ou la logique.
  • 4ème génération : Langages encore plus proches du langage humain, souvent utilisés pour des requêtes de bases de données (SQL) ou des générateurs d'applications. Ils sont conçus pour des tâches très spécifiques.
  • 5ème génération : Langages basés sur la logique et l'intelligence artificielle (Prolog, LISP, Python). Ils visent à permettre à l'ordinateur de résoudre des problèmes à partir de contraintes données, sans spécifier explicitement chaque étape.

Les langages de programmation peuvent être classés selon plusieurs critères, chacun ayant des implications sur la manière dont le code est écrit, exécuté et géré.

Key Concepts:

• Langages compilés vs interprétés :
  • Langages compilés : Avant d'être exécuté, le code source (écrit par le programmeur) est entièrement traduit par un programme appelé compilateur en un fichier exécutable (souvent en langage machine). Ce fichier peut ensuite être exécuté directement par l'ordinateur, sans avoir besoin du code source original ni du compilateur.
    • Avantages : Généralement plus rapides à l'exécution car la traduction est faite une seule fois, et le code machine est optimisé. Le code source n'est pas nécessaire pour l'exécution.
    • Inconvénients : Le processus de compilation peut prendre du temps. Chaque modification du code source nécessite une nouvelle compilation. Moins portables (un exécutable compilé pour Windows ne fonctionnera pas sur macOS sans recompilation).
    • Exemples : C, C++, Java (Java est un cas hybride : le code est compilé en bytecode qui est ensuite interprété par une machine virtuelle), Go.
  • Langages interprétés : Le code source est lu et exécuté ligne par ligne par un programme appelé interprète. Il n'y a pas de phase de compilation préalable en un exécutable autonome.
    • Avantages : Plus flexibles et rapides à développer (on peut tester le code immédiatement après modification). Plus portables (le même code source peut fonctionner sur différentes plateformes si un interprète est disponible).
    • Inconvénients : Généralement plus lents à l'exécution car chaque ligne doit être traduite à chaque fois qu'elle est exécutée. L'interprète et le code source sont nécessaires pour l'exécution.
    • Exemples : Python, JavaScript, Ruby, PHP.
• Langages statiquement vs dynamiquement typés : Ces termes décrivent comment les types de données (entier, chaîne de caractères, etc.) sont gérés.
  • Langages statiquement typés : Le type de chaque variable doit être connu et déclaré au moment de la compilation (ou de l'écriture du code). Le compilateur vérifie la cohérence des types avant l'exécution. Une erreur de type arrêtera la compilation.
    • Avantages : Détection précoce des erreurs (avant l'exécution), amélioration des performances (le compilateur sait à l'avance comment gérer les données), meilleure lisibilité et maintenance du code pour les grands projets.
    • Exemples : C, C++, Java, C#.
  • Langages dynamiquement typés : Le type d'une variable n'est pas déclaré explicitement et peut changer pendant l'exécution du programme. L'interprète détermine le type de la variable au moment de l'exécution.
    • Avantages : Plus de flexibilité et rapidité de développement, code souvent plus concis.
    • Inconvénients : Les erreurs de type ne sont détectées qu'à l'exécution (runtime errors), ce qui peut rendre le débogage plus difficile pour les grands projets.
    • Exemples : Python, JavaScript, Ruby, PHP.
• Exemples concrets :
  • Python : Langage interprété et dynamiquement typé. Très populaire pour sa simplicité et sa polyvalence (développement web, IA, science des données, scripts).
  • C : Langage compilé et statiquement typé. Très utilisé pour les systèmes d'exploitation, les pilotes et les applications nécessitant de hautes performances.
  • Java : Langage compilé en bytecode, puis interprété par une machine virtuelle (JVM), et statiquement typé. Très répandu pour les applications d'entreprise, Android et les systèmes distribués.

Un paradigme de programmation est une approche fondamentale ou un style de programmation. C'est une manière de conceptualiser et d'organiser la structure d'un programme pour résoudre un problème donné. Pensez-y comme différentes philosophies ou boîtes à outils pour construire un logiciel.

Key Concepts:

• Qu'est-ce qu'un paradigme ? : C'est un ensemble de principes, de concepts et de techniques qui guident la manière dont un programmeur pense à la solution d'un problème et l'implémente. Chaque paradigme propose une vision particulière de ce qu'est un programme et comment il devrait être construit.
• Approches de résolution de problèmes : Selon le problème à résoudre, certains paradigmes sont plus adaptés que d'autres. Par exemple, pour des problèmes de modélisation du monde réel, l'orienté objet peut être très efficace. Pour des calculs intensifs sans état, le fonctionnel peut briller.
• Influence sur la conception du code : Le choix d'un paradigme influence profondément la structure du code, la manière dont les données sont manipulées, la gestion des erreurs, et la réutilisation des composants. Il dicte les "bonnes pratiques" à suivre pour ce style de programmation.

Le paradigme impératif est l'un des plus anciens et des plus courants. Il décrit comment un programme doit procéder, étape par étape, pour modifier l'état d'un programme.

Key Concepts:

• Séquence d'instructions : Un programme impératif est une liste d'instructions exécutées séquentiellement par l'ordinateur. Chaque instruction modifie l'état du programme. C'est comme une recette de cuisine où chaque étape est une instruction.
• Modification d'état : L'état d'un programme est l'ensemble des valeurs de toutes ses variables à un instant donné. Les instructions modifient ces valeurs au fur et à mesure de l'exécution.
  • Exemple : x = 5 (l'état de x devient 5), puis x = x + 1 (l'état de x devient 6).
• Variables et affectations : Les variables sont des emplacements nommés en mémoire qui stockent des données. L'affectation est l'opération qui consiste à donner une valeur à une variable.
  • Exemple en Python :

    compteur = 0       # Affectation initiale
    compteur = compteur + 1 # Modification de la valeur de la variable
    print(compteur)    # Affiche 1
    

  • Le paradigme impératif est très intuitif car il correspond à la manière dont nous pensons souvent à la résolution de problèmes : une suite d'actions.

Le paradigme fonctionnel traite le calcul comme l'évaluation de fonctions mathématiques. Il met l'accent sur la déclaration de ce qui doit être fait plutôt que de décrire comment le faire étape par étape.

Key Concepts:

• Fonctions pures : Une fonction pure est une fonction qui, pour les mêmes arguments d'entrée, renvoie toujours le même résultat de sortie, et n'a aucun "effet de bord". Un effet de bord est toute modification de l'état du programme en dehors de la fonction elle-même (ex: modifier une variable globale, imprimer à l'écran, écrire dans un fichier).
  • Exemple (conceptuel) : somme(a, b) renvoie toujours a + b et ne modifie rien d'autre.
• Immuabilité : Dans la programmation fonctionnelle, les données sont souvent immuables, ce qui signifie qu'une fois créées, elles ne peuvent pas être modifiées. Au lieu de modifier une variable, on crée une nouvelle variable avec la nouvelle valeur.
  • Exemple : Au lieu de liste.append(element), on dirait plutôt nouvelle_liste = liste + [element].
• Éviter les effets de bord : C'est un principe fondamental. En évitant les effets de bord, les programmes deviennent plus faciles à raisonner, à tester et à paralléliser. Chaque fonction est une unité indépendante.
  • Le paradigme fonctionnel est très apprécié pour sa capacité à créer du code plus robuste, sans effets inattendus, et souvent plus facile à comprendre localement.

Le paradigme orienté objet (POO) organise le code autour d'objets, qui sont des entités combinant des données (attributs) et des fonctions (méthodes) qui opèrent sur ces données. Il vise à modéliser des concepts du monde réel.

Key Concepts:

• Objets et classes :
  • Une classe est un plan ou un moule pour créer des objets. Elle définit la structure (quels attributs possède l'objet) et le comportement (quelles actions l'objet peut effectuer).
  • Un objet est une instance concrète d'une classe. Par exemple, "voiture" est une classe, et "ma voiture rouge" est un objet de type voiture.
  • Exemple en Python :

    class Voiture: # La classe
        def __init__(self, couleur, marque):
            self.couleur = couleur # Attribut
            self.marque = marque   # Attribut
    
        def klaxonner(self): # Méthode
            print(f"La {self.marque} {self.couleur} klaxonne !")
    
    ma_voiture = Voiture("rouge", "Renault") # Un objet
    ta_voiture = Voiture("bleue", "Peugeot") # Un autre objet
    

• Encapsulation : C'est le principe de regrouper les données (attributs) et les méthodes qui les manipulent au sein d'une même unité (l'objet/la classe). L'encapsulation permet de cacher les détails internes de l'objet et de n'exposer qu'une interface contrôlée. Cela protège les données contre les modifications inattendues de l'extérieur.
• Héritage et polymorphisme (notions) :
  • Héritage : Permet à une nouvelle classe (classe fille ou sous-classe) d'acquérir les attributs et les méthodes d'une classe existante (classe mère ou super-classe). Cela favorise la réutilisation du code et la création de hiérarchies de classes.
    • Exemple : Une classe VoitureSport pourrait hériter de Voiture, ajoutant des attributs spécifiques comme vitesse_max.
  • Polymorphisme : Signifie "plusieurs formes". Il permet à des objets de classes différentes de répondre de manière différente à la même méthode. Par exemple, si Voiture et Moto ont toutes deux une méthode demarrer(), l'implémentation de demarrer() sera différente pour chaque type de véhicule.
  • La POO est très puissante pour modéliser des systèmes complexes et pour la réutilisation de code à travers l'héritage.

Les variables sont les briques fondamentales de tout programme impératif. Elles nous permettent de stocker et de manipuler des informations.

Key Concepts:

• Déclaration et affectation :
  • En Python, la déclaration d'une variable se fait implicitement lors de sa première affectation. L'affectation consiste à donner une valeur à une variable en utilisant l'opérateur =.
  • Exemple :

    age = 30         # Déclare 'age' et lui affecte la valeur 30 (entier)
    nom = "Alice"    # Déclare 'nom' et lui affecte "Alice" (chaîne de caractères)
    est_actif = True # Déclare 'est_actif' et lui affecte True (booléen)
    

• Types numériques (entiers, flottants) :
  • Entiers (int) : Nombres entiers, positifs ou négatifs, sans partie décimale.
    • Exemples : 5, -10, 0, 1000000
  • Flottants (float) : Nombres à virgule (ou à point décimal en informatique), utilisés pour représenter des nombres réels.
    • Exemples : 3.14, -0.5, 2.0, 6.022e23 (notation scientifique)
• Types textuels (chaînes de caractères) :
  • Chaînes de caractères (str) : Séquences de caractères (lettres, chiffres, symboles) entourées de guillemets simples ('...') ou doubles ("...").
    • Exemples : "Bonjour le monde", 'Python', "123" (ceci est une chaîne, pas un nombre)
• Booléens (bool) : Représentent une valeur de vérité, qui peut être soit True (vrai) soit False (faux). Ils sont fondamentaux pour les décisions logiques dans les programmes.
  • Exemples : True, False
  • Comprendre les types de données est crucial car ils déterminent quelles opérations peuvent être effectuées sur une variable.

Les opérateurs sont des symboles qui réalisent des opérations sur une ou plusieurs valeurs (appelées opérandes) pour produire un nouveau résultat. Une expression est une combinaison d'opérandes et d'opérateurs qui produit une valeur.

Key Concepts:

• Opérateurs arithmétiques : Utilisés pour des 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.0, toujours un flottant en Python 3)
  • // : Division entière (ex: 15 // 4 donne 3, le quotient sans la partie décimale)
  • % : Modulo (reste de la division entière) (ex: 15 % 4 donne 3)
  • ** : Exposant (puissance) (ex: 2 ** 3 donne 8 pour $2^3$)
• Opérateurs de comparaison : Utilisés pour comparer deux valeurs et renvoyer un booléen (True ou False).
  • == : Égal à (attention, ne pas confondre avec =) (ex: 5 <mark> 5 donne True, 5 </mark> 6 donne False)
  • != : Différent de (ex: 5 != 6 donne True)
  • < : Inférieur à (ex: 3 < 5 donne True)
  • > : Supérieur à (ex: 7 > 4 donne True)
  • <= : Inférieur ou égal à (ex: 5 <= 5 donne True)
  • >= : Supérieur ou égal à (ex: 8 >= 7 donne True)
• Opérateurs logiques : Utilisés pour combiner ou inverser des expressions booléennes.
  • and : ET logique (renvoie True si les deux opérandes sont True)
    • Ex: (5 > 3) and (10 < 20) donne True
  • or : OU logique (renvoie True si au moins une des opérandes est True)
    • Ex: (5 < 3) or (10 < 20) donne True
  • not : NON logique (inverse la valeur booléenne de l'opérande)
    • Ex: not (5 > 3) donne False
  • La priorité des opérateurs est similaire à celle des mathématiques (parenthèses, puissances, multiplication/division, addition/soustraction, puis comparaisons et logiques). Utilisez des parenthèses pour clarifier l'ordre d'évaluation.

Les structures conditionnelles permettent à un programme d'exécuter différentes blocs de code en fonction de la véracité d'une condition.

Key Concepts:

• Instruction if : Exécute un bloc de code si une condition est True.

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

• Instruction if-else : Exécute un bloc de code si la condition est True, et un autre bloc si elle est False.

  temperature = 25
  if temperature > 30:
      print("Il fait très chaud !")
  else:
      print("La température est agréable.")
  

• Instructions elif (else if) : Permettent de tester plusieurs conditions successives. Le premier bloc dont la condition est True est exécuté, et les autres sont ignorés.

  note = 14
  if note >= 16:
      print("Très bien")
  elif note >= 12: # Si la première condition est fausse, on teste celle-ci
      print("Bien")
  elif note >= 10: # Si les deux premières sont fausses, on teste celle-ci
      print("Passable")
  else: # Si aucune des conditions précédentes n'est vraie
      print("Insuffisant")
  

  L'indentation (les espaces ou tabulations au début des lignes) est cruciale en Python pour définir les blocs de code.

Les structures itératives (boucles) permettent de répéter un bloc de code plusieurs fois.

Key Concepts:

• Boucle for : Utilisée pour itérer sur une séquence (liste, chaîne de caractères, tuple, etc.) ou pour répéter un bloc de code un nombre prédéfini de fois (souvent avec range()).
  • Itération sur une liste :

    fruits = ["pomme", "banane", "cerise"]
    for fruit in fruits:
        print(fruit)
    # Affiche:
    # pomme
    # banane
    # cerise
    

  • Itération un nombre de fois avec range() :

    for i in range(5): # i prendra les valeurs 0, 1, 2, 3, 4
        print(f"Tour numéro {i + 1}")
    # Affiche:
    # Tour numéro 1
    # Tour numéro 2
    # ...
    

• Boucle while : Répète un bloc de code tant qu'une condition spécifiée reste True. Il est crucial de s'assurer que la condition finira par devenir False pour éviter une boucle infinie.

  compteur = 0
  while compteur < 3:
      print(f"Le compteur est à {compteur}")
      compteur = compteur + 1 # Incrémentation pour éviter la boucle infinie
  # Affiche:
  # Le compteur est à 0
  # Le compteur est à 1
  # Le compteur est à 2
  

• Itération sur des séquences : Les boucles for sont idéales pour parcourir les éléments d'une collection ordonnée.
  • Chaîne de caractères :

    mot = "Python"
    for lettre in mot:
        print(lettre)
    

  • Les boucles sont essentielles pour automatiser des tâches répétitives et traiter des collections de données.

Les fonctions sont des blocs de code réutilisables qui effectuent une tâche spécifique. Elles sont fondamentales pour structurer les programmes et éviter la répétition.

Key Concepts:

• Rôle des fonctions :
  • Réutilisabilité : Écrire un code une seule fois et l'utiliser à plusieurs endroits.
  • Modularité : Diviser un grand problème en sous-problèmes plus petits et gérables.
  • Lisibilité : Rendre le code plus facile à comprendre en lui donnant des noms descriptifs.
  • Maintenance : Faciliter la correction des erreurs et les modifications.
• Syntaxe de définition : En Python, une fonction est définie avec le mot-clé def, suivi du nom de la fonction, de parenthèses (qui peuvent contenir des paramètres) et d'un double point :. Le corps de la fonction est indenté.

  def saluer(nom): # 'saluer' est le nom, 'nom' est un paramètre
      """Cette fonction salue une personne.""" # Docstring (documentation)
      message = f"Bonjour, {nom} !"
      return message # La fonction renvoie une valeur
  

• Passage d'arguments :
  • Lors de l'appel d'une fonction, les valeurs passées entre les parenthèses sont appelées arguments. Ces arguments sont assignés aux paramètres de la fonction.

  • resultat = saluer("Alice") # Appel de la fonction avec "Alice" comme argument
    print(resultat) # Affiche: Bonjour, Alice !
    
    print(saluer("Bob")) # Appel direct dans un print
    

  • Une fonction peut ne prendre aucun argument, ou plusieurs. Elle peut aussi ne rien retourner (elle exécute juste une action, comme print()). Dans ce cas, elle retourne implicitement None.
  • Les fonctions sont le pilier de la programmation structurée et modulaire.

Portée des variables (locale et globale)

La portée d'une variable détermine où elle peut être accédée et utilisée dans un programme.

Key Concepts:

• Variables locales : Une variable déclarée à l'intérieur d'une fonction est dite locale à cette fonction. Elle n'existe que pendant l'exécution de la fonction et ne peut pas être accédée de l'extérieur.

  def ma_fonction():
      x = 10 # x est une variable locale à ma_fonction
      print(x)
  
  ma_fonction() # Affiche 10
  

• Variables globales : Une variable déclarée en dehors de toute fonction (au niveau principal du script) est une variable globale. Elle peut être accédée et utilisée par toutes les fonctions du programme.

  y = 20 # y est une variable globale
  
  def autre_fonction():
      print(y) # Peut accéder à y
  
  autre_fonction() # Affiche 20
  
  def modifier_globale():
      global y
      y = 30 # Modifie la variable globale y
  
  print(y) # Affiche 20
  modifier_globale()
  print(y) # Affiche 30 (la variable globale a été modifiée)
  

• Effets de bord : Modifier une variable globale depuis l'intérieur d'une fonction est un effet de bord. Bien que parfois nécessaire, il est généralement préférable de les minimiser car ils peuvent rendre le code plus difficile à comprendre, à tester et à déboguer. Préférer passer des arguments et retourner des valeurs plutôt que de modifier des variables globales directement.

Modularité et réutilisation du code

La modularité est un principe de conception qui consiste à diviser un système en composants plus petits, indépendants et interchangeables, appelés modules.

Key Concepts:

• Découpage en fonctions : La manière la plus élémentaire d'introduire la modularité est de découper le programme en fonctions. Chaque fonction est responsable d'une tâche bien définie.
• Avantages de la modularité :
  • Facilité de compréhension : Le code est organisé en blocs logiques.
  • Maintenance aisée : Les changements dans un module n'affectent pas (ou peu) les autres.
  • Débogage simplifié : Il est plus facile d'isoler la source d'une erreur.
  • Travail d'équipe : Plusieurs développeurs peuvent travailler sur différents modules simultanément.
  • Réutilisabilité : Les fonctions ou modules peuvent être utilisés dans d'autres parties du programme ou dans d'autres projets.
• Bibliothèques et modules :
  • Un module en Python est simplement un fichier .py contenant du code Python (fonctions, classes, variables).
  • Une bibliothèque (ou package) est une collection de modules liés.
  • Les modules et bibliothèques permettent de réutiliser du code écrit par d'autres ou par soi-même dans différents projets.
  • Exemple : Le module math fournit des fonctions mathématiques, le module random pour générer des nombres aléatoires.

  import math # Importe le module math
  print(math.sqrt(16)) # Utilise la fonction racine carrée du module math
  
  from random import randint # Importe seulement la fonction randint du module random
  print(randint(1, 10)) # Génère un entier aléatoire entre 1 et 10
  

  L'utilisation de fonctions et de modules est une pratique fondamentale pour écrire du code propre, efficace et maintenable.

Représentation des données et structures

Les listes (tableaux)

Les listes sont des structures de données fondamentales en Python, utilisées pour stocker des collections ordonnées d'éléments. Elles sont mutables, ce qui signifie que leur contenu peut être modifié après leur création.

Key Concepts:

• Définition et manipulation : Une liste est définie en plaçant des éléments séparés par des virgules entre crochets [].

  ma_liste = [10, 20, 30, 40]
  noms = ["Alice", "Bob", "Charlie"]
  melange = [1, "deux", True, 3.14] # Une liste peut contenir des types différents
  

• Accès par index : Les éléments d'une liste sont ordonnés et peuvent être accédés individuellement via leur index. L'indexation commence à 0 pour le premier élément.

  print(noms[0]) # Affiche "Alice"
  print(noms[2]) # Affiche "Charlie"
  print(noms[-1]) # Affiche le dernier élément, "Charlie"
  

• Opérations courantes (ajout, suppression, modification) :
  • Modification :

    ma_liste[1] = 25 # Modifie l'élément à l'index 1
    print(ma_liste) # Affiche [10, 25, 30, 40]
    

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

      noms.append("David")
      print(noms) # Affiche ["Alice", "Bob", "Charlie", "David"]
      

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

      noms.insert(1, "Eve") # Insère "Eve" à l'index 1
      print(noms) # Affiche ["Alice", "Eve", "Bob", "Charlie", "David"]
      

  • Suppression :
    • del : Supprime un élément par son index.

      del noms[1] # Supprime "Eve"
      print(noms) # Affiche ["Alice", "Bob", "Charlie", "David"]
      

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

      noms.remove("Bob")
      print(noms) # Affiche ["Alice", "Charlie", "David"]
      

  • Autres opérations : len() (longueur), min(), max(), sum(), sort() (tri), count() (compter les occurrences).
  • Les listes sont extrêmement polyvalentes et sont utilisées pour stocker des collections de presque tout type de données.

Les tuples

Les tuples sont similaires aux listes, mais avec une différence cruciale : ils sont immuables. Une fois créés, leurs éléments ne peuvent pas être modifiés, ajoutés ou supprimés.

Key Concepts:

• Définition et immuabilité : Un tuple est défini en plaçant des éléments séparés par des virgules entre parenthèses ().

  mon_tuple = (1, 2, 3)
  coordonnees = (10.0, 20.0)
  

  • Tentative de modification :

• Utilisation : Les tuples sont souvent utilisés pour :
  • Représenter des collections d'éléments qui ne devraient pas changer (ex: coordonnées géographiques, dates).
  • Retourner plusieurs valeurs d'une fonction.
  • Clés de dictionnaire (car les clés doivent être immuables).
  • Définir des collections d'éléments hétérogènes (de types différents) où la position a un sens.
• Différences avec les listes :

  Caractéristique	Liste ([])	Tuple (())
  Mutabilité	Mutable (modifiable)	Immuable (non modifiable)
  Syntaxe	Crochets []	Parenthèses ()
  Performance	Légèrement plus lente	Légèrement plus rapide
  Utilisation	Collections dynamiques	Données fixes, enregistrements

  • Choisissez un tuple lorsque vous avez une collection d'éléments qui ne doit pas changer et que la position des éléments est significative.

Les dictionnaires (tables de hachage)

Les dictionnaires sont des collections non ordonnées de paires clé-valeur. Chaque clé est unique et est utilisée pour accéder à sa valeur associée. Ils sont très efficaces pour stocker des données structurées et les récupérer rapidement.

Key Concepts:

• Paires clé-valeur : Un dictionnaire est défini avec des accolades {}. Chaque élément est une paire clé: valeur.

  personne = {
      "nom": "Dupont",
      "prenom": "Jean",
      "age": 30,
      "ville": "Paris"
  }
  

  • Les clés doivent être des types immuables (chaînes de caractères, nombres, tuples).
  • Les valeurs peuvent être de n'importe quel type et peuvent être dupliquées.
• Accès par clé : On accède aux valeurs en utilisant les clés entre crochets.

  print(personne["nom"])   # Affiche "Dupont"
  print(personne["age"])   # Affiche 30
  

  • Ajout ou modification :

    personne["profession"] = "Ingénieur" # Ajoute une nouvelle paire
    personne["age"] = 31                  # Modifie la valeur de la clé "age"
    print(personne)
    

  • Suppression :

    del personne["ville"]
    print(personne)
    

• Utilisation pour des données structurées : Les dictionnaires sont parfaits pour représenter des objets ou des enregistrements où chaque propriété a un nom distinct.

  etudiants = {
      "eleve1": {"nom": "Martin", "note": 15},
      "eleve2": {"nom": "Durand", "note": 12}
  }
  print(etudiants["eleve1"]["note"]) # Affiche 15
  

  • Les dictionnaires sont incroyablement utiles pour organiser des données complexes et y accéder de manière sémantique.

Chaînes de caractères

Les chaînes de caractères (str) sont des séquences ordonnées de caractères. En Python, elles sont immuables, comme les tuples.

Key Concepts:

• Séquence de caractères : Une chaîne est une série de caractères (lettres, chiffres, symboles, espaces).

  message = "Bonjour le monde !"
  

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

    prenom = "Alice"
    nom = "Smith"
    nom_complet = prenom + " " + nom
    print(nom_complet) # Affiche "Alice Smith"
    

  • Répétition (*) : Répéter une chaîne un certain nombre de fois.

    print("Ha" * 3) # Affiche "HaHaHa"
    

  • Accès par index : Comme les listes, on peut accéder aux caractères par leur position (index).

    print(message[0]) # Affiche "B"
    print(message[7]) # Affiche "l"
    

  • Découpage (slicing) : Extraire une sous-chaîne. [début:fin:pas] (fin est exclusive).

    print(message[0:7])  # Affiche "Bonjour"
    print(message[8:])   # Affiche "le monde !" (du 8ème caractère jusqu'à la fin)
    print(message[:7])   # Affiche "Bonjour" (du début jusqu'au 7ème caractère)
    print(message[::2])  # Affiche "Bnorl on!" (tous les deux caractères)
    

• Méthodes de manipulation : Les chaînes de caractères ont de nombreuses méthodes intégrées pour les manipuler.
  • len() : Longueur de la chaîne.

    print(len(message)) # Affiche 18
    

  • upper(), lower() : Convertir en majuscules ou minuscules.

    print(message.upper()) # Affiche "BONJOUR LE MONDE !"
    

  • strip() : Supprimer les espaces blancs au début et à la fin.

    texte = "  Salut !  "
    print(texte.strip()) # Affiche "Salut !"
    

  • replace(old, new) : Remplacer des sous-chaînes.

    print(message.replace("monde", "Python")) # Affiche "Bonjour le Python !"
    

  • split() : Diviser une chaîne en une liste de sous-chaînes.

    mots = message.split(" ") # Sépare par les espaces
    print(mots) # Affiche ['Bonjour', 'le', 'monde', '!']
    

  • join() : Joindre une liste de chaînes en une seule.

    liste_mots = ['Python', 'est', 'génial']
    phrase = " ".join(liste_mots)
    print(phrase) # Affiche "Python est génial"
    

  • find(), count(), startswith(), endswith(), etc.
  • Les chaînes de caractères sont omniprésentes dans la programmation, notamment pour l'interaction avec l'utilisateur et la manipulation de textes.