Informatique au lycée Faustin Fleret

# Création d'une liste par duplication
liste_de_zeros = [0] * 10
print(liste_de_zeros)

# Création d'une liste avec duplication d'éléments de types différents
liste_3_123 = [1, "toto", 3] * 3
print(liste_3_123)

# Création d'une liste vide
liste_vide = []
print("Une liste vide :", liste_vide)

# Création d'une liste de nombres de différents types
liste_nombres = [2, 10, 5 // 3, 7.2, 8, 2.0]
print("Ma liste :", liste_nombres)
print("Longueur de ma liste :", len(liste_nombres))  # Utilisation de la méthode len()

# Affichage des éléments de la liste pris un à un
print("Voici son contenu avec les éléments pris un à un :", end=' ')
for element in liste_nombres:
    print(element, end=', ')
print('\n')

# Parcours des éléments avec une boucle sur les indices
print('Parcours des éléments avec une boucle sur les indices :')
for i in range(len(liste_nombres)):
    print(liste_nombres[i], end=', ')
print('\n')

# Parcours des éléments avec une boucle sans les indices
print('Parcours des éléments avec une boucle sans les indices :')
for element in liste_nombres:
    print(element, end='; ')
print('\n')

# Parcours des éléments avec indices et éléments
print('Parcours des éléments avec indices et éléments :')
for indice, element in enumerate(liste_nombres):
    print("Le terme d'indice {} est {}.".format(indice, element))

# Exemple Python
planetes = ['Mercure', 'Vénus', 'Terre', 'Mars', 'Jupiter', 'Saturne', 'Uranus', 'Neptune']

# Accéder à un élément en utilisant l'index négatif
element_negatif = planetes[-6]
print(f"L'élément à l'index -6 est : {element_negatif}")

Concaténer les listes

Pour concaténer deux listes en Python, la méthode la plus simple est d'utiliser l'opérateur +. Cela permet de combiner les éléments de deux listes en une seule.

Supposons que nous ayons deux listes, une pour les planètes telluriques et une pour les planètes gazeuses :

tellurique = ["Mercure", "Vénus", "Terre", "Mars"]
gazeuse = ["Jupiter", "Saturne", "Uranus", "Neptune"]

La concaténation de ces deux listes se fait simplement en utilisant l'opérateur + :

planetes = tellurique + gazeuse
print(planetes)
# ['Mercure', 'Vénus', 'Terre', 'Mars', 'Jupiter', 'Saturne', 'Uranus', 'Neptune']

Le résultat est une nouvelle liste appelée planetes qui contient tous les éléments des listes tellurique et gazeuse.

Il est important de noter que cette opération ne modifie pas les listes d'origine, mais crée une nouvelle liste contenant les éléments des deux listes concaténées.

Modification des éléments dans une liste

Les éléments d'une liste sont mutables (modifiables), ce qui constitue une différence fondamentale avec une autre structure, les tuples, que nous verrons ultérieurement.

planetes.append("Pluton")
print(planetes)
# ['mercure', 'Vénus', 'Terre', 'Mars', 'Jupiter', 'Saturne', 'Uranus', 'Neptune', 'Pluton']

La méthode append() permet d'ajouter un élément à la fin de la liste.

planetes[2] = "La planète Bleue"  # Pour modifier le 3ème élément de la liste
print(planetes)
# ['mercure', 'Vénus', 'La planète Bleue', 'Mars', 'Jupiter', 'Saturne', 'Uranus', 'Neptune', 'Pluton']

La méthode remove() supprime le premier élément de la liste correspondant à l'élément passé en argument. Cela peut poser problème s'il y en a plusieurs occurrences.

planetes.remove("Pluton")
print(planetes)
# ['mercure', 'Vénus', 'La planète Bleue', 'Mars', 'Jupiter', 'Saturne', 'Uranus', 'Neptune']

liste = [2, 10, 5 // 3, 7.2, 8, 2.0]
liste.remove(2.0)
print(liste)
# [10, 1, 7.2, 8, 2.0] # Seul le premier 2 est supprimé !

Copier une liste

Pour créer une copie indépendante d'une liste, il est préférable d'utiliser la méthode copy(). L'utilisation du simple signe d'égalité (=) ne garantit pas une copie distincte.

liste_originale = [5, 10, 15]
copie_liste = liste_originale.copy()

# Modifions la liste originale
liste_originale[0] = 2

# Affichons les deux listes pour comprendre la différence
print("Liste originale :", liste_originale)
print("Copie de la liste :", copie_liste)
# Liste originale : [2, 10, 15]
# Copie de la liste : [5, 10, 15]

Ici, nous avons une liste appelée liste_originale, puis nous utilisons la méthode copy() pour créer une copie appelée copie_liste. En modifiant un élément dans la liste originale, nous pouvons voir que la copie reste inchangée, ce qui démontre l'indépendance des deux listes.

Liste par compréhension

La liste par compréhension est une manière concise et élégante de créer des listes en Python. Elle permet de générer une liste en utilisant une expression pour définir ses éléments, souvent combinée avec une boucle.

matiere = "Numérique"
tableau = [lettre for lettre in matiere]
print("Liste des lettres dans la matière :", tableau)
# Liste des lettres dans la matière : ['N', 'u', 'm', 'é', 'r', 'i', 'q', 'u', 'e']

carres_pairs = [k**2 for k in range(10) if k**2 % 2 == 0]  # 'if' permet une sélection à la création
print("Carrés des nombres pairs jusqu'à 10 :", carres_pairs)
# Carrés des nombres pairs jusqu'à 10 : [0, 4, 16, 36, 64]

Dans l'exemple ci-dessus, la première liste est créée en parcourant chaque lettre de la chaîne de caractères "Numérique". La deuxième liste, carres_pairs, est créée en générant les carrés des nombres pairs jusqu'à 10 en utilisant une condition avec l'instruction if.

Tableaux à plusieurs dimensions : listes de listes

Les tableaux à plusieurs dimensions, souvent représentés par des listes de listes en Python, sont utiles pour stocker des données structurées sous forme de grilles. Chaque liste interne peut être considérée comme une ligne du tableau.

tableau_2D = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Accéder à une ligne entière
print("Deuxième ligne du tableau :", tableau_2D[1])

# Accéder à un élément spécifique
print("Élément à la troisième ligne, deuxième colonne :", tableau_2D[2][1])
# Deuxième ligne du tableau : [4, 5, 6]
# Élément à la troisième ligne, deuxième colonne : 8

Dans cet exemple, tableau_2D est une liste de listes représentant un tableau à deux dimensions. Vous pouvez accéder à des lignes entières ou à des éléments spécifiques en utilisant des indices.

Les parties de listes : le slicing

Le découpage d'une liste, également appelé "slicing", permet d'extraire des parties spécifiques d'une liste en utilisant des indices. C'est une fonctionnalité puissante pour manipuler et travailler avec des sous-ensembles de données.

ma_liste = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Extraire les cinq premiers éléments (de l'indice 0 à l'indice 4 inclus)
print("Les cinq premiers éléments :", ma_liste[:5])

# Extraire les éléments à partir de l'indice 5 jusqu'à la fin
print("Les éléments à partir de l'indice 5 :", ma_liste[5:])

# Extraire les éléments de l'indice 2 à l'indice 5 (exclus)
print("Les éléments de l'indice 2 à l'indice 5 :", ma_liste[2:6])

# Extraire les éléments en sautant un élément (pas de 2)
print("Les éléments en sautant un élément :", ma_liste[::2])

# Extraire les éléments en sautant un élément en sens inverse
print("Les éléments en sautant un élément en sens inverse :", ma_liste[::-2])

Résumé de cours sur les tableaux

Les tuples en Python

Les tuples, également appelés « n-uplets » en français, sont similaires aux listes, à la différence qu'ils sont non modifiables (non mutables) : on ne peut ni réaffecter leurs éléments ni en ajouter de nouveaux. Si vous essayez de modifier un tuple existant, l'interpréteur Python générera une erreur. Contrairement aux listes qui peuvent être modifiées, notamment lors de la copie, les tuples résolvent ce problème en étant immuables. En pratique, ils utilisent des parenthèses au lieu des crochets. Comme mentionné précédemment, un tuple est une séquence. Voici un exemple simple :

mon_tuple = (19, 10, 2, 9, 6)

def recherche_notes_superieures(liste_notes):
    """
    Recherche le nombre de notes supérieures à 17 dans une liste.
    Paramètre: liste_notes de type list
    Return : compteur de type int
    """
    compteur = ...
    for elt in ... :
        if elt > ... :
            compteur = ... + 1
    return ...
    
    notes_sup_17 = [note for note in liste_notes if note > 17] # par compréhension (pas forcément le plus simple)
    return len(notes_sup_17)

points_maisons = [200, 123, 14, 18, 6, 19]

prenoms_harry_potter = ["harry", "hermione", "ron", "ginny", "luna","neville",
	 "draco",	"cho", "fred", "george", "albus", 
"severus", "nymphadora", "remus", "minerva"]

def echange_element(L, i, j):
    """
    Échange les éléments d'indices i et j dans une liste L.
    Parameters:
    - L ( ... ): Liste d'éléments.
    - i ( ... ): Indice du premier élément.
    - j ( ... ): Indice du deuxième élément.
    Returns:
    list: Liste modifiée avec les éléments d'indices i et j échangés.
    """
    # Vérifier si les indices i et j sont valides
    if 0 <= i < ... and 0 <= j < ...:
        # Échanger les éléments d'indices i et j
        temp = L[...]
        L[i] = ...
        L[j] = ...
    return L

# Exemple d'utilisation pour tromper Hermione
liste_potions = ["Potion de Sommeil", "Polynectar", "Felix Felicis", "Draught of Living Death", "Amortentia"]

# Draco trompe Hermione en échangeant la Potion de Sommeil avec Felix Felicis
liste_modifiee = echange_element(liste_potions, 0, 2)

# Affichage du résultat
print("Liste après l'échange pour tromper Hermione :")
print(liste_modifiee) # Vérifiez avec liste_potions

maisons_poudlard = [
    ["Gryffondor", "Harry", "Hermione", "Ron"],
    ["Serpentard", "Draco", "Pansy", "Vincent"],
    ["Poufsouffle", "Cedric", "Hannah", "Nymphadora"],
    ["Serdaigle", "Luna", "Cho", "Garrick"]
]

def sequence_complementaire(adn):
    """
    Transforme une séquence d'ADN en sa séquence complémentaire.
    Parameters:
    - adn (list): Liste représentant la séquence d'ADN.
    Returns:
    list: Séquence complémentaire d'ADN.
    """

assert sequence_complementaire(["A","C","G","T"]) == ['T', 'G', 'C', 'A']

mon_tuple = (19, 10, 2, 9, 6)