La mémoire de nos ordinateurs est vaste. Dans la mémoire d'un seul ordinateur, on peut stocker sans difficulté les noms et prénoms de tous les français où encore l'intégralité des œuvres de Jules Verne. Pour donner un ordre de grandeur, le texte du Tour du monde en quatre-vingts jours contient un demi-million de caractères alors que là mémoire d’un ordinateur d'au-jourd'hui peut en contenir plusieurs milliards et donc plusieurs milliers de romans.
Pour autant, nous avons jusqu'à présent utilisé une infime partic de cette mémoire gigantesque, avec seulement quelques variables. Bien sûr, rien ne nous empêche d'avoir des programmes avec un très grand nombre de variables mais cela atteint vite ses limites. Pour stocker de grandes quantités d'information, il faut se tourner vers d'autres solutions et le tableau est la
plus simple d'entre elles.
Considérons un programme qui stocke la pyramide des âges des français, c'est-à-dire la répartition de la population française par âge. el permet à l'utilisateur de la consulter, Par exemple, on peut saisir un âge et le programme affiche le nombre de français avant cet âge-là, où on saisit deux âges et le programme affiche le nombre de français ayant un âge compris entre
ces deux valeurs, etc.
Pour stocker la pyramide des âges dans le programme,
on pourrait utiliser autant de variables qu'il v a d'âges différents dans la pyramide :
age0 = 691165 # moins de 1 an
agel = 710534 # entre 1 et 2 ans
age2 = 728579 # entre 2 et 3 ans
et ainsi de suite jusqu'à l’âge maximum.
Après tout, cela ne fait qu'un peu plus de cent variables. Là où les choses deviennent vraiment pénibles, c'est lorsque l'on veut demander à l'utilisateur du programme de saisir un âge, pour afficher ensuite le nombre de français ayant cet âge-là. On peut le faire,
mais au prix d'une interminable succession de comparaisons.
a = int(input(\"quel âge : \"))
if a == 0:
print (age0)
elif a == 1:
print (agei)
elif ...
Ce n'est pas raisonnable.
D'une part, il faudrait recommencer une telle série de comparaisons pour tout autre calcul (par exemple, pour calculer le nombre de français ayant un âge compris entre deux valeurs données par l'utilisateur). D'autre part, si on avait maintenant plusieurs milliers, voire
plusieurs millions d'informations, il deviendrait humainement impossjble de procéder ainsi.
Il faut une meilleure solution.
Un tableau permet de stocker plusieurs valeurs dans une seule variable et d'y accéder ensuite facilement.
En Python, on construit un tableau en énumérant ses valeurs entre crochets et séparées par des virgules.
>>> t = [2, 3, 5]
Dans le script IDLE Python taper l'instruction ci-dessous.
Ici, on à déclaré une variable t contenant un tableau. Ce tableau contient trois entiers. Les valeurs contenues dans un tableau sont ordonnée :
- la première valeur contenue dans le tableau est 2,
- la deuxième 3
- et la troisième 5.
On peut se représenter un tableau comme dos cases consécutives contenant des valeurs.
| 2 | 3 | 5 |
C‘est en effet ainsi qu'un tableau est organisé dans la mémoire de l’ordinateur ; ses valeurs y sont rangées consécutivement.
Pour accéder à une valeur contenue dans le tableau t, il faut utiliser la notation t[i] où i désigne le numéro de la case à laquelle on veut accéder.
Les cases sont numérotées à partir de zéro ( t[0] ). Ainsi, la valeur contenue dans là première case cst t[0].
>>> t[0]
Tester l'instruction ci-dessous.
On dit que 0 est l'indice de la preinière case.
1 l'indice de la deuxième case
ete.
La taille d’un tableau est son nombre de cases. On obtient la taille du tableau t avec l'opération len(t).
>>> len(t)
Les indices d'un tableau t prennent donc des valeurs entre 0 et len(t)-1.
On peut se représenter le tableau mentalement avec l'indice de chaque case indiqué juste au-dessus.
| 2 | 3 | 5 |
Mais il faut comprendre que seules les valeurs sont stockées dans la mémoire de l'ordinateur. Les indices, eux, n'ont pas besoin d’être matérialisés.
En effet, chaque case du tableau occupe une taille identique et on peut donc calculer facilement où se trouve la case dans la mémoire par une opération arithmétique.
Erreurs : Si on cherche à accéder à une case en dehors des limites du tableau, on obtient une erreur.
Tester l'instruction ci-dessous et indiquer le type d'erreur.
>>> t[3]
Mettre le résultat ici.
Si on reprend notre exemple de Ia pyramide des âges, on peut la représenter très par un tableau pda.
pda=[706382,716159,729139,749142,770897,795049,801336,818973,824266,844412,836610,841774,833484,
847250,828874,828224,825535,824243,830859,832135,778595,767419,738255,741493,731720,709814,
710229,747365,762740,783278,793756,805709,809462,824388,823154,817616,809113,860183,868514,
876362,830619,812560,815529,795012,818506,859407,905508,925828,921091,900389,888940,878137,
872944,891913,893796,901416,889289,857860,858184,852627,845836,827046,818270,809103,799407,
795066,776073,784280,760998,783527,766434,759622,739203,692884,518955,502516,483835,443448,
389310,397453,408011,390052,372609,362050,336284,325338,293641,280250,250255,226053,186015,160562,
132403,110466,89330,69801,53201,39728,29030,20035,21860]
Dans la case 0 du tableau vcus avez le nombre de personnes née en 2019.
Donc la case i du tableau pda. on trouve le nombre de français ayant exactement l'âge i+1 .
Maintenant, nous pouvons demander un âge à l'utilisateur et afficher le nombre de français ayant cet âge-là.
age = int(input(\"quel âge : \"))
age = age - 1 # nous sommes en 2020 ey le tableau commence à patyir de 2019
print(\"il y a\", pda[age], \"personnes ayant\", age, ans\")
Tester le code dans le file de l'IDLE python.
Tester le cpde pohr votre age et 50 ans.
","title":" "},{"edit":"Mettre le résultat ici.
Le contenu d'un tableau peut être modifié. Pour cela, on utilise une affectation, exactement comme on le ferait avec unc variable. Ainsi, on peut modifier le contenu de la seconde case du tableau t pour y remplacer la valeur 3 par la valeur 17.
t = [2, 3, 5]
t[1] = 17
On pout observer que cette modification a bien été effectuée en demandant à Python d'afficher le tableau t.
t = [2, 3, 5]
print(t)
t[1] = 17
print(t)
Comme on le voit, un tableau est affiché avec la même forme que celle qui permet. de le définir.
Si on reprend notre exemple de la pyramide des âges, on peut traduire une naissance en ajoutant 1 à la première case du tableau, c'est-à-dire à la
case d'indice 0.
pda=[706382,716159,729139,749142,770897,795049,801336,818973,824266,844412,836610,841774,833484,
847250,828874,828224,825535,824243,830859,832135,778595,767419,738255,741493,731720,709814,
710229,747365,762740,783278,793756,805709,809462,824388,823154,817616,809113,860183,868514,
876362,830619,812560,815529,795012,818506,859407,905508,925828,921091,900389,888940,878137,
872944,891913,893796,901416,889289,857860,858184,852627,845836,827046,818270,809103,799407,
795066,776073,784280,760998,783527,766434,759622,739203,692884,518955,502516,483835,443448,
389310,397453,408011,390052,372609,362050,336284,325338,293641,280250,250255,226053,186015,160562,
132403,110466,89330,69801,53201,39728,29030,20035,21860]
print(pda)
#on ajoute une naissance à l'année 0
pda[0] = pda[0] + 1
print(pda)
En première approximation, on peut donc voir les cases d'un tableau comme autant de variables qu'on peut modifier à loisir, qui seraient appclées ici pdal0], pdal1], etc.
Mais avec une différence essentielle : l'indice peut être
le résultat d'un calcul.
Toujours sur notre exemple de la pyramide des âges, supposons qne nous voulions calculer le nombre de français ayant entre 10 et 20 ans. On obtient ce nombre en additionnant dix valeurs contenues dans le tableau.
total = pda[9] + pda[10] + pda[11] + pda[12] + pda[13] + pda[14] \\
+ pda[15] + pda[16] + pda[17] + pda[18]
print(total)
C'est un peu long à écrire, mais cela reste faisable. Mais cela deviendrait vraiment pénible si la plage était plus grande ou encore saisie par l'utilisateur.
Les tableaux de Python différent des tableaux que l'on trouve dans les autres langages de programmation par
plusieurs aspects.
Tout d'abord. ils sont appelés listes dans la documentation de Python, ce qui est assez malheureux car une liste désigne en général une structure de donnés différente du tableau.
Ensuite, les tableaux de Python peuvent être agrandis où rétrécis du côté droit. c'est-à-dire du côté des indices les plus grands (avec des opérations append et pop que nous n'avons pas présentées), Cela les distingue des tableaux usuel où la taille est fixée une fois pour tontes à la création.
Enfin, accéder à nn tableau Python avec un indice négatif ne provoque pas nécessairement une erreur, contrairement à ce que l'on pourrait imaginer.
Python permet en effet d'accéder au dernier élément du tableau t avec t[-1], à son avant-dernier élément avec t[-2]. etc.
De manière générale, les indices -1 à —n peuvent être utilisés pour accéder à partir de la droite à un tableau de taille n. C'est parfois utile mais aussi dangereux : il suffit d'une petite erreur de calcul dans un programme pour ce retrouver avec un indice -1 plutôt que 0.
Par exemple, l'exécution du programme va alors se poursuivre sans signaler d'erreur.
Pour un tableau de taille n. seul un indice en dehors de l'intervalle [-n , n - 1] provoquera une erreur.
Nous avons délibérément choisi de nous en tenir uniquement au vocabulaire et notions usuels des tableaux tels qu'on les trouve dans dans les
langares usuelles.
Une meilleur solution consiste à utiliser une boucle pour parcourir les les cases du tableau concerné tout en accumulant le nombre total dans variable. On commence par introduire cette variable, en l'initialisant à zéro.
>>> total = 0
Puis on effectue une boucle for donnant successivement à la variable total toutes les valeurs entre 9 et 19 exclus, et on ajoute à chaque fois la valeur pda[i] à la variable total.
>>> for i in range(9, 19):
total += pda[i]
Le nom i donné à la variable importe peu. On aurait pu l'appeler age par exemple. Mais il est courant d'utiliser les noms i, j où k pour des variables qui vont être utilisées comme indices dans des tableaux.
total = 0
for i in range(9, 19):
total += pda[i]
print(total)
Tester le code ci-dessus et conclure.
On peut vérifier qu'après la boucle on a bien calculé dans la variable total la même valeur que celle obtenue précédemment avec notre addition de dix valeurs du tableau.
Erreurs. La possibilité d'accéder aux cases d’un tableau par des indices négatifs rend certaines erreurs difliciles à analyser. imaginons une fonction renvoyant le nombre d'occurrences de la valeur v entre les indices a
(inclus) et b (exclu) du tableau t.
def nb_occurrences(v, a, b, t):
nb = 0
for i in range(a, b):
if t[i] == v:
nb += 1
return nb
Supposons qu'un programmeur écrive
alors la séquence suivante.
t = [2, 1, 3, 1]
debut = -1
fin = len(t)
n = nb_occurrences(1, debut, fin, t)
print(n)
Tester le programme.
Que se passe-t-11?
Ici, le dernier élément sera compté deux fois, une pour
l'indice -1 et une pour l'indice 3, et on obtiendra le résultat de trois occurrences de la valeur 1 dans le tableau [2, 1, 3, 1].
Cette valeur erronée pour n est susceplible de provoquer une erreur plus tard dont il peut être compliqué de retrouver l'origine, à savoir ici une mauvaise définition de la variable début.
Mettre le résultat ici (code et figure).
Le programme 8 contient une version plus générale de ce calcul, où la plage d'âge est donnée par l'utilisateur.
Programme 8 — pyramide des âges
pda=[706382,716159,729139,749142,770897,795049,801336,818973,824266,844412,836610,841774,833484,
847250,828874,828224,825535,824243,830859,832135,778595,767419,738255,741493,731720,709814,
710229,747365,762740,783278,793756,805709,809462,824388,823154,817616,809113,860183,868514,
876362,830619,812560,815529,795012,818506,859407,905508,925828,921091,900389,888940,878137,
872944,891913,893796,901416,889289,857860,858184,852627,845836,827046,818270,809103,799407,
795066,776073,784280,760998,783527,766434,759622,739203,692884,518955,502516,483835,443448,
389310,397453,408011,390052,372609,362050,336284,325338,293641,280250,250255,226053,186015,160562,
132403,110466,89330,69801,53201,39728,29030,20035,21860]
age_min = int(input(\"âge minimum (inclus) : \"))
age_max = int(input(\"âge maximum (exclu) : \"))
total = 0
for age in range(age_min, age_max):
total += pda[age]
print (\"il y a\",total, \"personnes qui ont entre\", \\
age_min, \"et\", age_max, \"ans\")
Un cas particulier consiste à parcourir toutes les cases d’un tableau t avec une boucle for allant de 0 inclus à len(t) exclu.
On peut calculer ainsi la population française en janvier 2020 en parcourant tout notre tableau pda.
popu = 0
for i in range(0, len(pda)):
popu += pda[i]
print(popu)
Tester les programmes.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
Si on doit construire un tableau vraiment grand, par exemple de plusieurs centaines d'éléments, il devient difficile de le faire en énumérant tous ses éléments.
Fort heureusement, il existe uue opération dans le langage Python pour construire un tableau d’une taille arbitraire.
Elle s'utilise ainsi :
t = [0] * 1000
print(t)
On donne la taille du tableau après le symbole *, ici 1000, et entre crochets une valeur qui sera donnée à toutes les cases du tableau, ici 0.
On obtient donc ici un tableau t de taille 1000 dont toutes les cases contiennent pour l'instant la valeur 0. On peut notamment vérifier que le tableau ainsi construit à bien la taille 1000.
print(len(t))
Il faut bien comprendre que l'opération [0]*1000 n'implique pas une multiplication, même si elle utilise le même symbole *.
Il s'agit là d’une opération spécifique aux tableaux. Sa syntaxe n’est cependant pas liée au hasard;
elle est là pour suggérer l’idée que l'on «multiplie par 1000» un tableau d'une case contenant 0.
Une fois le tableau ainsi construit, on peut maintenant le remplir avec des valeurs de son choix, en utilisant des affectations.
Si par exemple on veut y stocker les carrés des 1000 premiers entiers, on peut le faire avec une boucle,
for i in range(0, 1000):
t[i] = i*i
print(t)
Nous verrons, plus tard dans l'année, une autre façon de construire un tel tableau.
Mettre le résultat ici (code et figure).
Il est possible de concaténer deux tableaux, c'est-à-dire de construire un nouveau tableau contenant, bout à bout, les éléments
des deux tableaux. On le fait avec l'opération +.
t1 = [8, 13, 21]
t2 = [34, 55]
print(t1)
print(t2)
t3 = t1 + t2 #concaténation de 2 tableau
print(t3)
Conune pour l'opération * utilisée pour la construction de tableaux, on réutilise ici un symbole arithmétique, mais il n'y a pas d’addition à proprement parler.
","title":"Concaténation de 2 tableaux"},{"edit":"Mettre le résultat ici (code et figure).
Les chaines de caractères offrent une certaine ressemblance avec les tableaux. En particulier. où peut obtenir la taille d'une chaine de caractères. c'est-à-dire son nombre de caractéres. avec l'opération len et accéder au n-ième caractère d'une chaine avec les crochets.
ch = \"bonjour\"
print(\"longueur de ch \",len(ch))
print(\"caractère en position 3 \",ch[2])
Comme ou le voit sur cet exemple, les caractères sont numérotés à partir de Zéro. comme dans un tableur. Qui peut également concaténer deux chaines avec + où encore construire une chaine contenant 10 répétitions
de ab avec “ab\" * 10.
En revanche, contrairement aus tableaux. les caractères d'une chaine ne peuvent pas être modifiés,
ch[2] = \"a\"
Tester les codes et conclure.
Mettre le résultat ici (code et figure).
Comme on l’a expliqué, une variable déclarée avec
x = 1
peut être représentée par une boîte appelée x contenant la valeur 1. x
x
| 1 |
Lorsque l'on modifie la valeur de la variable x. par exemple avec l'affectation x = x + 1, la valeur 1 a été remplacée par la valeur 2.
x
| 2 |
Lorsque l'on affecte à une nouvelle variable y la valeur de x, avec l'instruction y = x. une seconde boîte est créée, qui reçoit la valeur de x, c'est-à-dire 2.
x
y
| 2 |
| 2 |
On à maintenant deux variables indépendantes. En particulier, modifier la variable y. par exemple avec y=3, n'a pas d'effet sur la variable x.
y
| 3 |
Tester le code :
x = 1
print(\"x=\",x)
x = x + 1
print(\"x=\",x)
y = x
print(\"x=\",x,\"y=\",y)
y = 3
print(\"x=\",x,\"y=\",y)
Si nous en reparlons ici, c'est parce la situation devient un peu plus subtile lorsque les variable contiennent des tableaux.
On pourrait penser qu'une variable t contenant un tableau, par exemple initialisée avec t = [1, 2, 3], désigne trois boîtes plutôt qu'une seule, ce que l'on pourrait se représenter ainsi.
t
| 1 | 2 | 3 |
Malheureusement, cette vision des choses est incorrecte. En réalité, la valeur affectée à la variable t est l’adresse mémoire de l'espace alloué au tableau.
La valeur précise de cette adresse importe peu et on peut donc se le représenter ainsi :
t
→
a.m ; adresse mémoire
| a.m. |
| 1 | 2 | 3 |
La flèche symbolise ici le fait que la variable t contient une valeur qui désigne l'emplacement mémoire où se trouve le tableau. En première approximation, cette distinction que nous venons de faire paraît inutile. Après tout, on visualise aussi bien l'accès à t[1} ou encore l'affectation t[2] = 7 avec notre premier schéma.
Mais considérons maintenant la création d’un nouveau tableau avec u = t. Comme avec les variables entières x et y plus haut, la variable u reçoit la valeur de la variable t. Maïs comme la valeur est ici une adresse mémoire, on se retrouve avec la situation suivante :
Autrement dit, les deux variables t et u désignent le même tableau. En particulier, toute modification du contenu du tableau t sera visible dans le tableau u.
Ainsi, si on exécute l'instruction t[2] = 7, on se retrouve avec la situation suivante.
On à donc également modifié la valeur de u[2]. On peut le vérifier dans Python.
t = [1, 2, 3]
u = t
print(\"t=\",t)
print(\"u=\",u)
t[2] = 7
print(\"t=\",t)
print(\"u=\",u)
Les tableaux t et u ne sont pas pour autant destinés à rester identiques éternellement. Rien ne nous empêche par exemple d'affecter un nouveau tableau à u, par exemple avec l'instruction u = [4, 5, 6], pour se retrouver alors dans la situation suivante.
t
→
a.m ; adresse
| a.m. |
| 1 | 2 | 7 |
u
→
a.m ; adresse
| a.m. |
| 4 | 5 | 6 |
Même s’il est peu fréquent, voire peu recommandé, de se retrouver ainsi avec deux variables qui désignent le même tableau, il est fondamental d’avoir compris cet aspect-là du fonctionnement de Python. C'est en particulier nécessaire lorsque l’on utilise des fonctions qui reçoivent des tableaux en argument, ce que nous allons expliquer maintenant.
","title":"Tableaux et variables"},{"edit":"Mettre le résultat ici (code et figure).
Illustrons le passage d'un tableau en argument d’une fonction à l'aide d'un petit exemple. Considérons une variable entière x et un tableau t, initialisées ainsi :
x = 1
t = [1, 2, 3]
Conformément à ce que nous avons expliqué précédemment, nous pouvons l'illustrer de la manière suivante :
x
t
→
| 1 |
| a.m. |
| 1 | 2 | 3 |
Définissons maintenant une fonction f prenant deux arguments, appelés a et b. La variable a est supposée recevoir un entier et la variable b un tableau.
def f(a, b):
a=a+1
b[a] = 7
Comme on le voit. la fonction f commence par incrémenter la variable x puis modifie le tableau b à l'indice 2. Considérons maintenant l'appel de fonction
f(x, t). Juste après l’appel, on à la situation suivante où deux nouvelles variables a et b :
Ceci est conforme à ce qui à été expliqué dans la séquence sur les fonctions, ainsi qu'à ce qui à été expliqué plus haut sur la valeur d'une variable désignant un tableau. Une fois que les deux instructions qui constitue le fonction f ont été exécutées, on se retrouve donc dans la situation suivante :
La variable a a été incrémentée. et contient maintenant la valeur 2, et la valeur 7 à été affectée à la case d'indice 2 du tableau b. Une fois l'appel de fonction terminé, les variables a et b disparaissent et on se retrouve avec les valours suivantes pour les variables x et t.
x
t
→
| 1 |
| a.m. |
| 1 | 2 | 7 |
def f(a, b):
print(\"2.\",\"a=\",a,\" b=\",b)
a=a+i
b[a] = 7
print(\"3.\",\"a=\",a,\" b=\",b)
x = 1
t = [1,2,3]
print(\"1.\",\"x=\",x,\" t=\",t)
f(x,t)
print(\"4.\",\"x=\",x,\" t=\",t)
Tester le programme ci-dessus et conclure.
Comme on le constate, le contenu du tableau t à été modifié par la fonction f, mais pas le contenu de la variable x.
Nous venons d'illustrer ici quelque chose d'important :
Une fonction peut modifier le contenu d'un tableau qui lui est passé en argument.
Mettre le résultat ici (code et figure).
De même qu'une fonction peut recevoir un tableau en argument, une fonction peut renvoyer un tableau comme résultat. Là encore, il convient de bien comprendre ce qui se passe, en l'illustrant de façon précise. Considérons la fonction suivante qui reçoit un entier n en argument et renvoie un tableau de taille n contenant les carrés des n premiers entiers.
def carres(n):
t= [0] * n
for i in range(n):
t[i] = i * i
return t
print(carres(5))
Supposons que l’on appelle cette fonction avec 4 comme argument et que l'on stocke le résultat dans une variable c, c'est-à-dire que l'on exécute l'instruction c = carres(4). Au moment où l'exécution de la fonction atteint l'instruction return. on est dans la situation suivante :
n
t
→
| 4 |
| a.m. |
| 0 | 1 | 4 | 9 |
La valeur renvoyée par la fonction est la valeur de la variable t, c'est-à-dire l'adresse du tableau contenant les quatre carrés. C'est cette valeur qui est stockée dans la variable c juste après l'appel.
c
→
| a.m. |
| 0 | 1 | 4 | 9 |
Autrement dit, la variable locale t qui à servi à la construction du tableau n'a pas survécu à l'appel mais en revanche la zone mémoire contenant ici quatre entiers à survécu à l'appel.
Mettre le résultat ici (code et figure).
Programme 8 — pyramide des âges
pda=[706382,716159,729139,749142,770897,795049,801336,818973,824266,844412,836610,841774,833484,
847250,828874,828224,825535,824243,830859,832135,778595,767419,738255,741493,731720,709814,
710229,747365,762740,783278,793756,805709,809462,824388,823154,817616,809113,860183,868514,
876362,830619,812560,815529,795012,818506,859407,905508,925828,921091,900389,888940,878137,
872944,891913,893796,901416,889289,857860,858184,852627,845836,827046,818270,809103,799407,
795066,776073,784280,760998,783527,766434,759622,739203,692884,518955,502516,483835,443448,
389310,397453,408011,390052,372609,362050,336284,325338,293641,280250,250255,226053,186015,160562,
132403,110466,89330,69801,53201,39728,29030,20035,21860]
age_min = int(input(\"âge minimum (inclus) : \"))
age_max = int(input(\"âge maximum (exclu) : \"))
total = 0
for age in range(age_min, age_max):
total += pda[age]
print (\"il y a\",total, \"personnes qui ont entre\", \\
age_min, \"et\", age_max, \"ans\")
Le prograunme 8 n’est pas très robuste. En effet, si
l'utilisateur donne pour age_max une valeur plus grande que 106 (la taille du tableau pda), alors le programme va échouer suite à un accès en dehors
des limites du tableau.
Améliorer ce programme pour que l'utilisateur puisse
spécifier une valcur de age_max arbitrairement grande, sans pour autant que le programme n’échoue.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
Il suffit de stopper le parcours au minimum de age_max et len(pda).
age_max = min(age_max, len(pda))
ou
if age_max > len(pda) :
age_max = len(pda)
Écrire une fonction occurrences(v, t) qui renvoie le nombre d'occurrences de la valeur v dans le tableau t.
Tester avec le code suivant :
t1 = [1,5,3,6,3,7,3,2,1,3]
x = 3
print(occurrences(x,t1))
Résultat : 4
Mettre le résultat ici (code et figure).
On utilise une variable occ comme accumulateur qu’on
incrémente à chaque occurrence de v trouvée.
def occurrences(v, t):
occ = 0
for i in range(len(t)):
if t[i] == v:
occ += 1
return occ
t1 = [1,5,3,6,3,7,3,2,1,3]
x = 3
print(occurrences(x,t1))
Écrire un programme qui construit un tableau de 100 entiers tirés au hasard entre 1 et 1000, puis l'affiche.
Mettre le résultat ici (code et figure).
Le tableau est créé avec une valeur quelconque dans
ses cases, ici 0.
from random import randint
tab = [0] * 100 # un tableau de taille 100
for i in range(0, 100):
tab[i] = randint(1, 1000)
print (tab)
Compléter le programme précédent pour déterminer l'élément maximum de ce tablean et l'afficher.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
from random import randint
tab = [0] * 100 # un tableau de taille 100
for i in range(0, 100):
tab[i] = randint(1, 1000)
print (tab)
#determination de l'élément max
maximum = 0
for i in range(0, 100):
if tab[i] > maximum:
maximum = tab[i]
print(maximum)
Ecrire un programme qui tire au hasard mille entiers entre 1 et 10 et affiche ensuite le nombre de fois que chaque nombre a été tiré. Relancer.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
from random import randint
#On utilise un tableau de taille 11 dans lequel on stocke
#le nombre de fois que chaque nombre à été tiré. La case 0 de ce tableau n’est
#pas utilisée. Initialement, tous les compteurs sont à zéro.
hist = [0] * 11
#Puis on répète mille fois le tirage d’un entier n entre 1 et 10 (inclus). À
#chaque fois, on augmente son compteur d’une unité.
for k in range(0, 1000):
n = randint(1, 10) # entre 1 et 10 inclus
hist[n] = hist[n] + 1
#Enfin, on affiche les résultats.
for v in range(1, 11):
print(v, \"apparaît\", hist[v], \"fois\")
En mathématiques, la très célèbre suite de Fibonacci est une séquence infinie d'entiers définie de la façon suivante :
on part des deux entiers 0 et 1
puis on construit à chaque fois l'entier suivant comme la somme des deux entier précédents.
0 , 1 , 1 (0+1) , 2 (1+1) , 3 (1+2) , 5 (2+3) , ...
Écrire un programme qui construit puis affiche un tableau contenant les 30 premiers termes de la suite. Le dernier élément de ce tableau doit être 514229.
Mettre le résultat ici (code et figure).
n = 30
fib = [0] * n
fib[0] = 0
fib[1] = 1
for i in range(2, n):
fib[i] = fib[i-2] + fib[i-1]
print(fib)
Écrire une fonction copie(t) qui prend en paramètre un tableau t et renvoie une copie de ce tableau.
Quelle expérience peut-on faire pour s'assurer qu'on ne s'est pas trompé?
Exemple :
t1 = [0, 1, 2, 3]
t2 = copie(t1)
print(t1)
print(t2)
Mettre le résultat ici (code et figure).
On crée un nouveau tableau de même longueur dans
lequel on place un à un les éléments de t.
def copie(t):
r = [0] * len(t)
for i in range(len(t)):
r[i] = t[i]
return r
t1 = [0, 1, 2, 3]
t2 = copie(t1)
print(t1)
print(t2)
On peut vérifier ensuite qu'un tableau et sa copie son bien indépendants :
aucune modification de l’un n’est répercuté sur l’autre.
t1[0] = 4
t2[1] = 7
print(t1)
print(t2)
Cette expérience n’aurait pas fonctionné avec la définition t2 = t1.
Ecrire une fonetion ajout(v, €) qui crée un nouveau tableau contenant d'ahord tous les éléments de t puis v.
Exemple :
x = 4
t1 = [0, 1, 2, 3]
t2 = ajout(x,t1)
print(t2)
Mettre le résultat ici (code et figure).
def ajoute(v, t):
r = [v] * (len(t) + 1)
for i in range(len(t)):
r[i] = t[i]
return r
ou
def ajoute(v, t):
r = [0] * (len(t) + 1)
for i in range(len(t)):
r[i] = t[i]
r[len(t)]=v
return r
Ecrire une fonction concatenation(t1, t2) qui crée un nouveau tableau contenant, dans l’ordre, tous les éléments de t1 puis tous les éléments de t2.
Exemple :
t1 = [0, 1, 2, 3]
t2 = [4, 5, 6, 7]
t3 = concatenation(t1,t2)
print(t3)
Résultat :
[0, 1, 2, 3, 4, 5, 6, 7]
Mettre le résultat ici (code et figure).
def concatenation(ti, t2):
r = [0] * (len(t1) + len(t2))
for i in range(len(t1)):
r[i] = t1[i]
for i in range(len(t2)):
r[len(t1) + i] = t2[i]
return r
Ecrire une fonction tableau_aleatoire(n, a, b) qui renvoie
un tableau de taille n contenant des entiers tirés au hasard entre a et b.
Exemple ;
t1 = tableau_aleatoire(20,1,6)
print(t1)
Résultat :
[1, 2, 1, 4, 2, 3, 5, 1, 4, 2, 2, 3, 1, 3, 2, 4, 3, 3, 6, 2]
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
from random import randint
def tableau_aleatoire(n, a, b):
tab = [0] * n
for i in range(0, n):
tab[i] = randint(a, b)
return tab
Ecrire une fonction tableau_croissant(n) qui renvoie un tableau de taille n contenant des entiers tirés au hasard et ayant la propriété d'être trié par ordre croissant.
Pour faire cela, on pourrait utiliser l'exercice précédent pour construire un tableau aléatoire, puis le trier avec un algorithmce de tri. Il y à néanmoins une façon plus simple de procéder, consistant à remplir le tableau de gauche à droite en ajoutant à chaque fois un entier positif on nul à l'élément précédent.
Ainsi, le tableau est trié par construction.
Exemple :
t1 = tableau_croissant(20)
print(t1)
Résultat :
[0, 4, 5, 9, 11, 18, 23, 31, 33, 34, 38, 40, 46, 51, 53, 61, 69, 75, 76, 82]
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
On suit l’indication, en tirant à chaque fois un nombre
aléatoire (entre 0 et 10) pour l’ajouter à l'élément précédent.
from random import randint
def tableau_croissant(n):
tab = [0] * n
for i in range(1, n):
tab[i] = tab[i-1] + randint(0, 10)
return tab
Écrire ne fonction echange(tab, i, j) qui échange dans le
tableau tab les éléments aux indices i et j.
Exemple :
t1 = [1,2,3,4,5]
print(t1)
echange(t1,1,3)
print(t1)
Résultat :
[1, 2, 3, 4, 5]
[1, 4, 3, 2, 5]
Mettre le résultat ici (code et figure).
On utilise pour cela une variable temporaire, appelée
ici tmp.
def echange(tab, i, j):
tmp = tab[i]
tab[i] = tab[j]
tab[j] = tmp
Écrire une fonction somme(tab) qui calcule et renvoie la somme des éléments d'un tableau d'entiers. En déduire unc fonction moyenne(tab) qui calcule et renvoie la moyenne des éléments du tableau tab, supposé non
vide.
Exemple :
t1 = [1,2,3,4,5]
print(\"somme de t1 :\",somme(t1))
print(\"moyenne de t1 :\",moyenne(t1))
Résultat :
somme de t1 : 15
moyenne de t1 : 3.0
Mettre le résultat ici (code et figure).
def somme(tab) :
s = 0
for i in range(len(tab)):
s += tab[i]
return s
def moyenne(tab) :
s = 0
for i in range(len(tab)):
s += tab[i]
moy = s / len(tab)
return moy
Ecrire une fonction produit(tab) qui calcule et renvoie le
produit des éléments d'un tableau d'entiers. Si le tableau contient 0, la fonction devra renvoyer 0 sans terminer le calcul.
Exemple :
t1 = [1,2,3,4,5]
print(\"produit t1 :\",produit(t1))
t1 = [1,2,0,4,5]
print(\"produit t1 :\",produit(t1))
Résultat :
120
0
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
def produit(tab):
p=1
for i in range(len(tab)):
p *= tab[i]
if p == 0: return 0
return p
Écrire une fonction miroir(tab) qui reçoit un tableau en argument et le modifie pour échanger le premier élément avec le dernier, le second avec l'avant-dernier, etc.
Dit autrement, on remplace le tableau par son image miroir. On pourra se servir de la fonction echange de l'exercice précédent.
Exemple :
t1 = [1,2,3,4,5]
print(t1)
miroir(t1)
print(\"miroir:\",t1)
Résultat :
[1, 2, 3, 4, 5]
miroir: [5, 4, 3, 2, 1]
Mettre le résultat ici (code et figure).
En se servant de la fonction echange de l’exercice
précédent, comme suggéré, le code est assez court, mais pas complètement évident pour autant.
def echange(tab, i, j):
tmp = tab[i]
tab[i] = tab[j]
tab[j] = tmp
def miroir(tab):
n = len(tab)
for i in range(0, n // 2):
echange(tab, i, n - 1 - i)
D'une part, il faut bien identifier n-1-i comme étant l’élément miroir de l'élément i. D'autre part, il faut se persuader que la boucle for parcourt le bon intervalle. Si le tableau à une taille paire, c’est-à-dire n = 2^k, alors la boucle for va de 0 inclus à k exclu. Elle parcourt donc bien la premièreDUIULIUIS UES EXEICILES ri
n = 2k +1, la boucle for va toujours de 0 inclus à k exclu. Elle parcourt
donc la première moitié du tableau, à l'exclusion de l'élément central. Mais
comme il n’y a pas lieu de modifier l’élément central, c’est correct.
Pour mélanger les éléments d'un tableau aléatoirement, il existe un algorithme très simple qui procède ainsi :
on parcourt le tableau de la gauche vers la droite et, pour chaque élément à l'indice i, on l'échange avec un élément situé à un indice tiré aléatoirement entre 0 et i (inclus). Écrire une fonetion melange(tab) qui réalise cet algorithme. On pourra sc resservir de la fonction echange de l'exercice précédent. (Cet algorithme s'appelle le mélange de Kruth.)
Exemple :
t1 = [1,2,3,4,5]
print(t1)
melange(t1)
print(\"t1 mélangé :\",t1)
Résultat :
[1, 2, 3, 4, 5]
t1 mélangé : [2, 5, 3, 1, 4]
Mettre le résultat ici (code et figure).
On suit l'algorithme donné :
def echange(tab, i, j):
tmp = tab[i]
tab[i] = tab[j]
tab[j] = tmp
def melange(tab) :
for i in range(1, len(tab)):
echange(tab, i, randint(0, i))
On note qu’on démarre à l'indice 1, car il est inutile d'échanger le premier élément avec lui-même.
Écrire une fonction prefixe(tab1, tab2) qui renvoie True si le tableau tab1 est un préfixe du tableau tab2. c'est-à-dire si le tablean tab2 commence par les éléments du tableau tab1 dans le même ordre.
Exemple :
t1 = [1,2,3]
t2 = [1,2,3,4,5]
print(prefixe(t1, t2))
t3 = [1,2,8,4,5]
print(prefixe(t1, t3))
t4 = [1,2]
print(prefixe(t1, t4))
Résultat :
True
False
False
Mettre le résultat ici (code et figure).
def prefixe(tab1, tab2):
for i in range(len(tab1)):
if i >= len(tab2) or tab1[i] != tab2[i]:
return False
return True
Écrire une fonction suffixe(tab1, tab2) qui renvoie True si le tableau tab1 est en suffixe du tableau tab2, c'est-à-dire si le tableau tab2 termine par les éléments du tableau tab1 dans le même ordre.
Exemple :
t1 = [3,4,5]
t2 = [1,2,3,4,5]
print(suffixe(t1, t2))
t3 = [1,2,3,4,6]
print(suffixe(t1, t3))
t4 = [3,4]
print(suffixe(t1, t4))
Résultat :
True
False
False
Mettre le résultat ici (code et figure).
Même stratégie qu’à l'exercice précédent, en partant
de la fin de chacun des tableaux.
def suffixe(tab1, tab2):
n1 = len(tab1) - 1
n2 = len(tab2) - 1
for i in range(len(tab1)):
if i > n2 or tab1[n1 - i] != tab2[n2 - i]:
return False
return True
Écrire une fonction hamming(tab1, tab2) qui prend en paramètres deux tableaux, que l'on supposera de la même taille, el qui renvoie le nombre d'indices auxquels les deux tableaux différent.
Exemple :
t1 = [1,2,3,4,5]
t2 = [1,4,3,5,5]
print(hamming(t1, t2))
Résultat :
2
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
def hamming(tab1, tab2):
d=0
for i in range(len(tab1)):
if tab1[i] != tab2[i]:
d += 1
return d
Ecrire une fonction qui donne le nombre de jour de chaque mois. On utilisera un tableau pour stocké le nombre de jours de chaque mois.
Exemple :
print(nbjoursmois(2020, 2))
print(nbjoursmois(2020, 4))
Résultat :
29
30
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
On fait un cas particulier pour le mois de février, puis
on utilise un tableau comme suggéré.
def nbjoursmois(a, m):
if m == 2 and a%4==0 :
return 29
t = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
return t[m - 1]