2 de

CORRIGÉ

P Y T H O N
Spécial SNT

Notions et outils

Exercices

Travaux pratiques

+
foucherconnect.fr/1218765
2
de

PY T H O N
Spécial SNT
CORRIGÉ

Hassan Dibesse
Professeur de sciences de l’ingénieur,
lycée Lesage, Vannes (56)
Patricia Kerner
Professeure de sciences de l’ingénieur, NSI, SNT
lycée Yves Thépot, Quimper (29)
Yannig Salaun
Professeur de mathématiques, NSI, SNT,
formateur académique,
lycée de l’Elorn, Landerneau (29)
Crédit photographique
p. 2 © python, © Vittascience ; p. 6 © blankstock / stock.adobe ; p. 9 ph © accogliente / stock.
adobe.com ; p. 11 ph © mr green / stock.adobe.com ; p. 13 ph © Lost_in_translation / stock.
adobe.com ; p. 16 ph © Oleksii / stock.adobe.com ; p. 29 ph © IDOL’foto / stock.adobe.com ;
p. 31 ph © Artem Varnitsin / stock.adobe.com ; p. 34 ph © Attant / stock.adobe.com ; p. 38
ph © Maksym / stock.adobe.com ; p. 44, 45, 46, 47 ph © HD

Maquette : Nicolas Piroux

Composition : Grafatom
Illustrations : Vincent Landrin

© Foucher, une marque des Éditions Hatier – Paris, 2023

ISBN : 978-2-216-14025-11
1

« Sous réserve des exceptions légales, toute

représentation ou reproduction intégrale ou partielle,
faite, par quelque procédé que ce soit, sans le
consentement de l’auteur ou de ses ayants droit, est
illicite et constitue une contrefaçon sanctionnée par le
Code de la Propriété Intellectuelle. Le CFC est le seul
habilité à délivrer des autorisations de reproduction par
reprographie, sous réserve en cas d’utilisation aux fins
de vente, de location, de publicité ou de promotion de
l’accord de l’auteur ou des ayants droit. »
Présentation
À qui s’adresse ce cahier ?
Ce cahier s’adresse principalement aux enseignants et aux élèves de SNT mais plus
largement à tous les enseignants et élèves de seconde générale et technologique. Il a
pour objectif d’illustrer le cours de SNT, de manière simple et de proposer des activités
de programmation Python pour chaque partie du programme de SNT.

Pourquoi ?
Python est le langage informatique le plus utilisé dans le monde. Il est à la fois simple
et puissant. La programmation sur Python est le thème transversal du programme
SNT.
Capacité attendue : écrire et développer des programmes simples pour répondre à
des problèmes et modéliser des phénomènes.
Les activités proposées dans cet ouvrage permettent d’approfondir les connaissances
et compétences des élèves en programmation.

Comment l’utiliser ?
La première partie de l’ouvrage peut servir d’introduction (ou de rappel) des différentes
notions de programmation au programme de SNT. Les élèves pourront aussi s’y référer
tout au long de l’année.
La seconde partie contient des activités indépendantes liées aux thèmes du
programme. Elle peut être traitée de façon non linéaire : l’enseignant peut utiliser les
fiches en fonction de sa progression et des connaissances en programmation de ses
élèves. Certaines activités nécessitent l’utilisation d’un ordinateur (elles sont signalées
par un pictogramme), d’autres sont réalisables sur le cahier.
Pour terminer, le cahier peut être utilisé de manière autonome. C’est un outil
d’apprentissage et d’entraînement pour toute personne souhaitant approfondir ses
connaissances en programmation.

Les activités de cet ouvrage sont réalisables directement sur la plateforme

Vittascience : https://fr.vittascience.com/python-foucher.

3
Sommaire
Présentation....................................................................................................3

Partie 1 Prise en mains de Python

1 L'environnement de travail..........................................................................6
2 Les variables...............................................................................................8
3 Les conditions (if, elif, else)........................................................................ 10
4 Les boucles bornées (for… in)................................................................... 12
5 Les boucles non bornées (while)............................................................... 13
6 Définir une fonction................................................................................. 14
7 Appeler une fonction............................................................................... 15

Partie 2 Python dans le programme de SNT

Internet
8 Les adresses IP.......................................................................................... 16
9 Les serveurs DNS...................................................................................... 18

Le web
10 Créer un serveur web............................................................................... 20
11 Créer un site dynamique........................................................................... 22
12 Valider et sécuriser un formulaire.............................................................. 24

Les réseaux sociaux

13 Identification et authentification............................................................... 26
14 Les graphes.............................................................................................. 28

4
Les données structurées et leur traitement
15 Dictionnaire et stockage...........................................................................30
16 Analyse des données................................................................................ 32

Localisation, cartographie et mobilité

17 Les cartes numériques..............................................................................34
18 La trame NMEA.......................................................................................36
19 Calculs d’itinéraires...................................................................................38

Informatique embarquée et objets connectés

20 Acquisition de données et IHM.................................................................40

La photographie numérique
21 Créer une image...................................................................................... 42
22 Manipuler une image...............................................................................44
23 Agir sur les composantes RGB..................................................................46

5
 21 L’environnement de travail
Notions Outils
• Un environnement de programmation • Exemple de console
Python comporte toujours 2 espaces :
– un éditeur de code qui permet de
rédiger et d’enregistrer les scripts.
– une console d’exécution qui permet
de lancer un script et d’exécuter des
instructions une à une.
• La console se reconnaît aux >>> qui
démarrent chaque ligne.

Il est possible de programmer en Python sur plusieurs supports.

1. Sur calculatrice
Plusieurs marques proposent des calculatrices programmables
en Python (Numworks, Texas Instrument et Casio).
Des mises à jour de Python sont disponibles sur leurs sites
Internet respectifs.
Avec une calculatrice, on est limité dans l’usage des
bibliothèques.
Éditeur de code Console

6
 Partie 1

2. Sur ordinateur, en local

Il existe de nombreux éditeurs de code qui permettent de programmer en Python
une fois installé sur la machine. Exemple : Thonny, IDLE, PyCharm, Visual Studio
Code, Spyder, etc.

Il faudra
installer certaines
bibliothèques.

Éditeur de code

Console

3. Sur ordinateur, en ligne

Il s’agit de la solution la plus simple à mettre en œuvre car elle ne requiert aucune
installation, toutefois, elle nécessite une connexion internet pour accéder au
serveur qui héberge le compilateur de Python.

Éditeur de code Console

Les activités de cet ouvrage sont réalisables directement sur

la plateforme Vittascience : https://fr.vittascience.com/python-foucher.
7
 2 Les variables
Notions
• Une variable est un emplacement
mémoire qui permet de stocker des
objets de différents types.
• Le nom d’une variable ne peut
contenir que des caractères
alphanumériques (A-Z, a-z, 0-9)
et le tiret du bas (_). Il ne peut
pas commencer par un chiffre ni
contenir d’espaces. Certains mots
réservés ne sont pas autorisés (in,
and, if, for, else, while, etc.)
Outils
• nom = valeur : on déclare une variable en
lui affectant une valeur. « = » est un signe
d’affectation. Il est différent d’une égalité
au sens mathématique.
• Type de variable : str : chaîne de
caractères, int : nombre entier, bool :
Booléen (True ou False), float : nombre à
virgule, list : liste.
• type() : indique le type de la variable.
• str(), int() et float() : convertissent
le type des données en str, int et float.

Exercices
print() :
1. Analyser le script et sa réponse puis donner la valeur et le type permet d’afficher
des variables a, b et c. des données.
1 a = bonjour
2 b = 15 Nom Valeur Type
3 c = True Réponse :
a « bonjour » Str
4 print(a,type(a)) bonjour <class 'str'>
15 <class 'int'> b 15 Int
5 print(b,type(b))
6 print(c,type(c)) True <class 'bool'> c True Bool

2. Les variables ci-dessous sont-elles valides ? Si non, proposer un nom valide.

Nom de la variable Valide ? Nom valide
#prénom1 Oui ✔ Non prenom

ageJoueur ✔ Oui Non

and Oui ✔ Non _and

3. Qu'affiche le script suivant ? Le script affiche : bac***.

1 a,b,c,d = "a", "b", "c", "d"
2 a,b = b,a
3 d = "***"
4 print(a,b,c,d)

8
 Partie 1

Travaux pratiques 40 mn

A. Tester et comprendre
1. Indiquer le résultat affiché par les scripts suivants.

1 d = 1 1 x = int(input("x:")) input() :
2 d = d + 2 2 plusDeux = x + 2 permet d’entrer
3 e = str(d) + "3") 3 print(plusDeux) des données.
4 print(e)
On entre 10, le script affiche :
Le script affiche : ✔ 12.
6. erreur.
123,0. 102.
✔ 33.

2. Tester les scripts pour vérifier vos réponses.

B. Faire connaissance avec l’ordinateur
1 # prenom = input("Entrez votre prénom:")
2 # age = input("Entrez votre âge:")
3 # age = int(input("Entrez votre âge:"))
4 # plusUn = age + 1
5 # print("Bonjour" + prenom + ", vous avez"
+ age + "ans")
6 # print("Bonjour" + prenom + ", vous avez" Une ligne commentée,
+ str(age) + "ans") c’est-à-dire débutant par
7 # print("Vous en aurez" + str(plusUn) + un #, n’est pas exécutée.
"dans un an !")

• Recopier le code précédent puis commenter ou décommenter les lignes afin de

tester les scripts indiqués. Relier chaque script à la réponse constatée et à la
solution lui correspondant.
Script Réponse constatée Solution
Lignes 1, 3
• •Erreur L5 : concaténation str • •int(input()) (1, 3, 4, 7)
et 5 et int !
Lignes 1, 2,
4 et 7 • •Script complet et correct. • •str() (1, 3, 6) ou (1, 2 ,5)
Lignes 1, 3, Erreur L4 : concaténation str
4, 6 et 7 • •et int ! • •Rien à faire.

9
 3 Les conditions (if, elif, else)
2
Notions
• En Python, on utilise des structures de
contrôle comme les conditions et les
boucles.
• Un test est effectué en utilisant une
condition (ou prédicat). La condition est
évaluée et renvoie vrai (True) ou faux
(False).
• Les structures conditionnelles
permettent d’exécuter des instructions
en fonction des conditions.
Exercices
1. Compléter le tableau, en indiquant pour chaque prédicat, s’il est vrai ou faux.
Conditions
a. "7" != 7
b. 9 < 2
c. not(False)
d. 6 == 4 + 2 and 6 > 8
2. Compléter le script suivant afin qu’il affiche « Admis » lorsque la note entrée est
supérieure ou égale à 10.
1 note = int(input("Note"))
2 if note >= 10
3 print("Admis"
3. Que réalise le script suivant ?
1 note = int(input("Note :"))
2 if note >= 10 :
3 print("Admis")
4 else :
5 print("Non admis")
10
Outils
• if : signifie « si ». Il évalue si le
résultat du test est vrai (et retourne
True) ou faux (et retourne False).
• else : signifie « sinon ».
• elif : signifie « sinon si ».
• Les conditions peuvent utiliser
des opérateurs de comparaisons
(==, !=, <, >, <=, >=) et des
opérateurs logiques (not, and, or).
• L’indentation (espaces) : permet de
définir un bloc d’instructions ainsi
que les imbrications entre les blocs.
Vrai Faux
✔
✔
✔
✔
:
)
Affichage obtenu :
Le programme affiche « Admis »
si la note est supérieure à 10
inon il affiche « Non admis ».
 Partie 1

Travaux pratiques 30 mn

A. Contrôle de l’âge
• Compléter et tester le script suivant afin d’afficher un message d’accès pour
chaque catégorie d’âge.
1 age = int(input("Entrez votre âge :"))
2 if age >= 18 :
3 print("Accès à partir de 18 ans")
4 elif age >= 16 :
5 print("Accès à partir de 16 ans")
6 elif age >= 12 :
7 print("Accès à partir de 12 ans")
8 else :
9 print("Accès interdit !")

B. Commande d’un volet programmable

• Le script suivant permet de commander un volet programmable. Le volet se
ferme la nuit. Le jour, il s’ouvre automatiquement à partir de 9 heures ou bien s’il
détecte un mouvement. Compléter et tester le script.
1 capteur = input("Entrer j (si jour), autre lettre (si nuit): ")
2 heure = int(input("Entrer heure : "))
3 mouvement = input("Entrer m (si mouvement), autre lettre sinon : ")
4 if capteur == "j" :
5 if mouvement == "m" or heure > 9 :
6 print("Ouverture volets")
7 else :
8 print("Volets fermés")
9 else :
10 print("Fermeture volets")

Défi ! Proposer un script qui demande la note obtenue puis affiche « Assez bien » à
partir de 12, « Bien » à partir de 14 et « Très bien » à partir de 16.

11
 4 Les boucles bornées (for… in)
2
Notions Outils
• Les boucles servent à répéter plusieurs • Structure d’une boucle for :
fois une ou plusieurs opérations. 1 for i in séquence :
• Elles permettent également de parcourir 2 bloc d’instructions
des données de types chaîne de 2 fin boucle for
caractères, listes, etc.
• i va prendre les valeurs successives
• Les boucles sont dites bornées si le
de séquence.
nombre d’itérations (répétitions) est
• range(n) : fonction qui donne une
connu à l’avance. On utilise l’instruction
liste de n éléments allant de 0 à n-1.
for.

Exercices
1. Que réalisent les scripts suivants ? Cocher la bonne réponse.
a. b. 1 for i in range(3):
1 for i in range(10):
2 print(i) 2 for j in range(11):
3 print(i*j)

Affiche 0 à 10. ✔ Affiche les tables de multiplication

✔ Affiche 0 à 9. de 0 à 2.
Affiche 1 à 10. Affiche 3 à 11.
Affiche 1 à 10.

2. Compléter le script à l’aide des étiquettes suivantes afin d’afficher les tables de
multiplications de 0 à 9.
i,"×",j,"=",i*j  ; range(10) ; for j in ; "Table de",i .

1 for i in range(10) :
2 print("Table de",i ) Les boucles
for peuvent
3 for j in range(11): s’imbriquer grâce
à l’indentation.
4 print(i,"×",j,"=",i*j )

12
 Partie 1

5 Les boucles non bornées (while)

Notions Outils
• Les boucles sont dites non bornées • Structure d’une boucle while :
quand le nombre d’itérations n’est pas 1 i=0
connu à l’avance. On utilise, dans ce 2 while condition :
cas, l’instruction while (« tant que » en 3 bloc d’instructions
français). 4 i+=1
• Les boucles non bornées doivent avoir
une condition de sortie afin d’éviter • i=0 : avant la boucle, on initialise
qu’elles s’exécutent à l’infini. i à 0.
• i+=1 : signifie i = i +1. Cette
instruction permet d’incrémenter une
variable (l’augmenter de 1).

Exercice
• Compléter le script suivant à l’aide
des commentaires (#).

1 codePin, pinSaisi = "1234", input("Entrez votre code PIN :")

2 # initialiser compteur à 0
3 compteur = 0
4 # tant que pinSaisi ≠ codePin et compteur ≠ 2
5 while pinSaisi != codePin and compteur != 2:
6 compteur += 1
7 print("Réessayez...", "Il vous reste", 3-compteur,
"essai(s)")
8 pinSaisi = input("Entrez à nouveau votre code PIN:")
9 # si pinSaisi est égale à codePin
10 if pinSaisi == codePin:
11 print("Code PIN correct. Bienvenue !")
12 # sinon
13 else :
14 print("Essais dépassés. Compte bloqué !")

13
 6 Définir une fonction
2
Notions Outils
• Une fonction est une partie d’un • def nom_de_la_fonction(a,b) :
programme informatique qui accomplit permet de définir une fonction en lui
une tâche spécifique. donnant un nom et des paramètres
• Définir une fonction c’est expliquer à la (a,b). Si la fonction ne possède pas
machine ce que doit réaliser la fonction. de paramètres on écrit : def nom_de_
la_fonction (). La ligne se termine
• Une fonction qui ne retourne pas de
par : .
résultat s’appelle une procédure.
• return : retourne le résultat d’une
fonction.
Paramètres Fonction
Sortie

Exercices
1. Corriger le script de la fonction inferieur(a,b) suivante.
1 definition inferieur[a,b] 1 def inferieur(a,b) :
2 if a<b : 2 if a<b : Tout le code
contenu dans
3 renvoi True 3 return True une fonction
4 else : else : est indenté
4
d’un niveau.
5 renvoi False 5 return False

2. Dans le script suivant, surligner en jaune le nom de la fonction et en bleu ses

paramètres. Indiquer ce qu’elle réalise et s’il s’agit d’une fonction ou d’une
procédure.
1 def parite(nombre) : Action : affiche si le nombre entier n
2 if nombre%2==0 :
est pair ou impair.
3 print("paire")
4 else : Fonction ✔ Procédure
5 print("impaire")

3. Écrire une fonction

1 def addition(a,b) :
addition(a,b), qui prend en
paramètres deux nombres a et b 2 return a+b
et retourne leur somme.

14
 Partie 1

7 Appeler une fonction

Notions Outils
• L’appel de fonction est l’opération qui • afficher_bonjour() : appel
permet d’exécuter le code contenu dans la fonction par son nom.
une fonction. • resultat = fonction() : stock
• Une bibliothèque est un ensemble le résultat de la fonction dans une
de fonctions, de classes et d’autres variable resultat.
éléments qui peuvent être utilisés dans • import random : charge
un programme. la bibliothèque random.
• Exemple de bibliothèques : math, • random.randint() : appel de
random, networkx, folium, pillow, tkinter, la fonction randint() de la
micro:bit. bibliothèque random.

Exercice
• En utilisant les fonctions suivantes, écrire les appels de fonctions
correspondant aux actions indiquées.
1 # Appel de la fonction afficher_bonjour sans paramètre
2 afficher_bonjour() # affiche « Bonjour ! »
3 # Appel de la fonction calculer_carre avec un paramètre
4 carre = calculer_carre(3) # carre contiendra la valeur 9
5 # Appel de la fonction addition avec deux paramètres
6 somme = addition(2, 3) # somme contiendra la valeur 5

a. Afficher « Bonjour ! » : afficher_bonjour()

Il possible
b. Calculer le carré de 7 : calculer_carre(7)
d’appeler une
c. Calculer le carré de -2 : calculer_carre(-2) fonction dans
une fonction.
d. Faire l’addition de 1 et 5 : addition(1,5)
e. Faire l’addition du carré de -3 et de 4 : addition(calculer_carre(-3),4)
f. Faire le carré de (4+11) : calculer_carre(addition(4,11))
Documentation Turtle
/
foucherconnect.fr 23py01
Défi ! La bibliothèque Turtle permet de dessiner à l’écran.
En utilisant cette bibliothèque, dessiner un damier à l’écran.

15
 8 Les adresses IP
Notions Outils
• Une adresse IP sert à identifier les machines sur • randint(0,255) : la fonction
un réseau. randint(a,b) génère un
• Nous utiliserons l’IPv4, composée de 4 nombres nombre aléatoire compris
compris entre 0 et 255. entre a et b inclus.
• Exemple d’adresse IP : 192.168.0.15 • adresse = [] : adresse est
une liste vide.
• adresse.append(165) :
la fonction append ajoute
un élément dans une liste.

Exercices
1. Les adresses IP suivantes sont-elles valides ? Si non, préciser pourquoi.
Adresse IP Valide ? Si non, pourquoi ?
192.172.12.2 ✔ Oui Non
265.123.25.158 Oui ✔ Non Le premier nombre est supérieur à 255.
168.168.168.168 ✔ Oui Non
128.0.255 Oui ✔ Non Il manque un nombre.

2. Proposer des adresses IP à attribuer à 4 ordinateurs différents dans un même

réseau. Pour cela, les 4 adresses doivent commencer par les 2 mêmes nombres.
Ordi 1 : 172.16.10.1 Ordi 2 : 172.16.20.1
Ordi 3 : 172.16.10.2 Ordi 4 : 172.16.34.25
3. Compléter le code de la fonction genereIP() ci-dessous :
1 from random import randint
2 def genereIP() :
3 #renvoie une adresse IP aléatoire sous forme de liste
4 adresse = []
5 for i in range( 4 ) :
6 adresse.append(randint( 0, 255 ))
7 return adresse

16
 Partie 2 I Internet

Travaux pratiques 30 mn

A. Création
1 def creerIP() :
Un tuple
2 #renvoie une adresse IP sous forme de 3 tuple ressemble à
4 a = 192 une liste, mais
5 b = 168 on ne peut pas
6 c = 0 le modifier
7 d = 15 une fois qu’il
a été créé.
8 return (a,b,c,d)

1. Quelle est l’adresse IP créée par la fonction creerIP() ci-dessus ?

192.168.0.15
2. Quelles lignes et comment faut-il les modifier dans la fonction pour obtenir
l’adresse IP 192.168.1.29 ?
Ligne 6 : c = 1 et ligne 8 : d = 29.
3. Modifier la fonction pour obtenir une adresse de la forme 192.168.c.d où c et d
sont deux nombres aléatoires compris entre 0 et 255.
Ligne 6 : c = randint(0,255) et ligne 8 : d = randint(0,255).

Ajouter from random import randint au début du programme.

B. Vérification
• Dans notre cas, pour pouvoir communiquer, deux ordinateurs doivent posséder
des adresses dont les 2 premiers nombres sont identiques. Écrire une fonction
qui prend en paramètres deux adresses IP et qui renvoie True si elles sont
compatibles et False dans le cas contraire.

1 def compatibles(adr1,adr2) : Le premier

2 if adr1[0]==adr2[0] and adr1[1]==adr2[1] élément d’un
tuple possède
3 and (adr1[2],adr1[3])!=(adr2[2],adr2[3]) l’indice 0.

4 return True
5 else :
6 return False

Défi ! Écrire une fonction qui donne la liste de toutes les adresses IP possibles de la
forme 192.168.c.d où c et d sont compris entre 0 et 255.

17
 9 Les serveurs DNS
Notions Outils
• DNS est l’acronyme de Domain Name • ping qwant.com : dans un terminal,
System. permet de tester la connexion avec
• Le système DNS est réalisé par un grand www.qwant.com.
nombre d’ordinateurs, répartis sur le • gethostbyname('qwant.com') :
réseau et constamment mis à jour. renvoie l’adresse IP de qwant.com.
Adresse symbolique • gethostbyaddr('194.187.168.99') :
wikipedia.com
renvoie l’adresse symbolique de
194.187.168.99.
141.94.212.184
Utilisateur naviguant Adresse Système • liste.index(a) : renvoi l’indice de
sur Internet numérique (IP) DNS
l’élément a dans la liste.

Exercices
1. Vrai ou Faux ? Cocher la bonne réponse.
Vrai Faux
a. Les navigateurs internet connaissent les adresses IP de tous
✔
les sites web qui existent.
b. Tous les ordinateurs possèdent un serveur DNS. ✔
c. Si le serveur DNS ne connaît pas l’adresse cherchée, il
✔
demande à un autre serveur DNS.
d. Les moteurs de recherche sont des serveurs DNS. ✔

2. À l’aide de l’extrait de l’enregistrement DNS ci-dessous, indiquer :

– l’adresse IP du site web www.qwant.com :
194.187.168.99.
– l’adresse symbolique du site web dont l’adresse IP est 141.94.212.184 :
www.wikipedia.fr.

Adresse symbolique Adresse IP

www.qwant.com 194.187.168.99
www.ecosia.org 52.29.238.134
www.wikipedia.fr 141.94.212.184

18
 Partie 2 I Internet

Fichiers
Travaux pratiques 50 mn /
foucherconnect.fr 23py02

A. Le module socket
1. Télécharger et exécuter le fichier adresse.py, puis noter les affichages obtenus.
>>>141.94.212.184 et >>>qwant.com.

2. En utilisant le script, compléter le tableau.

Adresse symbolique Adresse IP
cnil.fr 46.18.194.71
facebook.com 157.240.21.35
framasoft.org 88.198.21.14
eduscol.fr 185.53.177.53

B. Avec des listes

Les enregistrements DNS sont stockés dans deux listes :
1 liste_adr_symb = ['qwant.com','ecosia.org','wikipedia.fr']
2 liste_adr_ip = ['194.187.168.99','52.29.238.134','141.94.212.184']

1. Compléter la fonction verif_symb() qui vérifie si une adresse symbolique

donnée est présente dans la liste et renvoie son indice.
1 def verif_symb(adresse) :
2 if adresse in liste_adr_symb :
3 return liste_adr_symb .index(adresse)
4 else :
5 return None

2. Compléter la fonction renvoi_ip() qui renvoie l’adresse IP d’une adresse

symbolique donnée en paramètre.
1 def renvoi_ip(adresse) :
2 indice = verif_symb( adresse )
3 return liste_adr_ip[ indice ]

3. Écrire le résultat de l’exécution des lignes suivantes :

>>> verif_symb('ecosia.org') : >>> 1.
>>> renvoi_ip('ecosia.org') : >>> 52.29.238.134.

19
10 Créer un serveur web
Notions
• Un serveur web est un ordinateur qui
stocke des fichiers puis les envoie (les sert)
à l’appareil du visiteur du site (le client).
• Un serveur local simule un site, dans
les conditions réelles, sur son propre
ordinateur.
• L'URL d'une page est l'adresse par
laquelle elle est accessible.
• Un port est une porte d’accès donnée au
serveur pour émettre et recevoir.
Clients Serveur web
index.html
Réseau
image.jpg
Outils
• python -m http.server : permet de
créer un serveur local sur le port 8000
par défaut. Si non, il est possible de
préciser le port souhaité : python -m
http.server numéro de port.
• lochost : signifie qu’on se réfère
à son propre ordinateur,
correspondant à l’IP : 127.0.0.1.
• localhost:8000  : signifie serveur
local sur le port 8000.
• HTTPServer et HTTPRequestHandler :
modules de Python permettant de
gérer les échanges entre utilisateur et
serveur.

Exercices
1. Indiquer si les affirmations suivantes sont vraies ou fausses.
Vrai Faux
a. La saisie de l’URL 127.0.0.1:8000 sur le navigateur permet
✔
tester le serveur.
b. localhost:8000 et 127.0.0.1:8000 ne donnent pas le même
✔
résultat.
c. La commande python -m http.server 9999 crée un serveur
✔
local sur le port 9999.
2. On souhaite créer et tester un serveur local sur 2 ports différents.
Compléter le tableau.
Port Code dans l’invite de commande URL dans le navigateur
7777 python -m http.server 7777 127.0.0.1 : 7777
9999 python -m http.server 9999 127.0.0.1 : 9999

20
 Partie 2 I Le web

Fichiers
Travaux pratiques 40 mn /
foucherconnect.fr 23py03

A. Les modules HTTPserver et HTTPResquestHandler

1. Télécharger le dossier testServeur puis lancer le serveur en exécutant le fichier
serveur.py dans la console python ou par double-clic. Laisser tourner le serveur
(ne pas fermer la console python ou l’invite de commande).
Tester sur le navigateur à l'URL : 127.0.0.1:8000.
2. On souhaite améliorer le script afin de servir à l’adresse 127.0.0.1 sur le port
8888. Supprimer les « # » des lignes 4 et 5 afin de créer deux variables puis
modifier les lignes 4, 5 et 38. Enregistrer les modifications du script serveur.py,
arrêter puis relancer le serveur.
Tester sur le navigateur à l’URL : 127.0.0.1:8888.
4 host = '127.0.0.1'
5 port = 8888
38 serv = HTTPServer(( host , port ), Servir)

3. Modifier la ligne 41 afin que le message affiché lors du lancement du

serveur soit : « Serveur en service sur le port : numéro de port ». Enregistrer les
modifications et relancer le serveur afin de constater le nouveau message affiché
quand il est en service.
41 print("Serveur en service sur le port:", port)

4.
a. Renommer le fichier index.html en test.html puis relancer le serveur.
Résultat attendu :
Serveur en service…
127.0.0.1 - - [date et heure] "GET / HTTP/1.1" 404 -
b. Tester sur le navigateur avec la bonne URL.
Résultat attendu :
Oups… Erreur 404 !
c. Modifier la ligne la ligne 29 pour afficher le message d’erreur suivant :
Fichier introuvable !

29 fichier_a_ouvrir = "Fichier introuvable !"

d. Tester de nouveau.

21
11 Créer un site dynamique
Notions
• Un site dynamique permet de
générer du contenu web en fonction
de l’utilisateur.
• Flask est un ensemble d’outils
logiciels (framework) permettant la
création d’applications web simples
et dynamiques.
• Une route est un chemin d’accès
permettant de créer une URL et de la
lier à une fonction.
Outils
• request.form[] : récupère le contenu
d’un formulaire.
• flash() : envoie des messages courts
dans le navigateur, nécessite une clé de
sécurité (app.secret_key).
• render_template() : permet au moteur
de modèles 'templates' Jinja2 d’exécuter
des fichiers html contenant de la logique.
• @app.route('/') : crée l’URL '/' (racine
du site).

Exercices
1. Le script suivant permet de créer une page web simple affichant « Bonjour ! ».
Relier chaque action à la ligne la réalisant.
• 1 from flask import Flask
a. Retourne le texte « Bonjour ! » • • 2 app = Flask(__name__)
b. Crée la route '/' • • 3 @app.route(‘/’)
c. Crée une fonction liée à la route '/' • • 4 def index():
• 5 return "Bonjour !"

2. On insère le code suivant entre les lignes 2 et 3 puis on modifie la ligne 5

« return "Bonjour !" » par « return(html_template) ».
3 html_template = """ <style>body{background-color:aqua;}</style>
4 <h1 id="demo">Bonjour</h1>
5 <button type="button" onclick="modif()"> Modifier ici </button>
6 <script>function modif() {
7 document.getElementById("demo").innerHTML = "Modifié avec JS";
8 document.getElementById("demo").style.backgroundColor =
"yellow" ; }
9 </script> """

Pages web obtenues avant et après appui sur le bouton :

Bonjour Modifié avec JS

Avant : Modifier ici

Après : Modifier ici

22
 Partie 2 I Le web

Répondre par vrai ou faux. Vrai Faux

a. L’élément <script> permet d’écrire du code Javascript dans un
✔
code html.
b. Javascript ne permet pas au navigateur de modifier l’apparence
✔
d’une page web.
c. Bien qu’interactive, aucune information du « client » ne remonte
✔
au serveur.
d. La page web est dynamique, elle change en fonction de l’utilisateur. ✔

Fichiers
Travaux pratiques 40 mn /
foucherconnect.fr 23py04

A. Créer une page dynamique avec Flask

1. Télécharger le dossier projet1 et la méthode. Créer dans le dossier un
environnement virtuel envtest puis installer Flask à l’aide de la méthode. Lancer
app.py sur envtest et effectuer un test sur le navigateur à l’URL : 127.0.0.1:5000/
2. Saisir un prénom et appuyer sur le bouton. La page affichée est-elle dynamique ?
La réponse renvoyée tient compte du prénom, la page est dynamique.

3. Analyser les lignes 3 à 11 du script app1.py. Les deux routes créées

correspondent chacune à une URL, indiquer le nom et le rôle de la fonction
associée à chaque route.
URL 127.0.0.1:5000/ 127.0.0.1:5000/accueil
Fonction prenom() saluer()

Affiche un message flash Affiche un message flash avec

invitant à saisir le prénom. le prénom entré par l’utilisateur.

La fonction render_template L’objet request.form retourne

Rôle
exécute le fichier index.html. la valeur du champ name_input.

La fonction render_template

exécute le fichier index.html.

4. Supprimer la ligne 3 et tester le rendu sur le navigateur. Que peut-on en déduire

quant à l’utilisation de cette clé de sécurité ?
Cette clé secrète est obligatoire, sans elle la page ne s’affiche pas.

23
12 Valider et sécuriser un formulaire
Notions
• Le contenu d’un formulaire peut être
inexploitable ou contenir du code
malveillant.
• Une expression régulière RegEx
(Regular Expression), est un ensemble de
caractères appelé pattern (motif) qui sert
à vérifier si une expression correspond au
modèle décrit. Bien qu’insuffisantes, elles
permettent de valider et sécuriser un
formulaire côté serveur.
Outils
• re.fullmatch(regex,exp) : vérifie
la correspondance de l’expression exp
avec le modèle regex.
• [a-zA-Z0-9] : ensemble des
caractères alphanumériques.
• {m,n} : délimiteur, répète entre m et n
fois. {m,} répète m fois ou plus.
• re.compile() : permet de réutiliser
efficacement un modèle plusieurs fois
en évitant de le réécrire.

Exercices
1. Le script ci-dessous demande un prénom et indique s’il est valide.
Les prénoms suivants sont-ils valides ?
1 import re
2 prenom = input("Entrer un Prénom Valide ?
prénom :")
Gwennaelle Oui ✔ Non
3 pattern = r'[A-Za-z]{2,8}'
4 if re.fullmatch(pattern, Mehdi ✔ Oui Non
texte): Jean-Pierre Oui ✔ Non
5 print(prenom, "valide")

2. On remplace la ligne 3 par :

3 pattern = r'[A-zÀ-ú -]{2,20}'

Les prénoms suivants sont-ils valides ?

Prénom Valide ?
Pierre-Mickaël ✔ Oui Non
Anne Elise ✔ Oui Non
Clém17 Oui ✔ Non

A Oui ✔ Non

24
 Partie 2 I Le web

Fichiers
Travaux pratiques 40 mn /
foucherconnect.fr 23py05

A. Sécuriser le formulaire
1. Un utilisateur saisit son prénom et son email afin de s’inscrire à une newsletter.
Le script suivant vérifie les données entrées. Saisir et tester le script.
1 import re
2 prenom = input("Entrez votre prénom :")
3 email = input("Entrez votre email:")
4 regex1 = re.compile(r'[a-zA-Z]{3,10}')
5 regex2 = re.compile(r'[a-zA-Z0-9]{8,20}')
6 if not re.fullmatch(regex1, prenom):
7 print("Prénom non vaide !")
8 elif not re.fullmatch(regex2, email):
9 print("Email non valide !")
10 else :
11 print("Votre demande est enregistrée !")

2. Compléter le tableau en indiquant le résultat obtenu pour les données saisies.

Prénom Email Demande
Prénom Email
non valide non valide enregistrée
Maël Mael14mail ✔

Pierre pierre@mail.fr ✔

Julie Julie17mail ✔

3. Modifier la regex1 pour tenir compte des prénoms accentués. Tester à nouveau
avec Maël et mael14@mail.fr. Quelle est alors la réponse obtenue ?
Email non valide !
4. Télécharger le dossier projet2, créer un environnement de développement en y
installant Flask. Lancer le script dans le cmd puis tester la page web sur l’URL
127.0.0.1:5000 de votre navigateur.
5. Tester avec un email invalide. Le navigateur bloque, inspecter la page, modifier
le type de email à text puis valider. La sécurisation côté client (navigateur) est
contournée, on peut injecter ce qu’on veut dans le champ et valider.
<input type= « text » placeholder= « Email » name= « email_input »>

6. Dans le script app2.py, supprimer les « # » pour tenir compte de la regex2.

Tester et expliquer pourquoi la saisie de l’email est maintenant sécurisée.
L’expression régulière permet de couvrir 99,99 % des emails valides.

25
13 Identification et
authentification
Notions Outils
• S’identifier revient à donner son nom. • random.choice("abcdefg") :
• S’authentifier consiste à prouver que tirage aléatoire d’un caractère dans
l’on est bien cette personne. abcdefg.
1 Identification CONNEXION • liste.index(a) : renvoie l’indice
Qui êtes-vous ? Identifiant de l’élément a dans la liste.
Mot de passe
2 Authentification
Prouvez-le ! Se connecter

Exercices
1. Pour chaque élément du tableau, indiquer s’il s’agit d’un moyen d’identification
et/ou d’authentification.
Identification Authentification
Email ✔

Mot de passe ✔

Pseudo ✔

Empreinte digitale ✔ ✔

2. Répondre aux questions à l’aide du script suivant.

1 id = input("identifiant ?")
2 mdp = input("mot de passe ?")
3 if id == "alan" and mdp == "AT16$r" :
4 print("Vous êtes bien authentifié !") input() :
5 else : permet d’entrer
6 print("ERREUR") des données.

a. Quels sont l’identifiant et le mot de passe à saisir ?

L’identifiant à saisir est alan et le mot de passe est AT16$r.
b. Le mot de passe at16$r va-t-il fonctionner ?
Non car les majuscules ne sont pas respectées.

26
 Partie 2 I Les réseaux sociaux

Fichiers
Travaux pratiques 45 mn /
foucherconnect.fr 23py06

A. Générateur de mot de passe

1. Saisir et exécuter 3 fois la fonction mdp1() qui génère un mot de passe aléatoire.
1 import random
2 def mdp1() :
3 motDePasse= ""
4 for i in range(6) :
5 motDePasse += random.choice("abcdefghi")
6 return motDePasse
7 print (mdp1())

a. Indiquer les affichages obtenus : >>>bcabcf ; >>>beafag et >>>afbbac.

b. Quelle est la taille mot de passe généré ? 6
c. Modifier une ligne pour obtenir un mot de passe de taille 12.
ligne 4 : for i in range(12)

d. Quels sont les caractères utilisés pour former le mot de passe ?

abcdefghi

2. Compléter puis tester la fonction mdp2() qui génère un mot de passe constitué
uniquement de voyelles, de taille aléatoire entre 10 et 20 caractères.

1 import random
2 def mdp2() :
3 motDePasse= ""
4 longueur= random.randint( 10 , 20 )
5 caracteres = " aeiouy "
6 for i in range( longueur ) :
7 motDePasse += random.choice( caracteres )
8 return motDePasse

Défi ! Écrire une fonction qui demande à l’utilisateur la taille du mot de passe à
générer ainsi que la liste des caractères à utiliser, puis génère ce mot de passe.

27
14 Les graphes
Notions Outils
• Un graphe peut servir à représenter • g=nx.Graph() : création d’un graphe g.
un réseau social. • g.add_node('A') : ajout d’un nœud.
• Distance : plus petit nombre d’arêtes • g.add_edge('A','B') : ajout d’une
reliant 2 sommets. arête.
• nx.diameter(g) : renvoi le diamètre
• Diamètre : plus grande distance dans
de g.
le graphe.
• nx.radius(g) : renvoi le rayon de g.
• Centre : sommet dont la distance • nx.center(g) : renvoi le centre de g.
max est la plus petite. • add_edges_from() : permet d’ajouter
• Rayon : distance max à partir du centre. une liste d’arêtes.
Orlane
Exercices
1. a. À l’aide du graphe d’un Youna
Lilwenn
mini réseau social ci-contre, Madenn

compléter le tableau des Alwenna

distances suivant. Naïs

Madenn Youna Alwenna Lilwenn Orlane Naïs

Madenn 1 1 2 2 1
La distance
Youna 1 1 1 1 1
entre Lilwenn
Alwenna 1 1 1 2 1 et Madenn
est 2.
Lilwenn 2 1 1 2 2

Orlane 2 1 2 2 2

Naïs 1 1 1 2 2

b. Diamètre : 2 c. Centre : Youna d. Rayon : 1

2. Le script suivant génère un graphe à partir de ses arêtes.
1 import networkx as nx, matplotlib.pyplot as plt • Nombre d’arêtes ? 12
2 G = nx.Graph()
• Nombre de sommets ? 7
3 G.add_edges_from([ (1,2),(1,3),(1,4),(2,3),(2,4),
(3,5),(3,6),(3,7),(4,7),(5,1),(5,6),(6,7)])
4 nx.draw(G,with_labels=True)
5 plt.show()

28
 Partie 2 I Les réseaux sociaux

Fichiers
Travaux pratiques 45 mn /
foucherconnect.fr 23py07

A. Modifier un graphe
1. Après avoir téléchargé et exécuté le fichier graphe.py, recopier le graphe obtenu.
5

0
1
4
2

2. Ajouter au script les instructions pour exécuter les actions suivantes.

a. Ajouter un nœud n° 7 : G.add_node(7)
b. Ajouter une arête entre les nœuds 7 et 1 : G.add_edge(7,1)
c. Ajouter une arête entre les nœuds 7 et 2 : G.add_edge(7,2)
3. Relancer le script modifié puis exécuter les instructions suivantes dans la
console. Noter les réponses obtenues.
Un graphe
• G.number_of_edges() : 8 • nx.diameter(G) : 3 peut avoir
• nx.center(G) : [0,1,2] plusieurs centres.

B. Modéliser par un graphe.

1. Écrire un script permettant de créer et d’afficher le graphe représentant la
situation suivante.
– Albert est ami avec Béa, Charles et Emile.
– Béa est amie avec Albert et Charles.
– Charles est ami avec Albert, Béa et Emile.
– Damien est ami avec Béa et Emile.

2. Recopier le graphe obtenu.

Charles

Damien Emile Béa

Albert

3. Ajouter au script les instructions permettant de déterminer le centre du graphe

et son rayon.

29
15 Dictionnaire et stockage
Notions
• Le dictionnaire (dict) est une structure
de données permettant d’associer des
valeurs à des clés et d’accéder à ces
valeurs à partir de leurs clés.
• C’est un type de conteneur (comme les
listes et les tuple) où les valeurs sont
indexées par des clés.
• Les clés peuvent être de type : chaînes
de caractères, entiers, flottants, tuple.
• Les valeurs peuvent être de tout type.
Outils
• dico={cle1:valeur1,cle2:valeur2} :
créer un dictionnaire dico.
• dico[cle1] : accéder à la valeur de la
clé cle1 d’un dictionnaire dico.
• dico[nouvelle_cle]=nouvelle_valeur :
ajouter une valeur au dictionnaire.
• dico.keys() : permet d’obtenir la liste
des clés.
• dict(liste) : permet de créer un
dictionnaire à partir d’une liste.

Exercices
1. Indiquer les dictionnaires créés par le script suivant et identifier leurs clés et
leurs valeurs.
1 dico1 = {"chat":2,"chien":1}
2 dico2 = {"chat": ("cat","gato"),"chien":("dog","perro")}
3 dico3 = {x:x**2 for x in range(1,4)}

Dictionnaire Clé Valeur

dico1 {"chat":2,"chien":1} Chat, chien 2, 1
{"chat":("cat","gato"),"chien": Chat, chien cat, gato, dog,
dico2
("dog","perro")} perro

dico3 {1:1, 2:4, 3:9, 4 :16} Entier X Carré de X

2. Le script suivant crée et affiche un dictionnaire ayant pour clé des entiers de 1 à
7 et pour valeur les jours de la semaine.
1 jours="lundi","mardi","mercredi","jeudi","vendredi","samedi","dimanche"
2 for i in range(len(jours)):
3 dico.update({i+1:jours[i] }) Len() : permet
4 print(dico) d’obtenir la longueur
d’une liste.
a. Compléter le script.
b. Affichage obtenu : {1: "lundi"} {2: "mardi"} {3: "mercredi"} {4: "jeudi"} {5: "vendredi"}
{6: "samedi"}
30
 Partie 2 I Les données structurées et leur traitement

Fichiers
Travaux pratiques 30 mn /
foucherconnect.fr 23py08

A. Informaticien
1 informaticien = {"nom":"Turing","prenom":"Alan","naissance":1912,
"mort":1954}
2 print(informaticien ["prenom"] )
3 print(informaticien["naissance"] )
4 informaticien["nationalite"]= "anglaise"
5 print(informaticien)

1. Compléter les lignes 2 et 3 du script afin qu’il affiche les valeurs prenom et
naissance.
2. Alan Turing est de nationalité anglaise. Compléter la ligne 4 pour ajouter cette
information au dictionnaire.
3. Tester le script obtenu pour vérifier vos réponses.
B. Moyenne
1. Le script suivant crée un dictionnaire contenant les
moyennes obtenues (valeurs) dans chaque matières (clés)
par Zeynep, une élève de seconde. Le compléter afin
d’afficher la liste des matières.
1 resultats = {"snt":18,"maths":17,"svt":14,"français":14,"lv1":8,"HG":11}
2 for i in resultats.keys() :
3 print(i)

2. Télécharger et compléter le script moyenne.py afin de créer le dictionnaire à

partir de liste contenant les matières et les notes.
3. Compléter le script en ajoutant les matières et les notes suivantes.

Matière Notes
lv2 10
physique-chimie 16
SES 9

Défi ! Écrire un programme qui affiche les matières avec plusieurs notes, les
moyennes par matière et la moyenne générale d’un élève.

31
16 Analyse des données
Notions
Définition
• Pour le stockage et l’analyse de données
structurées on utilise des fichiers au
format CSV (comma separated values).
• Ce format universel permet de visualiser
des données séparées par une virgule.
Certains fichier CSV utilisent d’autres
séparateurs (tabulation, point-virgule…).
• La première ligne de ces fichiers
CSV contient les descripteurs. Ils
correspondent à l’entête d’un tableau et
informent sur le contenu des colonnes.
Outils
• Pandas : bibliothèque contant des
outils pour manipuler des données
structurées vers des fichiers de formats
différents tels CSV.
• Pandas.read_csv("fichier.csv") :
permet de lire les données du fichier
fichier.csv dont le séparateur est la
virugle.
• pandas.read_csv("fichier.csv",
sep= ";") : lorsque le séparateur du
ficher cvs n’est pas une virgule on
l’indique sep= ";".

Exercices
1. L'extrait suivant présente les premières lignes du fichier informaticien.csv.
Nom,Prénom,Date de naissance,Genre
Jacquard,Joseph-Marie,07/07/1752,M
Boole,George,02/11/1815,M
Lovelace,Ada,10/12/1815,F

a. Quels sont les descripteurs de ce fichier ?

Les descripteurs sont : Nom, Prénom, Date de naissance et genre.
b. Quel symbole est utilisé comme séparateur ?
La virgule est utilisée comme séparateur.

2. Le script suivant permet d’afficher certaines données du fichier informaticiens.csv.

1 import pandas
descripteur.
2 prenom = pandas.read_csv("informaticien.csv")
loc[()] : permet de
3 recherche = prenom.loc[(prenom['Genre'] == "F")] sélectionner une partie
4 print(prenom) d’un fichier suivant une
condition.
a. Quelles données du fichier affiche-t-il ?
Il affiche toutes les données du fichier.

32
 Partie 2 I Les données structurées et leur traitement

b. Indiquer la correction à apporter à la ligne 4 afin de n’afficher que les prénoms des
informaticiennes.
print(recherche)

Fichiers
Travaux pratiques 30 mn /
foucherconnect.fr 23py09

A. Analyse des naissances par département

1. Télécharger et enregistrer le fichier departement.csv dans un nouveau dossier. Ce
fichier regroupe une liste de prénoms par département de naissance.
2. Écrire un programme prenom.py permettant d’afficher le contenu du fichier
departement.csv. Le sauvegarder dans le même dossier que le fichier
departement.csv.
3. Exécuter le programme prenom.py.
a. La première ligne affichée correspond aux descripteurs, quels sont-ils ?
Les descripteurs sont genre (1 : Garçon, 2 : Fille), preusuel (prénom usuel),

annee (année de naissance), dpt (département) et nbr (nombre).

b. Dans la console, la ligne suivante s'affiche, que signifie-t-elle ?
3784670 2 ZYNA 2013 93 3

En 2013, dans le département 93, 3 filles sont nées et portent le prénom

Zyna .

4. Qu’affiche le script suivant ? sort_values(by=)) :

1 import pandas permet de trier suivant la
2 prenoms = pandas.read_csv donnée indiquée.
("departement.csv", sep=";")
3 recherche = prenoms.loc[(prenoms['dpt'] == "29") &
(prenoms['annee'] == "2021"), :]
4 print(recherche.sort_values(by="nbr"))

Il affiche la liste des prénoms donnés dans le Finistère (29) triée par nombre.

5. Recopier et exécuter le programme pour vérifier la réponse.

Défi ! Écrire un programme qui affiche pour une année choisie, dans un
département choisi, quels ont été les prénoms les plus donnés aux filles puis aux
garçons en utilisant le fichier departement.csv.

33
17 Les cartes numériques
Notions Outils
• OpenStreetMap est un projet de • Folium : bibliothèque ajoutant
cartographie libre du monde utilisant des fonctionnalités permettant de
le système GPS et d’autres données concevoir des cartes interactives. 
libres. • Cordonnée : latitude, longitude.
• Le système GPS (Global Positioning
System) permet à un appareil équipé
d’une puce GPS de déterminer sa
position (latitude, longitude et altitude).

Exercices
1. Dans OpenStreetMap, utiliser la recherche pour OpenStreetMap
accéder aux coordonnées suivantes et indiquer le lieu /
foucherconnect.fr 23py10

correspondant.
Coordonnées Lieu
48.92462, 2.36018 Stade de France

48.83885, 2.31715 Gare Montparnasse

48.860815, 2.33768 Le musée du Louvre

48.85314, 2.36863 La Bastille

48.87396, 2.29513 Arc de triomphe

2. Rechercher votre lycée sur OpenSteetMap, indiquer sa position.

Nom et ville du lycée : Pas de corrigé. Réponse personnelle.
Latitude :
Longitude :
3. Rechercher les lieux touristiques de votre ville et indiquer leurs coordonnées.
Coordonnées Lieu
Pas de corrigé. Réponse personnelle.

34
 Partie 2 I Localisation, cartographie et mobilité

Fichiers
Travaux pratiques 30 mn /
foucherconnect.fr 23py11

A. Créer une carte

1. Créer un dossier nommé carteOSM, puis enregistrer dans ce dossier un fichier
Python contenant le script suivant.
1 import folium
2 c= folium.Map(location=[48.85825, 2.29448])
3 c.save("c:/carteOSM/macarte.html");

2. Exécuter le script et vérifier qu’un fichier macarte.html a été créé.

3. Ouvrir le fichier dans navigateur et indiquer le résultat obtenu.
On obtient avec une carte centrée sur la tour Eiffel.

B. Visiter Paris
1. Télécharger le fichier louvre.py et compléter le script afin de créer une carte
centrée sur le musée du Louvre.
2. Améliorer le script afin de réaliser un zoom en modifiant la ligne 4 avec
l'introduction suivante.
4 c=folium.Map(location=[latLouvre,longLouvre],zoom_start=12)

3. Ajouter un marqueur sur la carte en insérant à ligne 5 l’instruction suivante.

5 folium.Marker([latLouvre,longLouvre)].add_to(c)

4. Modifier le script afin d’ajouter un marqueur aux lieux suivants : le stade de

France, la gare Montparnasse, la Bastille, l’Arc de triomphe.
5. Compléter le programme afin d’ajouter un popup indiquant « Musée du
Louvre » sur le marqueur du musée en utilisant l’instruction suivante.
6 folium.Marker([latLouvre,longLouvre ],popup="Musée du Louvre")

6. Compléter le programme afin d’ajouter des popup indiquant le lieu sur chaque
marqueur.

Défi ! Créer un programme permettant de créer la carte touristique de votre ville en

utilisant les coordonnées de votre lycée et des lieux touristique.

35
18 La trame NMEA
Notions
• La trame NMEA est un protocole
permettant aux marins de communiquer
des informations de géolocalisation. Elle
se présente sous forme d’une chaîne de
caractères séparée par une virgule.
Outils
• Liste=Trame.split(',') : exploite
le format particulier de la trame dont
les informations techniques sont
séparées par une virgule. On obtient
une liste de chaînes de caractères.

Heure Latitude Vitesse Date

$GPRMC,094040.000,A,2403.6319,N,12036.0099,E,9.50,79.65,200318,,A*53

Type de trame État Longitude Route Déclinaison/Parité

094040.000 : heure sous la forme hhmmss,sss (exemple : 9 h 40 min 40,000 s).
2403.6319 : latitude exprimée en ddmm.mmmm
(exemple : 24°03.6319’ = 24°03’37,914’’). ° : degré
N : indicateur de latitude, N (nord) ou S (sud). ’ : minute
12036.0099 : longitude exprimée en dddmm.mmmm ’’ : seconde
(exemple : 120°36.0099’ = 120°36’00,594’’).
E : indicateur de longitude, E (est) ou W (ouest).
9.50 : vitesse en nœuds (1 nœud = 1,852 km/h).
200319 : date exprimée en qqmmaa (exemple : 20 mars 2019).

Exercice
• On cosidère la trame NMEA suivante :
$GPRMC,180522.230,A,4329.127733,N,00128.75845,W,1.07,290220,000.0,W*64

a. Indiquer l’heure à laquelle a été relevée cette trame : 18 h 05 min 22,230 s.

b. Quelle est la position indiquée ?
Latitude : 43°29.127733’N = 43°29,2619’ nord.
Longitude : 1°28.7584W = 1°28,75845’ ouest.
c. Quelle est la vitesse en nœuds ? 1,07 nœud.
d. Quelle est la vitesse en km/h ? 1,07 x 1,852 = 1,98 km/h.
e. Que peut-on en conclure ? Le navire est presque immobile.

36
 Partie 2 I Localisation, cartographie et mobilité

Fichiers
Travaux pratiques 30 mn /
foucherconnect.fr 23py12

A. Analyser une trame NMEA

On considère la trame NMEA suivante :
$GPRMC,180522.230,A,4329.127733,N,00128.75845,W,290220,000.0,W*64

1. Le script suivant permet d’afficher l’heure d’envoi d’une trame.

Indiquer la valeur stockée dans les variables suivantes pour la trame considérée.
a. heure : 18 b. minute : 05 c. seconde : 22.230
1 def heure(liste):
int() : permet de
2 heure=int(liste[1][0:2]) convertir une chaîne en
3 minute=int(liste[1][2:4]) nombre entier.
4 seconde=float(liste[1][4:])
5 print("heure d'envoi :",heure,"h",minute,"min",seconde,"s")

2. Télécharger et compléter le programme nmea.py afin de pouvoir extraire de la

trame sa latitude et sa longitude.
3. Le script ci-dessous est extrait du fichier nmea.py. Que réalise la fonction
decodage(trame) ?
liste[1][0:2] :
1 def decodage(trame):
correspond aux deux
2 liste=trame.split(',') premiers éléments du
3 heure(liste) deuxième élément de la
4 latitude(liste) liste.

La fonction regroupe l’heure, la latitude et la longitude après avoir converti

la trame NMEA.

4. Dans la console, taper l’instruction suivante :

decodage("$GPRMC,180522.230,A,4329.127733,N,00128.75845,W,
290220,000.0,W*64")
Quel résultat obtient-on ?
heure d’envoi : 18 h 5 min 22.23 s

latitude : 43 °29 ' 7.664 ", N

longitude : 1 °28 ' 45.507 ", W

5. Tester le programme avec d’autres trames NMEA.

37
19 Calculs d’itinéraires
Notions
• Il existe des outils capables de calculer
des itinéraires à partir du lieu de départ
et du lieu d’arrivée.
• Ce calcul d’itinéraire repose sur des
algorithmes permettant d’obtenir le
chemin le plus court entre deux points.
• Par exemple, l’algorithme de Dijkstra
travaille sur des graphes dont chaque
ville est un sommet et chaque route est
une arête.
Outils
• pyroutelib3 : bibliothèque proposant
des outils pour calculer des itinéraires
à partir de données d’OpenStreetMap.
• router.findNode(latitude
longitude) : permet de déterminer
un sommet (un point sur la carte) de
coordonnées (latitude, longitude).
• router.doRoute(debut,fin) :
permet de déterminer un itinéraire
entre deux points indiqués.

Exercice
• Compléter le script suivant afin afficher l’itinéraire à
emprunter en voiture pour se rendre de la ville de Véronnes
(47.5339,5.2291) à la ville de Chazeuil (47.5594,5.2703).

1 from pyroutelib3 import Router

2 latitude1,longitude1 = 47.5339,5.2291
3 latitude2,longitude2 = 47.5594,5.2703
4 # moyens de transport parmi : car, cycle, foot, horse, tram,
train.
5 router = Router("car")
6 depart = router.findNode(latitude1,longitude1)
7 arrivee = router.findNode(latitude2,longitude2)
8 # tester l’existence d’une route entre le départ et l’arrivée
9 status, route = router.doRoute(depart, arrivee)
10 # créer la liste des points du parcours (coordonnées latitude,
longitude)
11 if status == 'success':
12 routeLatLon = list(map(router.nodeLatLon,route))
13 # afficher les points du trajet
14 print(routeLatLon)

38
 Partie 2 I Localisation, cartographie et mobilité

Fichiers
Travaux pratiques 30 mn /
foucherconnect.fr 23py13

A. Calculer un itinéraire
1. Télécharger le script itinéraire1.py et le compléter afin d’afficher le nombre de
points de l’itinéraire.
Len() :
23 print("cet itinéraire contient ",len(routeLatLon),
permet d’obtenir
"points de coordonnées :") la longueur
d’une liste.
2. Intégrer au script la fonction suivante afin d’afficher les coordonnées
de chaque point de l’itinéraire.
1 def aff_coord(liste):
2 print("cet itinéraire contient ",len(liste)," points de
coordonnées :")
3 for i in range(len(liste)):
4 print("point ",i+1," : ",liste[i])

B. Tracer des repères

1. Télécharger et exécuter le script itineraire2.py. Que réalise-t-il ?
Il affiche une carte de différents points d’itinéraire.

2. Modifier successivement la ligne 24 avec les instructions suivantes et tester le

script.
a. 24 if indice%20==0: b. 24 if indice%5==0:

3. Quel est le rôle de cette instruction ?

Modifier le nombre de point sur la carte.

C. Tracer un itinéraire
1.Télécharger et exécuter le script itineraire3.py. Que permet ce script ?
Affiche un tracé rouge et plusieurs repères de couleurs différentes.

2. Modifier le script afin de tracer un itinéraire en voiture.

3. Compléter le script afin d’ajouter les repères manquants.
4. Compléter le script afin d’ajouter en vert le tracé d’un itinéraire empruntant les
routes.
Défi ! Créer une carte d’itinéraire entre 5 lieux touristiques d'une ville choisie.

39
2O Acquisition de données
et IHM
Notions
• Une interface Homme-Machine
(IHM) est un ensemble de dispositifs
physiques (écran tactile, boutons)
et logiciels (interface graphique)
permettant à une personne
d’échanger des informations avec
une machine.
• L’acquisition de données consiste
à relever à l’aide de capteurs des
données physiques (température,
pression sur un bouton…) et à les
transformer en données utilisables
par l’IHM.
Outils
• from microbit import * : importer
les fonctions de la bibliothèque microbit
permettant de programmer la carte
• display.show() : créer un affichage
sur le pavé à led. Cela peut être un
caractère ou des images intégrées dans
la bibliothèque microbit. Par exemple : un
cœur (Image.HEART), un sourire (Image.
HAPPY), une grimace (Image.SAD).
• display.scroll() : créer un affichage
défilant sur le pavé à led.
• sleep(1000) : pause de 1 seconde.
• display.clear : éteint le pavé de leds.

Exercices
1. Recopier le script suivant sur une interface micro:bit. Indiquer l’affichage obtenu.
1 from microbit import *
2 while True:
3 display.show(Image.HAPPY)
4 sleep(1000)

Le pavé à led affiche un sourire. .

2. Ajouter l’instruction suivante après la ligne 2. Indiquer l’affichage obtenu.

3 if button_a.is_pressed():

Le pavé à led affiche un sourire lorsqu’on appuie sur le bouton A.

3. Compléter le script afin d’afficher un sourire lors d’un appui sur le bouton A
sinon une grimace.
5 else:
6 display.show(Image.SAD)

40
 Partie 2 I Informatique embarquée et objets connectées

Fichiers
Travaux pratiques 30 mn /
foucherconnect.fr 23py14

1. Télécharger et exécuter le scrpit temperature.hex.

2. Indiquer ce qu’il se passe lors de l’exécution du script.
La carte affiche la température. .

3. La fonction suivante permet de convertir la température en Fahrenheit. Modifier

le script afin d’afficher la température en Fahrenheit lors d’un appui sur le
bouton A de la carte.
1 def convertCtoF(C):
2 return C * 1.8 + 32

4. Modifiez le programme afin d’afficher une grimace si la température est

inférieure à 20° C, sinon un sourire.
5. Complétez le script suivant afin de programmer l’accéléromètre de la carte pour
qu’un D s’affiche lors de l’inclinaison à droite (20) et un G lors d’une inclinaison
à gauche (-20).
1 from microbit import *
2 while True:
3 reading = accelerometer.get_x()
4 if reading > 20:
5 display.show(“D”)
6 elif reading < -20 :
7 display.show(“G ”)
8 else:
7 display.show(“---”)

6. Tester le script obtenu.

7. Quelle est l’instruction qui permet de détecter une inclinaison à droite ?
Ligne 4 : if reading > 20:

8. Combiner le programme précédent (accéléromètre) avec le programme de

température afin d’afficher la température en degrés Celsius lors d’une inclinaison
à gauche et une température en degrés Fahrenheit lors d’une inclinaison à droite.

Défi ! Écrire un programme qui affiche un sourire quand la température est

supérieure à 19 °C, une grimace lorsque la température est inférieure à 13°C et
un cœur qui bat entre les deux valeurs.

41
21 Créer une image
Notions
• Une image est définie (définition) par sa
largeur (L) et sa hauteur (H), ce qui correspond
au nombre de pixels la composant (L x H).
• On crée une image en précisant ses
dimensions ainsi que la couleur de chaque
pixel.
• En mode RGB ou RVB, chaque pixel est
obtenu par un mélange de rouge, vert et
bleu. Chaque couleur peut prendre une
valeur entre 0 à 255.
Outils
• Image est un module de Pillow.
• img = Image.new(“RGB”, (L,H),
(r,v,b)) : crée une image et la
stocke dans la variable nommée img.
• img.putpixel((x,y),(r,v,b)) :
permet de modifier un pixel.
• img.paste() : permet de coller une
image sur une autre image.
• img.show() : affiche l’image.

(0,0) x
Exercices
1. Le script suivant permet de créer l’image de 6 x 5 pixels ci-contre.
Compléter les commentaires indiquant ce que réalise chaque ligne.
(x,1)
1 from PIL import Image
2 img = Image.new("RGB", (6,5), (255,255,255))
3 # créer une image de 30 pixels en blanc
y
4 for x in range(5):
En RGB :
5 # parcourir 5 pixels dans le sens de x
– blanc : (255,255,255),
6 img.putpixel((x,1),(0,255,0)) – noir : (0,0,0),
7 # modifier les 5 pixels de la 2ème ligne en – rouge : (255,0,0),
vert – vert : (0,255,0),
– bleu : (0,0,255).
2. Le script suivant crée une image de couleur blanche puis en modifie certains
pixels. Colorier sur l’image les cases correspondants aux pixels modifiés en
utilisant la bonne couleur.
1 from PIL import Image
2 img = Image.new("RGB", (6,5), (255,255,255))
N
3 for y in range(1,5): N
4 img.putpixel((4,y),(0,0,0)) B B B B
5 for x in range(2,6): N
6 img.putpixel((x,3),(0,0,255))

42
 Partie 2 I La photographie numérique

Travaux pratiques 40 mn

A. Créer des drapeaux à bandes

Le script suivant permet de créer une image du drapeau français.
1 from PIL import Image
2 img = Image.new("RGB", (300,200), "white")
3 bande1 = Image.new("RGB", (100,200), "blue")
4 bande2 = Image.new("RGB", (100,200), "red" )
5 img.paste(bande1,(0,0))
# coller la bande 1 au point(0,0)
6 img.paste(bande2,(200,0))
7 img.show()

1. Compléter la ligne 4 afin de créer la bande rouge.

2. Compléter la ligne 6 afin de coller la bande 2 au point (200,0).
3. Modifier la ligne 3 pour afficher le drapeau de l’Italie.
3 bande1 = Image.new(“RGB”, (100,200), “green”)

B. Créer un logo
On souhaite créer le logo suivant. Pour cela, on utilise le
module Image de Pillow en créant une image avec des bandes
de couleurs (blanche, rouge, noir et bleu) sur un fond vert.
1 from PIL import Image
2 img = Image.new("RGB", (500,350), (0,255,0))
3 bande1 = Image.new("RGB", (250,50), "white")
4 bande2 = Image.new("RGB", (50,250), "red")
5 img.paste(bande1,(0,100))
6 img.paste(bande2,(100,0))
7 img.show()

1. Compléter la ligne 4 pour créer une bande rouge de 50 pixels de largeur et

250 pixels de hauteur.
2. La ligne 5 permet de coller la bande 1 au point de coordonnées (0,100).
Complétez la ligne 7 afin de coller la bande rouge sur le fond vert.

43
22 Manipuler une image
Notions
• Il est possible de charger une image,
d’obtenir ses dimensions (size), son
format (jpg, png, etc.) ou son mode
(RGB par exemple).
• On peut également, rogner une image,
changer sa définition et lui faire faire une
rotation.
• La méthode img.crop((xa,ya,xb,yb))
découpe l’image chargée dans la variable
img selon un rectangle dont la diagonale
se situe entre les points a et b de
coordonnées (xa,ya) et (xb,yb).
Outils
• img=Image.open() : permet d’ouvrir
une image et de la stocker dans img.
• img.show() : affiche l’image stockée
dans img.
• img.resize() : redimensionne
l’image stockée dans img.
• img.crop() : rogne l’image stockée
dans img.
• img.rotate() : fait tourner l’image
stockée dans img.
• img.save() : enregistre l’image
stockée dans img.

Exercices (0,0)
1. Compléter la ligne 6 du script afin de découper
l’image ci-contre en un rectangle dont
la diagonale passe entre (0,0) et (1200,2448).
2. Compléter les commentaires sous chaque ligne
du script afin d’indiquer ce qu’elle réalise.
1 from PIL import Image
2 img = Image.open("lorient.jpg")
3 # charger l’image dans la variable img
4 print(img.format, img.size, img.mode) (1200,2448)

5 # afficher le format, la taille et le mode

6 im2 = img.crop((0,0,1200,2448))
7 # découper une image
8 im2.show()
9 # afficher l’image découpée
10 im2.save("im2f23ex.jpg")
11 # enregistrer l’image découpée

44
 Partie 2 I La photographie numérique

Fichiers
Travaux pratiques 30 mn /
foucherconnect.fr 23py15

• Télécharger l’image chat.jpg puis à l’aide du tableau ci-dessous proposer un

script qui permet :
– d’ouvrir l’image et la charger dans une variable img ;
– d’afficher le format, les dimensions et le mode de l’image ;
– de redimensionner l’image en 326 x 244 pixels (im2) ;
– de découper l’image (im3) ;
– de faire tourner l’image d’un angle de 45° (im4) ;
– d’afficher l’image d’origine et les 3 images modifiées.
Image obtenue Ligne du script

img.show()

im2 = img.resize((326,244))

im3 = img.crop((500,0,2500,2448))

im4 = img.rotate(45)

45
23 Agir sur les composantes RGB
Notions
• Le pixel, plus petit élément d’une image,
est composé d’un mélange de rouge,
vert et bleu. On parle de composantes
RGB (red, green, blue) ou RVB (rouge,
vert, bleu) d’une image.
• Une image est obtenue par le mélange
(la fusion) de 3 images différentes
représentant chacune un canal (rouge,
vert et bleu).
Exemple du canal vert d’une image :
Outils
• img.convert(‘L’) : convertit en gris
l’image stockée dans img.
• img.split() : retourne les bandes
RVB l’image.
• img.merge() : fusionne les 3 canaux
l’image.
• img.getpixel() : obtient les pixels
de l’image.
• img.putpixel() : modifie les pixels
de l’image.
• img.split() : stocke dans un tuple
les canaux de l’image dans l’ordre :
rouge, vert et bleu.
• Image.merge() : crée une nouvelle
image en fusionnant 3 canaux dans
l’ordre souhaité.

Exercices
1. Analyser le script suivant et indiquer le nom de chaque image obtenue.
1 from PIL import Image
2 img = Image.open("fleurs1.jpg")
3 im1 = img.convert('L')
4 r, v, b = img.split()
5 im2 = Image.merge("RGB", (b,v,r))

Image
obtenue

Nom img im2 im1

2. Analyser le script page suivante. Quelle transformation l’image obtenue a-t-elle

subie ?
Pour la moitié de l’image, inversion pour chaque pixel entre le vert et le rouge.

46
 Partie 2 I La photographie numérique

1 from PIL import Image Image obtenue

2 img = Image.open("fleurs1.jpg")
3 for x in range(0,int((img.width)/2)):
4 for y in range(0,(img.height)):
5 r, v, b = img.getpixel((x,y))
6 img.putpixel((x,y),(v,r,b))
7 img.show()

Fichiers
Travaux pratiques 30 mn /
foucherconnect.fr 23py16

• Télécharger l’image fleurs.jpg puis proposer un script qui permet :

– d’ouvrir l’image et la charger dans la variable img,
– de stocker la largeur dans la variable largeur (largeur = img.width),
– de stocker la hauteur dans la variable hauteur (hauteur = img.height),
– de parcourir tous les pixels avec deux boucles imbriquées for : for x in
range (0, largeur) puis for y in range(0, hauteur),
– d’obtenir pour chaque pixel le tuple (r,v,b),
– d’agir sur les pixels avec putpixel() afin d’obtenir l’image ci-dessous,
– d’afficher l’image. Le traitement et l’affichage peuvent prendre jusqu’à une minute.

Aide
Utiliser des tests multiples (if, elif, else) :
– Si x < largeur/2 et y < hauteur/2 (premier carré) :
conserver les couleurs d’origine : img.putpixel((x,y),(r,v,b))
– Sinon si : deuxième carré
intervertir le bleu et le rouge : img.putpixel((x,y),(b,v,r))
– Sinon si : troisième carré

47
NB-SB-CC/VO
Profite des ressources numériques
GRATUITES de ce manuel !

Accès en 1 clic sur www.foucherconnect.fr/1218765

DANS LA MÊME COLLECTION

Couverture : Ho Thanh Hung • Illustrations Cassandra Melo Dias

www.editions-foucher.fr