223	234
	1-4

@0 Préparer une présentation orale résumant 2 à 3 notions abordées lors de la dernière séance de cours :

choisir UNE notion différente par élève au sein de chaque équipe,
se préparer à réaliser, en 5 minutes maximum, sur 1/3 du tableau blanc, un croquis accompagné de mots clés et du titre de la notion abordée pour soutenir la présentation orale,
se préparer à présenter, SANS notes, sa notion en 1,5 minutes maximum.

TABLEAUX INDEXES

1 - Les séquences

Jusqu’à présent, nous avons manipulé des variables avec des types simples : int, bool, float. Ce sont des conteneurs (ou structures) ne contenant qu’une seule valeur.

Nous avons aussi utilisé des variables de type str qui :

ont la possibilité de stocker plusieurs valeurs dans une même structure (ou conteneur), et
permettent d’accéder à chaque valeur précisément selon sa position dans la structure.

Le type str en Python est ce qu’on appelle une chaîne de caractère et appartient à la famille des structures de données appelées séquences, mais il n’est pas le seul. Il existe aussi les p-uplets et les tableaux.

Les séquences sont donc des types de variables qui permettent à l’utilisateur de stocker plusieurs données les unes après les autres. Ainsi, on peut effectuer sur une séquence, des actions comme examiner et manipuler les éléments stockés.

Définitions :

une séquence est un ensemble ordonné d’éléments indicés de $0$ à $n-1$ (si cette séquence comporte n éléments). On parle aussi de structure indexée.
une séquence est aussi une structure itérable. Cela signifie que l’on peut organiser une itération (boucle for) sur celle-ci. Autrement dit on peut parcourir chaque élément d’une séquence à l’aide d’une boucle for.

Nous allons étudier plus particulièrement 2 types de séquences : les p-uplets et les tableaux (il en existe d’autres que nous évoquerons en terminale). Mais avant cela, revoyons déjà ce que permettent les séquences dites chaînes de caractères utilisées dans Python via le type str.

2 - Les chaînes de caractères

Les variables str sont utilisés pour créer et stocker des chaînes immutables (c’est-à-dire des variables qui ne changent pas une fois qu’ils sont créés). Python fournit une grande variété d’outils et de techniques de programmation que vous pouvez utiliser pour examiner et manipuler les chaînes de caractères.

Nous pouvons itérer sur chaque caractère d’une chaîne à l’aide de la boucle for :



nom="NSI"
for carac in nom
   print (carac)

Ce qui produit:

N
S
I

Chaque caractère d’une chaîne possède un indice. Le premier caractère a pour indice 0. On peut ainsi accéder à chaque caractère individuellement.


nom="NSI"
print(nom[2])

Ce qui produit:

La fonction intégrée len() renvoie la longueur d’une chaîne de caractères.



nom="NSI"
taille = len(nom)
print ("Le nom", nom, "a une longueur de", taille, "caractères.")

Ce qui produit:

Le nom NSI a une longueur de 3 caractères.

Remarque : Il existe de nombreuses fonctions associées aux chaînes de caractères que nous découvrirons au fil des besoins d’utilisation…

Nous allons, à présent, étudier plus particulièrement 2 types de séquences : les p-uplets et les tableaux qui possèdent beaucoup de similitudes avec les chaînes de caractères et aussi des différences à bien connaitre.

3 - Les p-uplets

Définition : Un p-uplet est une séquence immutable. C’est-à-dire une suite indexée de valeurs (de n’importe quel type) que l’on ne peut pas modifier une fois crée.

En Python, un p-uplet est de type tuple.

3.1 Créer un `tuple`

Un tuple est défini à l’aide de parenthèses.

Exemples présentant les différentes manières de définir un tuple :










monTuple1=() # commentaire
monTuple2=(3,) # commentaire
monTuple3=(1,4,5,'moto',4.6)
monTuple4=monTuple2+monTuple3 # commentaire
print(monTuple4) # commentaire

print(type(monTuple1)) # commentaire

monTuple5=monTuple2*5 # commentaire
print(monTuple5) # commentaire

@1 Tester puis commenter les exemples ci-dessus, à l’aide de PythonTutor :

Réponse :

3.2 Accéder à un élément d’un `tuple`

On accède à un élément d’un tuple à l’aide de crochets.

Exemples d’accès à un élément d’un tuple :







monTuple=(3, 1,4,5,'moto',4.6)

print(monTuple[2]) # commentaire
print(monTuple[0]) # commentaire
print(monTuple[-1]) # commentaire 

print(monTuple[2:4]) # commentaire

@2 Tester puis commenter les exemples ci-dessus, à l’aide de PythonTutor :

Réponses :

@3 On considère le tuple suivant : monTuple=(1,4,5,'moto',(12,'nsi','génial'),4.6). Ecrire les lignes de code correspondant aux commentaires ci-dessous :

Réponse :






monTuple=(1,4,5,'moto',(12,'nsi','génial'),4.6)

 # affiche moto
 # affiche le dernier élément du tuple 4.6
 # affiche (4,5)
 # affiche ('nsi','génial')

3.3 Modifier (muter) un `tuple`

Comme un tuple est un immutable (voir définition plus haut), on ne peut pas réaffecter ses éléments, supprimer un élément ou encore en ajouter. Autrement dit, on peut réaffecter (ou “modifier”) un tuple mais pas ses éléments.

Exemples d’actions de modification :

monTuple=(1,4,5,'moto',4.6) # commentaires
monTuple[3]='vive la moto !' # commentaires

monTuple=('A','B', 3,14) # commentaires
monTuple=monTuple[0:2] # commentaires

@4 Tester puis commenter les exemples ci-dessus, à l’aide de PythonTutor :

Réponse :

3.4 Parcourir (itérer) un “tuple”

@5 Compléter le code ci-dessous permettant d’afficher tous les éléments d’un tuple à l’aide d’une boucle for

Réponse :

monTuple=(5,4,2,8,"moto")

for i in ... : # i parcourt tous les indices de la séquence "monTuple"
	print(monTuple[i])

En réalité il est beaucoup plus simple de parcourir tous les éléments d’une séquence (ici d’un p-uplet). En effet en Python la boucle for ne sert pas qu’à parcourir une séquence de nombres entiers, mais permet de parcourir n’importe quelle séquence, c’est-à-dire n’importe quel tuple.

Comme un tuple est itérable (voir défiition d’une séquence), on peut organiser une itération dessus. Autrement dit on peut parcourir chaque élément d’un tuple à l’aide d’une boucle for.

Exemples d’actions d’itération :

monTuple=(5,4,2,8,"moto")

for element in monTuple : # element prend à chaque tour les éléments de la séquence
	print(element) #

Ainsi, la ligne for element in monTuple : signifie littéralement :

“pour chaque élément” element
“dans la séquence” monTuple
“faire ce qui suit :”

Reprenons la boucle for du @4

monTuple=(5,4,2,8,"moto")

for i in range(len(monTuple)): # i parcourt tous les indices de la séquence "monTuple"
	print(monTuple[i])

@6 Remplaçer monTuple[i] par i, puis tester puis commenter les exemples ci-dessus, à l’aide de PythonTutor :

Réponse :

Remarque : On peut donc en conclure que range(nombre) est un tuple ou plutôt se comporte comme un tuple.

@7 Créer une boucle for affichant les entiers de 1 à 9 et commenter le code.

Réponse :

@8 Tester puis commenter les exemples ci-dessous, à l’aide de PythonTutor :

Réponse :

Remarque : On peut donc en conclure que la fonction toto() est un tuple ou plutôt renvoie un tuple au terme de son exécution.








def toto ():
    return 1,2,3

print(toto())
print(type(toto()))

for i in toto() :
    print(i)

3.5 Opérations et méthodes sur les “tuple”

Considérons s une séquence de type tuple:

Opérations/méthodes	Description
`x in s`	Renvoie `True` si un élément de `s` est égal à `x`, `False` sinon
`x not in s`	Renvoie `True` si aucun un élément de `s` n’est égal à `x`, `False` sinon
`len(s)`	Renvoie le nombre d’éléments de `s`
`s == t`	Renvoie `True` si `s` et `t` sont de même type, ont la même longueur, et ont des éléments égaux deux à deux.
`s[i]`	Renvoie l’élément d’indice `i` de `s`. Le premier élément a pour indice `0`.
`s[i:j]`	Renvoie une partie de l’indice `i` à `j` non inclus
`s.index(x)`	Renvoie l’indice de la première apparition de `x` dans `s`
`s.count(x)`	Renvoie le nombre d’apparitions de `x` dans `s`
`s + t`	Renvoie une nouvelle séquence concaténation de `s` et `t`.
`n * t`	Renvoie une nouvelle séquence composée de la concaténation de `t` avec lui-même `n` fois.

Exemple d’opérations et méthodes à compléter.

jours_1=('lundi','mardi','mercredi','jeudi','vendredi')
jours_2=('samedi','dimanche')

 # Tester si samedi est un élément de jours_1

 # Donner la longueur de jours_2

 # Tester si jours_1 est égal à jours_2

 # Donner la partie de jours_1 entre le deuxième élément et le quatrième élément

 # renvoyer l'indice de dimanche dans jours_2

 # Renvoyer le nombre de samedi dans jours_2

 # Créer un tuple semaine par concaténation de jours_1 et de jours_2

@9 Compléter le code ci-dessus en utilisant les méthodes et les opérations du tableau pour réaliser les différentes actions précisées dans les commentaires. Tester le script sur un éditeur Python sur l’ordinateur ou en ligne comme Trinket ou Thonny Python :

Solutions :

@10 Ecrire une fonction est_dans() qui reçoit, en argument, un entier element et un tuple d’entier tple et renvoie un booléen indiquant la présence de element dans tple, puis tester :

est_dans(9,(1,2,3,4,5,6))
est_dans(4,(1,2,3,4,5,6))

Solution :

@11 Ecrire une fonction tri() qui accepte comme paramètre en entrée, trois nombres a, b et c et renvoie en sortie ces trois mêmes nombres mais triés par ordre croissant.

Correction :

Indice 1 :





def tri(a, b, c) :
    ...
    return ...

print(tri(5, 9, 3.14))

Indice 2 :















def tri (a, b, c) :
    if a<b:
        if b<c:
            tple=(a,b,c)
        elif c<a :
            tple=(c,a,b)
        else :
            tple=(a,c,b)
    else :
        ...

    return tple

print(tri(5, 9, 3.14))

4 - Les tableaux dynamiques

Définition : Un tableau dynamique est une séquence mutable. C’est-à-dire une suite indexée de valeurs (de n’importe quel type) que l’on peut modifier.

En Python, un tableau est de type list.
En Python, les tableaux (donc les list) sont dynamiques, cela veut dire qu’ils ont la particularité d’avoir une taille variable alors que les autres langages de programmation utilisent, par défaut, des tableaux de taille fixe.
Nous verrons en Terminale qu’en réalité ces variables sont des “mutants” : mi-tableaux / mi-liste chainée … d’où, peut-être le nom de list.

4.1 Créer une “list”

Une list est définie à l’aide de crochets.

Exemples issus du chapitre tuple convertis en list :

tab1=[] # ...
tab2=[3] # ...
tab3=[1,4,5,'moto',4.6]
tab4=tab2+tab3 # ...
print(tab4) # ...

print(type(tab1)) # ...

tab5=tab2*5 # ...
print(tab5) # ...

@12 Tester le script ci-dessus avec un éditeur Python sur l’ordinateur ou en ligne comme Trinket ou Thonny Python, puis rédiger les commentaires associés.

Réponses :

4.2 Accéder à un élément d’une “list”

On accède à un élément d’une list à l’aide de crochets, comme pour le type tuple.

Exemples issus du chapitre tuple mais en version list :

tab4=[3, 1,4,5,'moto',4.6]

print(tab4[2]) #
print(tab4[0]) # 
print(tab4[-1]) # 

print(tab4[2:4]) #

@13 Tester puis commenter les exemples ci-dessus.

Réponses :

4.3 Modifier (muter) une `list`

Comme une list est mutable (voir définition plus haut), on peut donc réaffecter ses éléments, supprimer un élément ou encore en ajouter.

Exemples de modification/mutation de list :









mon_tableau=[5,4,"A",8,"moto"]
mon_tableau = mon_tableau + [35] # Ajoute un élément à la fin du tableau
mon_tableau += [36] # Ajoute un élément à la fin du tableau

print(mon_tableau)

mon_tableau[2]= 5 # Modifie l'élément d'indice 2

print(mon_tableau)

@14 Dans les exemples ci-dessus, quelle ligne aurait provoqué une erreur si la variable avait été de type tuple au lieu de list ? Pourquoi ?

Réponse :

La ligne 7 modifie une partie du tableau (list) mon_tableau car un tableau (list) est mutable. On ne peut pas modifier l"intérieur" d’un tuple (le muter !)

4.4 Parcourir (itérer) une `list`

Comme une list est itérable (voir défiition d’une séquence), on peut organiser une itération dessus. Autrement dit on peut parcourir chaque élément d’une list à l’aide d’une boucle for.

@15 Compléter le code ci-dessous permettant d’afficher tous les éléments d’une list à l’aide d’une boucle for

Réponses :

tab=[5,4,2,8,"moto"]

for ... in ... :
	print(...)

Ainsi, la ligne for bidule in tab : signifie littéralement :

“pour chaque élément” bidule (on choisi le nom de varaible que l’on veut, mais un nom de variable element aurait été plus adapté)
“dans la séquence” tab
“faire ce qui suit :”

@15 bis Compléter le code ci-dessous permettant de faire la même chose que le programme précédant mais en utilisant range dans la boucle for

Réponses :

tab=[5,4,2,8,"moto"]

for ... in range(...) :
	print(...)

Il aurait été plus judicieux de choisir un nom de variable indice à la place de truc mais cela fonctionne.
On constate que ce programme est moins pratique que le for element in tab mais cela fonctionne aussi !!!

4.5 Création en extension

La création en extension consiste à ajouter à la fin d’une liste (un tableau) existante un élément, exemples :




tab=[3,8,"mot",True]
print(tab)
tab = tab + [1001]
print(tab)

On peut ainsi créer une liste (un tableau) à l’aide d’une boucle for:





tab=[]
for i in range (11) :
    tab = tab + [2**i]

print(tab)

On peut aussi utiliser la fonction extend qui permet d’ajouter un tableau à la fin d’un tableau. Attention à la manière d’appeler cette fonction qui doit être précédée du nom du tableau séparé par un point mon_tableau.extend(tableau_a_ajouter).

Remarque : On comprend bien que extend signifie extension à la fin !!!

@16 A l’aide de la fonction extend, ré-écrire le code de création par extension ci-dessus :

Solution

On peut aussi utiliser la fonction append qui permet d’ajouter un élément à la fin d’un tableau. Attention à la manière d’appeler cette fonction qui doit être précédée du nom du tableau séparé par un point mon_tableau.append(element_a_ajouter).

@17 A l’aide de la fonction append, ré-écrire le code de création par extension ci-dessus :

Solution

4.6 Création en compréhension

Comprendre :
Créer un tableau (list) par compréhension c’est faire en sorte que la ou les boucles for permettant de remplir le tableau soient comprises (compréhension) dans la déclaration (création) du tableau. Une sorte de ligne de code “tout-compris”… est-ce bien compris ? Pas de problème de compréhension particulier ? ;-)



tab1=[2*x for x in range(10)]
tab2=[2*x+1 for x in range(10)]
tab3=[x**2 for x in range(10)]

@18 Traduire les scrypts Python ci-dessus en script de création par extension :

Correction















tab1=[]
for x in range(10):
    tab1 = tab1 + ...

print(tab1)

tab2=[]
...

print(tab2)

tab3=[]
...

print(tab3)

@19 Ecrire deux scripts Python qui créent la liste (tableau) des entiers de 0 à 100 de deux méthodes différentes :

en extension
en compréhension

Correction

@20 Traduire les 3 scripts de l’exercice @18 en 3 scripts utilisant la fonction append()

Correction















tab1=[]
for x in range(10):
    tab1.append(...)

print(tab1)

tab2=[]
...

print(tab2)

tab3=[]
...

print(tab3)

@21 Comprendre la construction de tableau ci-dessous et écrire un script créant le même tableau (list) par extension.

Correction :



import random

liste=[random.randint(1,6) for i in range(1000)]

@22 Comprendre la construction de tableau ci-dessous et écrire une instruction réalisant le même tableau (list) par compréhension.

Correction :



tab=[]
for i in range (10) :
    tab = tab + ['i' * i]

Attention aux confusions :

Création par extension ne veut pas dire qu’il faut utiliser nécessairement extend().
Création par extension veut dire "créer une liste vide et la remplir avec une boucle for incluant :
- append(), ou
- extend(), ou
- +
Création par compréhension veut dire “créer une liste en une seule ligne” (tout-compris !)

4.7 Créer une liste d’éléments identiques

@23 Rédiger un script créant un tableau de 10 éléments prenant tous la valeur 7

Réponse :

Correction :

@24 Comprendre et expliquer la différence entre ['a'] * 5 et ['a' * 5]. Puis remplacer 'a'par 3 et compléter l’explication de la différence de construction de la liste (tableau).

Réponse :

la commande ['a'] * 5 génère une liste avec 5 éléments 'a' donc ['a', 'a', 'a', 'a', 'a'], alors que
la commande ['a' * 5] génère une liste de 1 élément composé de 5 caractères 'a' donc ['aaaaa']
la commande [3] * 5 génère une liste avec 5 éléments 3 donc [3, 3, 3, 3, 3], alors que
la commande [3 * 5] génère une liste de 1 élément produit de $3$ par $5 = 15$ donc [15]

Création par compréhension veut dire “créer une liste en une seule ligne”, donc les méthodes ci-dessus sont des créations par extension aussi !

4.8 Méthodes et opérations sur les “list”

@25 Créer une fonction permettant de compter le nombre d’éléments d’une liste (sans utiliser la fonction len()).

Correction :









def compteElements (liste):
    ...
    for element in liste :
        ...

    return nbElements

tab=["a","b","c",56432243,43,1345,4,3,7]
print(compteElements(tab))

@26 Créer une fonction permettant de compter le nombre d’occurences (d’apparitions) d’un élément dans une liste (sans utiliser la fonction count()).

Correction :








def nombreOccurences(element,liste):
    pass


    return nbOccurences

tab=["a","b","c",56432243,43,1345,4,3,7,'b']
print(nombreOccurences('b',tab))

@27 Créer une fonction permettant trouver l’indice d’un élément donné dans une liste (sans utiliser la fonction index()).

Correction :

En trichant “un petit peu” avec l’aide de len()on obtient :







def indiceElement (liste, recherche):
    for indice in range(len(liste)) :
        if liste[indice] == recherche:
            return indice

tab=["a","b","c",56432243,43,1345,4,3,7,'b']
indiceElement(tab,'b')





def indiceElement (liste, recherche):
    pass

tab=["a","b","c",56432243,43,1345,4,3,7,'b']
indiceElement(tab,'b')

@28 Créer une fonction permettant de supprimer un élément d’une liste, connaissant son indice.

Correction :

Attention le programme ci-dessous fonctionne, correspond à une autre consigne !









def supprimeElement(liste, element):
    newliste = []
    for i in liste:
        if i != element:
            newliste += [i]
    return newliste

tab=["a","b","c",56432243,43,1345,4,3,7,'b']
print(supprimeElement(tab,'b'))





def supprimeIndice(liste, indice) :
    pass

tab=["a","b","c",56432243,43,1345,4,3,7,'b']
print(supprimeIndice(tab,1))

@29 Créer une fonction permettant d’inverser les éléments d’une liste, exemple : [1,2,3,4,5] devient [5,4,3,2,1]. Tester ensuite cette fonction à l’aide du simulateur PythonTutor.

Correction :





def inverser(liste):
    pass

maListe = [1,2,3,4,5]
print(inverser(maListe))

Important : On peut appliquer au type list toutes les méthodes, fonctions et opérations du type tuple.

Considérons s une séquence de type list:

Opérations/méthodes	Description
`x in s`	Renvoie `True` si un élément de `s` est égal à `x`, `False` sinon
`x not in s`	Renvoie `True` si aucun un élément de `s` n’est égal à `x`, `False` sinon
`len(s)`	Renvoie le nombre d’éléments de `s`
`s == t`	Renvoie `True` si `s` et `t` sont de même type, ont la même longueur, et ont des éléments égaux deux à deux.
`s[i]`	Renvoie l’élément d’indice `i` de `s`. Le premier élément a pour indice `0`.
`s[i:j]`	Renvoie une partie de l’indice `i` à `j` non inclus
`s.index(x)`	Renvoie l’indice de la première apparition de `x` dans `s`
`s.count(x)`	Renvoie le nombre d’apparitions de `x` dans `s`
`s + t`	Renvoie une nouvelle séquence concaténation de `s` et `t`.
`n * t`	Renvoie une nouvelle séquence composée de la concaténation de `t` avec lui-même `n` fois.

Attention : Le type list possède en plus, des méthodes, fonctions et opérations spécifiques qui ne sont PAS applicables au type tuple.

Opérations/méthodes	Description
`s.append(x)`	Ajoute l’élément `x` à la fin de la liste `s`. Cela équivaut à `s = s + [x]`
`s.extend(l)`	Ajoute la liste `l` à la liste `s`. Est équivalent à `s = s + l`
`s[i] = x`	Modifie la liste et affecte la valeur `x` à la case d’indice `i`. Attention, cette case doit exister.
`s.insert(i,v)`	Insère l’élément `x` dans `s` à l’indice `i` . Cette méthode décale les indices suivants.
`s.remove(x)`	Supprime de la liste le premier élément dont la valeur est égale à `x`.
`s.pop(i)`	Enlève de la liste l’élément à la position `i` et renvoie sa valeur. En l’absence de `i`, c’est le dernier élément qui est supprimé et renvoyé.
`s.sort()`	Trie la liste. Attention, la liste est ainsi modifiée.
`s.reverse()`	Modifie la liste en inversant l’ordre des éléments de `s`.

@30 Pour chaque exercice de @25 à @29, proposer une ligne de script réalisant la même action à l’aide des “opérations spécifiques” au type list et des “opérations communes” aux type list et tuple décrites ci-dessus.

Correction :

@31 Tester avec le simulateur PythonTutor, le script ci-dessous puis expliquer pourquoi il ne permet pas réellement de “dupliquer” une liste.

liste = [1,2,3]
copie = liste

copie[1]=4
print(liste)
print(copie)

@32 Proposer une fonction duplique qui duplique une liste mais permet que les deux listes soient indépendantes. Tester les instructions ci-dessous.

BONUS A l’aide de recherches sur Internet, compléter le tableau des “opérations spécifiques” au type list ci-dessus des fonctions suivantes

copy
join
split

TABLEAUX INDEXES

1 - Les séquences

2 - Les chaînes de caractères

3 - Les p-uplets

3.1 Créer un tuple

3.2 Accéder à un élément d’un tuple

3.3 Modifier (muter) un tuple

3.4 Parcourir (itérer) un “tuple”

3.5 Opérations et méthodes sur les “tuple”

4 - Les tableaux dynamiques

4.1 Créer une “list”

4.2 Accéder à un élément d’une “list”

4.3 Modifier (muter) une list

4.4 Parcourir (itérer) une list

4.5 Création en extension

4.6 Création en compréhension

4.7 Créer une liste d’éléments identiques

4.8 Méthodes et opérations sur les “list”

3.1 Créer un `tuple`

3.2 Accéder à un élément d’un `tuple`

3.3 Modifier (muter) un `tuple`

4.3 Modifier (muter) une `list`

4.4 Parcourir (itérer) une `list`