Révision et approfondissement du langage Python

La différence principale réside dans la mutabilité :

1. Liste [ ] : Elle est mutable, ce qui signifie qu'on peut modifier, ajouter ou supprimer ses éléments après sa création (ex: L.append(5)).
2. Tuple ( ) : Il est immutable. Une fois créé, on ne peut plus changer son contenu. Il est plus rapide et protège les données contre les modifications accidentelles.

💡 À retenir : Utilisez une liste pour des collections de données homogènes qui évoluent, et un tuple pour des constantes ou des structures fixes.

Pour extraire les éléments aux indices pairs d'une liste L, on utilise le slicing avec un pas de 2 :

1. La syntaxe est L[début:fin:pas].
2. En laissant début et fin vides, on parcourt toute la liste.
3. Le code est : L[::2].

💡 À retenir : Le troisième paramètre du slicing définit le "pas" de progression.

La récursivité est une technique où une fonction s'appelle elle-même pour résoudre un problème. Pour qu'elle ne tourne pas à l'infini, elle doit impérativement avoir :

1. Un cas de base : Une condition simple où la fonction renvoie une valeur sans s'appeler (ex: $n=0$).
2. Une progression : Chaque appel doit rapprocher l'argument du cas de base.

💡 À retenir : Sans cas de base, Python génère une erreur RecursionError: maximum recursion depth exceeded.

1. == compare les valeurs des objets (le contenu).
2. is compare l'identité des objets (l'adresse mémoire). Exemple : L1 = [1, 2] et L2 = [1, 2]. Ici L1 == L2 est True, mais L1 is L2 est False car ce sont deux objets différents en mémoire.

💡 À retenir : Utilisez == pour vérifier l'égalité des données.

C'est une syntaxe compacte pour créer une liste à partir d'un itérable. Structure : [ <expression> for <item> in <iterable> if <condition> ]. Exemple : [x**2 for x in range(10) if x % 2 == 0] crée la liste des carrés des nombres pairs inférieurs à 10.

💡 À retenir : Elle remplace avantageusement une boucle for et un append() pour la lisibilité.

Un dictionnaire est une collection de paires clé: valeur. Contrairement aux listes, l'accès se fait par la clé et non par l'indice. Exemple : d = {"nom": "Ahmed", "age": 20}. Pour obtenir l'âge : d["age"].

💡 À retenir : Les clés doivent être uniques et de type immutable (str, int, tuple).

1. append(x) ajoute l'objet x tel quel à la fin de la liste. Si x est une liste, on aura une liste dans une liste.
2. extend(x) prend chaque élément de l'itérable x et les ajoute un par un à la fin.

💡 À retenir : append augmente la taille de 1, extend augmente la taille de len(x).

On place le code "risqué" dans le bloc try. Si une erreur survient, le programme ne s'arrête pas et exécute le bloc except.

try:
    res = 10 / x
except ZeroDivisionError:
    res = 0

💡 À retenir : Cela permet de rendre le programme robuste face aux entrées imprévues.

1. Locale : Créée à l'intérieur d'une fonction. Elle est détruite dès que la fonction se termine.
2. Globale : Créée dans le corps principal du script. Elle est accessible partout. Pour modifier une variable globale dans une fonction, il faut utiliser le mot-clé global.

💡 À retenir : Il est recommandé de limiter l'usage des variables globales pour éviter les bugs.

zip() permet de parcourir plusieurs itérables (listes, tuples) en même temps, en associant leurs éléments par position. Exemple : zip([1, 2], ['a', 'b']) produit (1, 'a') puis (2, 'b').

💡 À retenir : Très utile dans les boucles for x, y in zip(L1, L2):.

La méthode la plus propre est d'utiliser le gestionnaire de contexte with :

with open("data.txt", "r") as f:
    for ligne in f:
        print(ligne.strip())

strip() enlève le caractère de saut de ligne \n.

💡 À retenir : with ferme automatiquement le fichier, même en cas d'erreur.

1. Liste : L'accès par indice $L[i]$ est en $O(1)$. La recherche d'une valeur est en $O(n)$.
2. Dictionnaire : L'accès par clé est en moyenne en $O(1)$ grâce au hachage.

💡 À retenir : Les dictionnaires sont extrêmement performants pour la recherche de données liées à une clé.