NSI Cours Terminale : Rappel (3ème partie)

Rappel (3ème Partie)

Tuples

En Python, un tuple est une structure de données qui permet de regrouper plusieurs valeurs ensemble.

mignon = ('moi', 'moche', 'mechant')

type(mignon)

Comme pour les chaines de caractères, on peut connaître le nombre d’éléments d’un tuple en utilisant len

mignon = ('moi', 'moche', 'mechant')
len(mignon)

len( (1, 2, 3, 4, 5) )

Comme pour les chaines de caractères, on peut utiliser in pour savoir si un certain objet est dans la tuple.

mignon = ('moi', 'moche', 'mechant')
'moi' in mignon

True

mignon = ('moi', 'moche', 'mechant')
'm' in mignon

False

Comme pour les chaines de caractères, on peut accéder à un indice $x$ du tuple en utilisant [x].

mignon = ('moi', 'moche', 'mechant')
mignon[1]

'moche'

# Les indices négatifs marchent comme pour les chaines de caractères.
mignon = ('moi', 'moche', 'mechant')
mignon[-1]

'mechant'

Comme pour les chaines de caractères, on ne peut pas changer la valeur d’un élément d’un tuple.

mignon[1] = 'beau'

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In[5], line 1
----> 1 mignon[1] = 'beau'


TypeError: 'tuple' object does not support item assignment

On appelle une telle propriété l’immuabilité.

L’immuabilité désigne la propriété d’un objet ou d’une donnée qui ne peut pas être modifié une fois créé.

On peut utiliser + pour concaténer deux tuples.

plus_mignon = mignon + ('debile', 'pauvre')

print(plus_mignon)

('moi', 'moche', 'mechant', 'debile', 'pauvre')

Comme pour les chaines de caractères, on peut également découper des tuples:

plus_mignon[2:]

('mechant', 'debile', 'pauvre')

plus_mignon[1:3]

('moche', 'mechant')

On peut convertir des chaines de caractères en tuples en utilisant la fonction tuple.

mot = 'education'
tuple(mot)

('e', 'd', 'u', 'c', 'a', 't', 'i', 'o', 'n')

La fonction suivante renvoie un tuple.

def perimetre_et_surface_d_un_rectangle(longeur, largeur):
    perimetre = 2*longeur + 2*largeur
    surface = longeur * largeur
    return (perimetre, surface)

perimetre_et_surface_d_un_rectangle(5, 4)

(18, 20)

type( perimetre_et_surface_d_un_rectangle(5, 4) )

tuple

Lorsqu’une fonction renvoie un tuple, il n’est pas obligatoire de mettre des parenthèses.

def perimetre_et_surface_d_un_rectangle(longeur, largeur):
    perimetre = 2*longeur + 2*largeur
    surface = longeur * largeur
    return perimetre, surface

perimetre_et_surface_d_un_rectangle(5, 4)

(18, 20)

On peut également utiliser des virgules pour affecter plusiers variables en même temps.

On appelle ce processus unpacking.

a, b, c = (3, 4, 5)

Les tailles des deux côtés doivent cependant correspondre.

a, b = (3, 4, 5)

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

Cell In[19], line 1
----> 1 a, b = (3, 4, 5)


ValueError: too many values to unpack (expected 2)

a, b, c, d = (3, 4, 5)

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

Cell In[20], line 1
----> 1 a, b, c, d = (3, 4, 5)


ValueError: not enough values to unpack (expected 4, got 3)

Si on veut un tuple de taille $1$ , il faut mettre une virgule pour le distinguer d’un int entre parenthèses.

sans_comma = (3)
avec_comma = (3,)

type(sans_comma)

int

type(avec_comma)

tuple

(1, 2) + sans_comma

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In[24], line 1
----> 1 (1, 2) + sans_comma


TypeError: can only concatenate tuple (not "int") to tuple

Soit tup = (1, 4, 27, 256, 3125). Remplacer les # ??? # pour que chaque cellule renvoie True.

tup = (1, 4, 27, 256, 3125)
a = # ??? #
tup[a:] == (27, 256, 3125)

  Cell In[26], line 2
    a = # ??? #
        ^
SyntaxError: invalid syntax

tup = (1, 4, 27, 256, 3125)
b = # ??? #
tup[b] == 4

  Cell In[28], line 2
    b = # ??? #
        ^
SyntaxError: invalid syntax

tup = (1, 4, 27, 256, 3125)
c = # ??? #
tup[-c:] == (27, 256, 3125)

  Cell In[32], line 2
    c = # ??? #
        ^
SyntaxError: invalid syntax

tup = (1, 4, 27, 256, 3125)
d = # ??? #
tup[1:2] == d

  Cell In[36], line 2
    d = # ??? #
        ^
SyntaxError: invalid syntax

Parmi les cellules suivantes, lesquelles renvoient une erreur ?

Dans le cas échéant, pourquoi ?

Réfléchissez avant de les éxecuter.

a = (1, 2)
a = (2, 1)

a = (1, 2)
a[1] = 2

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In[39], line 2
      1 a = (1, 2)
----> 2 a[1] = 2


TypeError: 'tuple' object does not support item assignment

a = (1, 2)
print(a[-1])

a = (1)
len(a)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In[5], line 2
      1 a = (1)
----> 2 len(a)


TypeError: object of type 'int' has no len()

a = (1)
print(a[0])

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In[41], line 2
      1 a = (1)
----> 2 print(a[0])


TypeError: 'int' object is not subscriptable

a = (1,)
a[0] = 1

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In[3], line 2
      1 a = (1,)
----> 2 a[0] = 1


TypeError: 'tuple' object does not support item assignment

Compléter la fonction milieu.

# Cette fonction renvoie un tuple de floats, le milieu de (x0, y0) et (x1, y1).
def midpoint(x0, y0, x1, y1):
    x = (x0 + x1)/2
    y = # ??? #
    return # ??? #

  Cell In[44], line 4
    y = # ??? #
        ^
SyntaxError: invalid syntax

La fonction distance prend comme argument deux tuples p et q, chacun avec une taille 2.

Elle renvoie un float, la distance entre $p = (x_0, y_0)$ à $q = (x_1, y_1)$ .

La formule pour la distance est $\sqrt{(x_1 - x_0)^2 + (y_1 - y_0)^2}$

Compléter cette fonction.

from math import sqrt

def distance(p, q):
    x0 = # ??? #
    y0 = # ??? #
    x1, y1 = # ??? #
    return # ??? #

  Cell In[106], line 4
    x0 = # ??? #
         ^
SyntaxError: invalid syntax

Vérifiez votre reponse ici:

print( distance( (-2, 3), (1, -1) ) ) # 5.0
print( distance( (-1, 0), (0, -1) ) ) # 1.4142135623730951
print( distance(  (0, 0), (7, 24) ) ) # 25.0

5.0
1.4142135623730951
25.0

Listes

En Python, une liste est une structure de données qui permet de stocker une collection ordonnée d’éléments.

À la différence de tuples, on utilise des crochets au lieu des parenthèses.

mignon_liste = ['moi', 'moche', 'mechant']

type(mignon_liste)

list

Les listes présentent une forte similarité avec les tuples mais avec une différence majeur. Nous la verrons dans quelques minutes !

Comme pour les tuples, on peut connaître le nombre d’éléments d’une liste en utilisant len.

len(mignon_liste)

Comme pour les tuples, on peut utiliser in pour savoir si un certain objet est dans une liste.

mignon_liste = ['moi', 'moche', 'mechant']
'moche' in mignon

True

mignon = ['moi', 'moche', 'mechant']
'mignon' in mignon

False

Comme pour les tuples, on peut accéder à un indice $x$ du tuple en utilisant [x].

mignon_liste[1]

'moche'

🎺 Et maintenant, la différence majeur… 🎺

À la différence des tuples, les listes sont mutables, ça veut dire qu’on peut ajouter, supprimer ou modifier des éléments après leur création.

mignon_liste = ['moi', 'moche', 'mechant']
mignon_liste[1] = 'beau'
print(mignon_liste)

['moi', 'beau', 'mechant']

On peut utiliser la méthode .pop() pour enlever et renvoyer le dernier élément d’une liste.

mignon_liste = ['moi', 'beau', 'mechant']
enleve = mignon_liste.pop()
print(enleve)
print(mignon_liste)

mechant
['moi', 'beau']

Remarquer la nouvelle syntaxe !

Au lieu de pop(mignon_liste) (qui renvoie une erreur), on écrit mignon_liste.pop().

Nous découvrirons plus tard pourquoi on l’écrit comme ça.

On peut utiliser la méthode .append() pour ajouter un élément à la fin d’une liste.

mignon_liste = ['moi', 'beau']
mignon_liste.append('mais pas trop')
print(mignon_liste)

['moi', 'beau', 'mais pas trop']

Comme pour les tuples, on peut utiliser + pour concaténer deux listes et créer une nouvelle liste au lieu de modifier une liste.

mignon_liste = ['moi', 'beau', 'mais pas trop']
nimporte_quoi = [1, 2, 3]
nouvelle_liste = mignon_liste + nimporte_quoi
print(nouvelle_liste)
print(mignon_liste)

['moi', 'beau', 'mais pas trop', 1, 2, 3]
['moi', 'beau', 'mais pas trop']

Comme les tuples, on peut également éxtraire des sous-listes de la liste initiale.

mignon_liste = ['moi', 'beau', 'mais pas trop', 1, 2, 3]
nouvelle_liste = mignon_liste[-5:-1]
print(nouvelle_liste)
print(mignon_liste)

['beau', 'mais pas trop', 1, 2]
['moi', 'beau', 'mais pas trop', 1, 2, 3]

Remarquez que cet opération n’affecte pas la liste originale.

Depuis une chaîne de caractères, on peut utiliser la méthode split() pour obtenir une liste des mots ou des sous-chaînes en fonction d’un séparateur spécifié.

ma_chaine = "super,genial,trop top,inoui"
ma_chaine.split(",")

['super', 'genial', 'trop top', 'inoui']

ma_chaine = "super,genial,trop top,inoui"
ma_chaine.split(" ")

['super,genial,trop', 'top,inoui']

ma_chaine = "super,genial,trop top,inoui"
ma_chaine.split("op")

['super,genial,tr', ' t', ',inoui']

On peut également utiliser la méthode join() d’une chaine de caractères pour concaténer les éléments d’une liste en une seule chaîne de caractères, en les séparant par un séparateur spécifié.

ma_liste = ["trop beau", "groovy", "trop frais", "cheesy"]
",".join(ma_liste)

'trop beau,groovy,trop frais,cheesy'

ma_liste = ["trop beau", "groovy", "trop frais", "cheesy"]
"".join(ma_liste)

'trop beaugroovytrop fraischeesy'

ma_liste = ["trop beau", "groovy", "trop frais", "cheesy"]
"👏👏".join(ma_liste)

'trop beau👏👏groovy👏👏trop frais👏👏cheesy'

On peut “multiplier” des strings, des tuples, et des listes par des entiers. Voici des exemples:

'cou' * 10

'coucoucoucoucoucoucoucoucoucou'

'a' + ('na' * 2) + 's'

'ananas'

[0] * 8

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

[123456789] * 0

[]

Écrire une fonction liste_de_zeros qui prend comme argument un entier strictement positif x et qui renvoie une liste de taille x qui contient uniquement des 0.

print( liste_de_zeros(8) ) # [0, 0, 0, 0, 0, 0, 0, 0]

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

Cell In[56], line 1
----> 1 print( liste_de_zeros(8) ) # [0, 0, 0, 0, 0, 0, 0, 0]


NameError: name 'liste_de_zeros' is not defined

La fonction deja_visite prend comme arguments une chaine des caractères pays et une liste de chaines des caractères pays_visites, les pays qu’on a visité. Il retourne True si pays est dans la liste pays_visites et False sinon. Complétez cette fonction.

pays_visites = ['France', 'Italie', 'Kiribati']

def deja_visite(pays, pays_visites):
    return # ??? #

Verifier vos réponses ici:

pays_visites = ['France', 'Italie', 'Kiribati']
print( deja_visite('France', pays_visites) ) # True
print( deja_visite('Italie', pays_visites) ) # True
print( deja_visite('Corée du Nord', pays_visites) ) # False
print( deja_visite('Italie', ['France']) ) # False

True
True
False
False

La fonction tete_de_la_liste prend comme argument une liste d’entiers et un entier x. Il doit renvoyer une liste contenant le x premiere elements de la liste.

def tete_de_la_liste(liste, x):
    return # ??? #

Est-ce qu’une fonction peut modifier une liste définie hors d’une fonction?

Éxecuter les cellules suivantes puis compléter les phrases qui suivent.

def ajoute_par_append(liste, elt):
    resultat = liste.append(elt)
    return resultat

def ajoute_par_plus(liste, elt):
    resultat = liste + [elt]
    return resultat

ma_liste = [1, 2, 3]
print( ajoute_par_append(ma_liste, 4) )
print( ma_liste )
print( "\n" )
print( ajoute_par_plus(ma_liste, 5) )
print( ma_liste )
print( "\n" )
print( ajoute_par_append(ma_liste, 6) )
print( ma_liste )
print( "\n" )
print( ajoute_par_plus(ma_liste, 7) )
print( ma_liste )

None
[1, 2, 3, 4]


[1, 2, 3, 4, 5]
[1, 2, 3, 4]


None
[1, 2, 3, 4, 6]


[1, 2, 3, 4, 6, 7]
[1, 2, 3, 4, 6]

Répondez aux questions suivantes :

Le type de liste.append(elt) est :
- a. NoneType
- b. list
Donc la fonction ajoute_par_append renvoie quelque chose de type :
- a. NoneType
- b. list
Le type de liste + [elt] est :
- a. NoneType
- b. list
Donc la fonction ajoute_par_plus renvoie quelque chose de type :
- a. NoneType
- b. list
Quelle fonction ne modifie pas les listes définies hors de la fonction ?
- a. ajoute_par_append
- b. ajoute_par_plus
Quelle fonction modifie les listes même si la liste est definie hors de la fonction ?
- a. ajoute_par_append
- b. ajoute_par_plus

On ne vous interrogera pas sur ce sujet en terminale, mais c’est une subtilité importante à savoir si vous continuez dans l’informatique.

Dictionnaires

En Python, un dictionnaire est une structure de données qui permet de stocker des paires clé-valeur, permettant un accès rapide et efficace aux valeurs à partir de leurs clés.

emoji = {
    'content': '🙂',
    'triste': '😞',
    'fête': '🥳'
}

type(emoji)

dict

Dans l’exemple ci-dessus:

les clés sont 'content', 'triste' et 'fête' .
les valeurs sont des chaînes de caractères qui contiennent des emojis.

Les clés d’un dictionnaire doivent être immuables.

coords = {
    (3, 5): 'tresor',
    (-2, 3): 'demon',
    (1, 6): 'piege'
}

# Les listes comme clés sont interdit...
# ...parce que ils sont pas immuables.
coords_liste = {
    [3, 5]: 'tresor',
    [-2, 3]: 'demon',
    [1, 6]: 'piege'
}

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In[13], line 3
      1 # Les listes comme clés sont interdit...
      2 # ...parce que ils sont pas immuables.
----> 3 coords_liste = {
      4     [3, 5]: 'tresor',
      5     [-2, 3]: 'demon',
      6     [1, 6]: 'piege'
      7 }


TypeError: unhashable type: 'list'

Remarque: les types qu’on a vus dans la première session (str, int, bool, float, None) sont tous immuables donc on peut les utiliser comme clés.

On peut accéder à la valeur associée d’une clé en utilisant des crochets.

emoji = {
    'content': '🙂',
    'triste': '😞',
    'fête': '🥳'
}

emoji['fête']

'🥳'

coords = {
    (3, 5): 'tresor',
    (-2, 3): 'demon',
    (1, 6): 'piege'
}

coords[(1,6)]

'piege'

Si la clé n’existe pas dans le dictionnaire, on rencontre une erreur.

coords = {
    (3, 5): 'tresor',
    (-2, 3): 'demon',
    (1, 6): 'piege'
}

coords[(0,0)]

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

Cell In[34], line 7
      1 coords = {
      2     (3, 5): 'tresor',
      3     (-2, 3): 'demon',
      4     (1, 6): 'piege'
      5 }
----> 7 coords[(0,0)]


KeyError: (0, 0)

On peut ajouter des paires clé-valeurs.

emoji = {
    'content': '🙂',
    'triste': '😞',
    'fete': '🥳'
}

emoji['mdr'] = '🤣'
emoji

{'content': '🙂', 'triste': '😞', 'fete': '🥳', 'mdr': '🤣'}

On peut aussi changer la valeur d’une clé existante.

coords = {
    (3, 5): 'tresor',
    (-2, 3): 'demon',
    (1, 6): 'piege'
}

coords[(3,5)] = 'monstre'
coords

{(3, 5): 'monstre', (-2, 3): 'demon', (1, 6): 'piege'}

Il existe des méthodes .keys(), .values() et .items(), qui retournent des “listes” associées au dictionnaire.

emoji.keys()

dict_keys(['content', 'triste', 'fete', 'mdr'])

coords.values()

dict_values(['monstre', 'demon', 'piege'])

emoji.items()

dict_items([('content', '🙂'), ('triste', '😞'), ('fete', '🥳'), ('mdr', '🤣')])

Exercices

Voici un dictionnaire mon_dico.

mon_dico = {
    'nombres': [1, 2, 3],
    'lettres': ['a', 'b', 'c'],
    'sports':  ['foot', 'belote', 'petanque']
}

Remplacer # ??? # dans la cellule suivante pour qu’elle affiche ['a', 'b', 'c'].

print( mon_dico# ??? # )

Remplacer # ??? # dans la cellule suivante pour qu’elle affiche belote.

print( mon_dico# ??? # )

Modifiez dans le dictionaire mon_dico, la chaîne de caractères foot en football.

# ??? #
print( mon_dico )

Compléter la fonction formater_profil qui prend un dictionnaire profil comme argument.

Elle doit ajouter une clé age à profil avec la valeur de l’âge.

mon_profil_1 = {
    "prenom": 'Jean-Claude',
    "nom": 'Van Damme',
    "annee_naissance": 1960
}

mon_profil_2 = {
    "prenom": 'Jean-Claude',
    "nom": 'Van Damme Junior',
    "annee_naissance": 2006
}

def formater_profil(profil):
    # Ajouté un clé age avec la valeur appropriée pour 2024
    profil['age'] = # ??? #

  Cell In[36], line 15
    profil['age'] = # ??? #
                    ^
SyntaxError: invalid syntax

formater_profil(mon_profil_1)
print(mon_profil_1)
formater_profil(mon_profil_2)
print(mon_profil_2)

{'prenom': 'Jean-Claude', 'nom': 'Van Damme', 'annee_naissance': 1960, 'age': 64}
{'prenom': 'Jean-Claude', 'nom': 'Van Damme Junior', 'annee_naissance': 2006, 'age': 18}

Remplacer le # ??? # pour que le code affiche VICTOIRE.

a = {
    's': [1, 2, 3],
    't': [4, ('cinq', 5, 'V', 'five', {
        'gagner': 'PAIN_PERDU',
        'perdre': 'LALALAVICTOIRE!!!'
    }), 6],
}

print( a# ??? # )

Ce cours a été écrit grâce à une collaboration entre Pierre Brun, professeur de mathématiques et moi, Jared Asuncion. Il s'agit d'un cours de spécialité NSI pour des terminales générales.

Elles ont été initialement rédigées sous forme de notebooks Jupyter, mais nous les avons converties en HTML pour une meilleure lisibilité dans les browsers.

C'est un travail en cours de réalisation. N'hésitez pas à nous contacter à l'adresse mail nsi arobase guissmo point com pour tout commentaires, questions ou suggestions.

«NSI Cours Terminale : Rappel (2ème partie)NSI Cours Terminale : Rappel (4ème partie)»

GUISSMO