5 - Types construits

⏪

⏬

⏩

1 - Principe

2 - String

3 - tableau stat.

4 - n-uplet

5 - dictionnaire

6 - FAQ

Nous avons vu les types de données et le moyen de les stocker dans des variables.

Reste un problème : si vous avez besoin de stocker 100 données, il va vous falloir 100 variables...

Nous allons voir comment créer des sortes de variables-conteneurs à données : nous pourront ainsi stocker 100 données dans une seule variable. C'est mieux !

Un type construit, une sorte de meuble à tiroirs

Vous allez voir par exemple comment stocker les notes de 30 élèves d'une classe et comment récupérer facilement la note de l'élève numéro 12 : il a eu 0 :

>>> notes = [2, 13, 18, 13, 0, 18, 1, 4, 10, 13, 12, 17, 0, 20, 15, 16, 10, 6, 16, 18, 19, 17, 4, 6, 15, 18, 3, 12, 1, 6]
>>> notes[12]
0

Vous allez aussi comprendre qu'en informatique on commence à compter à partir de 0 et pas à partir de 1 (voir ci-dessus...).

Dernière remarque : vous avez déjà travaillé avec un type assez proche d'un type construit puisqu'un string est une structure qui contient plusieurs caractères.

Logiciel nécessaire pour l'activité : Thonny

Evaluation : 5 questions

✎ question 11

✌ questions 06-08-12

Exercices supplémentaires 🏠 : Exercices

Documents de cours PDF : .PDF

Sources latex : .TEX et entete.tex et licence.tex

Résumé : Version HTML ou fond blanc ou ou PDF (couleur ou gris)

MODE COURS (cacher les questions)

1 - Principe général

⇩ ⇧ ⤊

1.1 Type simple : principe

Voir

Le type simple fait référence à un contenu unique.

On peut voir une variable de ce type comme une liaison entre un NOM et un CONTENU en mémoire :

flowchart LR D([Variable]) --> A([Contenu])

1.2 Type construit : principe

Voir

Le type construit fait plutôt référence à une armoire qui contient plusieurs boites. Ici, un tableau t1 qui fait référence à 10, 100 et 1000 :

Il est néanmoins préférable d'y voir un NOM qui permet d'atteindre un ensemble de CONTENUS.

Ici, c'est un numéro qui permet de distinguer les contenus qu'on peut trouver dans le conteneur pointé par la variable de nom t1.

flowchart LR D([Variable]) --> M([Conteneur]) M -- étiquette A --> A([Contenu A]) M -- étiquette B --> B([Contenu B]) M -- étiquette C --> C([Contenu C])

2 - String

⇩ ⇧ ⤊

Les types construits permettent de stocker n'importe quel autre type de données.

Le string est donc un cas particulier : il permet de stocker plusieurs données mais uniquement des données de type caractère.

D'où sa place un peu à part.

Rappels

(Rappel) 2.1 STRING : définition

Voir

Le type permettant de gérer les textes se nomme souvent string. Il s'agit d'un conteneur formant une collection ordonnée d'éléments qui sont tous des caractères.

String est un mot anglais qui signifie "chaîne" en français. Or, un texte est une chaîne de caractères : un ensemble de caractères qui se suivent. Exemple avec le mot Bonjour :

Indice	0	1	2	3	4	5	6
Elément	'B'	'o'	'n'	'j'	'o'	'u'	'r'

Indice se traduit par index en anglais.

flowchart LR D([Variable]) --> M([conteneur-string]) M -- indice 0 --> A([caractère 0]) M -- indice 1 --> B([caractère 1]) M -- indice 2 --> C([caractère 2])

Notez bien que la première case est la case d'indice 0, pas celle d'indice 1. Les indices disponibles dans un string de 7 caractères vont donc de 0 à 6.

(Rappel) 2.2 STRING : déclaration avec Python

Voir

En Python, les strings sont gérés par le type nommé str.

Déclaration

Un string Python est délimité par deux indicateurs signalant le début et la fin du string.

Cet indicateur peut être :

soit un guillemet simple : 'Bonjour' (touche du 4)
soit un guillemet double : "Bonjour" (touche du 3)
soit trois guillemets simples : '''Bonjour'''
soit trois guillemets doubles : """Bonjour"""
mais jamais de mélange pour un même string : si on commence avec un double, on finit avec un double. Si on mélange, l'interpréteur Python perd le fil : c'est une erreur de syntaxe.


>>> "Hello World !'
  File "", line 1
    "Hello World !'
                  ^
SyntaxError: EOL while scanning string literal

La phrase d'erreur peut se traduire par "Je suis arrivé à la fin de la ligne sans rencontrer le caractère de fermeture pendant que j'étais en train de lire le string".

Exemples :

Un guillemet simple pour l'ouverture et la fermeture.


>>> 'Hello World !'
'Hello World !'
 
>>> type('Hello World !')
<class 'str'>

Un guillemet double pour l'ouverture et la fermeture.


>>> "Hello World !"
'Hello World !'
 
>>> type("Hello World !")
<class 'str'>

Python répond toujours avec des guillemets simples lorsqu'il le peut.

Déclaration d'un string multi-ligne

On peut déclarer un string intégrant des passages à la ligne (celles intégrant des appuis sur ENTREE) en utilisant 3 guillemets :

s = """Voici une liste :
- premier truc
- deuxième truc
- troisième truc
 
En ici, c'est fini"""
 
print(s)

Voici l'affichage obtenu dans la console :


Voici une liste :
- premier truc
- deuxième truc
- troisième truc
 
En ici, c'est fini

Déclaration d'un string vide

Deux solutions


>>> s = ""
>>> s
''
 
>>> s = str()
>>> s
''

(Rappel) 2.3 STRING : opérateurs Python

Voir

On va retrouver une partie des symboles de opérateurs applicables sur les valeurs numériques mais leur signification n'est pas exactement la même.

concaténation avec +

str + str -> str


>>> "bon" + "jour"
'bonjour'


>>> '5' + '5'
'55'

La concaténation correspond à une sorte d'addition, mais la mécanique utilisée est celle d'un juxtaposition. D'où l'utilisation d'un autre terme.

Le deuxième exemple peut être perturbant pour un humain ! Mais il suffit de le lire correctement pour comprendre la réponse '55' que fournit l'interpréteur : Que donne la concaténation du caractère '5' et du caractère '5' ?

Avec Python, on notera qu'on ne peut pas concaténer ou additionner un string et un nombre. C'est un peu logique d'ailleurs. Que répondriez-vous en tant qu'humain à ceci :?


>>> 'Bonj' + 5
TypeError: can only concatenate str (not "int") to str

répétition avec *

str * int -> str

int * str -> str

La répétition correspond à une sorte de copier-coller d'un string.


>>> "Bon" * 2
'BonBon'
 
>>> 4 * "Pom ! "
'Pom ! Pom ! Pom ! Pom ! '
 
>>> '#' * 20
'####################'

et les autres ?

Les autres opérateurs (- / // % **">) ne sont pas implémentés sur les strings. Leur utilisation sur un string provoque donc une erreur.

(Rappel) 2.4 STRING : déterminer sa longueur

Voir

La longueur d'un string correspond au nombre de "cases-caractères" du string.

Cette longueur est importante pour ne pas déborder hors du string lors d'une lecture par indice : si le string est de longueur 45, vous savez que les indices valides vont de 0 à 44.

On utilise la fonction native len().


Indice     0123456 
>>> mot = "Bonjour"
>>> len(mot)
7

Comme on voit qu'il y a 7 caractères, on sait alors qu'on peut demander des indices allant de 0 à ...6.

Nouveautés

2.5 STRING : accéder à une case avec [i]

Voir

Accés

On peut accéder au caractère stocké dans une case dont on connaît l'indice en tapant le nom de la variable-string suivie de crochets et de l'indice.


Indice     0123456 
>>> mot = "Bonjour"
>>> mot[0]
'B'
 
>>> mot[1]
'o'
 
>>> mot[2]
'n'
 
>>> mot[7]
IndexError: list index out of range

Trois choses à distinguer

Le conteneur ⇨ s (le string)
Les indices ⇨ i
Les contenus ⇨ s[i]

2.6 STRING : immuable en Python (pas de modification)

Voir

En Python, les strings sont immuables (ou non mutables en franglais) : on ne peut pas modifier le contenu d'une case après la création du string.


>>> a = "bonjour"
>>> a[0] = "d"
TypeError: 'str' object does not support item assignment

D'autres langages se comportent comme Python : Java, C#, JavaScript...

2.7 STRING : accéder à toutes les cases

Voir

On utilise une boucle for .. in couplée à la fonction len() pour connaître l'indice i limite.

Ainsi avec "bonjour", on a 7 caractères d'indices 0 à 6.

s = "bonjour"
 
for i in range(len(s)):  # Pour chaque indice possible dans s
    print(s[i])          # Affiche le contenu de la case i

Ce programme est équivalent à ceci :

s = "bonjour"
 
print(s[0])
print(s[1])
print(s[2])
print(s[3])
print(s[4])
print(s[5])
print(s[6])

Ils affichent l'un et l'autre ceci dans la console :


b
o
n
j
o
u
r

2.8 STRING : mot-clés in et not in

Voir

Test d'appartenance ou de présence

On utilise l'opérateur binaire in qui renvoie un booléen.

Pour savoir si le string contenu est présent dans le string s, on tape contenu in s.


>>> "bon" in "bonjour"
True
 
>>> "Bon" in "bonjour"
False

Traduction : "bon" est-il présent dans "bonjour" ? "Bon" est-il présent dans "Bonjour" ?

Test de non-appartenance ou d'absence

On utilise l'opérateur binaire not in qui renvoie un booléen.

Pour savoir si le string contenu n'est pas présent dans le string s, on tape contenu not in s.


>>> "bon" not in "bonjour"
False
 
>>> "Bon" not in "bonjour"
True

Traduction : "bon" est-il absent de "bonjour" ? "Bon" est-il absent de "Bonjour" ?

01° Réaliser un programme qui stocke dans deux variables nb1 et nb2 le nombre de caractères présents dans les deux paragraphes fournis ci-dessous.

Paragraphe 1

En informatique, un système d'exploitation (souvent appelé OS — de l'anglais operating system — ou parfois SE — en français) est un ensemble de programmes qui dirige l'utilisation des ressources d'un ordinateur par les autres programmes et applications.

Paragraphe 2

Linux ou GNU/Linux est une famille de systèmes d'exploitation open source de type Unix fondés sur le noyau Linux créé en 1991 par Linus Torvalds. De nombreuses distributions Linux ont depuis vu le jour et constituent un important vecteur de popularisation du mouvement du logiciel libre.

Correction ?

...CORRECTION...

Programme qui mémorise

p1 = "En informatique, un système d'exploitation (souvent appelé OS — de l'anglais operating system — ou parfois SE — en français) est un ensemble de programmes qui dirige l'utilisation des ressources d'un ordinateur par les autres programmes et applications."
p2 = "Linux ou GNU/Linux est une famille de systèmes d'exploitation open source de type Unix fondés sur le noyau Linux créé en 1991 par Linus Torvalds. De nombreuses distributions Linux ont depuis vu le jour et constituent un important vecteur de popularisation du mouvement du logiciel libre."
 
nb1 = len(p1)
nb2 = len(p2)

02° Trouver (à l'aide d'un programme Python) le 27e caractère de chacune des phrases suivantes (attention, il s'agit donc du caractère d'indice... 26) :

Phrase 1

On notera que l'indice du premier élément ne porte pas le numéro 1 mais bien le numéro 0 !

Phrase 2

On notera également qu'on peut avoir accès à l'élément 5 sans avoir lu au préalable le 2,3 et 4. Ce n'est pas le cas pour toutes les structures de données.

Correction ?

...CORRECTION...


1
2
3
4
5 phrase1 = "On notera que l'indice du premier élément ne porte pas le numéro 1 mais bien le numéro 0 !"
phrase2 = "On notera également qu'on peut avoir accès à l'élément 5 sans avoir lu au préalable le 2,3 et 4. Ce n'est pas le cas pour toutes les structures de données."
 
print(phrase1[26])
print(phrase2[26])

03° Rajouter des commentaires (sur chaque ligne n'en comportant pas) de façon à expliquer ce que réalise ce programme. Attention, il faut expliquer l'intention de chaque ligne, pas de traduction mot à mot qui n'apporterait rien.

txt = "On notera que l'indice du premier élément ne porte pas le numéro 1 mais bien le numéro 0 !"
nbr_e = 0  # Initialisation à 0 du compteur des e
 
for i in range( len(txt) ):
    caractere = txt[i]
    print(caractere)
    if caractere == 'e':
        nbr_e = nbr_e + 1
 
print("Nombre de e :")
print(nbr_e)

Correction ?

...CORRECTION...



 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11 txt = "On notera que l'indice du premier élément ne porte pas le numéro 1 mais bien le numéro 0 !"
nbr_e = 0  # Initialisation à 0 du compteur des e
 
for i in range( len(txt) ):  # pour chaque indice possible dans txt
    caractere = txt[i]       # on récupère le caractère en position i
    print(caractere)         # on affiche ce caractère 
    if caractere == 'e':     # si ce caractère est un e
        nbr_e = nbr_e + 1    # on incrémente le compteur
 
print("Nombre de e :")       # on affiche ce string
print(nbr_e)                 # on affiche le compteur

04° Rajouter des commentaires de façon à expliquer ce que réalise ce programme. Attention, il faut expliquer l'intention de chaque ligne, pas de traduction mot à mot qui n'apporterait rien.

def est_binaire(s):
    for i in range(len(s)):
        if s[i] not in "01":
            return False
    return True
 
reponse = est_binaire("011101200")

Correction ?

...CORRECTION...



1
2
3
4
5
6
7 def est_binaire(s):          # déclaration d'une fonction est_binaire()
    for i in range(len(s)):   # pour chaque indice possible dans le string s
        if s[i] not in "01":  # si le caractère en position i n'apparait pas dans "01"
            return False      # on sort immédiatement en répondant False
    return True               # après la boucle, on répond True si on arrive ici
 
reponse = est_binaire("011101200")  # on lance un appel en envoyant "011101200" dans s puis on stocke le résultat dans reponse

3 - Tableau statique

⇩ ⇧ ⤊

Imaginons qu'on veuille stocker des notes d'élèves sur un DS. Prenons une classe de 4 élèves pour l'exemple (un exemple très réaliste...)

Nous pourrions stocker les notes d'Alice, Bob, Charlie et Dolores de cette façon :

alice = 20
bob = 8
charlie = 18
dolores = 12

Mais avec une trentaine d'élèves par classe, ça devient vite lassant...

3.1 TABLEAU STATIQUE : définition

Voir

Un tableau statique est un tableau comportant un nombre de cases fixé à la création.

Un tableau est un conteneur formant une collection ordonnée d'éléments ayant tous le même type. On peut donc avoir un tableau statique d'integers, ou un tableau statique de floats par exemple.

Les cases sont identifiées par un numéro nommé indice (index en anglais).

Voici deux exemples de tableaux :

Un tableau de caractères de 3 cases (indices 0-1-2)

Indice	0	1	2
Elément	'A'	'B'	'C'

Un tableau de flottants de 4 cases (indices 0-1-2-3) :

Indice	0	1	2	3
Elément	5.89	12.56	15.89	5.0

flowchart LR D([Variable]) --> M([conteneur-tableau]) M -- indice 0 --> A([élément 0]) M -- indice 1 --> B([élément 1]) M -- indice 2 --> C([élément 2])

Notez bien que la première case est la case d'indice 0, pas celle d'indice 1. Si un tableau possède 20 cases, les indices disponibles vont de 0 à 19.

3.2 TABLEAU STATIQUE : déclaration avec Python

Voir

Les tableaux statiques sont implémentés en Python sous forme d'une structure de données dont le type se nomme list.

A - Déclaration

On peut enregistrer une séquence de données dans un tableau statique en utilisant la syntaxe suivante :

un crochet [ en ouverture,
un crochet ] en fermeture et
des virgules pour séparer les valeurs.

Exemple avec un tableau contenant les notes de quatre élèves :


>>> notes = [20, 8, 18, 12]
>>> type(notes)
<class 'list'>

On notera que le type list de Python n'est pas un vrai tableau STATIQUE. Il permet de faire beaucoup plus de choses car c'est un tableau DYNAMIQUE :

les cases peuvent contenir des données de types différents,
on peut créer ou supprimer des cases.

Nous n'utiliserons très peu les propriétés dynamiques en 1er pour nous focaliser sur la notion de tableau statique.

B - Déclaration d'un grand tableau

On peut déclarer un tableau sur plusieurs lignes en tapant sur ENTREE après chaque virgule. Exemple :

eleves = ["Lisa",
    "Scott",
    "Matthias",
    "Antoine",
    "Ethan",
    "Lucas",
    "Manon"]

Cela prend plus de lignes mais on comprend un peu mieux ce qu'on place où.

C - Déclaration d'un tableau vide

Deux solutions


>>> t = []
>>> t
[]
 
>>> t = list()
>>> t
[]

3.3 TABLEAU STATIQUE : opérateurs Python

Voir

concaténation avec +

list + list -> list

>>> [10, 20] + [5, 30]
[10, 20, 5, 30]

répétition avec *

list * int -> list

int * list -> list


>>> [10] * 3
[10, 10, 10]
 
>>> 3 * [12]
[12, 12, 12]

3.4 TABLEAU STATIQUE : accéder à une case avec [i]

Voir

Accès

On peut accéder à l'élément stocké dans une case dont on connait l'indice en tapant simplement le nom de la variable-tableau suivie de crochets et du numéro d'indice.


Indice        0  1   2   3 
>>> notes = [20, 8, 18, 12]
>>> notes[0]
20
 
>>> notes[1]
8
 
>>> notes[2]
18
 
>>> notes[3]
12
 
>>> notes[4]
IndexError: list index out of range

Trois choses à distinguer

Le conteneur ⇨ t (le tableau)
Les indices ⇨ i
Les contenus ⇨ t[i]

3.5 TABLEAU STATIQUE : déterminer sa longueur

Voir

La longueur d'un tableau correspond au nombre de "cases-éléments" du tableau.

On utilise la fonction native len().


Indice        0  1   2   3 
>>> notes = [20, 8, 18, 12]
>>> len(notes)
4

Comme on voit qu'il y a 4 notes, on sait alors qu'on peut demander des indices allant de 0 à ...3.

3.6 TABLEAU STATIQUE : muable en Python (modification possible)

Voir

En Python, les tableaux sont muables (ou mutables en anglais) : on peut modifier le contenu d'une case après la création du tableau.

Imaginons qu'on ai oublié des points à Bob (l'élève d'indice 1) : il n'a pas 8 mais 11 finalement. Voici comment nous pourrions modifier le tableau APRES création


Indice        0  1   2   3 
>>> notes = [20, 8, 18, 12]
>>> notes[1] = 11
>>> notes
[20, 11, 18, 12]

Ce n'est pas une affectation sur le tableau lui-même : l'affectation est faite sur l'une des cases notes[i] du tableau.

3.7 TABLEAU STATIQUE : accéder à toutes les cases

Voir

On utilise une boucle for .. in couplée à la fonction len() pour connaitre l'indice i limite.

Ainsi avec [20, 8, 18, 12], on a 4 notes d'indices 0 à 3.

t = [20, 8, 18, 12]
 
for i in range(len(t)):  # Pour chaque indice possible dans t
    print(t[i])          # Affiche le contenu de la case i

Ce programme est équivalent à ceci :

t = [20, 8, 18, 12]
 
print(t[0])
print(t[1])
print(t[2])
print(t[3])

Ils affichent l'un et l'autre ceci dans la console :

3.8 TABLEAU STATIQUE : mot-clés in et not in

Voir

Test d'appartenance ou de présence

On utilise l'opérateur binaire in qui renvoie un booléen.

Pour savoir si le contenu est présent dans le tableau t, on tape contenu in t.


>>> "Alice" in ["Alice", "Bob", "Charlie"]
True
 
>>> "Dana" in ["Alice", "Bob", "Charlie"]
False

Traduction : "Alice" est-elle présente dans la liste des élèves ? "Dana" est-elle présente dans la liste ?

Test de non-appartenance ou d'absence

On utilise l'opérateur binaire not in qui renvoie un booléen.

Pour savoir si le contenu n'est pas présent dans le tableau t, on tape contenu not in t.


>>> "Alice" not in ["Alice", "Bob", "Charlie"]
False
 
>>> "Dana" not in ["Alice", "Bob", "Charlie"]
True

Traduction : "Alice" est-elle absente de la liste des élèves ? "Dana" est-elle absente de la liste ?

05° Créer un programme qui stocke le tableau eleves, stocke le nombre d'élèves dans une variable nb et stocke dans mystere le nom de l'élève d'indice 75 et dans mystere2 le nom de l'élève du 75^e élève.

eleves = ["Lisa", "Scott", "Matthias", "Antoine", "Ethan", "Lucas", "Manon", "Alexandre", "Alexandre", "Kenzo", "Thomas", "Lilou", "Aurélien", "Charles", "Manon", "Francia", "Imrane", "Sarah", "Yassin", "Sofian", "Noé", "Lenny", "Matt", "Ryiad", "Yanis", "Jason", "Damien", "Antonin", "Samy", "Laurine", "Rayan", "Eliot", "Victor", "Theo", "Julien", "Benjamin", "Flavian", "Nathan", "Nassim", "Evan", "Hugo", "Quentin", "Gwennaël", "Sullyvan", "Mathias", "Yanis", "Mathis", "Simon", "Mathis", "Matthew", "Brandon", "Axelle", "Mathieu", "Stéphane", "Hadrien", "Thomas", "Anton", "Thomas", "Djason", "Lohan", "Kylian", "Corentin", "Julien", "Léa", "Laura", "Anthony", "Audrey", "Léo", "Reda", "Ayoub", "Quentin", "Maïssa", "Tanguy", "Giovanni", "Mélia", "Gwenaël", "Ismaël", "Thomas", "Victor", "Andrew", "Théo", "Florian", "Louis", "Djebrine", "Angele", "Loann", "Medhi", "Jordy", "Pierre", "Kylian"]

Correction ?

...CORRECTION...


1
2
3
4
5 eleves = ["Lisa", "Scott", "Matthias", "Antoine", "Ethan", "Lucas", "Manon", "Alexandre", "Alexandre", "Kenzo", "Thomas",  "Lilou", "Aurélien", "Charles", "Manon",  "Francia", "Imrane",  "Sarah", "Yassin", "Sofian", "Noé",  "Lenny", "Matt", "Ryiad", "Yanis", "Jason", "Damien", "Antonin", "Samy", "Laurine", "Rayan", "Eliot", "Victor", "Theo", "Julien", "Benjamin", "Flavian", "Nathan", "Nassim", "Evan", "Hugo", "Quentin", "Gwennaël", "Sullyvan", "Mathias", "Yanis", "Mathis", "Simon", "Mathis", "Matthew", "Brandon", "Axelle", "Mathieu", "Stéphane", "Hadrien", "Thomas", "Anton", "Thomas", "Djason", "Lohan", "Kylian", "Corentin", "Julien", "Léa", "Laura", "Anthony", "Audrey", "Léo", "Reda", "Ayoub", "Quentin", "Maïssa", "Tanguy", "Giovanni", "Mélia", "Gwenaël", "Ismaël", "Thomas", "Victor", "Andrew", "Théo", "Florian", "Louis", "Djebrine", "Angele", "Loann", "Medhi", "Jordy", "Pierre", "Kylian"]
 
nb = len(eleves)
mystere = eleves[75]
mystere2 = eleves[74]

✌ 06° Créer une variable cours_lundi référençant un tableau de strings de 11 cases :

Indice 0 : le nom de la journée : "lundi".
Indice 1 : le nom du cours que vous avez de 8h à 9h
Indice 2 : le nom du cours que vous avez de 9h à 10h
Indice 3 : le nom du cours que vous avez de 10h à 11h
Indice 4 : le nom du cours que vous avez de 11h à 12h
Indice 5 : le nom du cours que vous avez de 12h à 13h
Indice 6 : le nom du cours que vous avez de 13h à 14h
Indice 7 : le nom du cours que vous avez de 14h à 15h
Indice 8 : le nom du cours que vous avez de 15h à 16h
Indice 9 : le nom du cours que vous avez de 16h à 17h
Indice 10 : le nom du cours que vous avez de 17h à 18h

Si vous n'avez pas cours sur le créneau, on insère un string "-" puisqu'on veut que ce soit un tableau de strings.

Exemple de début de déclaration si le lundi vous n'avez rien de 8h à 9h puis NSI de 9h à 10h.


>>> cours_lundi = ['lundi', "-", "NSI", ...

Deuxième question : une fois la variable en mémoire, que faut-il taper dans la console pour avoir le cours de 14h à 15h à partir de votre variable cours ?

07° Compléter la fonction afficher_les_cours() pour qu'elle parvienne à afficher correctement les cours de la journée transmise. Le paramètre journee est bien entendu un tableau similaire à celui de la question précédente.

def afficher_les_cours(journee):
    for ...
        print(...)
 
cours_mardi = ["mardi", "Math", "Math", "NSI", "NSI", "-", "Français", "Anglais", "-", "-", "-", "-"]
 
afficher_les_cours(cours_mardi)

Correction ?

...CORRECTION...



1
2
3
4
5
6
7 def afficher_les_cours(journee):
    for i in range(len(journee)):
        print(journee[i])
 
cours_mardi = ["mardi", "Math", "Math", "NSI", "NSI", "-", "Français", "Anglais", "-", "-", "-", "-"]
 
afficher_les_cours(cours_mardi)

✌ 08° Compléter la fonction nb_heures() pour qu'elle parvienne à renvoyer le nombre d'heures de cours durant la journée transmise. Donc tout sauf les "-". Le paramètre journee est bien entendu un tableau similaire à celui de la question précédente. Avant de répondre, pensez bien à gérer le fait que la première case contient en réalité le nom de la journée et qu'il ne faut donc pas la compter.

def nb_heures(journee):
    compteur = 0
    for ...:
        if ... != ...:
            compteur = compteur + ...
    return ... - ...
 
cours_mardi = ["mardi", "Math", "Math", "NSI", "NSI", "-", "Français", "Anglais", "-", "-", "-", "-"]
 
reponse = nb_heures(cours_mardi)

Après exécution du programme, la variable reponse devrait donc ici contenir 6.

4 - n-uplet

⇩ ⇧ ⤊

La différence majeure entre un tableau et un n-uplet vient du fait qu'on peut placer des éléments de type différent dans chacune des cases.

Imaginons qu'on désire stocker des informations sur un individu :

nom = "In Borderland"
prenom = "Alice"
age = 18
speNSI = True

On voit bien qu'on veut stocker 2 strings, un entier et un booléen. Dans un tableau statique, ce n'est pas possible.

4.1 n-UPLET : définition

Voir

Généralités

Un n-uplet est un conteneur formant une collection ordonnée d'éléments pouvant avoir un type différent les uns des autres.

Les cases sont identifiées par un numéro nommé indice (index en anglais).

Voici deux exemples de n-uplets :

Un 2-uplet dont les indices sont 0-1

Indice	0	1
Elément	'DS'	18

Un 4-uplet dont les indices sont 0-1-2-3 :

Indice	0	1	2	3
Elément	"In Bordeland"	"Alice"	18	True

Noms usuels de quelques n-uplets particuliers :

1-uplet : singleton
2-uplet : couple
3-uplet : triplet
4-uplet : quadruplet

Le mot français uplet se traduit par tuple en anglais.

flowchart LR V([Variable]) --> M([conteneur-tuple]) M -- indice 0 --> A([InBorderLand]) M -- indice 1 --> B([Alice]) M -- indice 2 --> C([18]) M -- indice 3 --> D([True])

Notez bien que la première case est la case d'indice 0, pas celle d'indice 1. Si un tableau possède 20 cases, les indices disponibles vont de 0 à 19.

4.2 n-UPLET : déclaration avec Python

Voir

Les tuples sont implémentés en Python sous forme d'une structure de données dont le type se nomme tuple.

Déclaration

On peut enregistrer une séquence de données dans un tuple en utilisant la syntaxe suivante :

une parenthèse ( en ouverture,
une parenthèse ) en fermeture et
des virgules pour séparer les valeurs.

Exemple avec un élève : nom, prénom, age, NSI ou pas :


>>> eleve = ("In Bordeland", "Alice", 18, True)
>>> eleve
('In Bordeland', 'Alice', 18, True)
 
>>> type(eleve)
<class 'tuple'>

Déclaration d'un grand tuple

Sachez qu'on peut déclarer un tuple sur plusieurs lignes et tapant sur ENTREE après chaque virgule. Exemple :

eleve = ("In Borderland",
    "Alice",
    18,
    True
)

Cela prend plus de lignes mais on comprend un peu mieux ce qu'on place où.

Déclaration d'un tuple vide

Deux solutions


>>> tup = ()
>>> tup
()
 
>>> tup = tuple()
>>> tup
()

Cas particulier du singleton

Pour déclarer un tuple de 1 élément, il faut nécessairement placer une virgule, sinon l'interpréteur Python prendra vos parenthèses comme de simples parenthèses.

Correct pour du tuple :


>>> tp1 = (10,)
>>> tp1
(10,)
 
>>> type(tp1)
<class 'tuple'>

Incorrect pour du tuple :


>>> tp2 = (10)
>>> tp2
10
 
>>> type(tp2)
<class 'int'>

4.3 n-UPLET : opérateurs Python

Voir

concaténation avec +

tuple + tuple -> tuple

>>> (10, 20) + (5, 30)
(10, 20, 5, 30)

répétition avec *

tuple * int -> tuple

int * tuple -> tuple


>>> (10,) * 3
(10, 10, 10)
 
>>> 3 * (10, 12)
(10, 12, 10, 12, 10, 12)

Erreur de sémantique courante

Nous avions vu l'erreur de sémantique suivante :


>>> 5,2 + 1,2
(5, 3, 2)

Pour la comprendre, il faut se rendre compte qu'on demande à Python d'interpréter un tuple !

Voici ce que comprend l'intepréteur Python :


>>> (5,2 + 1,2)
(5, 3, 2)

On lui demande donc d'évalue un triplet contenant 5 sur l'indice 0, 2 + 1 sur l'indice 1 et 2 sur l'indice 2.

Moralité : explicite c'est mieux qu'implice.

4.4 n-UPLET : accéder à une case avec [i]

Voir

Accès

On peut accéder à l'élément stocké dans une case dont on connait l'indice en tapant simplement le nom de la variable-tuple suivie de crochets et du numéro d'indice.

Attention, on place des crochets pour accéder, les parenthèses c'est pour la déclaration.


Indice               0          1      2   3 
>>> eleve = ("In Bordeland", "Alice", 18, True)
>>> eleve[0]
'In Bordeland'
 
>>> eleve[1]
'Alice'
 
>>> eleve[2]
18
 
>>> eleve[3]
True
 
>>> eleve[4]
IndexError: tuple index out of range

Trois choses à distinguer

Le conteneur ⇨ tup (le n-uplet)
Les indices ⇨ i
Les contenus ⇨ tup[i]

4.5 n-UPLET : déterminer sa longueur

Voir

La longueur d'un tuple correspond au nombre de "cases-éléments" du tuple.

On utilise la fonction native len().


Indice               0          1      2   3 
>>> eleve = ("In Bordeland", "Alice", 18, True)
>>> len(eleve)
4

4 éléments, on sait alors qu'on peut demander des indices allant de 0 à 3.

4.6 n-UPLET : immuable en Python (pas de modification)

Voir

En Python, les tuples sont immuables (ou non mutables en anglais) : on ne peut pas modifier le contenu d'une case après la création du n-uplet.

Imaginons qu'on veuille mettre les informations sur Alice à jour le jour de ses 19 ans :


Indice               0          1      2   3 
>>> eleve = ("In Bordeland", "Alice", 18, True)
>>> eleve[2] = 19
TypeError: 'tuple' object does not support item assignment

4.7 n-UPLET : accéder à toutes les cases

Voir

On utilise une boucle for .. in couplée à la fonction len() pour connaitre l'indice i limite.

Ainsi avec ("In Borderland", "Alice", 18, True ), on a 4 éléments d'indices 0 à 3.

eleve = ("In Borderland", "Alice", 18, True)
 
for i in range(len(eleve)):  # Pour chaque indice possible dans eleve
    print(eleve[i])          # Affiche le contenu de la case i

Ce programme est équivalent à ceci :

eleve = ("In Borderland", "Alice", 18, True)
 
print(eleve[0])
print(eleve[1])
print(eleve[2])
print(eleve[3])

Ils affichent l'un et l'autre ceci dans la console :


'In Borderland'
'Alice'
18
True

4.8 n-UPLET : mot-clés in et not in

Voir

Fonctionne exactement comme avec les tableaux, si ce n'est que ce sont des tuples.

Test d'appartenance ou de présence

On utilise l'opérateur binaire in qui renvoie un booléen.

Pour savoir si le contenu est présent dans le tuple tup, on tape contenu in tup.


>>> "Alice" in ("Alice", "Bob", "Charlie")
True
 
>>> "Dana" in ("Alice", "Bob", "Charlie")
False

Traduction : "Alice" est-elle présente dans la liste des élèves ? "Dana" est-elle présente dans la liste ?

Test de non-appartenance ou d'absence

On utilise l'opérateur binaire not in qui renvoie un booléen.

Pour savoir si le contenu n'est pas présent dans le tuple tup, on tape contenu not in t.


>>> "Alice" not in ("Alice", "Bob", "Charlie")
False
 
>>> "Dana" not in ("Alice", "Bob", "Charlie")
True

Traduction : "Alice" est-elle absente de la liste des élèves ? "Dana" est-elle absente de la liste ?

09° L'encodage ASCII des caractères fait correspondre un nombre compris entre 0 et 127 à quelques caractères. Dans la mesure où la correspondance est figée, nous allons la stocker dans un tuple immuable plutôt que dans un tableau muable.

Deux questions

Afficher le caractère ayant l'indice 65 en utilisant le tuple ascii ci-dessous.
Trouver le message qui se cache derrière la suite d'indices 67-111-117-99-111-117.

ascii = ('\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f', ' ', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', '\x7f')

Correction ?

...CORRECTION...

On place ceci dans un programme et on lance pour le mettre en mémoire.

1

ascii = ('\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f', ' ', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', '\x7f')

Il suffit alors d'interroger l'interpréteur :


>>> ascii[65]
'A'
 
>>> ascii[67]
'C'
 
>>> ascii[111]
'o'
 
>>> ascii[117]
'u'
 
>>> ascii[99]
'c'
 
>>> ascii[111]
'o'
 
>>> ascii[117]
'u'

10° Compléter le programme pour parvenir à interpréter le tableau d'entiers compris entre 0 et 127 et à afficher le message ASCII correspondant. Rajoutez des commentaires de façon à rendre ce programme compréhensible.

Vous remarquerez que le print() possède un paramètre supplémentaire nommé end configuré pour remplacer le passage à la ligne par rien ("") à la fin de chaque print.

ascii = ('\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f', ' ', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', '\x7f')
 
message = [67, 111, 117, 99, 111, 117]
 
for i in ...
    valeur = ...[...]
    caractere = ...[...]
    print(..., end="")
 
print("")

Une fois votre programme fonctionnel, vous devriez voir Coucou s'afficher dans la console.

Correction ?

...CORRECTION...

ascii = ('\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f', ' ', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', '\x7f')
 
message = [67, 111, 117, 99, 111, 117]
 
for i in range(len(message)):  # pour chaque indice possible de message
    valeur = message[i]        # on récupère la valeur codant le caractère i
    caractere = ascii[valeur]  # on l'utilise avec ascii pour retrouver le caractère voulu
    print(caractere, end="")   # on affiche le caractère sans passer à la ligne
 
print("")  # passage à la ligne final

5 - Dictionnaire

⇩ ⇧ ⤊

Parfois, on ne connaît pas nécessairement les informations qu'on va vouloir stocker.

Imaginons qu'on veuille compter le nombre de fois où chaque mot est présent dans une phrase. Deux raisons de ne pas utiliser de tableau ou de n-uplet :

Au vu du nombre de mots possibles, pas moyen de créer un tableau statique ou un n-uplet, il y aurait beaucoup trop de cases (et la majorité des cases seraient vides).
Comment connaître l'indice d'un mot qu'on cherche ? Ca peut vite être long s'il faut lire les cases une par une depuis le début à chaque fois...

Dans ce cas, la meilleure solution est le dictionnaire.

(Rappel) 5.1 DICTIONNAIRE : définition

Voir

Un dictionnaire est un tableau associatif. Un dictionnaire est une collection non ordonnée d'éléments (contrairement aux tableaux et n-uplets où les éléments sont ordonnés via leurs indices).

Il comporte donc des cases qui portent un nom et possèdent un contenu.

On nomme :

clé (key en anglais) le nom de la case.
valeur (value en anglais) le contenu de la case.

Voici un dictionnaire décrivant le contenu d'un ds : les clés sont les noms des élèves et les contenus les notes.

Clé	"Alice"	"Bob"	"Charlie"
Valeur	13	8	12

On peut résumer cela ainsi par l'image ci-dessous : le nom du dictionnaire permet de trouver les clés du dictionnaire qui permettent de trouver les valeurs associées.

flowchart LR D([Variable notes]) --> M([conteneur-dictionnaire]) M -- Clé Alice --> A([13]) M -- Clé Bob --> B([8]) M -- Clé Charlie --> C([12])

(Rappel) 5.2 DICTIONNAIRE : déclaration

Voir

Le type de l'objet dictionnaire (dictionary en anglais) dans Python se nomme dict.

Déclaration

Les éléments délimiteurs sont les accolades {}.
On fournit un couple (cle, valeur) en utilisant la syntaxe Python suivante : cle: valeur.
Chaque couple est séparé des autres par une virgule.

Exemple avec le dictionnaire décrivant un devoir surveillé :

`1`	`ds = {"Alice": 13, "Bob": 8, "Charlie": 12}`

Déclaration d'un grand dictionnaire

Sachez qu'on peut déclarer un dictionnaire sur plusieurs lignes en tapant sur ENTREE après chaque virgule. Exemple :

ds = {
    "Alice": 13,
    "Bob": 8,
    "Charlie": 12
    }


>>> ds = {"Alice": 13, "Bob": 8, "Charlie": 12}
>>> type(ds)
<class 'dict'>

Déclaration d'un dictionnaire vide

Deux solutions


>>> d = {}
>>> d
{}
 
>>> d = dict()
>>> d
{}

5.3 DICTIONNAIRE : opérateurs Python

Voir

Ni concaténation, ni répétition.

C'est fini.

(Rappel) 5.4 DICTIONNAIRE : accéder à une valeur avec [cle]

Voir

Pour récupérer la valeur d'une case, il faut connaître sa clé. On accède à une valeur en tapant le nom du dictionnaire suivi de la clé entre crochets.

Attention, on place des crochets pour accéder, les accolades c'est pour la déclaration.


>>> ds = {"Alice": 13, "Bob": 8, "Charlie": 12}
>>> ds["Alice"]
13
 
>>> ds["Charlie"]
12
 
>>> ds["Bob"]
8
 
>>> ds["Bob l'éponge"]
KeyError: "Bob l'éponge"

Comme vous le voyez, si on fournit une clé inconnue, on déclenche une erreur, comme avec un mauvais indice pour un tableau.

Résumé :

Si d est un dictionnaire,
Si c est une clé valide dans le dictionnaire,
Alors d[c] est le contenu associé à la clé c du dictionnaire d,

5.5 DICTIONNAIRE : déterminer sa longueur

Voir

On peut utiliser la fonction native len() pour obtenir le nombre de couples (clé, valeur) enregistrés dans un dictionnaire.

Exemple


>>> ds = {"Alice": 13, "Bob": 8, "Charlie": 12}
>>> nbr = len(ds)
>>> nbr
3

5.6 DICTIONNAIRE : muable en Python (modification possible)

Voir

En Python, les dictionnaires sont muables (ou mutables en anglais) : on peut modifier le contenu d'une case après la création du dictionnaire.

Modification d'un couple existant

Imaginons qu'on ai oublié des points à Bob : il n'a pas 8 mais 11 finalement. Voici comment nous pourrions modifier le tableau APRES création


>>> {"Alice": 13, "Bob": 8, "Charlie": 12}
>>> notes["Bob"]
8
 
>>> notes["Bob"] = 11
>>> notes["Bob"]
11
 
>>> notes
{'Alice': 13, 'Bob': 11, 'Charlie': 12}

Notez bien que ce n'est pas une affectation sur le dictionnaire : l'affectation est faite sur l'un des contenus des associations clé-valeur du dictionnaire, pas sur le dictionnaire lui-même.

Rajout d'un nouveau couple

On peut rajouter de la même façon un couple qui n'existe pas encore.

Imaginons un nouvel élève nommé David qui a eu 15.


>>> {"Alice": 13, "Bob": 11, "Charlie": 12}
>>> notes["David"] = 15
 
>>> notes
{'Alice': 13, 'Bob': 11, 'Charlie': 12, 'David': 15}

5.7 DICTIONNAIRE : accéder à toutes les cases

Voir

On utilise une boucle for .. in mais on ne peut pas la coupler à la fonction len puisqu'un dictionnaire possède des clés, pas des indices.

Voici la manière usuelle d'obtenir les clés une par une.

ds = {"Alice": 13, "Bob": 8, "Charlie": 12}
 
for cle in ds.keys():  # Pour chaque cle possible dans ds
    print(ds[cle])     # Affiche la valeur associée à cette clé

Ce programme est équivalent à ceci :

ds = {"Alice": 13, "Bob": 8, "Charlie": 12}
 
print(ds["Alice"])
print(ds["Bob"])
print(ds["Charlie"])

Ils affichent l'un et l'autre ceci dans la console :


13
8
12

5.8 DICTIONNAIRE : mot-clés in et not in

Voir

Test d'existence d'une clé

On utilise l'opérateur binaire in qui renvoie un booléen.

Pour savoir si la cle est une clé dans le dictionnaire d, on tape cle in d.

Version explicite :


>>> d = {"Alice": 12, "Bob": 8}
>>> "Alice" in d.keys()
True
 
>>> "Dana" in d.keys()
False

Version implicite :


>>> d = {"Alice": 12, "Bob": 8}
>>> "Alice" in d
True
 
>>> "Dana" in d
False

Traduction : "Alice" est-elle une clé présente dans le dictionnaire d ? "Dana" est-elle une clé présente dans le dictionnaire d ?

Test d'absence d'une clé

On utilise l'opérateur binaire not in qui renvoie un booléen.

Pour savoir si la cle n'est pas une clé dans le dictionnaire d, on tape cle not in d.

Voici la version explicite :


>>> d = {"Alice": 12, "Bob": 8}
>>> "Alice" not in d.keys()
False
 
>>> "Dana" not in d.keys()
True

Voici la version implicite :


>>> d = {"Alice": 12, "Bob": 8}
>>> "Alice" not in d
False
 
>>> "Dana" not in d
True

Traduction : "Alice" est-elle absente en tant que clé dans le dictionnaire ? "Dana" est-elle absente en tant que clé dans le dictionnaire ?

✎ 11° Créer une variable cours_du_lundi référençant un dictionnaire de strings :

Les clés seront des strings du type "10-11" correspondant aux horaires de vos cours du lundi
Les valeurs associées devront être les intitulés des cours ("NSI", "Math", "LLCER"...)

Pensez à utiliser une déclaration sur plusieurs lignes, avec un seul couple clé: valeur par ligne, si vous voulez que cela soit facilement compréhensible.

Si vous n'avez pas cours sur le créneau, pas la peine de créer de clés.

Questions

Que faut-il taper dans la console pour avoir le cours de 14h à 15h à partir de votre variable cours_du_lundi ?
Peut-on le faire sans danger ou faut-il vérifier quelque chose avant ?

✌ 12° Expliquer à quoi sert ce programme en commentant chaque ligne en lui donnant du sens :

Remarque : la ligne 11 ne sert qu'à faire une pause le temps que l'utilisateur appuie sur ENTREE. De cette façon, la boucle se fait au rythme que vous voulez.

txt = "Linux ou GNU/Linux est une famille de systèmes d'exploitation open source de type Unix fondés sur le noyau Linux créé en 1991 par Linus Torvalds. De nombreuses distributions Linux ont depuis vu le jour et constituent un important vecteur de popularisation du mouvement du logiciel libre."
compteur = {}
 
for i in range(len(txt)):
    caractere = txt[i]
    if caractere in compteur.keys():
        compteur[caractere] = compteur[caractere] + 1
    else:
        compteur[caractere] = 1
    print(compteur)
    input()

🏠 TRAVAIL PERSONNEL° Réaliser les exercices supplémentaires Maison (voir le lien) en rédigeant correctement vos réponses.

Exercices

BILAN EN CLASSE° Répondre aux questions proposées pusi fournir le déroulé des lignes suivies par l'interpréteur lancé sur le programme ci-dessous.

Si t fait référence à un tableau :

Que veut dire à priori i ?
Que veut dire à priori t[i] ?
Que veut dire à priori t ?
Que veut dire à priori len(t) ?
Que veut dire à priori for i in range(len(t)): ?

Si t = [10, 20, 12] :

Quelle est l'évaluation de t[0] ?
Quelle est l'évaluation de t[1] ?
Quelle est l'évaluation de t[2] ?
Quelle est l'évaluation de len(t) ?
Quelles sont les valeurs prises successivement par i avec for i in range(len(t)): ?
Fournir les lignes que va exécuter l'interpréteur Python au fur et à mesure de l'éxécution du programme.

def somme(t):
    s = 0
    for i in range(len(t)):
        s = s + t[i]
    return s
 
def moyenne(t):
    total = somme(t)
    nbr = len(t)
    return total / nbr
 
moy = {}
notes_alice = [10, 15, 20]
notes_bob   = [10, 14]
 
moy["alice"] = moyenne(notes_alice)
moy["bob"]   = moyenne(notes_bob)

6 - FAQ

⇩ ⇧ ⤊

J'ai entendu parler de types composés ou structurés. C'est quoi ?

Voir

Des synonymes.

La notion de type construit est parfois dénommée également type structuré ou type composé.

On peut détruire une variable ?

Voir

Oui, on peut libérer la place mémoire attribuée à une variable. Pour cela, il faut utiliser le mot-clé del.

Exemple :


>>> a = 5
>>> a
5
 
>>> del a
>>> a
NameError: name 'a' is not defined

J'ai vu une notation bizarre : a += 1

Voir

Effectivement, on peut également utiliser une autre notation.

1
2

a = 10
a += 1

Cela donne ici le même résultat que ceci :

1
2

a = 10
a = a + 1

Attention, les deux façons de faire sont équivalentes ici, mais pas toujours. Evitez ces notations pour l'instant. De toutes manières, elles ne seront pas utilisées dans les sujets de NSI. Gardez la méthode n°2. C'est plus long mais c'est moins compliqué à comprendre de toutes manières.

Activité publiée le 17 09 2022
Dernière modification : 13 07 2023
Auteur : ows. h.

⏪

⏫

⏩