• Exercice 1 de la feuille d'exos

• Exercice 2 de la feuille d'exos - correction
• Évaluation (QCM) sur la numération : revoir le cours et les exercices du cours
  • notions de base, savoir compter dans différentes bases
  • passage d'une base quelconque vers la base 10, numération de position
  • conversion décimal vers binaire à la main ou par soustractions successives
  • opérations en binaire (addition, multiplication)
  • vocabulaire du binaire (octet, bit, byte, kilo/méga = 1024, ...)
  • passage binaire / hexadécimal / octal en regroupant par 3 ou 4 bits
  • conversion du décimal vers n'importe quelle base par divisions successives

• Composition d'une tour à 900 euros HT sur ldlc-pro : sans utiliser le configurateur, choisir dans l'ordre : processeur, carte mère, mémoire vive, SSD, carte graphique, alimentation, refroidissement, boîtier. Rendu : cliquer sur le lien "Partager" dans le panier et noter l'adresse de partage (prenez la en photo éventuellement). Si vous avez une imprimante, vous pouvez imprimer le papier.

• Exercice "maison" de la feuille d'exercices "portes logiques"

</div>
</div>

Cahier de textes - 1NSI G2 - 2025

• Septembre 2025
  • Mardi 2 septembre 2025
  • Jeudi 4 septembre 2025
  • Mardi 9 septembre 2025
  • Jeudi 11 septembre 2025

Septembre 2025

Mardi 2 septembre 2025

• Appel & récupération adresses email pour mattermost / gitlab
• Présentation rapide du programme
• Fonctionnement année
  • prise de notes & cours
  • évaluation "systématique" le jeudi
  • boulot à la maison

Thème : Représentation des données : types et valeurs de base

• intro à la numération dans différentes bases avec les doigts
• notion de numération de position (chiffres, "dizaines", "centaines"...)
• bases particulières : décimal, octal, hexa, binaire, nombres de 0 à 16
• binaire : vocabulaire (octet, bit, byte, méga = 1024)
• calculs en binaire : tables d'addition, de multiplications, additions, retenues, multiplications
• conversion d'une base quelconque vers la base 10
• conversion décimal - binaire "à la main"

Jeudi 4 septembre 2025

Séance intercalaire 1 : HTML & CSS

• principe d'un langage de balisage
• structure d'une page HTML
• balises principales
• attributs
• structure d'une page web
• introduction CSS
• sélecteurs, propriétés, valeurs
• intégration CSS dans une page HTML

Mardi 9 septembre 2025

Suite et fin de la numération :

• passage binaire -> hexa ou octal
• conversion par soustractions successives (binaire)
• conversion par divisions successives (toutes les bases)
• exercices

Jeudi 11 septembre 2025

Thème : Architecture matérielle et systèmes d'exploitation

• dissection d'un ordinateur
• composants principaux, rôles, caractéristiques et choix
• TP: choix des composants pour une tour à 900 euros HT sur ldlc-pro

Cahier de textes - TNSI - 2025-2026

Mardi 2 septembre 2025

Cours

• Présentation programme, fonctionnement année
• Exigences terminale et travail personnel / maison
• Évaluations "systématiques" le jeudi
• Récupération emails + logins mattermost (chat.solidev.net)
• Révisions de python : notebook diagnostic + à la main

Ressources

• Notebook "diagnostic"
• Feuille "A la main"

Jeudi 4 septembre 2025

Cours

Suite des révisions de python

• Feuille A la main
• Suite Notebook "diagnostic"
• Exos fonctions, listes et boucles, back to basics

Lundi 8 septembre 2025

• Rappels en classe : relecture du cours "bases de python"
• Fin des exos Notebook "diagnostic"
• Début Exos fonctions, listes et boucles, back to basics

Mardi 9 septembre 2025

• Suite Exos fonctions, listes et boucles, back to basics
• Début échauffement TNSI

Jeudi 11 septembre 2025

• Échauffement TNSI
• Codepuzzles épreuves pratiques NSI 2025.

Lundi 15 septembre 2025

Cours : System On Chip (SoC) : présentation / cours

Suite et fin des révisions python : échauffement TNSI et codepuzzles épreuves pratiques NSI 2025.

Mardi 16 septembre 2025

Cours :

• révisions cours dictionnaires
• exos dictionnaires

[B] Représentation des données : types et valeurs de base

CF programme officiel BO

[B.1] Écriture d'un entier dans une base b>=2

• Compter avec ses doigts
  • Nos 10 doigts
  • Avec moins ou plus de doigts
• Numération de position
• Cas particulier : la base 2 (binaire)
  • Vocabulaire
  • Conversion binaire -> décimal
  • Calculs en binaire
• Conversion décimal -> base 2
• Passages binaire <-> hexadécimal <-> octal
  • Hexadécimal
  • Octal
• Passage décimal -> base b quelconque

Compter avec ses doigts

Nos 10 doigts

Nous avons 10 doigts que nous emportons partout avec nous. Ces outils sont pratiques pour aider à compter. Nous utilisons donc une manière de compter qui utilise nos 10 doigts : la base 10.

Nos nombres s'écrivent avec 10 symboles (chiffres) : 0, 1, 2, 3, 4, 5, 6, 7, 8 et 9.

Quand on dépasse 9, on utilise une nouvelle position (chiffre) pour se "rappeler" qu'on a fait un tour complet des chiffres disponibles.

Ainsi :

• 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, tour complet
• 10, 11, 12, ..., 19, tour complet suivant
• 20, 21, ..., 29, ..., tour complet suivant
• ...
• ..., 97, 98, 99, tour complet suivant
• 100, 101, ...

Avec moins ou plus de doigts

En se coupant des doigts, ou en vivant dans un monde de dessins animés / bandes dessinées, on peut imaginer compter avec un autre nombre de doigts, et donc dans une autre base.

• Si on n'avait que 4 doigts à chaque main, on compterait en base 8 (en octal) : 0,1,2,3,4,5,6,7, tour complet 10,11,..., 77, tour complet suivant 100,...
• Si on n'avait que 3 doigts à chaque main, on compterait en base 6 (en sénaire) : 0,1,2,3,4,5, tour complet 10,11,..., 55, tour complet suivant 100,...
• Si on n'avait que 2 doigts à chaque main, on compterait en base 4 (en quaternaire) : 0,1,2,3, tour complet 10,11,..., 33, tour complet suivant 100,...
• Si on n'avait qu'un doigt à chaque main, on compterait en base 2 (en binaire) : 0,1, tour complet 10,11,... 111, tour complet suivant 1000,...

Et avec plus de doigts ? il faut plus de chiffres... avec 6 doigts à chaque main, soit 12 doigts, il faut 12 chiffres, mais attention 10 et 11 ne sont pas des chiffres, ce sont des nombres écrits avec deux chiffres ! Il faut donc inventer deux nouveaux symboles pour représenter les 10 et 11ème chiffres. Plutôt que de réinventer un symbole, on choisit souvent les lettres majuscules : A pour 10 et B pour 11 (et ainsi de suite si besoin. Pour les bases supérieures à 36 on peut utiliser les lettres minuscules aussi ou l'alphabet grec).

• Si on avait 6 doigts à chaque main, on compterait en base 12 (en duodécimal) : 0,1,2,3,4,5,6,7,8,9,A,B, tour complet 10,11,..., BB, tour complet suivant 100,...
• Si on avait 8 doigts à chaque main, on compterait en base 16 (en hexadécimal) : 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F, tour complet 10,11,..., FF, tour complet suivant 100,...

En s'intéressant aux 20 premiers entiers, on peut écrire le tableau suivant pour les bases 10, 8, 4, 2 et 16 :

Numération de position

Dans cette manière de compter, chaque position (chiffre) a une valeur qui dépend de sa position. Ce n'est pas le cas dans la numération non positionnelle comme les chiffres romains ( \( XIV = 10 + 5 - 1 = 14 \) ).

Par exemple, en base 10, le nombre 1789 s'écrit avec 4 chiffres (positions) : 1, 7, 8 et 9. La valeur de chaque position est :

• 1 millier : \( 1 \times 1000 = 1 \times 10^3 = 1000 \)
• 7 centaines : \( 7 \times 100 = 7 \times 10^2 = 700 \)
• 8 dizaines : \( 8 \times 10 = 8 \times 10^1 = 80 \)
• 9 unités : \( 9 \times 1 = 9 \times 10^0 = 9 \)

De manière générale, un nombre \( an a{n-1} ... a_2 a_1 a_0 \) s'écrit en base b (avec b un entier supérieur ou égal à 2) :

\[ a_n \times 10_b^n + a_{n-1} \times 10_b^{n-1} + ... + a_2 \times 10_b^2 + a_1 \times 10_b^1 + a_0 \times 10_b^0 \]

soit, en décimal :

\[ a_n \times b^n + a_{n-1} \times b^{n-1} + ... + a_2 \times b^2 + a_1 \times b^1 + a_0 \times b^0 \]

Quand on écrit avec une base b supérieure à 10, on utilise les lettres A, B, C, D, E... pour représenter les chiffres supérieurs à 9.

Cas particulier : la base 2 (binaire)

Vocabulaire

• un bit (contraction de "binary digit") est un chiffre binaire (0 ou 1), abbréviation "b"
• un octet est un groupe de 8 bits (en anglais "byte"), abbréviation "o" en français, "B" en anglais.
• un kilo-octet (Ko) est 1024 octets (2^10 = 1024), et non 1000 comme dans le système métrique,
• un méga-octet (Mo) est 1024 kilo-octet, etc..

Liste des préfixes par ordre croissant : kilo (k), méga (M), giga (G), téra (T), péta (P) et pour la culture only : exa (E), zetta (Z), yotta (Y).

Conversion binaire -> décimal

Les puissances de 2 sont à connaître par coeur au moins jusqu'à 2^12 :

La conversion d'un nombre binaire vers le décimal s'effectue assez facilement :

• en partant de la droite du nombre binaire, on se récite les puissances de 2 (1,2,4,8,16,...)
• on ne garde que les puissances de 2 correspondant aux positions où il y a un 1
• on fait la somme de ces puissances de 2

Astuce : quand on a un nombre du genre 1111 1111, on peut remarquer que le nombre juste après est 1 0000 0000, qui est beaucoup plus facile à convertir en décimal (ici 256). On peut donc calculer 1111 1111 en faisant 256 - 1 = 255.

Calculs en binaire

Les tables d'addition et de multiplication en binaire sont très simples :

On peut donc faire des additions et des multiplications en binaire, de la même manière qu'en décimal, en se rappelant que 1+1=10 (retenue 1) et 1×1=1.

Exercice : effectuer les opérations suivantes en binaire, et vérifiez vos calculs en passant par le décimal.

• 1011 0100 + 1011 1101
• 1011 x 110

Conversion décimal -> base 2

Cette méthode par soustractions successives ne fonctionne que pour le binaire (car on a un seul choix pour chaque puissance de la base : elle est présente ou pas).

Passages binaire <-> hexadécimal <-> octal

Hexadécimal

Le passage du binaire vers l'hexadécimal est très simple : on regroupe les bits par 4, en partant de la droite (on ajoute des 0 à gauche si besoin), puis on convertit chaque groupe de 4 bits en un chiffre hexadécimal (de 0 à F).

Pour passer de l'hexadécimal vers le binaire, on fait l'inverse : on convertit chaque chiffre hexadécimal en un groupe de 4 bits, puis on concatène les groupes.

Octal

C'est le même principe, mais on regroupe par 3 bits, pour obtentir des chiffres octaux (base 8, donc chiffres de 0 à 7).

Pour passer de l'octal vers le binaire, on fait l'inverse : on convertit chaque chiffre octal en un groupe de 3 bits, puis on concatène les groupes.

Passage décimal -> base b quelconque

Pour convertir un nombre décimal en une base b quelconque (supérieure ou égale à 2), on utilise la méthode des divisions successives.

[F] Archi matérielle et OS

[F.1] Archi séquentielle

[F.1.1] Composants

Valeurs de 2023 - à revoir en 2025 !

Processeur

• Marque : AMD / Intel
• Socket : AMD AM4, AMD AM5, Intel 1200, Intel 1700
• Nombre de coeurs : 2 → 128
• Fréquence horloge : 2 → 5 GHz
• TDP : 10 – 200 W
• Avec / sans carte graphique,

Carte mère

• Socket
• Format : ATX / Micro ATX / ..
• Type mémoire : DDR5
• Fréquence mémoire : 4400 MHz / 6200 MHz / …
• Nb canaux mémoire : dual channel / quad channel
• Nb emplacements mémoire : 4 / 8 / …
• Nb ports SATA : 4x SATA 6Gb/s
• Nb / type ports : M.2 PCI-E NVMe,2x M.2 PCI-E 4.0 4x
• Nb ports : PCI-E 3 16x,1x PCI Express 4.0 16x
• LAN : 1x 10/100/1000 Mbps

Mémoire

• Type : DDR4 / DDR5
• Frequence : 800 MHz → 8200 MHz
• CAS Latency : CL6 / CL16
• Capacité : 8 GB

Alimentation

• Puissance : 200 → 1200 W
• Certification : Bronze, Gold, ..
• Garantie
• Format : ATX
• Modulaire : Oui / non

Stockage SSD

• Format : M.2 NVME / 2.1/2
• Capacité : 64 Go → 2 To
• Vitesse en écriture : 3200 – 11800 Mo/s
• Vitesse en lecture : 12400 Mo/s

Stockage HDD

• Format : 2 1/2 / 3 1/2
• Interface : SATA 3 / SAS
• Vitesse de rotation : 5400 → 15000 tpm
• Capacité : 1 → 22 To

Cours terminale

Sera mis en ligne au fur et à mesure de l'année.

Introduction : markdown

Syntaxe

Sous-sous titre

Ceci est un texte qui peut être mis en forme. On peut écrire des maths $x^2$. On peut écrire du code : print("Hello")

<h1>Ceci est du html</h1>
<a href="cours">Mon cours</a>

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc nunc odio, viverra
maximus sodales sit amet, facilisis sit amet enim. Donec a scelerisque lacus.
Nullam laoreet eget orci id ornare.

Il faut une ligne vide pour changer de paragraphe.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc nunc odio, viverra
maximus odales sit amet, facilisis sit amet enim. Donec a scelerisque lacus.
Nullam laoreet eget orci id ornare.

- une
- liste
- de
- choses
  - sous
  - liste

1. une
2. liste
3. numérotée

---

Après la ligne

Ecrire des maths : $x^2$ ou une formule séparée : $$\frac{x^2}{\sqrt{3}}$$

Les bases

Les types

Les nombres

2 types de nombres en python :

• les nombres entier (int)
• les nombres à virgule (float)

La fonction type(donnee) renvoie le type de la donnée en argument.

type(2)

int

type(2.)

float

Les opérations disponibles :

• addition : +
• soustraction : -
• multiplicaiton : *
• division : /
• division entière : //
• modulo (reste de la division) : %
• puissance : **

# <---- ceci est un commentaire
print(2+2) # ceci est une addition

# division
print(3/2)

# division entière
print(3//2)
# reste
print(3%2)

4
1.5
1
1

# Le python n'est pas limité dans la
# précision des entiers

print(42**150)

30718044109628362431083481022093347337522521205249165162887883178792856
18913242769221546233801029309660240744684870161068642242819317186478113
20581112979155344834823272145421950205151779439580895845237852365648330
8658593843859108631095881498624

# Attention aux calculs avec des nombres à virgule
print(0.2+0.1)

0.30000000000000004

# Conversions de type

print(float(2))
print(int(3.14159))
print(int(3.9999))

2.0
3
3

Autres types (à voir plus tard)

• booléens (vrai/faux)
• chaînes de caractères ("bonjour")
• listes & les n-uplets
• dictionnaires
• objets
• ...

Les variables

Une variable est un espace de mémoire nommé.

On assigne une valeur à une variable avec le signe égal (=)

a=3

met la valeur 3 dans la case mémoire nommée a

• si la case existe déjà, on remplace la valeur existante
• si la case n'existait pas, on la crée et on met la valeur dedans

Règles pour les noms des variables :

• en minuscules
• sans accents
• sans espaces (utiliser le _ tiretduhuit)
• commence par une lettre

Bon :

• a
• ma_variable
• mon_resultat

Pas bon :

• maVariable
• ma Variable
• mon Résultat

x=3
print(x)

3

# Raccourcis intéressants :


x += 3 # pareil que x = x + 3
x -= 3 # pareil que x = x - 3
x /= 2 # pareil que x = x / 2
x *= 5 # pareil que x = x * 5

# Assignation multiple
x = 0
y = 0
z = 0
x = y = z = 0

Exercices

Exercice 1

Avec a=1 et b=2, prévoir la valeur de a += (b-3)

a=1
b=2
a += (b-3) # a <---- a + (b-3)
print(a, b)

0 2

Attention : le signe = est une opération d'affectation (parfois écrite dans d'autres langages <--- : de la droite vers la gauche)

Exercice 2

avec a="toto" et b="pouet"... inverser le contenu de a et de b

a="toto"
b="pouet"
print("au départ : ", a, b)

# a vous de jouer
# b <--- a
# a <--- b

c = a
print("après c=a", a,b,c)
a = b
print("après a=b : ", a,b,c)
b = c
print("après b=c : ", a,b,c)

print("résultat :", a, b)

au départ :  toto pouet
après c=a toto pouet toto
après a=b :  pouet pouet toto
après b=c :  pouet toto toto
résultat : pouet toto

Les fonctions

Les fonctions et les librairies

Par défaut, le python a très peu de fonctionnalités. Mais il existe une énorme bibliothèque de fonctions qu'on peut utiliser dans nos programmes. L'index de la bibliothèque se trouve https://docs.python.org section Library Reference.

Pour utiliser une fonction d'une bibliothèque, il faut l'importer (= dire à Python de charger le code de la fonction)

import math  # bourrin : importe TOUTE la bibli
math.sqrt(2)
math.cos(3)

# mieux : importation sélective
from math import sqrt,cos
sqrt(2)
cos(3)

# PAS BIEN DU TOUT, NE JAMAIS FAIRE
from math import *
cos(3)
sinh(12)

from math import cos, sin, pi
print(sin(3.14))
print(sin(pi))

0.0015926529164868282
1.2246467991473532e-16

print(pi)

3.141592653589793

import math
math.sin(math.pi)

1.2246467991473532e-16

Exercices

Exercice 1

Calculer le PGCD de 4956 et 8052... (en anglais: GCD)

from math import gcd
gcd(4956, 8052)

12

Exercice 2

Calculer la racine carrée de 40!.. idem, RTFM

# en anglais : factorial et square root
from math import factorial, sqrt
sqrt(factorial(40))

9.032802905233224e+23

Créer ses propres fonctions

Une fonction est un ensemble d'instructions avec un nom.

exemple : je veux

• multiplier un nombre par 5
• lui ajouter 12
• afficher "bip bip"

et je veux le faire plusieurs fois

a = 10
a = a * 5
a = a + 12
print("bip bip")

a = 20
a = a * 5
a = a + 12
print("bip bip")

a = 4
a = a * 5
a = a + 12
print("bip bip")

# ^^^^ trop de répétitions, on fait mieux

# définition de la fonction :
#   a est un argument de la fonction
def mafonction(a):
    a = a * 5
    a = a + 12
    print("bip bip")

# appel de la fonction
mafonction(10)
mafonction(20)
mafonction(4)

bip bip
bip bip
bip bip
bip bip
bip bip
bip bip

Une fonction en maths : $f(x)=3x+2$ (elle prend la valeur de x, la multiplie par 3 et ajoute 2) s'écrit en python :

def f(x):
    return 3*x+2

Plus précisément :

• le nom de la fonction = mêmes contraintes que pour le nom des variables (minuscules, pas accents ni espaces)
• on définit la fonction avec le mot clef def
• entre parenthèses, on fournit zéro ou plusieurs arguments
• on n'oublie pas les deux points à la fin de la définition
• le corps de la fonction (= les instructions qui font partie de la fonction) sont indentées (décalées par rapport à la marge)
• la réponse (éventuelle) de la fonction est donnée avec le mot clef return

def f(x):
    return 3*x+2
print(f(3))
print(f(f(1)))
print(f(f(f(f(f(f(f(3))))))))

11
17
8747

# Il faut fournir les arguments...
print(f())

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

TypeError                                 Traceback (most recent call last)

<ipython-input-55-04323a1e865c> in <module>
      1 # Il faut fournir les arguments...
----> 2 print(f())


TypeError: f() missing 1 required positional argument: 'x'

# Une fonction peut avoir des arguments par défaut
# le b=0 signifie la valeur utilisée si
#  la fonction est appelée sans b
def affine(x, a, b=0):
    return a*x+b

print(affine(2,3,5))
print(affine(2,3,0))
print(affine(2,3))

11
6
6

# Passage des arguments par position
# dans le même ordre que la définition
# Exemple
print(affine(2,3,5))

# Passage des arguments par nom
# ordre indifférent
print(affine(a=3,b=5,x=2))
print(affine(a=3,x=2))

# Mix de par position et par nom
# attention : les arguments par position sont en premier
print(affine(2,3,b=5))

11
11
6
11

# Il y a des variables "internes" à la fonction (locales),
# il y a des arguments
# il y a des variables "externes" (définies en dehors de la fonction)

toto = 1
titi = 2
tata = 3


def mafonction(titi, tutu):
    toto = 4  # recrée une variable toto **locale** (existe pas dehors)
    print("toto = ", toto)
    print("titi = ", titi) # argument de la fonction (donné à l'appel)
    print("tata = ", tata) # tata : pas argument, pas défini dans la fonction
                           # ==> on va chercher au dessus dans le prog principal
    print("tutu = ", tutu) # argument (donné à l'appel) = local

mafonction(titi=7, tutu=8)
print("---------------------")
print("toto = ", toto)
print("titi = ", titi)
print("tata = ", tata)
# print("tutu = ", tutu) ne marche pas car tutu n'existe que dans la fonction

toto =  4
titi =  7
tata =  3
tutu =  8
---------------------
toto =  1
titi =  2
tata =  3

# Une fonction est un "objet" python comme les autres

def yo():
    print("yo")
def yi():
    print("yi")

print(type(yo))
# on peut la mettre dans une variable
ya = yo
ya()

# on peut donner une fonction en argument à une fonction
def double(f):
    print("Je dis")
    f()
    print("et puis")
    f()

double(f=yo)
double(yi)

<class 'function'>
yo
Je dis
yo
et puis
yo
Je dis
yi
et puis
yi

Exercices

Exercice 1

définir une fonction pythagore(cote1, cote2) qui renvoie l'hypothénuse quand on lui donne 2 côtés

def pythagore(cote1, cote2):
    from math import sqrt
    return sqrt(cote1**2+cote2**2)

def pythagore(cote1, cote2):
    from math import sqrt
    a2 = cote1**2
    b2 = cote2**2
    c2 = a2+b2
    return sqrt(c2)
pythagore(3,4)

5.0

Exercice 2

Une équation $a{x}^2+bx+c$. Faire une fonction deg2 prenant comme arguments a, b, c et x, avec b qui vaut 1 par défaut, c qui vaut 0 par défaut et qui renvoie le résultat de $a{x}^2+bx+c$

def deg2(x,a,b=1,c=0):
    return a*x**2+b*x+c
deg2(1,1,c=3)

5

Exercice 3

le produit scalaire de 2 vecteurs $(ux,uy)$ et $(vx,vy)$ est défini par $u.v=ux\ast vx+uy\ast vy$

Définir une fonction produit_scalaire qui renvoie le produit scalaire de 2 nombres Si on ne donne pas une coordonnée de vecteur, par défaut elle est nulle

# Exo 2 : le produit scalaire de 2 vecteurs (ux, uy) et (vx, vy)
# est défini par u.v=ux*vx+uy*vy
# Définir une fonction produit_scalaire qui renvoie le produit
# scalaire de 2 nombres
# Si on ne donne pas une coordonnée de vecteur, par défaut elle
# est nulle

def produit_scalaire(ux=0,uy=0, vx=0, vy=0):
    return ux*vx+uy*vy

# La tester avec u=(1,0) v=(0,1)  et avec u=(3,4), v=(0,6)
print(produit_scalaire(1,0,0,1))
print(produit_scalaire(ux=1,vy=1))
print(produit_scalaire(3,4,0,6))
print(produit_scalaire())

0
0
24
0

Les structures du langage

Les booléens et les tests

Un booléen : valeur vraie ou fausse / 0 ou 1 / en python : True ou False

type(True)

bool

type(False)

bool

Les opérations sur le booléens sont :

• et = and
• ou = or
• non = not

print("vrai et vrai = ", True and True)
print("vrai ou faux = ", True or False)
print("non vrai = ", not True)
print("vrai non-et faux = ", not(True and False))

vrai et vrai =  True
vrai ou faux =  True
non vrai =  False
vrai non-et faux =  True

Les tests renvoient une valeur booléenne

"est-ce que machin est plus grand que truc ?" : vrai / faux

liste des tests disponibles :

• > supérieur
• < inférieur
• >= supérieur ou égal
• <= inférieur ou égal
• == égalité
• != différent
• in cf plus tard

print(3<4)
print(2>=2)
print(3!=2)

True
True
True

Exercices

Exercice 1

Ecrire un test permettant de vérifier que 3 est bien dans l'intervalle [2,6[

print(2<=3 and 3<6)
print(2<=3<6)

True
True

Exercice 2

Ecrire une fonction intervalle renvoyant vrai ou faux selon que l'argument x est à l'intérieur de l'intervalle [a, b] sachant que a et b sont deux arguments de la fonction, avec a=0 et b=100 par défaut

def intervalle(x, a=0, b=100):
    return x >= a and b >= x

# Une manière de tester automatiquement qu'une fonction
# fait ce qu'on veut :
assert intervalle(12, 5, 15) == True
assert intervalle(19, 5, 15) == False

Les structures conditionnelles

Plusieurs manières de faire des actions qui dépendent d'une condition :

SI condition
ALORS on fait machin

SI condition
ALORS on fait machin
SINON on fait truc

SI condition
ALORS on fait machin
SINON SI une autre condition
ALORS on fait truc
SINON SI une encore autre condition
ALORS on fait bidule
SINON on fait chouette

Au niveau de la syntaxe, le python ne précise pas le "ALORS".

# Exemple complet

age = 56
if age < 6:
    print("Regarde thcoupi")
elif age < 9:
    print("Regarde power rangers")
elif age < 12:
    print("Joue avec ta PS4")
elif age < 16:
    print("Quitte le téléphone et fais tes devoirs")
elif age < 80:
    print("Abonne toi à Netflix")
else:
    print("Regarde Rex et Derrick")

Abonne toi à Netflix

Exercice 1 : comparaison

Ecrire une fonction compare(a, b) qui affiche (print)

• "plus petit" si a < b
• "plus grand" si a > b
• "pareil" si a egal b

def compare(a,b):
    if a < b:
        print("plus petit")
    elif a > b:
        print("plus grand")
    elif a == b:
        print("pareil")
    # else:
    #    print("pareil")

compare(2,3)
compare(3,2)
compare(3,3)

plus petit
plus grand
pareil

Exercice 2 : factorielle

La factorielle $n!$ d'un nombre est le produit de $1\times 2\times \mathrm{3...}\times n$

Ecrire une fonction factorielle(n) qui renvoie la factorielle du nombre n d'après l'algorithme suivant :

SI n est égal à 1
ALORS renvoie 1
SINON renvoie n * factorielle(n-1)

def factorielle(n):
    if n == 1:
        return 1
    else:
        return n*factorielle(n-1)
def factorielle(n):
    if n == 1:
        return 1
    return n*factorielle(n-1)

factorielle(5)

120

Les boucles (épisode 1)

TANT QUE une condition
REPETE des instructions

La condition est évaluée au début de chaque itération.

En python :

while CONDITION:
    instruction1
    instruction2
endehorsduwhile

Les instructions de la boucle sont exécutées TANT QUE la condition est VRAIE

# Exemple : compter jusqu'à 10
compteur = 1
while compteur <= 10:
    print(compteur, end=" ")
    compteur = compteur + 1 # compteur += 1
print("Fini...")

1 2 3 4 5 6 7 8 9 10 Fini...

# boucle infinie = pas bien
# mais si on doit l'utiliser, il faut avoir un moyen d'en sortir
# : instruction break
compteur = 0
while True:
    print("yo", end=" > ")
    compteur += 1
    if compteur >= 5:
        break

yo > yo > yo > yo > yo >

L'instruction continue permet de passer directement à l'itération suivante

compteur = 1
while compteur <= 10:
    compteur += 1
    # si le reste de la division par 2
    # de compteur est nul = compteur est
    # un nombre pair
    if compteur % 2 == 0:
        print("je suis pair")
        continue
    print("je suis impair")

print("FINI")

je suis pair
je suis impair
je suis pair
je suis impair
je suis pair
je suis impair
je suis pair
je suis impair
je suis pair
je suis impair
FINI

Exercices

Exercice 1 : compter de différentes manières

Ecrire plusieurs fonctions multiples_de(n) qui compte de 0 jusqu'à 1000 en affichant uniquement les multiples de n.

Exemple multiples_de(3) : 0, 3, 6, 9, 12...

# Exercice 1

def multiples_de(n):
    i = 0
    while i<=1000:
        # est ce que i est divisible par n
        if i % n == 0:
            print(i, end=" ")
        i += 1

def multiples_de2(n):
    i = 0
    while i<=1000:
        # est ce que i est divisible par n
        print(i, end=" ")
        i += n

def multiples_de3(n):
    i = 0
    while i*n<=1000:
        # est ce que i est divisible par n
        print(i*n, end=" ")
        i += 1

multiples_de(13)

0 13 26 39 52 65 78 91 104 117 130 143 156 169 182 195 208 221 234 247
260 273 286 299 312 325 338 351 364 377 390 403 416 429 442 455 468 481
494 507 520 533 546 559 572 585 598 611 624 637 650 663 676 689 702 715
728 741 754 767 780 793 806 819 832 845 858 871 884 897 910 923 936 949
962 975 988

multiples_de2(13)

0 13 26 39 52 65 78 91 104 117 130 143 156 169 182 195 208 221 234 247
260 273 286 299 312 325 338 351 364 377 390 403 416 429 442 455 468 481
494 507 520 533 546 559 572 585 598 611 624 637 650 663 676 689 702 715
728 741 754 767 780 793 806 819 832 845 858 871 884 897 910 923 936 949
962 975 988

multiples_de2(13)

0 13 26 39 52 65 78 91 104 117 130 143 156 169 182 195 208 221 234 247
260 273 286 299 312 325 338 351 364 377 390 403 416 429 442 455 468 481
494 507 520 533 546 559 572 585 598 611 624 637 650 663 676 689 702 715
728 741 754 767 780 793 806 819 832 845 858 871 884 897 910 923 936 949
962 975 988

Exercice 2 : factorielle

Calculer la factorielle de n avec une boucle while

def factorielle(n):
    i = 1
    etape = 1
    while i <=n:
        etape *= i  # etape = etape * i
        i += 1
    return etape

# On teste ici le résultat de la fonction
# syntaxe : assert UN TEST QUI DOIT RENVOYER TRUE, message d'erreur


assert factorielle(5) == 1*2*3*4*5, "non ça marche pô"
assert factorielle(1) == 1, "non ça marche pô"
assert factorielle(10) == 1*2*3*4*5*6*7*8*9*10, "non ça marche pô"

Listes et n-uplets

Une liste est une structure de données qui permet de stocker des valeurs les unes à la suite des autres, de manière séquentielle.

Chaque élément est associé à une position dans la liste. Attention : les positions ne commencent pas à 1 mais à 0 car les positions sont en fait des décalages par rapport au début de la liste.

On écrit une liste entre crochets []. Exemple : [1, 2, 3]

mes_courses = ["pain","lait","beurre","camembert","masques"]

Pour récupérer un élément d'une liste : on utilise la notation [position]. Exemple : mes_courses[2] # beurre

print(mes_courses[2])
print([1,2,3][1])
print(["pain","lait","beurre","camembert","masques"][2])

beurre
2
beurre

Pour connaitre la longueur d'une liste : la fonction len(liste) renvoie le nombre d'éléments de la liste.

attention le dernier élément d'une liste est situé à la position len(liste)-1

On peut récupérer des éléments en partant de la fin de la liste en utilisant une position négative

• [-1] renvoie le dernier élément
• [-2] renvoie l'avant dernier élément

assert mes_courses[3] == "camembert"
assert mes_courses[-2] == "camembert"
assert mes_courses[len(mes_courses)-2] == "camembert"

Lorsqu'on essaie de récupérer un élément à une position qui n'existe pas , on déclenche une erreur (une exception) IndexError

mes_courses[999]

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

IndexError                                Traceback (most recent call last)

<ipython-input-161-a8e2444d3ef1> in <module>
----> 1 mes_courses[999]


IndexError: list index out of range

Un n-uplet est une liste non modifiable. On l'écrit entre parenthèses, voire sans aucune parenthèse si le contexte le permet

alphabet1 = ("A", "B", "C", "D")
alphabet2 = "A", "B", "C", "D"
print(type(alphabet2))
print(type([1,2,3]))

<class 'tuple'>
<class 'list'>

On peut avoir des listes dans des listes

morpion = [
    [" ", "x", "o"],
    ["x", " ", "W"],
    ["x", " ", " "]
]
print(morpion[1])
print(morpion[1][2])

['x', ' ', 'W']
W

tableau = [[3,4,5,6], [1,2,42]]
assert 4 == tableau[0][1]
assert 42 == tableau[1][2]
assert 6 == tableau[0][3]
assert 1 == tableau[1][0]

tableau = [1,2, [3,4, [5,6, [7,8]]]]
assert 1 == tableau[0]
assert 2 == tableau[1]
assert 3 == tableau[2][0]
assert 4 == tableau[2][1]
assert 5 == tableau[2][2][0]
assert 6 == tableau[2][2][1]
assert 7 == tableau[2][2][2][0]
assert 8 == tableau[2][2][2][1]

Assignation

Remplacer dans un tableau

Assigner une valeur dans une liste, c'est écrire la valeur à la position donnée. La position doit déjà exister.

tableau = ["A", "B", "W", "D"]
tableau[2] = "C"
print(tableau)

['A', 'B', 'C', 'D']

tableau[43]="braaa"

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

IndexError                                Traceback (most recent call last)

<ipython-input-176-6ead7e28e1e9> in <module>
----> 1 tableau[43]="braaa"


IndexError: list assignment index out of range

tableau[-1] = "fini"
print(tableau)

['A', 'B', 'C', 'fini']

tableau = [["A","B"], ["C", "W"]]
tableau[-1][-1]="D"
print(tableau)

tableau[0]="bouuu"
print(tableau)

[['A', 'B'], ['C', 'D']]
['bouuu', ['C', 'D']]

Autres opérations

Pour ajouter un élément à la fin d'un tableau : on utilise "append"

tableau = [1,2,3]
tableau.append(42)
print(tableau)

[1, 2, 3, 42]

Pour insérer un élément dans un tableau : on utilise insert(position, element)

tableau = [1,2,3]
tableau.insert(1,42)
print(tableau)

[1, 42, 2, 3]

Pour retirer un élément dans un tableau :

• on utilise del tableau[pos]
• on utilise tableau.pop(pos)

tableau = [1,2,3,4,5,6]
print(tableau)
del tableau[3]
print(tableau)
tableau.pop(1)
print(tableau)

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

Les slices / morceaux de tableau

Pour récupérer juste une partie de tableau, on utilise la notation des slices : tableau[debut:fin:pas]; le début est inclus, la fin est exclue

tableau = [1,2,3,4,5,6]
print(tableau[2:3])
print(tableau[2:5])
print(tableau[0:6])
print(tableau[0:])
print(tableau[0:-1])
print(tableau[:])

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

# Bonus pas duuuu tout au programme
tableau = [1,2,3,4,5,6]
print(tableau[2:3:2])
print(tableau[2:5:2])
print(tableau[0:6:2])
print(tableau[0::2])
print(tableau[0:-1:2])
print(tableau[::2])

[3]
[3, 5]
[1, 3, 5]
[1, 3, 5]
[1, 3, 5]
[1, 3, 5]

# Pour la culture : pour renverser un tableau
tableau = [1,2,3,4]
print(tableau[::-1])

[4, 3, 2, 1]

Pour tester si un élément est dans un tableau : l'opérateur in

tableau = [1,2,3,4]
print(12 in tableau)
print(3 in tableau)

False
True

Pour trier un tableau, on peut utiliser la méthode tableau.sort ou la fonction sorted

tableau = [2,4,1,3]
tableau.sort() # trié en place
print(tableau)

tableau = [2,4,1,3]
tableautrie = sorted(tableau) # renvoie une copie du tableau
print(tableautrie, tableau)

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

Exercice 1 - morpion python

Créer un tableau morpion qui contient 3 lignes de 3 cases. Lorsque une case est vide, la valeur vaut 0, lorsqu'elle a été jouée par le J1 elle vaut 1, et elle vaut 2 pour le J2.

Jouer une partie de morpion en utilisant la notation morpion[][]=

morpion = [[0,0,0],
           [0,0,0],
           [0,0,0]]
morpion[1][1] = 1
morpion[0][0] = 2
morpion[2][0] = 1
morpion[0][2] = 2
morpion[0][1] = 1
morpion[2][1] = 2
print(morpion)

[[2, 1, 2], [0, 1, 0], [1, 2, 0]]

Les boucles for

Les listes sont très utiles à partir du moment où on peut accéder à tous leurs éléments de manière itérative.

Pour accéder à tous les éléments d'une liste, la structure est la suivante :

for variable_destination in liste_source:
    instruction
    instruction

maliste = ["un", "deux", "trois", "quatre"]

for truc in maliste:
    print("Je sais compter jusqu'à", truc)
print("fini")

Je sais compter jusqu'à un
Je sais compter jusqu'à deux
Je sais compter jusqu'à trois
Je sais compter jusqu'à quatre
fini

On peut avoir besoin de connaitre non seulement la valeur, mais aussi la position dans la liste à chaque itération. Dans ce cas on peut énumérer la liste.

maliste = ["un", "deux", "trois", "quatre"]
for machin, truc in enumerate(maliste):
    print(machin, truc)

0 un
1 deux
2 trois
3 quatre

Pour les boucles for, on a aussi les instructions break et continue

maliste = ["un", "deux", "trois", "quatre"]
for pos, val in enumerate(maliste):
    # dans la première varialbe : la position
    # dans la deuxième variable : la valeur
    print("Position ", pos)
    if val == "deux":
        continue
    print("Valeur", val)
    if val == "trois":
        break

Position  0
Valeur un
Position  1
Position  2
Valeur trois

Une fonction très pratique : la fonction range(debut, fin, pas), ou range(debut, fin) ou range(fin) : elle renvoie une liste de nombre, de début inclus, jusqu'à fin non inclus, avec un pas

for i in range(0,10,3):
    print(i, end=", ")

0, 3, 6, 9,

for i in range(10):
    print(i, end=", ")

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

for i in range(2,10):
    print(i, end=", ")

2, 3, 4, 5, 6, 7, 8, 9,

Exercices

Exercice 1 : Ajouter à une liste

Ecrire une fonction bonus(notes, valeur) qui ajoute valeur à chaque note de la liste notes et calcule la moyenne de l'élève.

Exemple : notes : 12, 14, 13 / valeur : 3 moyenne $$\frac{(12+3)+(14+3)+(13+3)}{3}$$

def bonus(notes, valeur):
    total = 0 # sert d'accumulateur
    for n in notes:
        total += n
        total += valeur
    return total/len(notes)

bonus([12,14,13], 3)

16.0

Exercice 1 bis

Ecrire une fonction moyenne(notes) qui renvoie la moyenne des notes données dans la liste notes

def moyenne(notes):
    tot = 0
    for note in notes:
        tot = tot + note
    return tot/len(notes)

moyenne([10, 12, 14, 16])

13.0

Exercice 1 ter

Ecrire une fonction mini(notes) qui renvoie la plus petite de toutes les notes données dans notes

Ecrire une fonction maxi(notes) qui renvoie la plus grande de toutes les notes données dans notes

def mini(notes):
    derniermini = 100000000
    for note in notes:
        if note < derniermini:
            derniermini = note
    return derniermini

print(mini([14, 11, 13]))

def maxi(notes):
    derniermaxi = -100000000
    for note in notes:
        if note > derniermaxi:
            derniermaxi = note
    return derniermaxi

print(maxi([12, 14, 13]))

11
14

Exercice 2 : Moyenne coefficientée

Ecrire une fonction moyenne(notes) qui calcule la moyenne d'une liste de notes avec leur barème et leur coefficient (chaque note est donnée sous forme [12, 20, 1] : note, barème, coefficient

def moyenne(notes):
    A = 0
    B = 0
    for n in notes:
        A = A + n[0]*n[2]
        B = B + n[1]*n[2]
    return A*20/B
moyenne([[3, 5, 1], [2, 10, 3], [16, 20, 2]])

10.933333333333334

Exercice 3 : Morpion (v2)

Faire une fonction verif(morpion) qui vérifie si une grille de morpion est gagnante ou non, en utilisant des boucles for et des boucles whiles

def verif(morpion):
    # morpion[ligne][colonne]
    # Est-ce que le joueur 1 a gagné ?
    for ligne in range(3):
        for colonne in range(3):
            print("l",ligne, "c",colonne)

verif([[0,0,0], [0,0,0], [1,1,1]])

l 0 c 0
l 0 c 1
l 0 c 2
l 1 c 0
l 1 c 1
l 1 c 2
l 2 c 0
l 2 c 1
l 2 c 2

Exercice 4 : Crible d'Eratosthène

Programmer le crible d'Eratosthène d'après l'algorithme donné sur : https://fr.wikipedia.org/wiki/Crible_d%27%C3%89ratosth%C3%A8ne

Arguments par référence ou par valeur

Les listes sont représentées par une "adresse" (une référence) en mémoire. Lorsqu'on assigne une liste à une variable, la variable ne contient qu'une "référence" vers cette liste. Si la liste est assignée à plusieurs variables, elle n'existe réellement qu'une seule fois.

Si on la modifie dans une des variables, elle sera modifiée partout.

maliste = [0,1,2,3]
taliste = maliste
taliste[0] = 42
print(maliste)
print(taliste)

[42, 1, 2, 3]
[42, 1, 2, 3]

def mafonction(toto):
    # toto: argument passé par référence
    toto[1]=42
mafonction(maliste)
print(maliste)

[42, 42, 2, 3]

# solution
# Pour une liste: on peut "copier la liste" (solution correcte..)
maliste = [0,1,2,3]
taliste = maliste[:]
taliste[0] = 42
print(maliste)
print(taliste)

[0, 1, 2, 3]
[42, 1, 2, 3]

## Contre exemple
# solution
# Pour une liste: on peut "copier la liste" (solution correcte..)
maliste = [[0,1,2,3],[4,5,6,7]]
taliste = maliste[:]
taliste[0][0] = 42
print(maliste)
print(taliste)

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

# Solution propre
from copy import deepcopy
maliste = [[0,1,2,3],[4,5,6,7]]
taliste = deepcopy(maliste)
taliste[0][0] = 42
print(maliste)
print(taliste)

[[0, 1, 2, 3], [4, 5, 6, 7]]
[[42, 1, 2, 3], [4, 5, 6, 7]]

Les "compréhensions" de liste

On se retrouve souvent à faire des opérations du genre :

carres = []
for nombre in range(1,11):
    carres.append(nombre**2)
print(carres)

on peut le réécrire en "plus court" et moins compréhensible :

carres = [nombre ** 2 for nombre in range(1,11)]

On peut même mixer des conditions dans les compréhensions de liste, mais attention aux excès qui enlèvent de la lisibilité au programme

carres_pairs = [nombre**2 for nombre in range(1,20) if nombre % 2 == 0 ]
print(carres_pairs)

[4, 16, 36, 64, 100, 144, 196, 256, 324]

Les dictionnaires

Les listes permettent de stocker les objets les uns à la suite des autres, les dictionnaires permettent d'associer des clefs avec des valeurs.

exemple: un contact doit stocker nom, prénom, adresse, tel, email...

moi = {"nom": "BARBIER", "prenom": "Jean-Matthieu",
      "mail": "jm.barbier@solidev.net", "clef": "valeur"}

Les clefs peuvent être des chaînes de caractères (le plus souvent), mais aussi (presque) n'importe quel type de données. Idem pour les valeurs, qui peuvent prendre absolument n'importe quel type.

moi = {"nom": "BARBIER", "prenom": "Jean-Matthieu",
      "mail": "jm.barbier@solidev.net",
      "adresse": { "numero": 4, "rue": "clos d'ivry",
                 "ville": "houlbec", "cp": "27120"}}
print(moi)
print(moi["nom"])
print(moi["adresse"])
print(moi["adresse"]["cp"])

{'nom': 'BARBIER', 'prenom': 'Jean-Matthieu',
 'mail': 'jm.barbier@solidev.net',
 'adresse': {
    'numero': 4,
    'rue': "clos d'ivry",
    'ville': 'houlbec',
    'cp': '27120'
  }
}
BARBIER
{'numero': 4, 'rue': "clos d'ivry", 'ville': 'houlbec', 'cp': '27120'}
27120

Pour rajouter un élément dans un dictionnaire, il suffit d'assigner une valeur à une clef.

• si la clef n'existe pas dans le dictionnaire, elle est créée
• si elle existe, la valeur correspondante est modifiée

moi = {}
moi["mail"] = "jm.barbier@solidev.net"
print(moi)
moi["nom"] = "BARBIER"
print(moi)
moi["prenom"] = "Toto"
print(moi)
moi["prenom"] = "Jean-Matthieu"
print(moi)

{'mail': 'jm.barbier@solidev.net'}
{'mail': 'jm.barbier@solidev.net', 'nom': 'BARBIER'}
{'mail': 'jm.barbier@solidev.net', 'nom': 'BARBIER', 'prenom': 'Toto'}
{'mail': 'jm.barbier@solidev.net', 'nom': 'BARBIER', 'prenom': 'Jean-Matthieu'}

# Pour supprimer une valeur
moi["portnawak"] = 42
print(moi)
del moi["portnawak"]
print(moi)

{'mail': 'jm.barbier@solidev.net', 'nom': 'BARBIER',
 'prenom': 'Jean-Matthieu', 'portnawak': 42}
{'mail': 'jm.barbier@solidev.net', 'nom': 'BARBIER',
 'prenom': 'Jean-Matthieu'}

Pour savoir si une clef est dans un dictionnaire : mot clef in :

dico = {"toto": 1, 22: "cuicui"}
print("toto" in dico) # True
print("titi" in dico) # False
print(22 in dico) # True

On peut parcourir un tableau de 3 manières :

• en utilisant ses clefs
• en utilisant ses valeur
• en utilisant clefs et valeurs

# En utilisant les clefs
for aazeaze in moi:
    print(aazeaze)

mail
nom
prenom

# En utilisant les valeurs
for sdsdf in moi.values():
    print(sdsdf)

jm.barbier@solidev.net
BARBIER
Jean-Matthieu

# En utilisant les clefs et les valeurs
for clef, valeur in moi.items():
    print(clef, valeur)

mail jm.barbier@solidev.net
nom BARBIER
prenom Jean-Matthieu

Subtilité : pour obtenir la première clef / valeur d'un dictionnaire (lors d'une recherche de maximum/minimum par exemple):

dico = {"a": 3, "b": 5}
# Première valeur
print(list(dico.values())[0])
# ou bien (plus élégant mais complexe)
print(next(iter(dico.values())))

# Première clef
print(list(dico.keys())[0])
# ou bien (plus élégant mais complexe)
print(next(iter(dico.keys())))

# Première clef et valeur
# (full classe)
k,v = next(iter(dico.items()))
print(k,v)

Divers

# Imprimer joliment
moi = {"nom": "BARBIER", "prenom": "Jean-Matthieu",
      "mail": "jm.barbier@solidev.net",
      "adresse": { "numéro": 4, "rue": "clos d'Ivry",
                 "ville": "houlbec", "cp": "27120"}}
import pprint
pprint.pprint(moi)

{'adresse': {'cp': '27120',
             'numéro': 4,
             'rue': "clos d'évry",
             'ville': 'houlbec'},
 'mail': 'jm.barbier@solidev.net',
 'nom': 'BARBIER',
 'prenom': 'Jean-Matthieu'}

import yaml
print(yaml.dump(moi, allow_unicode=True))

adresse:
  cp: '27120'
  numéro: 4
  rue: clos d'évry
  ville: houlbec
mail: jm.barbier@solidev.net
nom: BARBIER
prenom: Jean-Matthieu

Intéractivité : fonction input(message) -> str

reponse = input("Quel est votre nom ?")
print("Votre nom est : ", reponse)

Quel est votre nom ? BARBIER


Votre nom est :  BARBIER

Exercice 1 : Création d'une fiche de carnet d'adresse

Créer une fonction qui demande à l'utilisateur son nom, son prénom et son email, et qui renvoie les infos dans un dictionnaire

Exercice 2 : Création d'un carnet d'adresse

Créer une fonction qui demande à l'utilisateur combien de personnes il veut entrer, et qui ensuite demande autant de fois que désiré le nom, prénom et email à ajouter, et qui stocke ces fiches stockées à la suite les unes des autres dans une liste

Exercice 3 : Recherche dans un carnet d'adresse

Créer une fonction prenant comme arguments un carnet d'adresses et un nom, et qui renvoie la fiche dont le nom correspond si elle existe, et ne renvoie rien si rien n'est trouvé.