Listes Python: Initialisation et Accès

Listes en Python

• Une liste est une structure de données mutable et ordonnée.

Initialisation d'une liste

• Initialiser une liste vide : I = list() ou I = [].
• Créer une liste avec des éléments : I = [1, 2, 3, 4].
• Créer une liste d'entiers avec range() : I = list(range(5)).
• Obtenir la longueur d'une liste : len(I).
• Créer une copie triée d'une liste : I_ = sorted(I).

Accéder et affecter des éléments d'une liste

• Accéder à un élément par son indice : print(I[0]) pour le premier, print(I[-1]) pour le dernier.
• Extraire une sous-liste : print(I[1:3]) (éléments d'indice 1 à 3, 3 exclus).
• Modifier un élément : I[0] = "a".
• L'indice commence à 0.
• Un indice négatif, comme -2, correspond à l'avant-dernier élément.

Itérer sur une liste

• Boucle for : for x in I:, où I est un ensemble itérable et x prend les valeurs des éléments de la liste.
• Utiliser enumerate() pour obtenir l'indice et la valeur : for (i, x) in enumerate(I):.

Opérations sur les listes

• Utiliser append(), extend(), remove(), etc.
• Tester l'appartenance d'un élément : if 5 in list(range(5)):.

Test d'appartenance

• L'opérateur in vérifie si un élément appartient à une structure de données (liste, tuple, dictionnaire, ensemble, chaîne de caractères).
• Exemple : if 5 in list(range(5)): teste si 5 est dans la liste [0, 1, 2, 3, 4].

Chaînes de caractères (strings)

• Ce sont des listes de caractères non modifiables.
• On ne peut pas utiliser append(), mais on peut créer une nouvelle chaîne.
• Initialisation : I = "abcde".
• Opérations : concaténation (+), itération.
• La méthode join() : s.join(I) retourne une chaîne formée des éléments de I séparés par s.
  • Exemple : "--".join(["a", "b", "c"]) renvoie "a--b--c".

Dictionnaires

• Les clés permettent de retrouver les valeurs.

Initialisation d'un dictionnaire

• d = dict() : dictionnaire vide.
• d = {} : dictionnaire vide.
• d = dict([("un", 1), ("deux", 2)]) : construit à partir d'une liste de couples clé, valeur.
• d = {"un": 1, "deux": 2}.

Accéder et affecter des dictionnaires

• L'accès est rapide via les clés : print(d["un"]).
• Ajouter une entrée : d["trois"] = 3.
• Supprimer une entrée : del d["trois"].

Itérer sur un dictionnaire

• Par défaut, l'itération se fait sur les clés : for k in d:.
• Ici, k représente chaque clé et non les valeurs.

Test d'appartenance (d'une clé)

• L'opérateur in renvoie vrai ou faux selon si la clé est présente.
• if 2 in {1: 2, 3: 4}: renvoie faux car 2 est une valeur, pas une clé.

F-strings

• Permettent d'inclure des expressions Python dans une chaîne.
• Préfixer la chaîne par f.
• Insérer des expressions entre accolades : {expression Python}.
• Les expressions sont évaluées, converties en str et insérées.
• Pour insérer une accolade littérale, doubler les accolades : {{ ou }}.
• Pour mettre une accolade autour d'une expression, utiliser trois accolades : {{{expression Python}}}.

Fonctions

• Les fonctions sont des variables ordinaires.
• Une variable peut contenir une fonction.
• f = math.cos assigne la fonction cos à la variable f.
• Les fonctions peuvent être passées en paramètre à d'autres fonctions.
• Définition :

  def valeur_en_zero(f):
      return f(0)
  

• Fonction lambda : fonction définie à la volée : lambda x: 2 * x.

Fonction MAP

• Prend une fonction et une liste en arguments.
• Applique la fonction à chaque élément de la liste.
• Retourne une nouvelle liste transformée.
• Exemple : I_ = list(map(lambda x: x ** 2, I)).

Fonction FILTER

• Prend une fonction booléenne et une liste en arguments.
• Retourne une liste des éléments pour lesquels la fonction renvoie True.

Fonction REDUCE

• Prend une fonction (à deux arguments) et une liste en arguments.
• Réduit la liste à une seule valeur en appliquant la fonction de manière cumulative.
• Exemple : R = reduce(lambda X, Y: X + Y, I).
• La fonction reduce est définie dans le module functools.

Listes en compréhension

• Notation simplifiée pour définir une liste à partir d'une autre liste en appliquant une fonction (map) et/ou un filtre (filter).
• Syntaxe : [expression(x) for x in I if condition(x)].

Dictionnaires en compréhension

• Peut également être utilisée pour les dictionnaires.
• Syntaxe : {expression1(x): expression2(x) for x in I}.