Voici comment supprimer les éléments en double d’une liste en utilisant Python :

unique_list = list(set(my_list))

my_list = [1, 2, 3, 3, 4, 4, 5]
unique_list = list(set(my_list))
print(unique_list)  # [1, 2, 3, 4, 5]

unique_list = []
seen = set()

for element in my_list:
  if element not in seen:
    unique_list.append(element)
    seen.add(element)

print(unique_list)  # [1, 2, 3, 4, 5]

Dans cet exemple,

est la liste originale et

est une nouvelle liste qui ne contient que des éléments uniques. Nous avons utilisé la fonction

pour convertir la liste en un ensemble, qui ne permet pas les éléments en double. Nous avons converti l’ensemble en une liste à l’aide de la fonction

, puis nous avons assigné le résultat à la variable

.

Voici un exemple complet qui montre comment supprimer les éléments en double d’une liste nommée

:

Vous pouvez également utiliser une boucle

pour parcourir la liste et ajouter chaque élément à un nouvel ensemble, puis convertir l’ensemble en une liste. Voici comment cela peut être fait :

Dans cet exemple, nous avons créé un ensemble vide nommé

pour stocker les éléments déjà vus. Nous avons parcouru la liste

et ajouté chaque élément à la liste

si il n’était pas déjà présent dans l’ensemble

. Nous avons utilisé la méthode

de l’ensemble pour ajouter chaque élément à l’ensemble. Cette approche est plus lente que la première approche, mais elle permet de conserver l’ordre des éléments dans la liste originale.

Voici un exemple de programme Python qui parcourt deux listes en parallèle:

list1 = [1, 2, 3, 4]
list2 = ['a', 'b', 'c', 'd']

for x, y in zip(list1, list2):
    print(x, y)

La fonction

permet de combiner les éléments de deux listes en un tuple, et la boucle

permet de parcourir ces tuples.

Vous pouvez également utiliser la fonction

pour parcourir les deux listes en parallèle. Voici un exemple:

list1 = [1, 2, 3, 4]
list2 = ['a', 'b', 'c', 'd']

for i, (x, y) in enumerate(zip(list1, list2)):
    print(i, x, y)

Voici comment obtenir le dernier élément d’une liste en utilisant Python :

last_element = my_list[-1]
try:
  last_element = my_list[-1]
except IndexError:
  print("La liste est vide")

my_list = [1, 2, 3, 4]

try:
  last_element = my_list[-1]
  print(f"Le dernier élément de la liste est {last_element}")
except IndexError:
  print("La liste est vide")

last_element = my_list.pop()
my_list = [1, 2, 3, 4]

try:
  last_element = my_list.pop()
  print(f"Le dernier élément de la liste est {last_element}")
except IndexError:
  print("La liste est vide")

Le symbole

indique l’index du dernier élément de la liste. Si la liste est vide, cela lèvera une exception

. Vous pouvez utiliser un bloc

–

pour gérer cette exception :

Vous pouvez également utiliser la méthode

de la classe

pour obtenir le dernier élément de la liste et le supprimer de la liste en même temps. Voici comment cela peut être fait : last_element = my_list.pop()

La méthode

retire l’élément à l’index spécifié de la liste et renvoie sa valeur. Si aucun index n’est spécifié, elle retire et renvoie le dernier élément de la liste. Si la liste est vide, cela lèvera une exception

, que vous pouvez gérer en utilisant un bloc

–

.

Voici comment cela fonctionne : la fonction booléenne

renvoie

si l’expression qui suit est

, et

si elle est

. En Python, une liste vide est considérée comme

, tandis qu’une liste non vide est considérée comme

.

if not my_list:
  # la liste est vide
else:
  # la liste n'est pas vide

Vous pouvez également utiliser l’instruction

suivie de la longueur de la liste, comme ceci :

if len(my_list) == 0:
  # la liste est vide
else:
  # la liste n'est pas vide

Ou encore, vous pouvez utiliser la méthode

de la classe

, comme ceci:

if my_list.isempty():
  # la liste est vide
else:
  # la liste n'est pas vide

Cela fonctionne parce que la méthode

renvoie

si la liste est vide et

sinon. Cette méthode est disponible à partir de Python 3.9. Si vous utilisez une version antérieure de Python, vous devrez utiliser l’une des deux premières approches.

Voici comment on peut écrire un programme Python qui parcourt une liste en utilisant la boucle

et qui affiche l’index et la valeur de chaque élément de la liste :

ma_liste = [10, 20, 30, 40, 50]

# On parcourt la liste
for i, valeur in enumerate(ma_liste):
  # On affiche l'index et la valeur
  print("Index : {} / Valeur : {}".format(i, valeur))

# Output :
# Index : 0 / Valeur : 10
# Index : 1 / Valeur : 20
# Index : 2 / Valeur : 30
# Index : 3 / Valeur : 40
# Index : 4 / Valeur : 50

La fonction

permet de parcourir une liste tout en retournant à chaque itération l’index et la valeur de l’élément courant. Dans la boucle

, on utilise l’instruction

pour parcourir la liste et récupérer à chaque itération l’index de l’élément courant dans la variable

et sa valeur dans la variable

.

Ainsi, à chaque itération de la boucle, l’index de l’élément courant est affiché ainsi que sa valeur.

Il y a plusieurs façons d’itérer sur une liste en Python. Voici quelques exemples :

En utilisant une boucle

classique :

numbers = [1, 2, 3, 4, 5]
for number in numbers:
    print(number)

2. 2. En utilisant la fonction
      enumerate

      :

   3. numbers = [1, 2, 3, 4, 5]
      for i, number in enumerate(numbers):
          print(f'Index {i}: {number}')
      

   4. En utilisant la fonction
      range

      et la boucle

      for

      :

      numbers = [1, 2, 3, 4, 5]
      for i in range(len(numbers)):
          print(f'Index {i}: {numbers[i]}')
      

   5. En utilisant la boucle
      while

      :

numbers = [1, 2, 3, 4, 5]
i = 0
while i < len(numbers):
    print(f'Index {i}: {numbers[i]}')
    i += 1

Voici comment vous pouvez écrire un programme en Python pour obtenir le dernier élément de la liste my_list:

def get_last(my_list):
  # Obtenir le dernier élément de la liste
  last = my_list[-1]
  return last

# Test the function
print(get_last([1, 2, 3]))  # Output: 3
print(get_last([]))         # Output: IndexError
print(get_last([1]))        # Output: 1

La fonction get_last prend un argument: my_list, qui est la liste dont vous voulez obtenir le dernier élément. Elle utilise l’indexation en négatif pour obtenir le dernier élément de la liste et affecte la valeur à la variable last. Enfin, la fonction renvoie la valeur de last.

Les trois tests à la fin de l’exemple vérifient que la fonction fonctionne correctement pour différentes valeurs de my_list. Le premier appel de la fonction avec [1, 2, 3]  en tant qu’argument devrait renvoyer 3 , qui est le dernier élément de la liste. Le deuxième appel de la fonction avec une liste vide en tant qu’argument devrait générer une exception IndexError, car il n’y a pas d’élément à retourner. Le troisième appel de la fonction avec [1] en tant qu’argument devrait renvoyer  1, qui est le seul élément de la liste.

En Python, les listes sont des structures de données qui permettent de stocker et de manipuler des séquences d’éléments. Les listes en Python sont similaires aux tableaux dans d’autres langages de programmation, mais elles ont la particularité d’être dynamiques et d’accepter des éléments de différents types.

Voici quelques-unes des méthodes couramment utilisées sur les listes en Python :

• append()

  : ajoute un élément à la fin de la liste

• insert()

  : insère un élément à un index spécifique dans la liste

• extend()

  : ajoute plusieurs éléments à la fin de la liste en les étendant

• remove()

  : supprime un élément de la liste en fonction de sa valeur

• pop()

  : supprime un élément de la liste en fonction de son index (ou la dernière valeur par défaut)

• index()

  : retourne l’index d’un élément dans la liste en fonction de sa valeur

• count()

  : retourne le nombre d’occurrences d’un élément dans la liste

• sort()

  : trie les éléments de la liste dans l’ordre croissant

• reverse()

  : inverse l’ordre des éléments de la liste

# Créer une liste vide
ma_liste = []

# Ajouter un élément à la fin de la liste en utilisant la méthode append()
ma_liste.append(10)

# Ajouter plusieurs éléments à la fin de la liste en utilisant la méthode extend()
ma_liste.extend([20, 30, 40])

# Insérer un élément à un index spécifique en utilisant la méthode insert()
ma_liste.insert(1, 15)

# Supprimer un élément en utilisant la méthode remove()
ma_liste.remove(20)

# Trouver l'index d'un élément en utilisant la méthode index()
index = ma_liste.index(30)

# Compter le nombre d'occurrences d'un élément en utilisant la méthode count()
count = ma_liste.count(10)

# Trier une liste en utilisant la méthode sort()
ma_liste.sort()

# Inverser l'ordre des éléments dans une liste en utilisant la méthode reverse()
ma_liste.reverse()

 




# Créer une liste vide 
ma_liste = [] # Ajouter des éléments à la liste 
ma_liste.append('élément 1') 
ma_liste.append('élément 2')
 ma_liste.append('élément 3') 
# Insérer un élément à une position spécifique 
ma_liste.insert(1, 'élément 1.5') 
# Trier les éléments de la liste 
ma_liste.sort() 
# Supprimer un élément de la liste
 ma_liste.remove('élément 1') # Afficher la liste print(ma_liste)

Il existe bien d’autres méthodes pour les listes en Python, ces exemples sont simplement les plus couramment utilisés. Vous pouvez en apprendre plus sur les listes en Python en consultant la documentation officielle.

Pour supprimer un élément d’une liste en Python, vous pouvez utiliser la méthode

de la liste. Voici un exemple:

# Créer une liste avec quelques éléments
ma_liste = ["un", "deux", "trois", "quatre", "cinq"]

# Supprimer l'élément "trois" de la liste
ma_liste.remove("trois")

# Afficher la liste après avoir supprimé l'élément
print(ma_liste)

Ce code imprimera la liste suivante:

.

Notez que la méthode

ne fonctionne que si l’élément que vous souhaitez supprimer est présent dans la liste. Si vous essayez de supprimer un élément qui n’est pas dans la liste, vous obtiendrez une erreur. Par exemple:

ma_liste = ["un", "deux", "trois", "quatre", "cinq"]

# Essayer de supprimer l'élément "six"
ma_liste.remove("six")

ma_liste = ["un", "deux", "trois", "quatre", "cinq"]

# Vérifier si "six" est dans la liste
if "six" in ma_liste:
    # Si c'est le cas, on peut l'appeler la méthode remove()
    ma_liste.remove("six")

Il existe plusieurs façons d’ajouter des éléments à une liste en Python. La plus simple consiste à utiliser la méthode

, qui permet d’ajouter un élément à la fin de la liste. Par exemple, si vous avez une liste

et que vous souhaitez ajouter l’élément

à la fin de cette liste, vous pouvez utiliser la syntaxe suivante:

my_list = [1, 2, 3]
my_list.append("foo")

Après exécution de ces instructions,

sera égal à

.

Vous pouvez également utiliser l’opérateur

pour concaténer deux listes et créer une nouvelle liste contenant tous les éléments des deux listes d’origine. Par exemple:

my_list = [1, 2, 3]
other_list = ["foo", "bar"]
combined_list = my_list + other_list

Après exécution de ces instructions,

sera égal à

.

Enfin, vous pouvez également utiliser la méthode

pour étendre une liste en lui ajoutant les éléments d’une autre liste. Par exemple:

my_list = [1, 2, 3]
other_list = ["foo", "bar"]
my_list.extend(other_list)

Après exécution de ces instructions,

sera égal à

. La différence entre

et l’opérateur

est que la méthode

modifie la liste d’origine en place, tandis que l’opérateur

crée une nouvelle liste.