La pensée computationnelle

Objectifs
✔ Définir la pensée computationnelle.
✔ Identifier les stratégies de la pensée computationnelle.

Définition de la pensée computationnelle :

La pensée computationnelle  est une façon de résoudre des problèmes afin de présenter des
solutions qu’un ordinateur, un humain, ou les deux, peuvent comprendre
C’est une approche de:
● Formulation d’un problème
● Expression de sa solution

La pensée computationnelle comporte 4 étapes

1. la décomposition
2. la reconnaissance des schémas et des modèles
3. l'abstraction
4. l'algorithme

Application Trouver la somme de tous les nombres entre 1 et 1000 .

1+2+3+4+5+………………+999+1000

Etape1: décomposition
Consiste à diviser un problème initialement complexe en problèmes moins complexes ou
abordables
Comment peut-on diviser ce problème en sous problèmes simples ?
● additionner deux à deux (l’addition la plus simple)

Remarque : ça va prendre plusieurs itérations et c'est vraiment difficile de garder ça dans la tête.
● additionner les nombres par symétrie
Remarque : nombre de couples = 5
Somme d’un couple =11
Etape2 : reconnaissance des schémas et des modèles (pattern recognition) :
Consiste simplement à rechercher des similitudes et les differences entre le problème et à
l’intérieur des sous-problèmes (Détecter et analyser les séquences répétitives).

Retournons à notre problème initial :

Trouver la somme de tous les nombres entre 1 et 1000.
D’après le modèle 2, on remarque que la somme des couples formés par le i eme nombre et le
(1000+1-i)ieme nombre est la même pour tous les i, On a besoin de connaitre le nombre de couples
:Il suffit de prendre le plus grand nombre et le diviser par 2
Soit :1000/2=500 couples.

Etape3 : abstraction :
Consiste à éliminer tous les détails inutiles afin que nous puissions nous concentrer sur le détail
qui est le plus important

Trouver la somme de tous les nombres entre 1 et 1000.

Trouver les similitudes et les différences :
⇒Tous les couples ont la même somme.
Maintenant si on remarque un détail important on peut exprimer le problème en une équation
(1000+1)*(1000/2)=500500=> on trouve la somme
La formule générale sera:
Somme de chaque couple*le nombre des couples <= c’est l’abstraction

Étape 4 : algorithme
Un algorithme est une séquence d’étapes ou d’instructions qui sont exécutées pour résoudre un
problème donné.

Développer un algorithme : Déterminer étape par étape les instructions pour résoudre le problème
Étape1 : trouver la somme d’un couple 1000+1=1001
Étape2 : trouver le nombre de couples 1000/2=500 couples
Étape3 : multiplier les résultats de l’etape1 par le résultat de l’étape 2 : (1001*500=500500)

Cet algorithme peut être appliqué pour trouver la somme de tous les valeurs entre 1et nombre pair
quelconque.
Voyons :
Trouver la somme de chaque couple entre 1 et 200 200+1=201
Nombre de couple = 200 / 2=100
Somme de tous les nombres =201*100=20100
 DEMARCHE DE RESOLUTION DE PROBLEMES

Activité 1
On veut préparer un gâteau au chocolat. Identifier les étapes nécessaires pour le réaliser en
utilisant les données suivantes :

Etapes de réalisation :
● Préparer les ingrédients
● Suivre les instructions de la recette dans l’ordre
● Le gâteau au chocolat est prêt

I. Démarche de résolution de problèmes

L’intérêt de la programmation est de spécifier à une machine un certain travail à effectuer de façon
automatique en suivant une démarche à suivre qui lui a été fourni à l’avance sous forme de
programme.

D’après ce schéma nous constatons que :

● Chaque problème doit avoir un objectif bien défini.
● Les instructions doivent être ordonnées d’une manière correcte afin de résoudre un
problème.
● Les instructions peuvent se répéter plusieurs fois dans un problème.
I. Les étapes de Résolution des problèmes :
Activité N°2 :
Ecrire un algorithme qui permet de saisir deux nombres a et b, de calculer et d’afficher leur
somme.
Quelles sont les étapes à suivre pour résoudre ce problème

✰Première étape : Position du problème

Cette étape consiste à reposer le problème avec ses détails pour être clair et facile à résoudre :
- Les données : qui seront saisies au clavier (c’est une opération de lecture).
- Le traitement : (calcul, recherche, tri, ….)
- Le résultat final : qui sera affiché sur écran (c’est une opération d’affichage).

✰Deuxième étape : Ecriture de l’algorithme

Un algorithme est une suite ordonnée et finie d’actions ou instructions écrites dans un ordre
chronologique bien déterminé afin de résoudre un problème donné.

Structure générale d’un algorithme

Algorithme nom_algorithme
Début
…………..
………………
fin nom_algorithme

Déclaration des objets

Objet Type / Nature

Remarques :
● Le nom_algorithme est généralement un nom qui donne une idée sur ce que fait
l’algorithme. Par exemple, si on écrit un algorithme qui calcule la somme de 2 entiers, on attribue à
notre algorithme le nom somme.
● Chaque algorithme possède un nom et commence par le mot « Début » comme il finit par le
mot «Fin»
● Le verbe « Lire » est utilisé pour la saisie d’une donnée.
● Le verbe « Afficher »est une notation utilisée pour afficher un objet sur l’écran.
● L’utilisation du signe « 🡨 (reçoit) » pour l’affectation d’une valeur ou une expression à une
variable.
Exp : X 🡨 5 on dit : x reçoit 5
Correction Activité 2
ALGORITHME Somme
DEBUT
Afficher ("A = ") Lire (A)
Afficher ("B = ") Lire (B)
S 🡨A + B
Afficher ("S = ", S)
FIN

Déclaration des objets

Objet Type
A Entier
B Entier
S Entier

✰Troisième étape : Ecriture du programme

Un langage de programmation est un ensemble de règles syntaxiques (grammaire et vocabulaire)
et sémantiques (étude du sens des mots) qui sert à traduire un algorithme en un programme
source pour que l’ordinateur puisse l’exécuter.
Interprétés Compilés
APL, Python, Basic Algol, C , C++, Pascal
On distingue deux types de langages évolués : les langages interprétés et les langages compilés.
Exemples :

Pour le langage interprété, le programme source est exécuté instruction par instruction.
Dans le cas d’un langage compilé, le programme source est compilé (les erreurs sont corrigées)
pour produire un autre programme dit exécutable.
Le langage de programmation qu’on va utiliser est le : PYTHON
Vous pouvez télécharger IDLE Python à partir de ce lien :https://www.python.org/downloads/
Python est un langage de programmation interprété multi-paradigme et multiplateformes.
 Implémentation en Python :
a = input (‘’ Donner le 1er nombre : ‘’ )
b = input (‘’ Donner le 2eme nombre : ‘’ )
s = int (a) + int (b)
print (‘’ La somme est = ‘’ , s )
Ce programme se présente sous forme d’une suite d’instructions (appelées script)
compréhensibles par le langage de programmation Python
✰Quatrième étape : Exécution et tests du programme
Une fois l’écriture du programme est achevée, on procède à son exécution. Cette étape
consiste à tester le programme s’il répond bien au problème demandé.
Exemple d’exécution du programme somme :

Après l’écriture du programme on doit l’exécuter sur machine.

L’exécution du programme permet de tester son fonctionnement et vérifie si le résultat attendu est
abouti.
Si le programme testé n’aboutit pas au résultat attendu alors on doit apporter des modifications
(corrections, améliorations) et l’exécuter une autre fois et ainsi de suite.
Introduction
Activité 1 :
Donnez la démarche à suivre pour calculer et afficher la somme S de deux entiers A et B.
Constatation :
- Donner la valeur de A.
- Donner la valeur de B.
- Réaliser la somme S=A+B
- Afficher la valeur de S.

Les actions simples qu’on peut réaliser sur les objets sont :
- Lecture des données (opération d’entrée)
- Affichage des données (opération de sortie)
- Attribuer à une variable une valeur (opération d’affectation)

I. L’opération de sortie
Activité 2 :
Soit le programme suivant :
print(‘Bienvenue’)
1. Exécutez le programme « Affichage » sur la machine.
2. Quel est le rôle de ce programme ?
Constatation :
Ce programme permet d’afficher le message « Bienvenue » à l’écran.
1. Définition :
L’opération de sortie permet d’afficher une information à une destination de sortie, l’écran par
défaut.
La fonction print() permet d’afficher ou sortir des informations sur écran
2. Vocabulaire et syntaxe :
En algorithmique En Python
Ecrire ("message") print (‘message’)
Ecrire ("message", variable) print(‘message’,variable)
En général Ecrire (variable) print (variable)
Ecrire print(variable1,variable2,variable3)
(variable1,variable2,variable3)
Exemple Ecrire ('Bienvenue')
S=10
A=5
B=2
Ecrire ('S=',S)
Ecrire (S)
Ecrire (A,B,S)
II. L’affectation
Activité 2 :
Soient les instructions suivantes, avec X et Y sont deux variables réelles.
1) X 🡨 8.05
2) Y 🡨 10
3) X 🡨 X+Y
4) Y 🡨 X-Y
5) X 🡨 X-Y
Remplissez le tableau suivant :
N° de l’instruction Valeur de X Valeur de Y
1
2
3
4
 5
Qu’est-ce que vous constatez 
Constatation :
Ces instructions ont permis de permuter les valeurs de X et Y en modifiant à chaque fois leurs
valeurs par le résultat des opérations arithmétiques (+ et -).
1. Définition :
L’opération d’affectation consiste à ranger dans une variable une valeur de même type ou de type
compatible.
2. Vocabulaire et syntaxe :
En algorithme En Python
En général variable 🡨 valeur Variable = valeur 
Exemple X 🡨 8.05 X = 8.05
Remarques :
- Après l’affectation d’une valeur à une variable, son ancien contenu sera perdu.
- La valeur ou le résultat de l’expression à droite du signe d’affectation doit être de même
type ou de type compatible avec celui de la variable à gauche.
- La valeur à affecter à une variable peut être :
● Une constante.
● Le résultat d’une expression arithmétique ou logique.
● Le contenu d’une autre variable.

Pour savoir si 2 nombres sont égaux, on utilise “==”

Exemples :
>>> a = 6
>>> a
6
>>> b = 9
>>> a == b
False
III. L’opération d’entrée
Activité 3 :
Soit le programme suivant :
a=int(input(‘Donnez la valeur de a’ ) )
b=int(input(‘Donnez la valeur de b:’) )
S =a+b 
print(‘S=’,S)
1. Exécutez le programme « Somme » sur la machine.
2. Quel est le rôle de ce programme ?
Constatation :
Ce programme permet de calculer la somme de deux entiers donnés par l’utilisateur.
1. Définition :
La fonction input() effectue toujours une saisie en mode texte (la valeur retournée est une chaîne)
dont on peut ensuite changer le type (on dit aussi « transtyper » ou cast en anglais)
2. Vocabulaire et syntaxe :
En algorithme En Python
En général Lire(variable) Variable=input(‘donner la valeur’)
Lire (nom) nom = input ( )
Exemples Lire(n) n = int (input( ))
Lire(x) x = float (input( ))
 I. Les objets :
Dans un programme informatique, on va avoir en permanence besoin de stocker provisoirement
des valeurs. Il peut s’agir de données issues du disque dur, fournies par l’utilisateur (frappées au
clavier). Ces données peuvent être de plusieurs types : elles peuvent être des nombres, du texte,…
Activité1 :
On veut écrire un programme qui permet de calculer et d’afficher la surface d’un cercle de rayon R 

Constatations :
Un programme manipule « des objets » qui peuvent changer de valeurs (appelés « variables » et
d’autres objets qui ne changent pas de valeurs (appelés des « constantes »)

1) Les constantes :
Définition :
Une constante est un objet qui est initialisé par une valeur fixe (invariable). Une constante est une
case mémoire qui est caractérisé par un nom et la valeur qui lui est attribué.
Déclaration :
Tableau de Déclaration des Objets :
Objet  Type/Nature
Nom_const Constante de valeur
Exemple :
pi Constante de valeur 3,14

Python:

Activité 2:
Ecrire un code en Python qui permet :
▪ D’afficher la constante pi,
▪ D’incrémenter pi de 1
▪ D’afficher pi
▪ Exécuter ce code, que constatez-vous?
Constatations:
- On constate que la constante ………….peut être changée au cours du programme. Mais sa
valeur initiale reste la ……………
- Après la fermeture de l'éditeur IDLE et son ouverture de nouveau, on remarque que la valeur
pi est à …………….
II. Les variables  :
Définition :
Une variable est une case mémoire dans laquelle une valeur est enregistrée ou stockée. Cette
valeur peut être modifiée tout au long du programme.
Elle est caractérisée par :
● Un Nom (identificateur )
● Un Type
● Une Valeur (Contenu) C’est la valeur stockée dans la variable à un moment donné
Déclaration  :
Nom_Variable = valeur_variable
Exp :
A 🡨2 # On définit la variable« a » avec sa valeur 2

Remarque : le contenu d’une variable peut être modifié soit par une opération d’affectation soit par
une opération de lecture ( lire ( a ))

Une fois une variable initialisée, on peut modifier sa valeur en utilisant de nouveau l’opérateur
d’affectation (=). La valeur actuelle de la variable est remplacée par la nouvelle valeur qu’on lui
affecte. Dans l’exemple suivant, on initialise une variable à la valeur 12 et on remplace ensuite sa
valeur par 99 :
a 🡨 12
a 🡨 99
ecire (a)

● Dans python les variables n’ont pas besoin d’être déclarées à l’ avance, mais toute variable
doit avoir une valeur avec le signe d’affectation =.
● Une variable n’a pas de type unique
● On obtient le type d’un objet o avec la fonction type(o) et son identité avec id(o) c’est un
entier unique associe à tout objet : son adresse en mémoire
● id() : renvoie un entier représentant l’identifiant interne d’un objet
● type() : renvoie le type d’un objet.
● dir() : liste l’ensemble des fonctionnalités d’un objet.

Rq :
Commentaires : Tout texte qui suit le caractère dièse « # » n’est pas exécuté par Python mais sert
à expliquer le programme.

Nomenclature
En Python, une variable :
● Le nom d'une variable s'écrit avec des lettres de a..z ou de A..Z (non accentuées), des
chiffres ou bien tiret bas_
● Les accents sont possibles mais à éviter
● Les mots clé du langage sont interdits
● Le nom d'une variable ne doit pas commencer par un chiffre.
● ne contient pas des caractères spéciaux pas d'espaces on peut utiliser des underscores '_'
● doit commencer par une lettre ou un Underscore« _ »(Exp :age _age)
● contient des chiffres
● ne contient pas de caractères spéciaux (@ -  ; ?  ! …)
● ne contient pas d’espaces
● peut avoir des underscores pour les noms de variables combinés (Exp :age_personne)

Attention !
Python distingue les majuscules des minuscules (Python est sensible à la casse)
Donc age, AGE ou Age sont des variables différentes.
Exp :
x1 est un identificateur valide
_x1 est un identificateur ………………..
1x_y n'est pas un identificateur valide car il commence par un ……………….
x-y…………………………………………………………………………………………..

Exemples d’identificateurs
– valides : toto, proch_val, max1, MA_VALEUR, r2d2, bb8, _mavar
– non valides : 2be, C-3PO, ma var

Conventions : pour les variables en Python :

● utiliser des minuscules
● pas d’accents

III. Les types

Il caractérise les valeurs que peut prendre cette donnée ainsi que les opérations autorisées sur
celle-ci.

a) Type entier : (int)

Definition
Une variable de type int est un nombre sans virgule flottante. Le type int n’est limité en taille que
par la mémoire de la machine (pratiquement la taille d’un entier en Python est illimitée)
Déclaration  :

Objet : Type/Nature
Nom_variabl Entier
e

Python

b) Type réel : à virgule flottante (float)

Définition
Une variable de type float est un nombre décimal avec virgule flottante (avec un point décimal) un
float en python doit être écrit avec un point décimal (jamais avec une virgule)

Déclaration :
Objet : Type/Nature
Nom_variabl Réel
e

Python

Opérateurs :
Operation Algorithme python type
ADDITION + + ENTIER/REEL
SOUSTRACTION - - ENTIER/REEL
MULTIPLICATION * * ENTIER/ REEL
DIVISION REELLE / / REEL
DIVISION ENTIERE DIV // ENTIER
RESTE DE DIVISION ENTIERE MOD % ENTIER
LES COMPARAISONS < > <= >= = ≠ < > <= >= == != BOOLEEN
APPARTENANCE A UN X ∈[1..5] X in range(1,6) BOOLEAN
INTERVALLE 1<=x<=5
Les opérateurs relationnels sur les entiers et réels

x=3 # x est un entier

print(x in range(2,5))# x dans l’intervalle 2..4
print(x in range(5))# x dans l’intervalle 0..4

N.B.:
Il ne faut pas confondre entre l’opérateur d’affectation « = » et l’opérateur de comparaison «==» qui
compare les valeurs de deux variables
Les opérateurs arithmétiques sur les entiers et réels :
Ordre de priorité des opérateurs :
L'ordre de priorité est :
1. les parenthèses ()
2. la multiplication *, la division /, la division entière // et le reste de la division entière %
3. L'addition + et la soustraction –

N.B. Si les opérateurs ont même priorité, on commence de gauche vers la droite
Application :
Ecrire un algorithme intitulé CHIFFRE permettant de saisir un nombre « N» formé de 3 chiffres, de
calculer et d’afficher la somme S et le produit P des chiffres formant « N »
Exemple : N= 265 
le programme affichera : La somme des chiffres est = 13(2+6+5 = 13)
Le produit des chiffres est = 60(2*6*5= 60)
Algorithme : …………………….
Debut
T.D.O. 
Obje
Type
t

…………………………….........
…………………………………
……………………………………
………………………………….
…………………………………
…………………………………
…………………………………
………………………………….

Les méthodes mathématiques sur les entiers et réels

 Les fonctions arithmétiques standards relatives aux types entier et réel :
Nom en
Nom en Python Rôle Exemples
algorithme
Le module qui gère trunc en
python est le module math: Y🡨tronc (3.14)
Extraire la partie
Y contient …………..
entière de x
y🡨tronc (x) from math import *
(supprime la partie
print(trunc(3.14)) y🡨tronc (-1.25)
décimale)
Y contient …………..

y🡨arrondi (9.499)
Y contient …………..

y🡨arrondi (2.5)
Arrondir une valeur Y contient …………..
y🡨arrondi (x) y=round(x) réelle à l’entier le
plus proche y🡨arrondi (3.5)
Y contient …………..

y🡨abs (x) y=abs(x)
from math import *
y🡨racine carre (x) print(sqrt(4))
y🡨carre (x) y= x ** 2
Le module qui gère
l’aléatoire en python est le
module random:
from random import *
y🡨alea (vi,vf)
random() #donne un réel
entre [0 et 1[
randint(vi,vf) #donne un
enttier entre [vi et vf[
y🡨arrondi (8.99)
Y contient …………..
Donner la valeur y🡨abs (-5)
absolue de x Y contient …………..
Donne la racine
y🡨racinecarre(4)
carré de x (si x est
Y contient …………..
positif)
y🡨carre (5)
Donne le carré de x
Y contient …………..
y🡨alea()
Y contient …………..
Retourne une
valeur numérique y🡨alea(0,30)
aléatoire de Y contient …………..
l’intervalle [vi,vf]
Y🡨alea(2.6,10)
Y contient …………..
 uniform(vi,vf) #donne un
réel entre [vi et vf]
y🡨ent (‘3’)
Y contient …………..
Permet de modifier
y🡨ent (x) y=int(x) une variable en y🡨ent (‘-1’)
entier Y contient …………..
y🡨ent (3.22)
Y contient …………..
 Série 1
Exercice 1 :
Pour chacune des propositions suivantes, mettre dans la case correspondante la lettre V si elle est
juste ou la lettre F si elle est fausse.
1) En algorithme, pour saisir un objet A on doit utiliser l’instruction :
écrire(A)
saisir(A)
lire(A)
input(A)
2) En Python, pour afficher un objet S, on peut utiliser l’instruction :
print(S)
print(‘S’)
ecrire(S)
print("S=",S)
3) En algorithme, pour affecter la valeur 5 à la variable X, on doit écrire :
X=5
X 5
X==5
X := 5
Exercice 2 :
Ecrire un algorithme et une implémentation d’un programme qui permet de convertir une durée de
temps donnée T en seconde, en nombre d’heures, minutes, et secondes.
Exemples : T = 5000 le programme affichera : Heures = 1 Minutes = 23 Secondes = 20 T = 6100 le
programme affichera : Heures = 1 Minutes = 41 Secondes = 40
Exercice 3
Ecrire un programme qui permet d’afficher la valeur de la surface d’un cercle.
NB : On peut utiliser l’objet pi
Exercice 4

Exercice n°5 : Compléter le tableau suivant

X= random() Donne au hasard un flottant (réel) dans l’intervalle [0,1[
………………………………………………………… Donne au hasard un flottant entre deux valeurs 8 et 18.6
X=randint(5,10) …………………………………………………………………………………
X=randint(0,6) +12 …………………………………………………………………………………
 Série 2
Exercice n°1
Pour chacune des propositions suivantes, donner le type de la variable A.
Propositions Type de la variable A
A = input(″Saisir A″)
A =float(input(″Saisir A″))
A =int(input(″Saisir A″))
Exercice n°2
Pour chaque instruction donner le résultat et son type (int, float, str ou bool):
Instruction Résultat Type
A=3/2
A=9%3
A=15//2
age = 18
age==17
Exercice n°3
Question : Mettre Vrai (V) ou Faux (F)
1) Pour affecter a x un entier aleatoire entre 0 et 6 :
x=random() x=randint(0,6) x=uniform(0,6)
2) Soit l’action suivante :
x=randint(2,10)
x dans [0..10] x dans [2..9] x dans [2..10]

3)Quelle est la valeur affichée par la séquence d'instructions suivante :

from random import *
x= 6 + randint(1,5)
print(x)
Valeur aléatoire de type entier comprise entre 6 et 11

Valeur aléatoire de type entier comprise entre 7 et 12

Valeur aléatoire de type entier comprise entre 7 et 11

Valeur aléatoire de type entier comprise entre 6 et 10

4) L’action : print("bonjour")
Lire le message Saisir le message Afficher le message
"bonjour" "bonjour" "bonjour"

5) Soit l’action : x=17//3+25%3

x=10 x de type entier x=6

Exercice n°4
Donner les instructions Python  permettant de :

…………………………….………………………………………….
Saisir un réel X
Afficher le message suivant : « Bon …………………………..……………………………………………
travail pour tous »
Affecter à X le reste de la division …………………..…………………………………………………….
entière de A par B.
 …………………………………………………………………………
Affecter à Z : XY
Incrémenter (augmenter) la variable B ……………………………………………………………………….
de 1

Exercice n°5
Ecrire un algorithme et l’implémentation du programme en python qui permet de :
• Saisir deux entiers m et n.
• Concaténer l’entier m avec l’entier n
• Affecter le résultat de concaténation à une variable p puis afficher le résultat de concaténation.
Exemple : m = 167, n =25 le programme affichera : p =16725
Exercice n°6

c) Le type booléen :
Définition
Ce type est appelé type logique .
en python, une variable de type bool peut prendre soit la valeur True (vrai) soit False(faux)
Exp :
A 🡨 2>5
A🡨 vrai
A🡨 faux

Déclaration
Objet  Type/Nature
Nom_varaibl Booléen
e

Python :

Les opérateurs logiques sur les booléens

Opérateur
Signification
Algorithme Python
NON  not Négation( le contraire)
ET  and ou & Conjonction
OU or ou | Disjonction
OU EX ^ Ouexclusif

Table de vérité
P Q Non(P) P ET Q P OU Q P OUEX
Q
Faux Fau Vrai Faux Faux Faux
x
Faux Vrai Vrai Faux Vrai Vrai
Vrai Vrai Faux Vrai Vrai faux
Vrai faux Vrai Faux Vrai Vrai
5) (8<7) OUex (0<-1)
6) Non (9<5) OUex (2<14)
7) (2<7) OUex (3<-8)

N.B. Si les opérateurs ont même priorité, on commence de gauche vers la droite

d) Type caractère :
Définition :
Une variable de type caractère est un objet qui peut prendre un seul caractère
● Les caractères sont les lettres ( minuscules [″ a ″ .. ″z″] et majuscules [″ A ″ .. ″ Z ″]), les
chiffres [″ 0 ″ ..″ 9 ″] et les caractères spéciaux : ponctuation, signes et mêmes les caractères non
imprimables comme : Retour chariot, , Bip sonore,échappe, l’espace…
● à chaque caractère correspond un code appelée code ASCII qui est un entier entre 0 et 255
(voir table des codes ASCII (American Standard Code for Information Interchange).
Caractère Code ASCII
‘’A’’ 65
‘’Z’’ 90
‘’a’’ 97
‘’2’’ 50
‘’ ‘’ :espace 32

● Un caractère doit être placé entre deux guillemets ou entre apostrophes en algorithme et en
python.
Déclaration :
Objet  Type/Nature
Nom_varaibl caractère
e
Opérateurs logiques applicables sur les caractères :
- Tous les opérateurs relationnels (suivant le code ASCII).
Exemple : ‘’a’’ < ‘‘b’’ …
- L’appartenance à un ensemble.
Exemple : ‘‘A’’ dans [‘’A’’..’‘Z’’]
- La concaténation des deux caractères s’effectue avec le +
Exemple : ‘’a’’+’’z’’ ‘’az’’
- La répétition des caractère s’effectue avec le *
c= ‘’a’’*2
c contient ‘’aa’’

Les fonctions prédéfinies relatives au type caractère

Nom Code en Python Rôle Exemples

ord(c)
ord(‘A’) donne 65
ord (c) print(ord('0')) # 48 Renvoie le code ASCII du caractère c
ord(‘a’)donne 97
print(ord('A')) # 65
Chr(n)
Renvoie le caractère dont le code
chr(n) print(chr(97)) # a chr(65) donne ’A’
ASCII est n
print(chr(65)) # A

Python ne supporte pas le type caractère. De là un caractère n’est plus qu’une chaine de caractère
de longueur 1
c=’A’
t=len(c) # taille de la chaine c
print(c)
donne 1

e) Type chaîne de caractère : (str)

Définition : Une variable de type str et un objet qui peut prendre une suite de caractères
Une chaîne de caractère doit être placée entre deux guillemets ou entre apostrophes en
algorithme et en python.
Objet : Type/Nature
Nom_varaibl Chaîne de caractère
e

Déclaration :
Tableau de Déclaration des Objets :
Objet : Type/Nature
Mot1 chaine
Mot2 chaine
Python:
Chaine="" #représente une chaine vide

Accès aux éléments d'une chaîne :

Une chaine de caractère est représentée sous la forme d'un tableau(List) chaque caractères est
rangée dans une case et identifié par son indice(0 à N-1 ou -1 à –N)
Python offre des mécanismes permettant d’accéder séparément à chacun des caractères d’une
chaîne,
on peut accéder aux caractères d’une chaîne par leurs indices dans la chaîne, et extraire des
sous-chaînes d’une chaîne. Les indices peuvent être positive( 0 à N-1)ou négative( 1 à -N).

Exemple
Ch= B o n j o u r
Indice positif 🡪 0 1 2 3 4 5 6
Ou bien
Indice negatif🡪 -7 -6 -5 -4 -3 -2 -1
 Remarque ::Les chaînes de caractères sont immuables ((c-à-d non modifiable : ni changement, ni
suppression et ni insertion ni tri.).
Il est donc, interdit d’écrire par exemple : ch[0]=’P’

Pour modifier une chaîne de caractères doit construire une nouvelle chaîne qui peut remplacer la
précédente avec le même identificateur.

Operateurs
Operation Algorithm python type exemple
e
Concaténation (la mise bout à + + chaine ‘’bon’’+’’jour’’
bout) donne ‘’bonjour’’

Repetition * * chaine ch= ‘’bon’’*2

c contient ‘’bonbon’’

LES COMPARAISONS < > <= < > <= >= == BOOLEEN ‘Bonjour ‘<
Remarque : >= = ≠ != ‘BonJour’ donne
La comparaison se fait 2 a 2 du faux
gauche vers la droite ‘Bonjour’<’bonjour’
donne vrai

Appartenance a un intervalle c ∈[‘A’..’C’] in BOOLEAN c in [‘A’,’b’,’C’]

ou
‘A<=c<=’C’
Ou
C in ‘ABC’

Indexage et slicing :
La séquence d'échappement \n représente un saut ligne :

Plus simplement, on peut utiliser les triples guillemets (ou les triples apostrophes) pour encadrer
une chaîne définie sur plusieurs lignes :

On ne peut pas mélanger les types(ici type str et type int) :

La fonction input( ) lance une invite de commande (en anglais : prompt) pour saisir une chaîne de
caractères.
Les fonctions et méthodes prédéfinies relatives au type chaine de caractères

Nom Code en Python Rôle Exemples

ch🡨’’2020’’
Retourne le nombre de
n🡨long (ch) n=len(ch) n🡨long(ch)
caractère de la chaine ch
n contient4
ch1🡨’’2’’
Retourne la première ch2🡨’’2020’’
position de la chaine ch1 ch3🡨’’3’’
n🡨pos (ch1, ch2) n=ch2.find(ch1) dans la chainech2(retourne n🡨pos(ch1,ch2)
-1 si ch1 n’existe pas dans n contient0
ch2) p🡨pos(ch3,ch2)
pcontient-1
Convertir le nombre den une ch🡨convch (2020)
Ch🡨convch(d) ch = str(d)
chaine de caractères chcontient‘’2020’’
n = int(ch) #entier ch🡨’’2020’’
n= float(ch) #réel n🡨valeur (ch)
n contient 2020
n=int('2020')
Convertir une chaine de
ch🡨’’12.8’’
caractère en une valeur
n🡨valeur (ch) n=float(‘12.8’) n🡨valeur (ch)
numérique (entier ou réel) si
n contient 12.8
c’est possible (sinon erreur)
ch🡨’’2Info2’’
n=int(‘2Info2’)
n🡨valeur (ch)
#erreur
ERREUR
Ch1🡨majus(’’Devoir
Convertir la chainech en ’’)
Ch1🡨majus (ch) Ch1=ch.upper()
majuscule Ch1contient
DEVOIR
Ch1🡨minus(’’BONj
Convertir la chainech en en our’’)
Ch1🡨minus (ch) Ch1=ch.lower()
minuscule Ch1contient
bonjour
a🡨estnum(ch) a=Ch.isdigit() Retourne Vrai si la chaîne ch a🡨estnum(’’25’’)
est convertible en une valeur a contient vrai
numérique, elle retourne b🡨estnum(’’a25’’)
Faux sinon. a contient faux
Ch1🡨Souschaine(ch,d, Ch1=Ch[d:f] Retourne une partie de la Ch1🡨souschaine(’’
f) chaine ch à partir de la baccalauréat
position d Jusqu'à la 2021’’,5,12)
position f (non incluse) Ch1 contient
‘’lauréat’’
effacer(ch, d,f) Ch[:d]+ch[f:] Supprime une partie de la Ch🡨’’baccalaureat’’
chaine ch à partir de la effacer(ch, 3,12)
position d Jusqu'à la Ch contient ‘’bac’’
position f (non incluse)
Une chaîne de caractères est un objet itérable on peut utiliser la structure répétitive for pour
parcourir caractère par caractère une chaîne
Exemple1: utilisation des indices avec la fonction range() et len()

Exemple2: utilisation des caractères au lieu des indices

 Série 3
Exercice n°1
Donner l’affichage adéquat pour chaque instruction après l’exécution :
Code Exécution
…………………………………
…………………………………

…………………………………

…………………………………

…………………………………

Exercice n°2
Donner le résultat de chacune des instructions suivantes :
Instructions Affichage
ch=’radar’
x=ch[2]+ch[1]+ch[0] • True
y=ch[2 :] • False
print(x==y) • ‘’Rad’’

• 97
ch=’yes we can’ • 99
print(ord(ch[8]) • 101
mot1=’travail’
mot2=’réussir’ • <Class ‘str’>
c=mot1==mot2 • <Class ‘bool’>
print(type(c)) • <Class ‘int’>

mot1=’travail’
• ‘’C’’
c=chr(len(mot1)+61)
• ‘’D’’
print(c)
• 67

Exercice n°3 :
Soit la chaine suivante ch = "BON COURAGE A TOUS" Donner, en Python, les instructions
permettant de : 1) Afficher la longueur de la chaine.
.....................................................................................................................................................................
... 2) Afficher la position du caractère "C" dans ch.
.....................................................................................................................................................................
... 3) Convertir la chaine ch en minuscule et l’affecter à ch1.
.....................................................................................................................................................................
... 4) Modifier le mot "courage" par le mot "chance" dans la chaine ch .
.....................................................................................................................................................................
...
Exercice n°4 :
Soit Ch="DevoirdeSynthese"
Déterminer la valeur de chaque objet
Actions Resultat
x=len(ch) …………………….……………
print(x)
y=ch[-1] …………………….……………
print(y)
z=ch[ :6] …………………….……………
print(z)
a=ch.isdigit() …………………….……………
print(a)
b=ch.lower() …………………….……………
print(b)
f=ch.find("e") …………………….……………
print(f)
Exercice n°5
Ecrire l’algorithme d’un programme intitulé Cryptage qui permet de saisir un mot donné et
d’effectuer le chiffrement suivant le principe suivant :
● Permuter le 1er caractère du mot avec le dernier
● Remplacer l’élément du milieu du mot par son code ASCII

Par exemple:
Ch=’bonjour’
Résultat =’ ron106oub’
Introduction :
Activité :
❑ Relier les expressions de la colonne A avec celle de la colonne B :
1-Si je ferai mes leçons a- Ali prend son parapluie.
2-S‘il pleut b- j’aurais des bonnes notes.
3-Si j’étais riche c- je visiterai le monde entier.
❑ Soit la phrase suivante souligne en vert la condition en rouge l’action :
Si je fais option sciences alors je ferai des études de médecine

Cette expression a la structure suivant:

Si condition Alors traitement
Constatation :
❑ On constate qu’il y a 2 parties condition et traitement.
❑ On remarque que la première partie a obligé l’exécution de la deuxième partie.

Pour montrer qu’il y a une condition donc il y a un traitement qui est exécuté donc
« Tout élève ayant une moyenne supérieur ou égal à 10 est déclaré admis »
🡪Pour qu’un élève soit admis, il faut que sa moyenne soit supérieure ou égale à 10.
🡪C'est-à-dire la condition de réussite de l’élève est Si «moyenne>=10 »

🡪Cette structure est

dite : structure de
contrôle
conditionnelle

Définition
La structure de contrôle conditionnelle permet à un programme de choisir et modifier son
traitement selon une condition.
On distingue 3 formes de structures conditionnelles :
● Simple
● Généralisées
● à choix multiples
I-Structures de Contrôle Conditionnelles simple:
1. structure conditionnelle simple réduite:
a-Définition :
La structure conditionnelle simple est dite structure conditionnelle simple réduite si on restreint à
l’exécution d’un seul traitement et cela dans le cas où la condition est vérifiée.
b-Syntaxe :
Algorithme Python
Sicondition Alors if condition:
traitement Traitement
Fin si
Instruction k
Remarque :
✔ Cette structure est dite structure conditionnelle simple réduite.
✔ Si la condition est vraie alors le traitement sera exécuté sinon, l’exécution passe au bloc
d’instructions qui suit la condition.
Activité 1 :
Ecrire un algorithme et son script python qui permet de saisir un entier « N » strictement positif et
d’afficher sa racine carré.

Algorithme :racine
Début Python :
Afficher (‘’ Donner n : ‘’) from math import*
Lire (n) n=int(input(‘donner n :’))
Si n >0 alors if n >0 :
Afficher ( racinecarrée(n)) print( round(sqrt(n), 2 ))
Fin si
Fin
Activité 2 :
Ecrire un algorithme et son script python qui permet de saisir un entier « N » et d’afficher sa valeur
absolue sans utiliser la fonction abs.

Début Absolue Python :

Afficher (‘’ Donner n : ‘’) n = int(input("Saisir une valeur de n : "))
Lire (n) if n<0:
Si n  <0 alors n = -n
n 🡨 -n print(n)
Fin si
Afficher ( n )
Fin
2-structure conditionnelle simple complète ou alternative:
a-Définition :
Une structure de contrôle conditionnelle à une forme simple complète si selon la valeur d’une
condition on exécute soit un traitement1 soit un traitement2.
b-Syntaxe :
Algorithme Python
Si condition Alors ifcondition :
Traitement1 Traitement1
Sinon else
Traitement2 Traitement2 
Fin si

Remarque :
✔ [Init] est une séquence d’instructions qui contiendra les éventuelles initialisations.
✔ La condition est une expression logique qui peut être « vraie» ou « faux »
✔ Lorsque la valeur de la condition est :
- VRAI : le Traitement 1 sera exécuté
- FAUX : le Traitement2 sera exécuté.
✔ Une condition peut être composée de plusieurs expressions logiques liées par les
opérateurs booléens. Exemple : (a>2) ET (b<9) OU (c=3)
✔ On remarque la présence essentielle des deux points ( : )et du retrait. Les deux points
marquent la fin de la condition. Tout Traitement doit faire l'objet d’un léger retrait(indentation ou
Tabulation (4 espaces)) indispensable pour être exécuté, sinon une erreur peut se produira.

Activité 4 :
Améliorer l’algorithme précédent pour afficher la racine carrée si cet entier est positif sinon
afficher son carré.

Constations :
✔ L’activité présente maintenant deux traitements : soit N positif pour afficher sa racine carrée
soit N négatif pour afficher son carré d’où la présence d’une nouvelle structure conditionnelle dite
structure conditionnelle alternative ou complète.
Réponse de l’activité3 :
Algorithme : racineV2 Python :
Début from math import *
Afficher (‘’ Donner n : ‘’) n=int(input(‘donner n :’))
Lire (n) if n >0 :
Si n >0 alors print( round(sqrt(n), 2 ))
Afficher ( racinecarrée(n)) else :
Sinon print(pow(n, 2))
Afficher (carrée(n))
Fin si
Fin
Activité N°4:
Ecrire un algorithme intitulé Existence puis un script python qui permet de déterminer si une
chaîne ch1 existe dans une chaîne ch2. Le résultat final consiste à afficher le message « Existe »
et la position p si ch1 existe dans ch2 sinon afficher le message « N’existe pas ».
Algorithme : exist Python :
Début from math import *
Afficher (‘’ Donner un caractere : ‘’) c=input(‘Donner un caractere  c :’))
Lire (c) ch=input(‘Donner une chaine de caractères
Afficher (‘’ Donner une chaine de caractere : ‘’) ch :’))
Lire (ch) if c in ch :
Si c dans ch alors print (c,’existe dans’ , ch)
Afficher (c,’existe dans’ ,ch) else :
Sinon print (c,’n’’existe pas dans’ , ch)
Afficher (c,’n’’existe pas dans’ ,ch)
Fin si
Fin

II-structure conditionnelle généralisée :

a-Définition :
La structure conditionnelle simple fait appel au maximum à deux traitements possible selon une
condition est vérifié ou pas. c.a.d si la condition est vérifié (vrai) on exécute le traitement1 et si la
condition n’est pas vérifié (faux) on exécute le traitement2.

Une structure de contrôle conditionnelle est dite généralisée si on a plusieurs traitements à

exécuter suivants plusieurs conditions.

b-Syntaxe :
Algorithme Python
Si condition1 Alors if condition1 :
Traitement1 Traitement 1 
Sinon Si condition2 Alors elif condition2 :
Traitement2 Traitement 2 
Sinon Si condition3 Alors elif condition3 :
Traitement3 Traitement 3 
Sinon .
. .
. elif condition_n-1 :
Sinon Si condition_n-1 Alors Traitement n-1 
Traitement n-1 else :
Sinon Traitement n 
Traitement n
fin si

Remarque :
● Si la condition1 égal:
● Vrai : Seul le traitement1 est exécuté
● Faux : On passe à l’évaluation de la condition2, Si elle donne:
● Vrai : Alors seul le traitement 2 est exécuté
● Faux : On passe à la condition3 et ainsi de suite.
● Si aucune des n-1 premières conditions ne produit la valeur Vrai, c’est le traitement n qui
sera exécuté.

Activité N°5 :
Ecrire un algorithme intitulé signe puis un script python qui permet de déterminer et afficher la
nature d’un nombre entier N saisi à partir du clavier(positif, négatif ou nul).

Constations :
✔ L’activité N°5 présente plusieurs possibilités sur le signe d’un entier : positif ou négatif ou
même nul. D’où une nouvelle structure conditionnelle dite structure conditionnelle Généralisée.
Algorithme : signe Python :
Début n= int (input(‘donner un entier :’))
Afficher (‘’ Donner unentier : ‘’) ifn <0  :
Lire ( n) print(n, ‘est négatif ‘)
Si (n <0 ) alors elif x == 0  :
Afficher (n, ’’est négatif ‘’) print(n, ‘’ est null ‘’)
Sinon Si n =0 alors else :
Afficher (n, ‘’ est null ‘’) print(n, ‘ est positif ‘ )
Sinon
Afficher (n, ‘’ est positif ‘’) TDO :
Fin si
Fin Objet Nature / Type
n entier

Activité N°6 :
Ecrire un algorithme et un script en Python qui permet de lire le numéro du mois et d’afficher la
saison correspondante.
Algorithme Python :
Début Saison m=int(input('donner un mois'))
Ecrire ("donner le numéro du mois ") if m==1 or m==12 or m==2:
Lire (mois) print('Hiver')
Si (mois ∈[3..5]) Alors elif m==3 or m==4 or m==5:
Saison ← "printemps" print('Printemp')
Sinon si (mois dans [6..8]) Alors elif m==6 or m==7 or m==8:
Saison ← "Eté" print('Ete')
Sinon si (mois dans [9..11]) Alors elif m==9 or m==10 or m==11:
Saison ← "Automne" print('Automne')
Sinon else:
Saison ← "Hiver" print(ch,'n est pas un saison')TDO :
Fin Si
Objet Nature / Type
Ecrire (Saison) m entier
Fin Saison
 Série 4
Exercice1 
☺ Cocher 🗹 la bonne réponse.

x = int(input("x= ")) X=-9

❶ R=x Le programme affiche :
if x<0 :
R=-x ⬜
⬜ |-9| =-9
print( "|" + str(x)+ "| =" + str(R))
⬜ |-9| =9
| 9| =9

chaine1= input("Chaîne 1 : ") Chaîne 1 : 2 Ti2

chaine2= input("Chaîne 2 : ") Chaîne 2 : 2 Info2
❷
if (len(chaine2) > len(chaine1) ): Le programme affiche :
print (chaine2)
else: ⬜
⬜ 2 Ti2
print (chaine1)
⬜ chaine2
2 Info2

❸ A🡨 7 Après l'exécution du code

Si (A ≠ 7) alors suivant, quelle sera la valeur
C🡨A*A de C
Sinon
C🡨-A
Finsi

Exercice 2 :
Ecrire un programme qui permet de saisir un entier a, puis d’afficher si a est un entier positif ou
négatif.
Exercice 3 :
Ecrire un programme qui permet de saisir deux entiers a et b, puis d’afficher si a est un diviseur de
b. Exemple :
Si a = 5 et b = 30 5 est un diviseur de 30
Si a = 5 et b = 27 5 n’est pas un diviseur de 27
Exercice 4:
Ecrire un programme qui permet de Saisir les 3 côtés d’un triangle (a, b et c) puis déterminer si ce
triangle est isocèle.
Exercice 5 :
Ecrire un programme qui permet de Saisir un caractère c puis déterminer si ce caractère est chiffre
ou non.
Exercice 6:
un programme qui permet de saisir une chaine de caractère ch et un caractère c, puis d’afficher si
c existe dans ch ou non . Exemple :
Si ch = «test » et c = «e » e existe dans test
Si ch = «test » et c = «v » v n’existe pas dans test
Exercice 7
Ecrire un programme intitulé type_Ent qui permet de saisir un entier n et d’affiche à l’écran :
Si n >0 alors on affiche ‘ n est supérieur à 0’
Si n < 0 alors on affiche ‘ n est inférieur à 0’
Si n Si n =0 alors on affiche ‘n est égal à 0 ‘
Exercice 8:
Ecrire un algorithme puis un script qui permet de saisir successivement un réel (r1), un opérateur
(op) et un 2ème réel (r2) puis d’afficher le résultat (R) de l’expression « r1 op r2 » si l’opération est
possible SINON affiche les messages convenables en cas d’erreur.
Exemple1 : Pour r1= 50 , op= ‘’+’’ , r2=20 le programme affichera 50.0 +20.0 = 70.00
Exemple2 : Pour r1= 5 , op= ‘’*’’ , r2= 9 le programme affichera 5.0 * 9.0 = 45.00
Exercice 9 :
Ecrire un algorithme intitulé AGE permettant d’afficher un commentaire en fonction l’age (A), d’une
personne donné :

Exercice 10 :
Ecrire un algorithme du programme intitulé SAISON qui affiche à l’écran la saison correspondante
à sa lettre initiale saisie. Exemple Si le caractère saisi est E ou e alors on affiche Eté Si le caractère
saisi est H ou h alors on affiche Hiver
Les structures répétitives(ou boucles) nous permettent de gagner énormément de temps en
éliminant les répétions. Imaginez que vous avez à exécuter une certaine instruction un certain
nombre de fois, disons 100 fois, alors au lieu de taper ces instructions 100 fois, les structures
répétitives nous permettent de la taper une seule fois en indiquant le nombre de fois que
l'ordinateur doit l'exécuter.
Une structure répétitive est aussi appelée boucle. On distingue deux types de boucles :
- Une structure itérative complète où le nombre d’itérations est connu à l’avance : La boucle Pour …
Faire …
- Une structure itérative à condition d’arrêt où le nombre d’itérations est inconnu à l’avance.
● La boucle Répéter … Jusqu'à …
● La boucle Tant que … Faire …

A. La structure de contrôle itérative complète(boucle for)

Définition
On sait à l’avance combien de fois la boucle devra tourner et une variable (le compteur) compte
les répétitions
La boucle for permet de répéter une ou plusieurs instructions un nombre fini de fois connu à
l'avance
Syntaxe :
Algorithme Python
Pour compteur de Début à Fin (pas) for compteur in range(debut,fin,pas):
Faire Traitement
Traitement
Fin Pour

Remarques
● Traitement : bloc d’instructions à répéter pendant que compteur prend les valeurs de la
plage définie par range
● début : représente la borne inférieure du compteur, c'est le point départ, si on ne met pas la
borne inférieure, par défaut la borne inférieure commence par 0
● fin: représente la borne supérieure du compteur, c'est le point d'arrêt du compteur, (cette
valeur est exclue), donc il faut obligatoirement mentionné cette valeur
● Pas : représente la valeur d’avancement du compteur, par défaut le pas = 1

● Le compteur doit être de type scalaire(type entier ou caractère).

● début et fin Peuvent être des valeurs, des variables définies avant le début de la boucle ou
des expressions de même type que compteur.
● Pas : est un entier qui peut être positif ou négatif. Pas peut ne pas être mentionné, car par
défaut sa valeur est égale à 1. Dans ce cas, le nombre d'itérations est égal à finale - initiale+ 1.
● Il faut éviter de modifier la valeur du compteur (et de finale) à l'intérieur de la boucle
● On peut écrire la boucle Pour sans spécifier le pas d’incrémentation, dans ce cas le pas
d’incrémentation par défaut est 1

● Si le compteur est de type caractère, alors le nombre de répétitions est

E(Ord(Vf)-Ord(Vi)/pas) +1.
● L’incrémentation du compteur est automatique avec un pas de 1par defaut ou un pas de n
● Le nombre d’itérations fixe et connu.
● La fonction range : par défaut début et pas valent respectivement 0 et 1

Activite :
Ecrire un programme en python dans lequel on affiche la table de multiplication d’un entier
donnée
Algorithme Python
…… n = int(input("Saisir un entier : "))
Ecrire (‘Saisir un entier : ’)
Lire(n) for i in range(1,11):
Pour i de 1 à 10 faire print(i,'*',n,'=',n*i)
Ecrire (i,'*',n,'=',n*i)
Fin Pour
……

Console d’affichage
Saisir un entier : 9
1*9=9
2 * 9 = 18
3 * 9 = 27
4 * 9 = 36
5 * 9 = 45
6 * 9 = 54
7 * 9 = 63
8 * 9 = 72
9 * 9 = 81
10 * 9 = 90

Exercice  d’application:
Ecrire un programme en python dans
lequel on affiche les nombres pairs
compris entre 20 et 0 sur une seule ligne :
for i in range(20,-1,-2):
print(i, end=" ")
Ecrire un programme en python dans lequel
on affiche tous les nombres de 10 à 20 sauf le
nombre 13, le tout sur une seule ligne.
for i in range(10,21):
if i == 13:
 continue
print(i,end=" ")

Exercice 1 :
Dans chaque cas , dire ce que s’affiche dans la console

Exercice 2 :
Ecrire un algorithme d’un programme qui permet d’afficher les caractères d’une chaines.

Algorithme Python
Debut ch=input('donner une chaine')
Ecrire (‘Saisir une chaine: ’)
Lire(ch)
Pour i de 0 à long(ch) faire for c in ch :
Ecrire (‘caractere',ch[i]) print('caractere:',c)
Fin Pour
fin
 Série 5
Exercice1 ☺ Cocher 🗹 la bonne réponse.

x = int(input("x= ")) X=3 et y= 5

y= int (input("y= ")) Le programme affiche :
❶ s=1
for i in range(y+1) : ⬜
⬜ 18
s= s +x
print(s) ⬜ 1914
x = int(input("x= ")) X=3 et y= 5
y= int (input("y= ")) Le programme affiche :
s=0
❷ for i in range(x,y+1) : ⬜
⬜ 10
s= s +i
print(s) ⬜ 12
11

x=0
y=1 Le programme affiche :
❸ for i in range(1,5):
x=x+i ⬜
⬜ x= 20 y=25
y=y*i
print('x=',x,'y=',y) ⬜ x=x= 1010 y=24
y=40

Exercice2 :
☺ Soit le script Python suivant :

1. Exécuter le programme ci-dessus pour chacune des chaînes suivantes:

Chaine ch "bonjour" "2 Info2" "python" "informatique"

nv ……………………… ……………………… ……………………… …………………………
… …

2. Déduire le rôle de ce programme :

…………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
Exercice3
Ecrire un programme qui permet de saisir une chaine de caractère ch non vide puis afficher le
nombre d’occurrences d’un caractère donné dans ch.
Exercice4
Ecrire un algorithme et un programme python intitulé CAL_SOM permettant de calculer la somme
des chiffres d’un entier positif saisi au clavier.
 Robotique
Introduction :

Prise en main avec la carte ESP32

L’ESP32 développée par la société Espressif , est une carte microcontrôleur de développement à
faible coût dédié à l’internet des objets (IoT) et les applications embarquées et doté de
communications sans fil Wifi et Bluetooth.
Installation pilotes (Driver) ESP32
Après branchement de la carte au port usb, Windows détecte " CP2102 USB To UART Bridge
Controller".

Il faut télécharger le pilote au lien suivant:

 https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers

Liens direct drivers pour windows 10 :

https://www.silabs.com/documents/public/software/CP210x_Universal_Windows_Driver.zip

Décompresser le fichier CP210x_Windows_Drivers.zip puis exécuter le fichier correspondant à

votre architecture 32 bit ou 64 bit :CP210xVCPinstaller.exe

Suivre les étapes d'installation:

 Terminer l'installation

Laisser installer le pilote:

Installation du pilote terminé sur le COM7 dans notre cas:

Vous pouvez vérifier que le pilote est installé dans le gestionnaire de périphériques:

Installations logiciels pour ESP32

Installation Thonny IDE pour ESP32
Pour installer l'éditeur pour Python Thonny commencer par le télécharger au site
https://thonny.org/ 
Téléchargement Thonny IDE
1. Accédez à https://thonny.org
2. Téléchargez la version pour Windows et attendez quelques secondes pendant le
téléchargement.
3. Exécuter le fichier .exe

Suivez l'assistant d'installation pour terminer le processus d'installation. Il vous suffit de cliquer
sur "Suivant".
5. Une fois l'installation terminée, ouvrez Thonny IDE. Une fenêtre, comme illustré dans la figure
suivante, devrait s'ouvrir.

Flasher/Téléverser le firmwareMicropython à la carte ESP32

Pour téléverser le firmwareMicroPython à la carte ESP32 :
1. Ouvrir la page http://micropython.org/downloads  puis choisir la dernière version du
firmware pour ESP32

2. Brancher la carte à l'ordinateur puis démarrer le gestionnaire de périphériques pour voir sur
quel port COM est connectée la carte ESP32

3. Dans Thonny IDE ouvrir le menu "Outils" puis "Options" enfin choisir l'onglet "Interpréteur"
choisir l'interpréteur : Micropython (ESP32) et le port : Silicon Labs CP210x USB to UART Bridge
(ici COM4)

4. Choisir le port et le Firmware précédemment téléchargé puis cliquer sur Install.

5. Lors de l'apparition de la fenêtre suivante,maitenir le bouton de la carte ESP32
"BOOT/FLASH" appuyé jusqu'a démarrage du flashage.

6. Une fois EraseFlash commence relâcher le bouton "BOOT" , après quelques secondes le
firmware sera téléversé vers la carte ESP32.

Remarque : Si le message suivant s'affiche:

A fatal erroroccurred: Failed to connect to ESP32: Invalidhead of packet (0x08)
Process failed, return code: 2
cela veut dire que la carte ESP32 n'est pas dans le mode de flashage, pour la mettre dans ce
mode, refaire les étapes et maintenir le bouton "BOOT/FLASH" appuyé.

Après flashage de la carte ESP32 par le firmware de Micropython:

1. Brancher la carte ESP32 sur le port USB du PC puis exécuter Thonny
2. Ouvrir le menu "Outils" puis "Options" ensuite choisir l'onglet "Interpréteur" enfin définir
l'interpréteur "MicroPython (Esp32)" et le port correspondant finalement cliquer sur "Ok"

3. l'invite de commande >>> apparait et vous pouvez maintenant tapper des commande

Micropython

4. Redémarrer la carte par la commande

>>>import machine
>>>machine.reset()
ou en pressant le bouton "EN" Enable de la carte "ESP32"

5. Démarrage de la carte at affichage du firmware installé Micropython

LED clignotant utilisant Thonny sur la carte ESP32:

Faire clignoter le led incorporé dans la carte ESP32 avec une période de 0.5 seconde.(sachant que
le LED est branché sur le pin 2)
1. Commencer par créer un nouveau fichier: Fichier-> Nouveau ou Taper "Ctrl+N"
2. Saisir le code suivant :
code Micropython:
import time
from machine import Pin

led=Pin(2, Pin.OUT) #Définir le pin2 comme pin de sortie

whileTrue:
led.value(1) #allumer le LED
time.sleep(0.5)
led.value(0) #éteindre le LED
time.sleep(0.5)
Copier le code
3. Enregistrer le fichier: fichier -> enregistrer sous -> Save ou cliquer sur le bouton "Save"

4. Choisir "Cet ordinateur" ou "appareil MicroPython" pour enregistrer directement dans la

carte ESP32.

5. choisir le nom main puis cliquer sur le bouton "Ok"

Remarque : -Dans le dossier "appareil MicroPython", il y a par défaut "boot.py" qui se charge au
démarrage de la carte ESP32 et permet de définir les options de configuration.
-Il est recommandé d'écrire le code principal à exécuter dans un fichier "main.py" pour être exécuté
immédiatement après "boot.py"
Pour lancer le code il suffit de cliquer sur le bouton " Exécuter le script courant" (F5)
Remarques: Il faut arrêter l'exécution (Ctrl+F2) , avant de pouvoir enregistrer à nouveau sur la carte
ESP32.

Utilisation de Mu editor

On peut télécharger Mu editor version Alpha au lien suivant:lien
liens directs: Winows 32bit Winows 64bit
Une fois installé, il faut choisir le mode ESP MicroPython

Remarque : La carte ESP32 doit être flashée par le Micropython pour pouvoir l'utiliser avec Mu
editor.

Projet 1 :
Clignoter une diodes LED avec un délai de changement de 1 secondes 5 fois
Pièces nécessaires
Les composantes à utiliser :

Vous aurez besoin des pièces suivantes :

• Carte ESP32 :
• Câble micro USB
Pour que ton ordinateur puisse envoyer des instructions à ta carte microcontrôleur, tu vas devoir
les connecter avec un câble USB. Si tu souhaites envoyer une instruction comme « allumer la LED
» .
Connecte la carte à ton ordinateur en utilisant un câble USB.

• 4 x FILS male-male
• 3 fils male-femelle

•Led
Sont de petites lumières puissantes utilisées dans de nombreuses applications différentes.
Lorsque vous regardez la LED, vous remarquerez que ses jambes sont de longueurs différentes. La
longue jambe, l '«anode», est l'endroit où le courant entre dans la LED. Cette broche doit toujours
être connectée à la source actuelle. La jambe la plus courte, la «cathode», est la sortie du courant.
La jambe courte doit toujours être connectée à une voie d'accès à la terre GND.
Attention au sens d’installation, le méplat indique la cathode

• Résistance 220 ohms

une résistance de 220 Ω entre la LED et le GND à éviter un courant excessif qui
pourrait brûler la LED.
• La planche d’essai : Plaquette d’essai (breadboard), permet de réaliser des
montages électroniques sans soudure. Les connexions internes sont comme
ci-contre.
Les lignes verticales sont les rails d'alimentation. Ceux-ci fonctionnent de la
même manière des deux côtés de la planche à pain.
Nous utilisons normalement les bandes rouges pour l'alimentation (3.3 V sur la
esp32) et les bleues pour GND.
Les lignes horizontales, chaque groupe

La séquence est la suivante :

• Le feu s’allume pendant 1 secondes
• on attend une seconde
• Le feu s’eteint pendant 1 secondes,
• on attend une seconde
Cette séquence se répète 5 fois

Montage
le ESP32
d
 - GND
+ P23

Code :
from time import sleep
from machine import Pin # importer pin à partir du module machine
r=Pin(23, Pin.OUT) # Définir le pin 23 comme output(sortie)
for i in range(5): # boucle for pour repeter le traitement 5 fois
r.value(1)
sleep(1)# Allumer la LED rouge
r.value(0)
sleep(1)# Allumer la LED rouge

Projet 2 :
Réaliser un feu de circulation en utilisant 3 diodes LED de couleurs (rouge, vert, orange) et 3
résistances de 220 Ω , avec un délai de changement de 5 secondes , commandé par la carte esp32
Pièces nécessaires
Les composantes à utiliser :
La séquence est la suivante :
• Le feu vert s’allume pendant 3 secondes, puis
s’éteint,
• Le feu orange s’allume pendant 1 seconde puis
s’éteint et on recommence
• Le feu rouge s’allume pendant 3 secondes, puis
s’éteint,

Montage
led ESP32
GND/-GND
R P12
​O P14
V P27

Code :
from time import sleep
from machine import Pin # importer pin à partir du module machine
r=Pin(12, Pin.OUT) # Définir le pin 12 comme output(sortie)
j=Pin(14, Pin.OUT) # Définir le pin 14 comme output(sortie)
v=Pin(27, Pin.OUT) # Définir le pin 27 comme output(sortie)
while True: # boucle while , boucle infinie puisque condition toujours vrai ->True
r.value(1) # Allumer la LED rouge
j.value(0)
v.value(0)
sleep(5)
r.value(0) # Allumer la LED jaune
j.value(1)
v.value(0)
sleep(5)
r.value(0) # Allumer la LED vert
j.value(0)
v.value(1)
sleep(5)
r.value(0) # Allumer la LED jaune
j.value(1)
v.value(0)
sleep(5)
Projet 3 :
Dans ce projet on utilise le capteur tactile esp32 comme bouton-poussoir pour allumer et éteindre
Led d’un miroir de la salle de bain.

 La puce ESP32 fournit 9 capteurs tactiles (GPIO 2,4,15,12,13,14,27,32 et 33).

Ils peuvent ainsi détecter les variations induites lors du contact du GPIO avec le doigt.
Ces capteurs tactiles sont du type capacitif. Ces capteurs tactiles sont partagés avec les broches
GPIO d'ESP32. Le capteur capacitif peut détecter les changements électriques sur les broches
GPIO respectives. 
Par exemple, si vous touchez l'une de ces broches, la broche GPIO produira une sortie en fonction
de la charge électrique de votre doigt. 
Parce que le corps humain détient également une charge électrique. Par conséquent, ces capteurs
tactiles sont également appelés capteurs capacitifs.

Pièces nécessaires
Vous aurez besoin des pièces suivantes :
• Carte ESP32
• Câble micro USB
• 1 x fil cavalier
Montage

Code
from machine import Pin,TouchPad
from time import sleep
touch0 = TouchPad(Pin(4))
led=Pin(23,Pin.OUT)
seuil=100 #configurer le seuil pour lequel le pin est considéré comme touché

while True:
if touch0.read()<seuil: # vérifier si la valeur sur le touchpin< seuil
led.on() # Allumer la lampe LED
else:
led.off() # Eteindre la lampe LED