Itérations sur les éléments d'un tuple

14.1 Boucle for

En Python, le parcours des éléments d'un tuple est généralement réalisé à l'aide de la boucle for. C'est le moyen le plus courant et ça te permet d'accéder simplement à chaque élément du tuple et d'exécuter un bloc de code pour chacun.

Boucle for

La boucle for parcourt chaque élément du tuple, attribuant temporairement la valeur de l'élément actuel à la variable indiquée après le mot clé for. Exemple:

my_tuple = (1, 2, 3, 4, 5)
for number in my_tuple:
    print(number)

Tu as déjà de l'expérience avec les listes et la boucle for, alors voyons quelques exemples pratiques:

Exemple 1 : Somme des éléments d'un tuple

Regardons un exemple où nous additionnons tous les éléments d'un tuple.

my_tuple = (10, 20, 30, 40, 50)
total = 0

for number in my_tuple:
    total += number

print(f"Somme des éléments du tuple : {total}")

Dans cet exemple, nous créons un tuple my_tuple et une variable total pour stocker la somme des éléments. En utilisant la boucle for, nous itérons sur chaque élément du tuple et l'ajoutons à total. Au final, nous obtenons la somme de tous les éléments du tuple.

Exemple 2 : Recherche de l'élément maximum

Examinons maintenant un exemple de recherche de l'élément maximum dans un tuple.

my_tuple = (5, 17, 23, 11, 2)
max_value = my_tuple[0]

for number in my_tuple:
    if number > max_value:
        max_value = number

print(f"Valeur maximale dans le tuple : {max_value}")

Dans cet exemple, nous initialisons la variable max_value au premier élément du tuple. Ensuite, nous itérons sur tous les éléments du tuple, comparant chaque élément avec la valeur maximale actuelle et mettant à jour max_value si nous trouvons une valeur plus élevée.

14.2 Tuples imbriqués

Les tuples peuvent contenir d'autres tuples, et la boucle for peut être utilisée pour itérer sur des structures de données imbriquées.

nested_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))

for inner_tuple in nested_tuple:
    for number in inner_tuple:
        print(number, end=' ')
    print()

Dans cet exemple, nested_tuple contient des tuples. Nous utilisons des boucles imbriquées for pour itérer sur chaque élément des tuples imbriqués. Le résultat de l'exécution :

1 2 3 
4 5 6 
7 8 9 

14.3 Boucle for avec index

Tout comme avec une liste, les éléments d'un tuple ont des index, ce qui permet de parcourir ses éléments à l'aide d'une boucle for (combinée à la fonction range()). Cela te permet de travailler non seulement avec les éléments eux-mêmes, mais aussi avec leurs positions, ce qui est nécessaire pour effectuer des manipulations de données plus complexes.

Les bases de l'itération indexée

Pour itérer sur un tuple avec accès à l'index de chaque élément, tu peux utiliser un code de type :

my_tuple = ('a', 'b', 'c', 'd')
for i in range(len(my_tuple)):
    print(f'index: {i}, Élément: {my_tuple[i]}')

Les avantages de l'utilisation des index

Avec les index, il est facile de réaliser des algorithmes qui nécessitent un accès simultané à plusieurs éléments du tuple, par exemple, pour comparer l'élément actuel avec le précédent ou le suivant.

Exemple :

my_tuple = (15, 20, 23, 18, 22, 19, 21)
for i in range(1, len(my_tuple)):
    if my_tuple[i] > my_tuple[i - 1]:  # Compare l'élément avec le précédent
        print(f'{my_tuple[i]} est supérieur à {my_tuple[i - 1]}')

Utilisation de la boucle for avec index pour le traitement des données

Supposons que nous avons un tuple avec des données de température pour la semaine, et nous voulons calculer la température moyenne, en excluant les valeurs extrêmes (la plus basse et la plus élevée).

temperatures = (15, 20, 23, 18, 22, 19, 21)
sorted_temps = sorted(temperatures)

# Exclure la première et la dernière température
filtered_temps = sorted_temps[1:-1]

average_temp = sum(filtered_temps) / len(filtered_temps)
print(f"Température moyenne de la semaine (sans valeurs extrêmes) : {average_temp}")

14.4 Utilisation de la fonction enumerate()

En Python, la fonction enumerate() fournit un moyen pratique d'itérer sur les éléments d'un tuple tout en accédant à leurs index. C'est particulièrement utile lorsque tu dois traiter à la fois l'index et la valeur d'un élément dans le cadre d'une boucle.

Les bases de la fonction enumerate()

La fonction enumerate() enveloppe le tuple dans un objet spécial et renvoie un itérateur qui génère des paires de valeurs sous forme de tuples, constituées de l'index et de la valeur de l'élément du tuple :

my_tuple = ('apple', 'banana', 'cherry')
for index, element in enumerate(my_tuple):
    print(f'index: {index}, Élément: {element}')

Tu as maintenant non seulement l'élément, mais aussi son index.

Les avantages de enumerate()

L'utilisation de enumerate() rend le code plus lisible et évite la nécessité de gérer les index manuellement à l'aide de range(len(…)). Cela facilite les manipulations avec les éléments de la liste, comme la modification, l'accès aux éléments et l'exécution de vérifications conditionnelles.

Exemples d'utilisation

Parfois, il est nécessaire de trouver tous les index où se trouve une certaine valeur dans le tuple.

my_tuple = (1, 2, 3, 2, 4, 2, 5)
search_value = 2
indices = []

for index, value in enumerate(my_tuple):
    if value == search_value:
        indices.append(index)

print(f"La valeur {search_value} se trouve aux index : {indices}")

Ce code trouve tous les index où la valeur 2 se trouve dans le tuple :

La valeur 2 se trouve aux index : [1, 3, 5]

Filtrage de données basé sur les index

Voyons un exemple où nous filtrons les données en fonction des index, en gardant uniquement les éléments avec des index pairs.

my_tuple = ('a', 'b', 'c', 'd', 'e', 'f')

filtered_tuple = tuple(value for index, value in enumerate(my_tuple) if index % 2 == 0)
print(f"Tuple avec des éléments aux index pairs : {filtered_tuple}")

Ce code crée un nouveau tuple, ne contenant que les éléments aux index pairs :

Tuple avec des éléments aux index pairs : ('a', 'c', 'e')