Sciences Numériques et Technologie

Introduction Évaluation et organisation

SNT est un acronyme qui signifie : Sciences Numériques et Technologiques. Cette Au niveau de l’évaluation, vous serez évalués par :
matière a pour objectif de vous permettre d’acquérir une certaine culture numérique. • Des contrôles généralement en début de cours (QCM, exercices).
Tout au long de l’année, nous allons découvrir un certain nombre d’objets qui vont • Des TP sur ordinateur notés.
nous permettre d’appréhender les systèmes numériques. Par le biais de l’étude de • Des projets informatiques à rendre.
certains objets, nous allons parcourir les différents thèmes du programme : Au niveau de l’organisation, le cours à trou (avec les exercices) vous sera envoyé sur
l’ENT (espace numérique de travail). Vous pourrez compléter le cours soit dans votre
1. Internet
cahier soit directement sur l’ordinateur en utilisant un logiciel permettant d’écrire
2. Le Web sur un PDF. Ainsi il vous est demandé de toujours :
3. Les réseaux sociaux 1. Ramener à chaque séance de SNT votre ordinateur fourni par la région (néces-
saire pour les TP). Votre ordinateur devra être chargé.
4. Les données structurées et leur traitement
2. Ramener votre cahier de SNT où vous mentionnerez certains points du cours et
5. Localisation, cartographie et mobilité vous ferez les exercices dans ce cahier.
6. Informatique embarquée et objets connectés 3. Enregistrer vos travaux sur votre ENT ou sur un support de stockage externe
(clé USB etc).
7. La photographie numérique.
Un bonus/malus sera ajouté à votre moyenne de SNT permettant d’évaluer à la
Les concepts en lien avec les systèmes numériques seront mentionnés dans un fois votre participation en classe et de sanctionner en cas d’absence répétée de votre
encadré. Ces encadrés seront à connaître par cœur. matériel (ordinateur, cahier).

En parallèle de ces chapitres, des travaux pratiques (TP) et projets sur ordinateur
seront prévus (TP en lien avec les réseaux et internet, projet web etc). Tout au long
de l’année, vous allez être initiés à la programmation en Python, HTML et CSS.

Si vous le souhaitez, vous pourrez poursuivre vos études d’informatique après la

seconde en optant pour la spécialité NSI en première générale.

Sciences numériques et technologie – page 2

 Algorithmique - Initiation à python
1
1. Structures de base en langage naturel Variables: x
1: DEBUT_ALGORITHME
2: x ← 2
1) Variables et affectations 3: x ← x+1
4: FIN_ALGORITHME

Les variables en algorithmique Après exécution de l’algorithme, la variable x contient la valeur :

• Les variables algorithmiques peuvent servir à stocker des données de différents
types, mais nous nous contenterons ici d’utiliser des variables du type NOMBRE.
• La valeur d’une variable peut changer au fil des instructions de l’algorithme.
▶ Exercice n°3
• Les opérations sur les variables s’effectuent ligne après ligne et les unes après les Ajoutons la ligne « x ← 4*x » à la fin du code précédent. Ce qui donne :
autres. Variables: x
1: DEBUT_ALGORITHME
• Quand une ligne du type « mavariable ← un calcul », on effectue d’abord le cal-
2: x ← 2
cul et on stocke ensuite le résultat dans mavariable. 3: x ← x+1
4: x ← 4*x
5: FIN_ALGORITHME
▶ Exercice n°1
On considère l’algorithme suivant : Après exécution de l’algorithme, la variable x contient la valeur :
Variables: x,y,z
1: DEBUT_ALGORITHME
2: x ← 2 ▶ Exercice n°4
3: y ← 3 On considère l’algorithme suivant :
4: z ← x+y Variables: A,B,C
5: FIN_ALGORITHME 1: DEBUT_ALGORITHME
2: A ← 5
Après exécution de l’algorithme : la variable x contient la valeur : ; 3: B ← 3
4: C ← A+B
la variable y contient la valeur : ; la variable z contient la valeur : 5: B ← B+A
6: A ← C
7: FIN_ALGORITHME
▶ Exercice n°2 Après exécution de l’algorithme : la variable A contient la valeur : ;
On considère l’algorithme suivant :

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 3

la variable B contient la valeur :
Il est aussi possible d’indiquer en plus à l’algorithme de traiter le cas où la condi-
la variable C contient la valeur : tion n’est pas vérifiée. On obtient alors la structure suivante :
SI...ALORS
▶ Exercice n°5 ...
On considère l’algorithme suivant : FIN_SI
Variables: x,y,z SINON
1: DEBUT_ALGORITHME ...
2: LIRE x
FIN_SINON
3: y ← x-2
4: z ← -3*y-4
5: AFFICHER z
6: FIN_ALGORITHME ▶ Exercice n°6
On cherche à créer un algorithme qui demande un nombre à l’utilisateur et qui af-
On cherche maintenant à obtenir un algorithme équivalent sans utiliser la variable fiche la racine carrée de ce nombre s’il est positif. Compléter la ligne 3 dans l’algo-
y. Compléter la ligne 3 dans l’algorithme ci-dessous pour qu’il réponde au problème. rithme ci-dessous pour qu’il réponde au problème.
Variables: x,z Variables: x,racine
1: DEBUT_ALGORITHME 1: DEBUT_ALGORITHME
2: LIRE x 2: LIRE x
3: z ← .................... 3: SI (.........)
4: AFFICHER z √ ALORS
4: racine ← x
5: FIN_ALGORITHME 5: AFFICHER racine
6: FIN_SI
7: FIN_ALGORITHME
2) Instructions conditionnelles
▶ Exercice n°7
SI...ALORS...SINON On cherche à créer un algorithme qui demande à l’utilisateur d’entrer deux nombres
Comme nous l’avons vu ci-dessus, un algorithme permet d’exécuter une liste (stockés dans les variables x et y) et qui affiche le plus grand des deux. Compléter les
d’instructions les unes à la suite des autres. Mais on peut aussi demander à un ligne 5 et 8 dans l’algorithme ci-dessous pour qu’il réponde au problème.
algorithme de n’exécuter des instructions que si une certaine condition est rem- Variables: x,y
plie. Cela se fait grâce à au bloc d’instructions SI...ALORS : 1: DEBUT_ALGORITHME
2: LIRE x
3: LIRE y
SI...ALORS 4: SI (x>y) ALORS
... 5: AFFICHER .......
FIN_SI 6: FIN_SI
7: SINON
8: AFFICHER ......
9: FIN_SINON
10: FIN_ALGORITHME

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 4

▶ Exercice n°8
On considère l’algorithme suivant : • Lorsqu’on connait par avance le nombre de fois que l’on veut répéter les
Variables: A,B instructions, on utilise une boucle du type POUR...DE...A dont la structure
1: DEBUT_ALGORITHME est la suivante :
2: A ← 1 POUR...ALLANT_DE...A...
3: B ← 3 ...
4: SI (A>0) ALORS
FIN_POUR
5: A ← A+1
6: FIN_SI • Exemple : l’algorithme ci-dessous permet d’afficher la racine carrée de tous
7: SI (B>4) ALORS
les entiers de 1 jusqu’à 50.
8: B ← B-1
9: FIN_SI Variables: n et racine
10: FIN_ALGORITHME 1: DEBUT_ALGORITHME
2: POUR n ALLANT_DE
√ 1 A 50
Après exécution de l’algorithme : 3: racine ← n
• La variable A contient la valeur : 4: AFFICHER racine
5: FIN_POUR
• La variable B contient la valeur : 6: FIN_ALGORITHME

▶ Exercice n°9 La variable n est appelée « compteur de la boucle ».

• Remarques :
On cherche à concevoir un algorithme correspondant au problème suivant : — La variable servant de compteur pour la boucle doit être du type NOMBRE et doit être
• on demande à l’utilisateur d’entrer un nombre (représenté par la variable x) déclarée préalablement (comme toutes les variables).
• si le nombre entré est différent de 1, l’algorithme doit stocker dans une va- — Par défaut, cette variable est automatiquement augmentée de 1 à chaque fois.
— On peut utiliser la valeur du compteur pour faire des calculs à l’intérieur de la boucle,
riable y la valeur de 1/(x-1) et afficher la valeur de y (note : la condition x
mais les instructions comprises entre POUR et FIN_POUR ne doivent en aucun cas modifier
différent de 1 s’exprime avec le code x!=1). On ne demande pas de traiter le la valeur de la variable qui sert de compteur.
cas contraire.
Compléter l’algorithme ci-dessous pour qu’il réponde au problème.
▶ Exercice n°10
Variables: x,y
1: DEBUT_ALGORITHME On cherche à concevoir un algorithme qui affiche, grâce à une boucle POUR...DE...A,
2: LIRE ...... les résultats des calculs suivants : 8*1 ; 8*2 ; 8*3 ; 8*4 ; ... jusqu’à 8*10 .
3: SI (........) ALORS La variable n sert de compteur à la boucle et la variable produit sert à stocker et
4: ....... ← .......
afficher les résultats. Compléter les lignes 2 et 3 dans l’algorithme ci-dessous pour
5: AFFICHER .......
6: FIN_SI qu’il réponde au problème :
7: FIN_ALGORITHME Variables: n,produit
1: DEBUT_ALGORITHME
2: POUR n ALLANT_DE .... A .....
3: produit ← .......
3) Boucles 4: AFFICHER produit
5: FIN_POUR
Boucles POUR...DE...A 6: FIN_ALGORITHME
• Les boucles permettent de répéter des instructions autant de fois que l’on
souhaite.

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 5

▶ Exercice n°11
On considère l’algorithme suivant : • Exemple : Comment savoir ce qu’il reste si on enlève 25 autant de fois que
Variables: n,somme l’on peut au nombre 583 ? Pour cela on utilise une variable n, qui contient
1: DEBUT_ALGORITHME 583 au début, à laquelle on enlève 25 tant que c’est possible, c’est à dire
2: somme ← 0 tant que n est supérieur ou égal à 25.
3: POUR n ALLANT_DE 1 A 100
4: somme ← somme+n Variables: n
5: FIN_POUR 1: DEBUT_ALGORITHME
6: AFFICHER somme 2: n ← 583
3: TANT_QUE (n>=25) FAIRE
7: FIN_ALGORITHME 4: n ← n-25
5: FIN_TANT_QUE
Compléter les phrases suivantes : 6: AFFICHER n
• Après exécution de la ligne 2, la variable somme contient la valeur : 7: FIN_ALGORITHME
• Lorsque le compteur n de la boucle vaut 1 et après exécution du calcul ligne
4, la variable somme vaut :
• Remarques :
• Lorsque le compteur n de la boucle vaut 2 et après exécution du calcul ligne — Si la condition du TANT QUE... est fausse dès le début, les instructions entre
4, la variable somme vaut : TANT_QUE...FAIRE et FIN_TANT_QUE ne sont jamais exécutées (la structure TANT QUE
ne sert alors strictement à rien).
Que permet de calculer cet algorithme ? — Il est indispensable de s’assurer que la condition du TANT QUE... finisse par être vérifiée
(le code entre TANT_QUE...FAIRE et FIN_TANT_QUE doit rendre vraie la condition tôt ou
tard), sans quoi l’algorithme ne pourra pas fonctionner.

▶ Exercice n°12
▶ Exercice n°13
Compléter les lignes 3 et 4 de l’algorithme ci-dessous pour qu’il permette de calculer
On cherche à connaître le plus petit entier N tel que 2N soit supérieur ou égal à
la somme 52 + 62 + 72 + · · · + 242 + 252 .
Variables: n, somme 10000. Pour résoudre ce problème de façon algorithmique :
1: DEBUT_ALGORITHME • On utilise une variable N à laquelle on donne au début la valeur 1.
2: somme ← 0 • On augmente de 1 la valeur de N tant que 2N n’est pas supérieur ou égal à
3: POUR n ALLANT_DE .... A ......
10000.
4: somme ← somme+......
5: FIN_POUR Une structure TANT QUE est particulièrement adaptée à ce genre de problème car
6: AFFICHER somme on ne sait pas a priori combien de calculs seront nécessaires.
7: FIN_ALGORITHME Compléter les lignes 3 et 4 de l’algorithme ci-dessous pour qu’il réponde au pro-
blème :
Boucles TANT QUE... Variables: N
• Il n’est pas toujours possible de connaitre par avance le nombre de répéti- 1: DEBUT_ALGORITHME
2: N ← 1
tions nécessaires à un calcul. Dans ce cas là, il est possible d’avoir recours à 3: TANT_QUE (2N .......) FAIRE
la structure TANT QUE... qui se présente de la façon suivante : 4: N ← .......
TANT_QUE...FAIRE 5: FIN_TANT_QUE
6: AFFICHER N
...
7: FIN_ALGORITHME
FIN_TANT_QUE

Cette structure de boucle permet de répéter une série d’instructions

(comprises entre TANT_QUE...FAIRE et FIN_TANT_QUE) tant qu’une certaine
condition est vérifiée.

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 6

▶ Exercice n°14
Un individu a emprunté à un ami une somme de 2500 euros (prêt sans intérêts). Pour FONCTION mafonction(paramètres...)
rembourser son ami, il prévoit de lui remettre 110 euros par mois. Mais comme cela DEBUT_FONCTION
ne correspond pas à un nombre pile de mois, il se demande quel sera le montant à ...
rembourser le dernier mois. RETOURNER...
Compléter la ligne 3 dans l’algorithme ci-dessous pour qu’il réponde au problème : FIN_FONCTION
Variables: montant
1: DEBUT_ALGORITHME
2: montant ← 2500
3: TANT_QUE (............) FAIRE Utiliser une fonction en algorithmique n’a d’intérêt que si on l’appelle plusieurs
4: montant ← montant-110 fois.
5: FIN_TANT_QUE
6: AFFICHER montant
▶ Exercice n°16
7: FIN_ALGORITHME
On cherche à élaborer un algorithme qui donne en fonction de x la somme des hy-
poténuses des trois triangles rectangles de la figure ci-dessous :
▶ Exercice n°15
On considère le problème suivant :
• On lance une balle d’une hauteur initiale de 300 cm.
• On suppose qu’à chaque rebond, la balle perd 10% de sa hauteur (la hauteur
est donc multipliée par 0.9 à chaque rebond).
x+3
• On cherche à savoir le nombre de rebonds nécessaire pour que la hauteur de
x+2
la balle soit inférieure ou égale à 10 cm. x+1
Compléter les lignes 4 et 6 de l’algorithme ci-dessous pour qu’il réponde au pro-
blème.
Variables: nombre,hauteur
1: DEBUT_ALGORITHME 3x 2x x
2: nombre_rebonds ← 0
3: hauteur ← 300 Pour cela, on va utiliser une fonction hypo qui renvoie l’hypoténuse d’un triangle
4: TANT_QUE (hauteur......) FAIRE
5: nombre_rebonds ← nombre_rebonds+1 rectangle dont les côtés de l’angle droit sont a et b.
6: hauteur ← ........... Compléter les lignes 3 et 7 pour que l’algorithme réponde au problème posé :
7: FIN_TANT_QUE Variables: x
8: AFFICHER nombre_rebonds 1: FONCTION hypo(a,b)
9: FIN_ALGORITHME 2: DEBUT_FONCTION
3: Retourner . . . . . . . . . . . . . . . . . .
4: FIN_FONCTION
5: DEBUT_ALGORITHME
4) Fonctions 6: Lire x
7: AFFICHER hypo(3*x,x+3)+hypo(2*x,x+2)+hypo(. . . . . .,. . . . . .)
Les fonctions en algorithmique 8: FIN_ALGORITHME
Pour éviter de répéter certaines instructions, on peut utiliser une fonction, c’est
à dire une bloc d’instructions qui ne sera exécuté que quand on l’appelle. Une
fonction dépend en général d’un ou plusieurs paramètres et retourne une valeur
dépendant de ces paramètres.

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 7

2. Initiation à python 2. En utilisant un éditeur (+ console python) en ligne a par exemple basthon :
https ://console.basthon.fr
1) Introduction

Langage informatique
Un langage informatique permet de traduire un algorithme en une série d’instruc- 2) Équivalences entre langage naturel et python
tions compréhensibles et exécutables par un ordinateur. Pour cela, les instructions
écrites dans le langage informatique doivent respecter des spécificités et notam- Affectation d’une valeur à une variable x
ment une syntaxe plus précise et plus compliquée que celle d’un langage naturel.
Langage naturel Équivalent en python
x ← valeur x = valeur
Quelques principes de base à propos du langage python
• Par défaut, le langage python n’inclut pas bon nombre de fonctions mathé-
matiques. C’est pour cela que certains scripts python commenceront par
Lire la valeur d’une variable x entrée au clavier
l’instruction suivante qui indique à python de charger les fonctions mathé-
matiques standard : Si x est un entier (et si l’algorithme ne manipule que des entiers) :
from math import* Langage naturel Équivalent en python
• Les débuts et fins de bloc d’instructions se marquent en langage python LIRE x x = int(input("x?"))
par un décalage horizontal (appelé indentation) et pas par des instructions
Si x est un réel :
particulières. Il faut donc faire très attention en python à ce que les instruc- Langage naturel Équivalent en python
tions d’un même bloc soient écrites avec le même décalage horizontal par x = float(input("x?"))
LIRE x
rapport à ce qui précède et suit ce bloc (on dit que ces instructions doivent
avoir la même indentation). Si on a besoin d’entrer une valeur résultant d’un calcul mathématique (fraction, ra-
cine carrée...) :
Langage naturel Équivalent en python
from math import*
LIRE x
x = eval(input("x?"))

Afficher la valeur d’une variable x

Langage naturel Équivalent en python

AFFICHER x print(x)

V Afficher un message
Vous pouvez programmer en python en utilisant :
Langage naturel Équivalent en python
1. En utilisant un éditeur par exemple Edupython.
AFFICHER "Message" print("message")

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 8

Les opérations mathématiques de base Pour a et b entiers Équivalent en python
reste de la division euclidienne de a par b a%b
Langage naturel Équivalent en python
quotient de la division euclidienne de a par b a//b
from math import*
resultat ← a+b resultat=a+b ▶ Exercice n°17
resultat ← a-b resultat=a-b Compléter le code du script python ci-dessous pour qu’il corresponde à l’algorithme
resultat ← a×b resultat=a*b en langage naturel.
resultat ← ba resultat=a/b Langage naturel Équivalent en python
resultat ← a2 resultat=a**2
√ LIRE distance distance=float(input("distance?"))
resultat ← a resultat=sqrt(a)
LIRE temps temps=............................
vitesse ← distance
temps vitesse=..........................
AFFICHER vitesse print(vitesse)

▶ Exercice n°18
Compléter le script python ci-dessous pour qu’il affiche la valeur de la diagonale
d’un rectangle après avoir entré sa largeur et sa longueur :
Script python
from math import*
largeur=float(input("largeur?"))
longueur=.......................................
diagonale=......................................
print(...............)

Instructions conditionnelles
• Avec un SI...ALORS
Langage naturel
Instructions précédant le bloc si...alors
SI condition ALORS
Instructions exécutées si la condition est vérifiée
..................................................
FIN_SI
Instructions suivant le bloc si...alors

Équivalent en python

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 9

▶ Exemple : • Syntaxe python pour les conditions
Langage naturel Équivalent en python Situation Syntaxe python correspondante
LIRE x Si a égal à b (a et b entiers) if a==b:
SI x>0 ALORS x=float(input("x?")) Si a est différent de b (a et b entiers) if a!=b:
AFFICHER "x est strictement positif" if x>0: Si a est strictement supérieur à b if a>b:
FIN_SI print("x est strictement positif") Si a est strictement inférieur à b if a<b:
AFFICHER "son opposé est" print("son opposé est",-x) Si a est inférieur ou égal à b if a<=b:
AFFICHER -x Si a est supérieur ou égal à b if a>=b:
• Avec un SI...ALORS...SINON
Cas particulier de la comparaison de deux réels de type float (qui ne sont pas
Langage naturel représentés de façon exacte en informatique) :
Instructions précédant le bloc si...alors...sinon
SI condition ALORS Situation mathématique Syntaxe pour python (>=3.5)
Instructions exécutées si la condition est vérifiée from math import*
.................................................. Si a égal à b (a et b flottants) if isclose(a,b):
SINON Si a est différent de b (a et b flottants) if not(isclose(a,b)):
Instructions exécutées si la condition n’est pas vérifiée
.................................................. ▶ Exercice n°19
FIN_SI Compléter le code du script python ci-dessous pour qu’il corresponde à l’algorithme
Instructions suivant le bloc si...alors...sinon en langage naturel.
Langage naturel Équivalent en python
Équivalent en python LIRE age
age=int(input("age?"))
SI age>=18 ALORS
............................
AFFICHER "majeur"
............................
FIN_SI

▶ Exercice n°20
Parmi les quatre scripts python ci-dessous, déterminer le seul valide indiquant le
plus grand de deux entiers.
Script 1 Script 2
a=int(input("a?")) a=int(input("a?"))
b=int(input("b?")) b=int(input("b?"))
if a>b if a>b:
print("le plus grand est a") print("le plus grand est b")
else: else:
print("le plus grand est b") print("le plus grand est a")
Script 3 Script 4
a=int(input("a?")) a=int(input("a?"))
b=int(input("b?")) b=int(input("b?"))
if a>b: if a>b:
print("le plus grand est a") print("le plus grand est a")
else: else:
print("le plus grand est b") print("le plus grand est b")

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 10

• Opérateurs ET/OU/CONTRAIRE dans les conditions Équivalent en python
Situation Syntaxe python correspondante
Si condition1 OU condition2 if condition1 or condition2:
Si condition1 ET condition2 if condition1 and condition2:
Si CONTRAIRE(condition ) if not(condition ):

▶ Remarque : or, and et not doivent être en minuscules

▶ Exemple :
Langage naturel Équivalent en python
LIRE x
x=float(input("x?"))
SI x>0 ET X<1 ALORS
if x>0 and x<1:
AFFICHER "x est dans ]0;1["
print("x est dans ]0;1[")
FIN_SI

▶ Exercice n°21
1
On considère l’expression A(x) = √ où x est un réel.
(x − 1) x ▶ Exemple :
Compléter le code du script python ci-dessous pour qu’il corresponde à l’algorithme Langage naturel Équivalent en python
en langage naturel. POUR i ALLANT_DE 1 A 10
for i in range(1,11):
Langage naturel Équivalent en python AFFICHER 7×i
print(7*i)
from math import* FIN_POUR
LIRE x print("script terminé")
x=..................................... AFFICHER "script terminé"
SI x>0 ET x,1 ALORS if.....................................
AFFICHER "A(x) existe" ....................................... ▶ Exercice n°22
SINON else: Compléter le code du script python ci-dessous pour qu’il corresponde à l’algorithme
AFFICHER "A(x) n’existe pas" ....................................... en langage naturel dont le but est de calculer la somme 1 + 2 + 3 + · · · + 99 + 100.
FIN_SI
Langage naturel Équivalent en python
somme ← 0
Boucles POUR...DE...A somme=0
POUR i ALLANT_DE 1 A 100
for i .....................
• Rappel : ces boucles permettent de répéter des instructions un certain nombre somme ← somme+i
somme=................
(connu par avance) de fois. FIN_POUR
print(somme)
Langage naturel AFFICHER somme
Instructions précédant le bloc pour...de...a
▶ Exercice n°23
POUR i ALLANT_DE 1 A 10
Parmi les quatre scripts
√ √python
√ ci-dessous,
√ déterminer
√ le seul valide qui permet de
Instructions qui seront répétées 10 fois
..................................................
calculer la somme 1 + 2 + 3 + · · · + 49 + 50.
FIN_POUR
Script 1 Script 2
Instructions suivant le bloc pour...de...a
from math import* from math import*
somme=0 somme=0
for i in range(1,51) for i in range(1,51):
somme=somme+sqrt(i) somme=somme+sqrt(i)
print(somme) print(somme)

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 11

 Script 3 Script 4 ▶ Exercice n°24
from math import* from math import* Compléter le code du script python ci-dessous pour qu’il corresponde à l’algorithme
somme=0 somme=0 en langage naturel dont le but est de déterminer le premier entier n tel que le
for i in range(1,50): for i in range(1,51): produit 1 × 2 × 3 × · · · × n dépasse 10000 .
somme=somme+sqrt(i) somme=somme+sqrt(i)
print(somme) print(somme) Langage naturel Équivalent en python
n ← 1
n=1
Boucles TANT QUE produit ← 1
produit=1
TANT_QUE produit<10000 FAIRE
• Rappel : ces boucles permettent de répéter des instructions tant qu’une certaine while ........................
n ← n+1
condition est vérifiée. La condition en question s’exprime en python de la même n=.............
produit ← produit × n
façon qu’avec un if. produit=....................
FIN_TANT_QUE
Langage naturel print(n)
AFFICHER n
Instructions précédant le bloc tant que
TANT_QUE condition FAIRE ▶ Exercice n°25
Instructions qui seront répétées tant que la condition sera vérifiée Parmi les quatre scripts python ci-dessous, déterminer le seul valide indiquant le
..................................................................... plus petit entier n tel que 0, 9n ⩽ 0.001
FIN_TANT_QUE
Instructions suivant le bloc tant que Script 1 Script 2
n=0 n=0
Équivalent en python
while 0.9**n<=0.001: while 0.9**n>0.001:
n=n+1 n=n+1
print(n) print(n)
Script 3 Script 4
n=0 n=0
while 0.9**n<=0.001 while 0.9**n>0.001:
n=n+1 n=n+1
print(n) print(n)

Les fonctions en programmation

• Rappel : une fonction en programmation est un bloc d’instructions qui ne sera
▶ Exemple : exécuté que quand on l’appelle. Une fonction dépend en général d’un ou plusieurs
Script permettant de déterminer le premier entier dont le cube dépasse 5000. paramètres et retourne une valeur dépendant de ces paramètres. L’utilisation d’une
Langage naturel Équivalent en python fonction n’a en général d’intérêt que si on l’appelle plusieurs fois.
n ← 0
n=0 Langage naturel
TANT_QUE n3 < 5000 FAIRE
while n**3<5000: FONCTION mafonction(paramètres séparés par des virgules )
n ← n+1
n=n+1 DEBUT_FONCTION
FIN_TANT_QUE
print(n) Instructions
AFFICHER n
RETOURNER...
FIN_FONCTION

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 12

 Équivalent en python 3) Application

▶ Exercice n°27
Compléter le code du script python ci-dessous pour qu’il corresponde à l’algorithme
en langage naturel.

Langage naturel Équivalent en python

▶ Exemple : POUR i ALLANT_DE 1 A 100
for i .....................
Un cycliste et un piéton se déplacent à une vitesse respective de 18 km · h−1 et 6 AFFICHER i3
print(............)
km · h−1 . Ce script donne le nombre de kilomètres parcourus par le cycliste et le FIN_POUR
piéton durant un même temps t (en heures).
▶ Exercice n°28
Langage naturel Équivalent en python Que fait ce script python ?
FONCTION distance(vitesse,temps)
DEBUT_FONCTION
Script python
RETOURNER vitesse × temps def distance(vitesse,temps): from math import*
FIN_FONCTION return vitesse*temps i=0
while i*sqrt(i)<500:
DEBUT_ALGORITHME t=float(input("t?"))
i=i+1
LIRE t print(distance(42,t))
print(i)
AFFICHER distance(42,t) print(distance(6,t))
AFFICHER distance(6,t) Réponse : .............................................................................................................
FIN_ALGORITHME ..............................................................................................................................

▶ Exercice n°26 ▶ Exercice n°29

La formule de conversion entre la valeur d’une température en degrés farenheit et La valeur d’une voiture était de 20 000 euros en 2018. On suppose qu’elle est
sa valeur en degrés celsius est la suivante : multipliée par 0, 9 chaque année. Compléter le script python ci-dessous pour qu’il
5 × (degrés Fahrenheit) − 160 indique la première année à partir de laquelle la valeur de la voiture sera inférieure
degrés Celsius = ou égale à 12 000 euros.
9
Compléter le code du script python ci-dessous pour qu’il donne la valeur en degrés
celsius d’une température de 100 et de 200 degrés farenheit. Script python
annee=2018
Script python valeur=20000
def celsius(farenheit): while .........................
return ................................... valeur=valeur*0.9
annee=annee+1
print(celsius(100))
print(annee)
print(..........................)

▶ Exercice n°30
Un ticket de tramway coûte 1 euro sans abonnement. Avec un abonnement annuel de
30 euros, le ticket ne coûte plus que 0,75 euros. Déterminer parmi les quatre scripts
python ci-dessous le seul valide qui affiche, après avoir entré le nombre de tickets
achetés n, si prendre un abonnement est rentable :

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 13

 Script 1 Script 2 4) Autres fonctionnalités utiles de python
n=int(input("n?")) n=int(input("n?"))
Chaines de caractères
if 30+0.75*n<n: if 30+0.75*n<n:
print("abonnement rentable") print("abonnement rentable") On peut affecter à une variable une chaine de caractères en l’encadrant simplement
else: else par des guillemets. Exemple : a="blabla"
print("abonnement pas rentable") print("abonnement pas rentable")
Script 3 Script 4 Situation (a et b : chaines) Syntaxe python
mettre b au bout de a a+b
n=int(input("n?")) n=int(input("n?"))
connaitre la longueur de a len(a)
if 30+0.75*n<n: if 30+0.75*n>n:
récupérer le (i + 1)ième caractère de a a[i]
print("abonnement rentable") print("abonnement rentable")
else: else: Exemple :
print("abonnement pas rentable") print("abonnement pas rentable") Code python Résultat
a="bon"
▶ Exercice n°31 b="jour"
Durant une année un individu a acheté n DVD valant 15 euros pièce et p livres print(a+b) bonjour
valant 22 euros pièce. Compléter le script python ci-dessous pour qu’il indique si print(len(a)) 3
cet individu a dépensé plus de 300 euros en dvd et livres ou non : print(a[0]) b
print(b[3]) r
Script python
def depense_totale(n,p):
return .......................... Les listes

n=int(input("nombre de dvd?")) On peut affecter à une variable une liste de nombres (ou de chaines de caractères)
p=int(input("nombre de livres?")) en les encadrant par des crochets et en les séparant par des virgules. Exemple :
if depense_totale(n,p)..................... a=[1,3,5,7]
print("plus de 300 euros")
else: ▶ Remarque : en python, on commence à compter les éléments d’une liste à partir
print("pas plus de 300 euros") de la position 0. Par exemple, si a=[1,3,5,7] :
• le premier élément de la liste est a[0] (position 0) qui vaut donc 1 ;
• le deuxième élément de la liste est a[1] (position 1) qui vaut donc 3 ;
▶ Exercice n°32
• etc.
Un automobiliste roule à 90 km · h−1 pendant 2 heures, puis roule à 120 km · h−1 .
• le dernier terme de la liste est a[3] (position 3) qui vaut donc 7 ;
Compléter le script python ci-dessous pour qu’il indique le nombre de kilomètres
Donc le terme à la position i d’une liste correspond à son (i + 1)ième terme
parcourus en fonction du temps de parcours exprimé en heures :
Situation (a : liste) Syntaxe python
Script python
connaitre le nombre d’éléments de a len(a)
def distance(temps):
if temps<=2: récupérer le terme de a à la position i a[i]
return ........................ ajouter l’élément e à la liste a a.append(e)
else: supprimer le terme de a à la position i del a[i]
return .........................
insère l’élément e à la position i a.insert(i,e)

t=float(input("temps?"))
print (distance(t))

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 14

▶ Exemple :
Code python Résultat
a=[1,3,5,7]
print(len(a)) 4
print(a[3]) 7
a.append(9)
print(a) [1, 3, 5, 7, 9]
del a[1]
print(a) [1, 5, 7, 9]
a.insert(1,12)
print(a) [1, 12, 5, 7, 9]

Nombres pseudo aléatoires avec python

En ajoutant au début d’un script l’instruction suivante, on indique à python de
charger des outils qui permettent de simuler le hasard :

from random import*

L’instruction randint(a,b) (avec a et b entiers) permet alors de tirer au hasard un

entier compris entre a et b (a et b inclus).

Sciences numériques et technologie 1. ALGORITHMIQUE - INITIATION À PYTHON – page 15