Les tableaux :¶

Un tableau est une suite ordonnée d'éléments. Ces éléments sont séparés par des virgules et entourés par des crochets.

En Python, un tableau est de type list.

A voir sur Lumni : https://www.lumni.fr/video/notion-de-listes-en-informatique-et-application-aux-images-numeriques

Exemples :¶

Un tableau vide :¶

In [1]:

monTableau = []
monTableau, type(monTableau)

monTableau = [] monTableau, type(monTableau)

Out[1]:

([], list)

Un tableau d'entiers :¶

In [2]:

tab_entiers = [ 1, 2, 3, 4, 5]
tab_entiers, type(tab_entiers)

tab_entiers = [ 1, 2, 3, 4, 5] tab_entiers, type(tab_entiers)

Out[2]:

([1, 2, 3, 4, 5], list)

Un tableau de chaines de caractères :¶

In [3]:

tab_chaines = [ "toto", "titi", "tata", "tutu", "tete"]
tab_chaines, type(tab_chaines)

tab_chaines = [ "toto", "titi", "tata", "tutu", "tete"] tab_chaines, type(tab_chaines)

Out[3]:

(['toto', 'titi', 'tata', 'tutu', 'tete'], list)

Un tableau de tuples :¶

In [4]:

tab_tuples = [(1, 2, 'moi'),(3, 4, 'toi'),(5, 6, 'nous')]
tab_tuples, type(tab_tuples)

tab_tuples = [(1, 2, 'moi'),(3, 4, 'toi'),(5, 6, 'nous')] tab_tuples, type(tab_tuples)

Out[4]:

([(1, 2, 'moi'), (3, 4, 'toi'), (5, 6, 'nous')], list)

Un tableau de tableau :¶

In [5]:

tab_tableaux = [[0, 2, 4, 6, 8],[1, 3, 5, 7, 9]]
tab_tableaux, type(tab_tableaux)

tab_tableaux = [[0, 2, 4, 6, 8],[1, 3, 5, 7, 9]] tab_tableaux, type(tab_tableaux)

Out[5]:

([[0, 2, 4, 6, 8], [1, 3, 5, 7, 9]], list)

Présentation sous forme de matrice en ligne et colonne :

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

Pour cibler un élément particulier de la matrice, on utilise la notation avec "doubles crochets" : matrice[ligne][colonne]

In [7]:

tab_tuples = [(1, 2, 'moi'),
              (3, 4, 'toi'),
              (5, 6, 'nous')]

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

tab_tuples = [(1, 2, 'moi'), (3, 4, 'toi'), (5, 6, 'nous')] tab_tableaux = [[0, 2, 4, 6, 8], [1, 3, 5, 7, 9]]

Lecture d'un tableau par index :¶

Le premier élément est toujours à l'index 0, le dernier est toujours à l'index -1 :

"toto"	"titi"	"tata"	"tutu"	"tete"
0	1	2	3	4
-5	-4	-3	-2	-1

Accès à un élément :¶

In [8]:

tab_chaines[-2]

tab_chaines[-2]

Out[8]:

'tutu'

In [9]:

tab_tuples[1][2]

tab_tuples[1][2]

Out[9]:

'toi'

In [10]:

"toto" in tab_chaines

"toto" in tab_chaines

Out[10]:

True

In [11]:

tab_chaines.index("toto")

tab_chaines.index("toto")

Out[11]:

0

Parcours des éléments d'un tableau :¶

In [12]:

for element in tab_chaines :
    print(element)

for element in tab_chaines : print(element)

toto
titi
tata
tutu
tete

La fontion len(monTableau) renvoie la taille d'un tableau, le nombre d'éléments qu'il contient :

In [8]:

for i in range(len(tab_chaines)) :
    print(tab_chaines[i])

for i in range(len(tab_chaines)) : print(tab_chaines[i])

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-8-cdb0e2564bbf> in <module>
----> 1 for i in range(len(tab_chaines)) :
      2     print(tab_chaines[i])

NameError: name 'tab_chaines' is not defined

In [14]:

for i in range(len(tab_tableaux)) :
    for j in range(len(tab_tableaux[i])) :
        print(tab_tableaux[i][j])

for i in range(len(tab_tableaux)) : for j in range(len(tab_tableaux[i])) : print(tab_tableaux[i][j])

0
2
4
6
8
1
3
5
7
9

Modification du contenu d'un tableau :¶

Contrairement à un tuple, un tableau est mutable, c'est à dire que l'on peut modifer l'un de ses éléments.

Modifier un élément :¶

In [6]:

tab_chaines[4]="tyty"
tab_chaines

tab_chaines[4]="tyty" tab_chaines

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-6-52bea0574696> in <module>
----> 1 tab_chaines[4]="tyty"
      2 tab_chaines

NameError: name 'tab_chaines' is not defined

Ajouter/supprimer un élément :¶

• Pour ajouter un élément à une liste on utilise la méthode append()

In [7]:

tab_chaines.append("toto")
tab_chaines

tab_chaines.append("toto") tab_chaines

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-7-54095f747353> in <module>
----> 1 tab_chaines.append("toto")
      2 tab_chaines

NameError: name 'tab_chaines' is not defined

In [8]:

# Remplissage d'un tableau dans une boucle
tab_cubes = [] # on déclare un tableau vide
for k in range(10):
    tab_cubes.append(k**3) # on ajoute le cube de l'indice à chaque tour de boucle
tab_cubes

# Remplissage d'un tableau dans une boucle tab_cubes = [] # on déclare un tableau vide for k in range(10): tab_cubes.append(k**3) # on ajoute le cube de l'indice à chaque tour de boucle tab_cubes

Out[8]:

[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]

• Pour supprimer un élément à une liste on utilise la méthode remove() ou encore la fonction del()

In [9]:

tab_chaines.remove("toto")
tab_chaines

tab_chaines.remove("toto") tab_chaines

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-9-2ece3f050679> in <module>
----> 1 tab_chaines.remove("toto")
      2 tab_chaines

NameError: name 'tab_chaines' is not defined

In [13]:

tab_chaines.remove(tab_chaines[-1])
tab_chaines

tab_chaines.remove(tab_chaines[-1]) tab_chaines

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-13-8a9468f4ac9c> in <module>
----> 1 tab_chaines.remove(tab_chaines[-1])
      2 tab_chaines

NameError: name 'tab_chaines' is not defined

In [ ]:

del(tab_chaines[0])
tab_chaines

del(tab_chaines[0]) tab_chaines

Concaténation :¶

In [18]:

tab_chaines = ["toto"] + tab_chaines + ["tete"]
tab_chaines

tab_chaines = ["toto"] + tab_chaines + ["tete"] tab_chaines

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-18-28763239a2d2> in <module>
----> 1 tab_chaines = ["toto"] + tab_chaines + ["tete"]
      2 tab_chaines

NameError: name 'tab_chaines' is not defined

In [19]:

monTableau = [0] * 6
monTableau

monTableau = [0] * 6 monTableau

Out[19]:

[0, 0, 0, 0, 0, 0]

Autre méthodes :¶

Placer le curseur après le point et appuyer sur la touche Tab

In [28]:

monTableau.append

monTableau.append

Out[28]:

<function list.append(object, /)>

Tableau par compréhension :¶

Il est possible de créer un tableau et de le remplir en une ligne grâce à la compréhension de tableau :

In [29]:

new_tab_entier = [n for n in range(1,6)]
new_tab_entier

new_tab_entier = [n for n in range(1,6)] new_tab_entier

Out[29]:

[1, 2, 3, 4, 5]

In [30]:

new_tab_cubes = [k**3 for k in range(10)]
new_tab_cubes

new_tab_cubes = [k**3 for k in range(10)] new_tab_cubes

Out[30]:

[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]

In [31]:

ma_liste_de_mots = [ "Cosinus", "Sinus", "Tangente", "Cotangente" ]
new_tab = [ len(mot) for mot in ma_liste_de_mots]
new_tab

ma_liste_de_mots = [ "Cosinus", "Sinus", "Tangente", "Cotangente" ] new_tab = [ len(mot) for mot in ma_liste_de_mots] new_tab

Out[31]:

[7, 5, 8, 10]

In [32]:

tab_input = [input("saisir un entier positif = ") for n in range(4)]
tab_decimal = [int(n) for n in tab_input]
tab_binaire = [bin(n) for n in tab_decimal]
tab_hexadecimal = [hex(n) for n in tab_decimal]
tab_input, tab_decimal, tab_binaire, tab_hexadecimal

tab_input = [input("saisir un entier positif = ") for n in range(4)] tab_decimal = [int(n) for n in tab_input] tab_binaire = [bin(n) for n in tab_decimal] tab_hexadecimal = [hex(n) for n in tab_decimal] tab_input, tab_decimal, tab_binaire, tab_hexadecimal

saisir un entier positif = 4
saisir un entier positif = 5
saisir un entier positif = 2
saisir un entier positif = 1

Out[32]:

(['4', '5', '2', '1'],
 [4, 5, 2, 1],
 ['0b100', '0b101', '0b10', '0b1'],
 ['0x4', '0x5', '0x2', '0x1'])

La compréhension de tableau permet de rajouter une condition if :

In [33]:

new_tab_tableaux = [[i for i in range(10) if i % 2 == 0],[j for j in range(10) if j % 2 == 1]]
new_tab_tableaux

new_tab_tableaux = [[i for i in range(10) if i % 2 == 0],[j for j in range(10) if j % 2 == 1]] new_tab_tableaux

Out[33]:

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

In [34]:

multiples_de_cinq_ou_de_sept_mais_pas_des_deux = [n for n in range(100) if ((n % 5 == 0 or n % 7 == 0) and n % 35 != 0)]
multiples_de_cinq_ou_de_sept_mais_pas_des_deux

multiples_de_cinq_ou_de_sept_mais_pas_des_deux = [n for n in range(100) if ((n % 5 == 0 or n % 7 == 0) and n % 35 != 0)] multiples_de_cinq_ou_de_sept_mais_pas_des_deux

Out[34]:

[5,
 7,
 10,
 14,
 15,
 20,
 21,
 25,
 28,
 30,
 40,
 42,
 45,
 49,
 50,
 55,
 56,
 60,
 63,
 65,
 75,
 77,
 80,
 84,
 85,
 90,
 91,
 95,
 98]

Une instruction par compréhension se construit de la façon suivante :

[fonction for i in sequence condition]

Identité et copie de tableau :¶

Deux tableaux qui sont liés par une relation d'égalité pointent vers la même adresse mémoire.

La modification de l'un entraîne la modification de l'autre.

Si l'on souhaite mémoriser l'état initial d'un tableau avant sa modification il faut le copier au préalable avec la méthode copy()...

In [35]:

t1 = [1,2,3]
t2 = t1
t3 = t1.copy()
t1, t2, t3

t1 = [1,2,3] t2 = t1 t3 = t1.copy() t1, t2, t3

Out[35]:

([1, 2, 3], [1, 2, 3], [1, 2, 3])

In [36]:

t1[0] = 5
t1, t2, t3

t1[0] = 5 t1, t2, t3

Out[36]:

([5, 2, 3], [5, 2, 3], [1, 2, 3])

Observation avec Python tutor¶

In [37]:

from metakernel import register_ipython_magics
register_ipython_magics()

from metakernel import register_ipython_magics register_ipython_magics()

In [38]:

%%tutor
t1 = [1,2,3]
t2 = t1
t3 = t1.copy()
t1[0] = 5
t3[1] = 7

%%tutor t1 = [1,2,3] t2 = t1 t3 = t1.copy() t1[0] = 5 t3[1] = 7

A programmer vous-même :

EXERCICE n°1 :¶

1- Écrire une fonction additionne_element(tableau) qui retourne la somme des éléments d’un tableau.

Tester pour tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]

2- Écrire une fonction moyenne_element(tableau) qui retourne la moyenne des éléments d’un tableau.

Tester pour tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]

EXERCICE n°2 :¶

Écrire une fonction supprimer_doublons(tableau) qui permet de supprimer les doublons d'un tableau.

Tester pour tableau = [20,41,52,41,20,78,41,63,52,20]

EXERCICE n°3 :¶

1- Écrire une fonction multiplie_par_2(tableau) qui multiplie par 2 chaque élément du tableau

Tester pour tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]

2- Écrire une compréhension de tableau qui permet d’effectuer cette tâche.

3- Compléter cette instruction pour que le tableau ne contienne que des valeurs supérieures à 50

In [ ]:

1)

1)

In [42]:

def additionne_element(tableau):
    somme=0
    for i in range(len(tableau)):
        somme += tableau[i]
    return somme

def additionne_element(tableau): somme=0 for i in range(len(tableau)): somme += tableau[i] return somme

In [43]:

tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]
additionne_element(tableau)

tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ] additionne_element(tableau)

Out[43]:

250

In [52]:

def moyenne_element(tableau):
    return additionne_element(tableau) / (len(tableau))

def moyenne_element(tableau): return additionne_element(tableau) / (len(tableau))

In [53]:

moyenne_element(tableau)

moyenne_element(tableau)

Out[53]:

35.714285714285715

In [ ]:

2)

2)

In [5]:

def supprimer_doublons(tableau):
    nvtableau = []
    for i in range(len(tableau)):
        if not tableau[i] in nvtableau:
            nvtableau += [tableau[i]]
    return nvtableau
tableau = [20,41,52,41,20,78,41,63,52,20]
supprimer_doublons(tableau)

def supprimer_doublons(tableau): nvtableau = [] for i in range(len(tableau)): if not tableau[i] in nvtableau: nvtableau += [tableau[i]] return nvtableau tableau = [20,41,52,41,20,78,41,63,52,20] supprimer_doublons(tableau)

Out[5]:

[20, 41, 52, 78, 63]

In [ ]:

3)

3)

In [4]:

def multiplie_par_2(tableau):
    for i in range(len(tableau)):
        tableau[i] = tableau[i]*2
    return tableau
test = [10,20,30,10,20,60,100]
multiplie_par_2(test)

def multiplie_par_2(tableau): for i in range(len(tableau)): tableau[i] = tableau[i]*2 return tableau test = [10,20,30,10,20,60,100] multiplie_par_2(test)

Out[4]:

[20, 40, 60, 20, 40, 120, 200]

In [3]:

test = [10,20,30,10,20,60,100]
toto = [test[i]*2 for i in range (len(test))]
toto

test = [10,20,30,10,20,60,100] toto = [test[i]*2 for i in range (len(test))] toto

Out[3]:

[20, 40, 60, 20, 40, 120, 200]

In [2]:

test = [10,20,30,10,20,60,100]
toto = [test[i]*2 for i in range (len(test)) if test[i]*2 > 50]
toto

test = [10,20,30,10,20,60,100] toto = [test[i]*2 for i in range (len(test)) if test[i]*2 > 50] toto

Out[2]:

[60, 120, 200]

---

Références aux programmes :¶

Contenus	Capacités attendues	Commentaires
Tableau indexé, tableau donné en compréhension	Lire et modifier les éléments d’un tableau grâce à leurs index. Construire un tableau par compréhension. Utiliser des tableaux de tableaux pour représenter des matrices : notation a [i] [j]. Itérer sur les éléments d’un tableau.	Seuls les tableaux dont les éléments sont du même type sont présentés. Aucune connaissance des tranches (slices) n’est exigible. L’aspect dynamique des tableaux de Python n’est pas évoqué. Python identifie listes et tableaux. Il n’est pas fait référence aux tableaux de la bibliothèque NumPy.

Pour Aller plus loin :¶

Le type list de Python permet de créer des tableaux (des listes de listes) pas obligatoirement homogènes en taille, ni en type :

In [1]:

monTableau= [[1,2,3,4],["toto","titi","tata"], [-3.14, 0.5, 1, 2.35, 6.48]]
monTableau[1][0], type(monTableau)

monTableau= [[1,2,3,4],["toto","titi","tata"], [-3.14, 0.5, 1, 2.35, 6.48]] monTableau[1][0], type(monTableau)

Out[1]:

('toto', list)

La bibliothèque numpy permet de gérer des tableaux numériques homogènes, des matrices...