Parcours de tableaux/de tuples
Vous connaissez la manière d'adresser un élément de tableau avec la syntaxe : nom_du_tableau[indice].
Indiquer numériquement la valeur de l'indice suffit quand on ne manipule que quelques éléments d'un tableau ou d'un tuple, mais qu'en est-il si on voulait adresser tous les éléments d'un tableau/tuple contenant un très grand nombre d'éléments ?
notes = [10, 12, 9, 3, 14, 11, 8, 6, 7, 15, 19, 12, 13, 13]
somme = notes[0] + notes[1] + notes[2] + notes[3] + notes[4] + notes[5] + notes[6] + notes[7] + notes[8] + notes[9] + notes[10] + notes[11] + notes[12] + notes[13]
Pas très pratique de faire la somme de tous les éléments !!
Il existe heureusement une manière d'adresser "automatiquement" les éléments d'un tableau/tuple les uns après les autres, et cela correspond à un parcours de tableau/tuple.
Parcours d'un tuple ou d'un tableau
Un tuple ou un tableau est, comme une chaîne de caractères, un objet itérable, que l'on peut donc parcourir avec une boucle pour adresser chacun de ses éléments les uns après les autres.
Comme pour les chaînes, deux types de parcours existent :
Parcours par valeur
for element in notes : # pour chaque élément du tableau
print(element) # la variable 'element' contient la valeur de l'élément
10
12
9
3
....
A chaque tour de boucle, la variable element prend comme valeur celles des éléments successifs du tuple/tableau.
L'inconvénient est que l'on n'adresse à chaque fois que la valeur de l'élément, et pas son indice; pour adresser ces deux données en même temps, utiliser la fonction enumerate() :
for indice, element in enumerate(notes) :
print(indice, element)
0 10
1 12
2 9
3 3
....
Parcours par indice
L'idée est d'utiliser une boucle bornée for .... in range(), dont le compteur ira de 0 ( indice du premier élément du tableau ) à len(tableau) - 1 ( = indice du dernier élément ).
On se sert alors du compteur pour adresser successivement chaque élément du tableau :
for indice in range(len(notes)) : # pour i variant de 0 à len()-1
print(indice, notes[indice]) # la variable indice contient l'indice de l'élément, notes[indice] représente sa valeur
0 10
1 12
2 9
3 3
....
Exemple : faire la somme des éléments
Si on revient à notre exemple du début, pour faire la somme de tous les éléments du tableau, il faut suivre l'algorithme suivant :
somme ← 0
pour chaque élément du tableau :
somme ← somme + valeur de l'élément
Soit en Python, avec un parcours par valeur :
somme = 0
for element in notes :
somme = somme + element
Et avec un parcours par indice :
somme = 0
for i in range(len(notes)) :
somme = somme + notes[i]
Parcours par indice ou par valeur ?
Pour simplement adresser les éléments d'un tableau/tuple, on peut pratiquement toujours utiliser l'un ou l'autre indifféremment !
Mais :
- Le parcours par valeur ne permet pas, dans le cas d'un tableau, de modifier ses éléments; on utilisera plutôt pour cela le parcours par indice ( voir chapitre suivant ).
- le parcours par valeur ne permet pas d'adresser plusieurs éléments en même temps, mais un seul, alors que le parcours par indice le permet, du moment que les indices de ces éléments sont en rapport les uns avec les autres; par exemple indices i et i+1, i-2 et i, etc...
Exercices
On utilisera dans ces exercices les méthodes de parcours pour adresser successivement tous les éléments des tuples et des tableaux suivants.
A vous de choisir entre le mieux adapté, un parcours par indice ou un parcours par valeur.
Produit des valeurs
Il s'agit ici de faire le produit ( la multiplication ) de tous les nombres présents dans un tableau.
- Compléter la fonction
produitci-dessous qui prend en paramètre un tableau tab d'entiers, et renvoie le produit de tous les entiers présents dans le tableau.
Par convention, si le tableau est vide on considérera que le produit est égal à 1. - Tester votre fonction grâce au jeu de tests ci-dessous :
produit([2, 3, 2]) == 12produit([1, 2, 3, 4, 5, 6]) == 720produit([1, 1, 1, 1, 1, 1]) == 1produit([1, 14, 32, 0, 15, 6]) == 0produit([]) == 1produit([7]) == 7produit([12, 11, 3, 21, 5, 41, 4, 6, 4, 7]) == 1145612160
Inversion d'un tableau
Inverser un tableau, c'est mettre tous ses éléments dans "l'autre sens" par rapport au "sens" initial :
t = [12, 56, 6, 1, 78, 96]
t_inverse = [96, 78, 1, 6, 56, 12]
- écrire une fonction
inverse_tableau, qui prend en paramètre un tableau t, et qui renvoie un nouveau tableau dont les éléments sont inversés par rapport au premier. - tester votre fonction avec le jeu de tests suivant :
inverse_tableau([12, 56, 6, 1, 78, 96]) == [96, 78, 1, 6, 56, 12]inverse_tableau([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]inverse_tableau([12]) == [12]inverse_tableau([]) == []
Tableau trié ?
Comment déterminer si les éléments d'un tableau d'entiers sont tous dans l'ordre croissant ( ou décroissant ? )
Simple : il suffit de parcourir les éléments du tableau, en comparant chaque élément avec son précédent ( ou son suivant, au choix...) : si, en un point du parcours, ces deux éléments ne sont pas dans le "bon" ordre, c'est que le tableau n'est pas ( complètement ) trié...
Écrire une fonction est_trie qui :
- prend comme paramètre un tableau d'entiers
- renvoie
TrueouFalseselon que le tableau est complètement trié ou pas, dans l'ordre croissant ou décroissant ( au choix )
Statistiques sur l'ADN
Dans cet exercice, il faut parcourir les éléments d'un tableau pour y tester la présence de certaines valeurs.
- Écrire une fonction
analyse_ADN, qui prend un paramètre un tableau ( comme le tableau ADN ci-dessous ), et qui renvoie le nombre de fois où le "gène" 'A' apparaît dans le tableau. - Modifier la fonction pour qu'elle renvoie également le nombre de fois où les "gènes" 'C', 'G' et 'T' apparaissent.
- Compléter la fonction pour qu'elle renvoie le pourcentage que représente chaque "gène" sur le nombre total de "gènes".
Partage d'un tableau
On souhaite écrire une fonction partage_tableau qui :
- prend comme paramètres un tableau tab ( contenant des valeurs de type quelconque ), et un entier n de valeur strictement positive et inférieure au nombre d'élément de la liste
- renvoie deux tableaux, le premier constitué de la partie "gauche" du tableau d'origine, c'est à dire les éléments d'indice inférieurs ou égaux à n, et l'autre de la partie "droite" ( indices supérieurs à n ).
Exemple : partage([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 4) renvoie : [1, 2, 3, 4, 5], [6, 7, 8, 9, 10]
Si vous êtes efficaces, votre fonction peut tenir en 3 lignes...
Compter les différences
On dispose ici de deux tableaux de même longueur. Il s'agit de calculer le nombre de différences entre les deux tableaux.
Par exemple avec :
tab_1 = ['a', 'g', 'u', 'u', 'c', 'o', 'p', 'l', 'm', 'v', 'p']
tab_2 = ['a', 'g', 's', 'u', 'c', 'k', 'p', 'l', 't', 'v', 'p']
→ il y a trois différences entre les deux tableaux : aux indices 2, 5 et 8.
- Compléter la fonction compter_
differencesci-dessous qui prend en paramètres deux tableaux t1 et t2 de même longueur, et renvoie le nombre de différences entre les deux tableaux. - Tester la fonction avec les paires de tableaux proposées.
Moyenne coefficientée
On dispose ici de deux tableaux de même longueur : un tableau de notes (sur 20) et un tableau de coefficients.
Il s'agit de calculer la moyenne coefficientée correspondante.
Par exemple avec :
notes = [12, 15, 14, 18]
coeffs = [1, 2, 1, 4 ]
→→la moyenne sera calculée ainsi : (12*1 + 15*2 + 14*1 + 18*4)/(1 + 2 + 1 + 4) = 16.
- Compléter la fonction
moyenne_coefficientci-dessous qui prend en paramètre deux tableaux non vides notes et coeffs et renvoie la moyenne coefficientée correspondante. - Tester votre fonction avec les tableaux proposés.
Dénivelées
La dénivelée entre deux points d'un parcours correspond à la différence entre les altitudes de ces deux points.
En randonnée cycliste, pédestre ou à skis, on définit les dénivelés positif et négatif cumulés :
- le dénivelé positif cumulé correspond au «nombre total de mètres en hauteur» qui ont été montés du début à la fin du parcours,
- le dénivelé négatif cumulé correspond au «nombre total de mètres en hauteur» qui ont été descendus du début à la fin du parcours.
Par exemple, soit un tableau dont chaque élément représente l'altitude d'un point d'un parcours de randonnée : [7, 4, 3, 6, 7, 4, 3, 1, 8].
→ on rencontre trois dénivelés positifs lors de son parcours :
- +3 pour passer de la valeur 3 à la valeur 6,
- +1 pour passer de la valeur 6 à la valeur 7,
- +7 pour passer de la valeur 1 à la valeur 8;
soit un dénivelé positif cumulé de +11.
Et le dénivelé négatif cumulé vaut quant à lui : -3-1-3-1-2 = -10.
Plus généralement, dans un tableau tab de taille n éléments, le dénivelé à l'indice i est égal à tab[i+1] - tab[i] (à condition que
l'indice i+1 existe).
Remarque : on considérera que dans un tableau vide ou de taille 1, le dénivelé cumulé est égal à zéro.
- Voici le schéma d'un tableau tab de taille n :
--------------------------------------------- | indices | 0 | 1 | 2 | 3 | ... | n-2 | n-1 | --------------------------------------------- | valeurs | . | . | . | . | ... | . | . | ---------------------------------------------
Le plus grand indice possible est donc n-1.
Pour avoir le droit d'écrire
tab[i+1] - tab[i]avec un tableau tab de taille n, quelle est alors la plus grande valeur de i possible : n-2, n-1, n ou n+1 ? - Compléter la fonction
compter_denivelesci-dessous qui prend en paramètre un tableau alt de valeurs représentant des altitudes, et renvoie un tuple de deux éléments correspondant aux dénivelés positif cumulé et négatif cumulé.
Le parcours de tab sera fait par indice. - Tester votre fonction grâce au jeu de tests ci-dessous :
compter_deniveles([1, 2, 3, 4, 5]) == (4, 0)compter_deniveles([5, 4, 3, 2, 1]) == (0, -4)compter_deniveles([0, 10, 0, 10]) == (20, -10)compter_deniveles([0, 10, 0, 10, 10, 10, 10, 0]) == (20, -20)compter_deniveles([3, 7, 8, 9, 1, 0, 7, 8, 9, 3, 7, 8, 9, 4, 6, 1, 0, 0, 9, 5, 7, 34, 4, 5, 6, 7, 8, 9]) == (66, -60)compter_deniveles([]) == (0, 0)compter_deniveles([5]) == (0, 0)