L ' e sse nt i e l d u l a ng a g e P y t ho n p o u r l e s é l è v e s d e l a se ct i o n S I e t se ct i o n s sc i e nt i f i q ue s

L'essentiel du langage Python

(Pour les élèves de la 4ème SI et 4ème sections scientifiques)
1. Les bibliothèques utilisées
Au début d'un programme Python nous devons importer les bibliothèques (ou modules)
correspondantes aux fonctions et méthodes que nous allons utiliser dans notre implémentation.
 from math import* # contient toutes les fonctions mathématiques et constantes tel que
'cos', 'sin', 'sqrt', 'pi', 'pow', 'trunc', 'fabs', …
 from random import* # utilisée pour importer les fonctions aléatoires tel que 'random',
'randint', 'randrange', 'uniform', …
 from numpy import* # contient toutes les fonctions et méthodes permettant de manipuler
les tableaux (array en Python).
 from pickle import* # contient toutes les fonctions et méthodes permettant de manipuler
les fichiers.
NB : Si nous utilisons une fonction ou méthode sans avoir importé à l' avance la bibliothèque
correspondante nous aurons un message d'erreur.
Exemple :

Si nous écrivons print (pi), nous

aurons le message d'erreur suivant :

Pour corriger ce problème nous devons importer la bibliothèque math en ajoutant la ligne de
commande from math import pi (importer seulement pi) ou from math import* (importer tout le
contenu de la bibliothèque math)

2. L'affichage en Python
Pour afficher un message, une variable ou le résultat d'une expression nous utiliserons la fonction
print (argument1, argument2, …)
Affichage simple :

Par défaut, print permet d'afficher puis de

retourner à la ligne. Si nous ajoutons l'argument
end = "c" (avec c un caractère ou une chaîne de
caractères), print affiche "c" après les arguments
mentionnés.
Si nous voulons afficher et rester sur la même
ligne pour l'affichage suivant, nous devons donner
la valeur chaîne vide à "c", ce qui revient à écrire
end="" (2 guillemets) ou end='' (2 apostrophes)

M o e z B e l ha j / L y c é e Ib n R a c hi k - E z z a hr a / N o v e m b r e 2 0 21 1
L ' e sse nt i e l d u l a ng a g e P y t ho n p o u r l e s é l è v e s d e l a se ct i o n S I e t se ct i o n s sc i e nt i f i q ue s
Affichage formaté :
L'affichage formaté est un mécanisme permettant d'afficher des variables avec un certain format, par
exemple justifiées à gauche ou à droite, ou encore avec un certain nombre de décimales pour les réels
(float). Python utilise les f-strings (formatted string literals) pour mettre en place l'écriture formatée.

Le caractère f avant les guillemets va indiquer à Python qu'il s'agit d'une f-string permettant de mettre
en place le mécanisme de l'écriture formatée, contrairement à un affichage normal.
Dans une écriture f-string le message à afficher entre guillemets doit être précédé de f, les variables à
afficher dans le message doivent être mises entre accolades {}, on peut ajouter les détails du formatage
après le nom de la variable entre les accolades.
Exemples :
 {nom}, {a}, {b}  affichage normal des variables entre accolades
 {nom:20}  afficher la variable nom sur 20 positions avec un alignement à gauche
 {a:5d} ou {a:5} afficher la variable a au format entier sur 5 positions ( 80)
 {a:10f}  afficher la variable a (sachant que la variable a contient un entier) au format réel
sur 10 positions (80.000000)
 {a:10.3f}  afficher la variable a (sachant que la variable a contient un entier) au format réel
sur 10 positions avec 3 chiffres après la virgule ( 80.000)
 {b:10.2f}  afficher la variable b au format réel sur 10 positions avec 2 chiffres après la
virgule ( 175.25)
NB : le f-string n'est pas le seul moyen pour le formatage de l'affichage, Python admet d'autres
techniques pour l'affichage formaté.
3. La saisie en Python
L'action de saisie en Python se fait grâce à la fonction input.
Syntaxe : nom_variable = input ("message")
Exemple :
 x = input ("Saisir un nombre : ")  permet d'afficher le message entre guillemets, saisir une
valeur au clavier puis l'affecter à la variable x. la valeur saisie est considérée par défaut au
format string (chaîne de caractères)
 pour saisir un entier, il faut faire une conversion de type (appelée transtypage) en ajoutant la
fonction int () avant input  a = int (input ("Saisir un nombre : "))
 pour saisir un réel, il faut ajouter la fonction float () avant input, ce qui veut dire que la valeur
numérique entrée au clavier est convertit en une valeur de type réel
 b = float ((input ("Saisir un nombre : "))

M o e z B e l ha j / L y c é e Ib n R a c hi k - E z z a hr a / N o v e m b r e 2 0 21 2
L ' e sse nt i e l d u l a ng a g e P y t ho n p o u r l e s é l è v e s d e l a se ct i o n S I e t se ct i o n s sc i e nt i f i q ue s
4. Les opérateurs
Nous ne donnerons ici que les opérateurs autorisés par le programme officiel.
En algorithme En python
+, -, *, /, div, mod +, -, *, /, //, %
non, et, ou not, and (ou bien &), or (ou bien |)
>, ≥, <, ≤, =, ≠ >, >=, <, <=, ==, !=
∈ (entier ou caractère) in
Exemple : Exemple :
si x ∈ ['A','Z'] alors if x in ['A','Z'] :
si x ∈ ['A'. .'Z'] alors if 'A' <= x <= 'Z' :
on peut aussi écrire (if x in range (ord ('A'), ord ('Z') + 1) : )
si n ∈ [10 . . 99] alors if 10<= n <=99 :
on peut aussi écrire (if n in range(10,100) : )

5. Les fonctions prédéfinies

Aussi dans ce paragraphe, nous ne donnerons que les opérateurs autorisés par le programme officiel
(Voir les conventions algorithmiques – septembre 2021).

En algorithme En python
round(x)
Arrondi (x)
NB : round (x.50) donne l’entier pair le plus proche de x
RacineCarré (x) sqrt (x)
Ent (x) int (x)
Abs(x) abs(x)
Aléa (vi, vf) randint (vi, vf)
Chr(x) chr (x)
Ord(c) ord (c)
Long (ch) len (ch)
Pos (ch1, ch2) ch2.find (ch1)
Convch(x) str (x)
Estnum (ch) ch.isdecimal () ou ch.isdigit () ou ch.isnumeric ()
int (ch) pour la conversion en un entier
Valeur (ch)
float (ch) pour la conversion en un réel

Sous_chaine (ch, d, f) #f exclu ch [d : f]

Effacer (ch, d, f) #f exclu ch [: d] + ch [f :]

Majus (ch) ch.upper ()

NB : il faut faire attention aux caractères majuscules et minuscules en effet Python est sensible à la
casse, ce qui signifie que Abs n'est pas la fonction abs et que les variables TesT, test ou TEST sont
différentes.

M o e z B e l ha j / L y c é e Ib n R a c hi k - E z z a hr a / N o v e m b r e 2 0 21 3
L ' e sse nt i e l d u l a ng a g e P y t ho n p o u r l e s é l è v e s d e l a se ct i o n S I e t se ct i o n s sc i e nt i f i q ue s
6. Les structures de données (enregistrements, tableaux et matrices)

En algorithme En python
La structure enregistrement. La structure enregistrement est implémentée en
Exemple utilisant la structure dictionnaire.
Eleve = Enregistrement Exemple :
mat : chaine Eleve = {'mat' : str, 'np' : str, 'moy' :float}
np : chaine [30]
moy : réel e = {} déclare une variable de type dictionnaire vide
Fin
Les vecteurs (tableaux à une dimension) On doit importer la bibliothèque numpy
T = tableau de 30 entiers T= array ([int]*30)
T = tableau de 30 chaines T= array ([str]*30)
T = tableau de 30 Eleve T= array ([Eleve]*30) ou T= array ([{}]*30)

Les matrices (tableaux à 2 dimensions) On doit importer la bibliothèque numpy

M = tableau de 10 lignes*20 colonnes de réels M = array ([[float]*20]*10)

 Un champ dans une variable enregistrement (dictionnaire) x est manipulé en Python comme suit :
 Lors de la saisie : x ['champ'] = input ()
Exemple : e ['mat'] = input ("saisir le matricule de l'élève")
 Lors de l'affichage : Print (x ['champ'])
Exemple : print ("le matricule de l'élève est ", e ['mat'])
 Lors de l'affectation : x ['champ'] = valeur
Exemple : e ['mat'] = 'A125478'
 Les tableaux et les matrices sont manipulées en Python de la même manière qu'en algorithmique

7. Les structures de contrôle conditionnelles

 Structure simple :
Exemple :
n = float (input ("Saisir un nombre : "))
if Condition : if n > 0 :
Traitement 1 print ("Le nombre choisi est positif")
print ("Fin du programme")

 Structure complète : Exemple :

n = float (input ("Saisir un nombre : "))
if Condition : if n > 0 :
Traitement 1 print ("Le nombre choisi est positif")
else : else :
Traitement 2 print ("Le nombre choisi est négatif")
# Suite du programme sans indentation print ("Fin du programme")

M o e z B e l ha j / L y c é e Ib n R a c hi k - E z z a hr a / N o v e m b r e 2 0 21 4
L ' e sse nt i e l d u l a ng a g e P y t ho n p o u r l e s é l è v e s d e l a se ct i o n S I e t se ct i o n s sc i e nt i f i q ue s
 Structure généralisée :
if Condition 1 :
Traitement 1
elif Condition 2 :
Traitement 2
elif Condition 3 :
Traitement 3
elif ….. :
……………..
……………..
else :
Autre traitement
# Suite du programme sans indentation

 La structure de contrôle conditionnelle à choix multiples :

En algorithmique :
Selon <Sélecteur>
Valeur1 : Instruction1
Valeur2, Valeur3 : Instruction2
Valeur4 .. Valeur5 : Instruction3
……………………………………………..
……………………………………………..
[Sinon Instruction_ n]
Fin Selon
En Python : Pour utiliser cette structure il faut installer Python 3.10
match x :
case Valeur1 : Instruction1
case Valeur2 | valeur3 : Instruction2
case x if valeur4 <= x <= valeur5 : Instruction3
case _ : Instruction_ n
NB : Si vous n'avez pas encore le Python 3.10, vous pouvez toujours utiliser la structure de contrôle
conditionnelle généralisée.
8. Les structures de contrôle itératives
 La structure de contrôle itérative complète
Exemple 1:
for variable in range (n) :
for i in range (10) :
Traitement
print (i)
# Fin de la boucle
# Affichage des valeurs de 0 à 9
# Le traitement est répété n fois de la
valeur 0 à la valeur (n-1)
Exemple 3:
for i in range (1, 10, 3) :
Exemple 2: print (i)
for i in range (1,10) : # Affichage des valeurs de 1 à 9 par pas de 3,
print (i) c’est-à-dire on aura l'affichage suivant :
# Affichage des valeurs de 1 à 9 1
4
7

M o e z B e l ha j / L y c é e Ib n R a c hi k - E z z a hr a / N o v e m b r e 2 0 21 5
L ' e sse nt i e l d u l a ng a g e P y t ho n p o u r l e s é l è v e s d e l a se ct i o n S I e t se ct i o n s sc i e nt i f i q ue s
Remarque :
1. Pour implémenter la boucle pour avec un compteur de type caractères, nous pourrons utiliser
la structure suivante : (Pour i de 'A' à 'Z' Faire)
for i in range (ord ('A'), ord ('Z') + 1) :
# Traitement

 La structure de contrôle itérative à condition d'arrêt Tant Que

while condition :
Traitement
# Fin de la boucle
 La structure de contrôle itérative à condition d'arrêt Répéter … jusqu’à
Cette structure n'existe pas en Python, mais on peut l'implémenter de la manière suivante :

# Initialisation de la condition d'arrêt

While not condition :
Traitement
# il ne faut pas oublier de modifier
# la condition d'arrêt dans le traitement
# Fin de la boucle
Exemple :
n = int (input ("Saisir un nombre : "))
Répéter Est implémenté en while n <=10 :
Lire (x) Python comme suit : n = int (input ("Saisir un nombre : "))
Jusqu’à x >10

9. Les fichiers binaires (typés)

En algorithme En python
Ouvrir ("nom_fichier", Nom_Logique, "mode ") Nom_Logique= open ("nom_fichier", "mode ")
Mode : "rb " : Lecture Mode : "rb" : Lecture
"wb" : Ecriture (création) "wb" : Ecriture (création)
"ab" : Ajout "ab" : Ajout
Lire (Nom_Logique, Var) var= load (Nom_Logique)

Ecrire (Nom_Logique, Var) dump (Var, Nom_Logique)

Fermer(Nom_Logique) Nom_Logique.close ()
Parcourir un fichier binaire :
Fin=False
while Fin == False :
try :
Fin_fichier (Nom_Logique)
traitement
except :
Fin = True

NB : Si le fichier est ouvert en mode ajout ("ab") et qu'il n'existe pas physiquement, alors il sera créé

M o e z B e l ha j / L y c é e Ib n R a c hi k - E z z a hr a / N o v e m b r e 2 0 21 6
L ' e sse nt i e l d u l a ng a g e P y t ho n p o u r l e s é l è v e s d e l a se ct i o n S I e t se ct i o n s sc i e nt i f i q ue s
10. Les fichiers texte
En algorithme En python
Ouvrir ("nom_fichier", Nom_Logique, "mode ") Nom_Logique= open ("nom_fichier", "mode ")
Mode : "r " : Lecture Mode : "r" : Lecture
"w" : Ecriture (création) "w" : Ecriture (création)
"a" : Ajout "a" : Ajout
Lire (Nom_Logique, ch) Nom_Logique.read ()

Lire_ligne (Nom_Logique, ch) Nom_Logique.readline ()

Ecrire (Nom_Logique, ch) Nom_Logique.write (ch)

Ecrire_nl (Nom_Logique, ch) Nom_Logique.write (ch + "\n")

Parcourir un fichier texte :
ch=F.readline ()
while ch != ''" : # ch diffèrent de chaîne vide
Fin_fichier (Nom_Logique) ch = ch [:-1]
traitement
ch = F.readline ()

11. Les modules

 Les fonctions :
En algorithmique :
Fonction Nom_fonction (pf1: type1, pf2: type2, …, pfn : typen) : Type_résultat
DEBUT
Traitement
Retourner Résultat
FIN
En Python :
def Nom_fonction (pf1, pf2, …) :
Instruction(s)
return Résultat
 Les procédures :
En algorithmique :
Procédure Nom_procédure (pf1: type1, pf2: type2, …, @pf3: type3, @pf4: type4, …)
DEBUT
Traitement
FIN
Si le mode de passage est par référence (par adresse), on ajoutera le symbole @ avant le nom
du paramètre.
En Python :
def Nom_ procédure (pf1, pf2, …) :
Instruction(s)
return pf3, pf4
NB : en Python, Tout objet de type composé (tableau, matrice, enregistrement, fichier) hérite
automatiquement les modifications subies dans le corps du module appelé (par défaut le mode de
passage est par référence).

M o e z B e l ha j / L y c é e Ib n R a c hi k - E z z a hr a / N o v e m b r e 2 0 21 7
L ' e sse nt i e l d u l a ng a g e P y t ho n p o u r l e s é l è v e s d e l a se ct i o n S I e t se ct i o n s sc i e nt i f i q ue s
12. Compléments
12.1 Variable globale, variable locale
 Le même nom mais deux variables différentes :
a = 15 #variable globale
def plusUn():
a = 0 #variable locale (à la fonction)
a=a+1
print(a)
plusUn() #affiche 1
print(a) #affiche 15

 Programme qui ne fonctionne pas :

a = 15 #variable globale
def plusUn():
a=a+1 #Erreur car a n’est pas initialisée
print(a)
plusUn()
print(a)

 Utilisation d’une variable globale dans une procédure

a = 15 #variable globale
def plusUn():
global a #on utilise la variable globale a
a=a+1
print(a) #affichage 16
plusUn() #appel de la fonction, affichage 16
print(a) #affichage : 16
#la nouvelle valeur de a

12.2 Plus sur les chaînes de caractères en Python

Une chaîne est toujours déclarée entre 2 guillemets ou 2 apostrophes.
Le premier caractère d'une chaîne commence toujours par l'indice 0.
On peut accéder à un caractère dans une chaîne, en écrivant son indice entre 2 crochets.

On ne peut pas modifier le contenu d'une chaîne une fois initialisée

M o e z B e l ha j / L y c é e Ib n R a c hi k - E z z a hr a / N o v e m b r e 2 0 21 8
L ' e sse nt i e l d u l a ng a g e P y t ho n p o u r l e s é l è v e s d e l a se ct i o n S I e t se ct i o n s sc i e nt i f i q ue s

On peut extraire une partie d'une chaîne ch, en

écrivant : ch [ind_debut : ind_fin]
NB : Le caractère ch [ind_fin] est exclu de
l'extraction.

ch[-1] représente le dernier caractère de la chaîne ch

ch[::-1] permet d'inverser une chaîne

ch[9:2:-1] permet d'extraire une sous chaîne allant

du caractère d'indice 9 au caractère d'indice 1 (en
ordre inverse)

Il existe certains caractères spéciaux

comme \n (pour le retour à la ligne). Le
caractère \t (produit une tabulation). Si on veut
écrire des guillemets simples ou doubles et que
ceux-ci ne soient pas confondus avec les guillemets
de déclaration de la chaîne de caractères, on peut
utiliser \' ou \". (Ces caractères spéciaux sont
utilisés uniquement avec la fonction print)

Quand on souhaite écrire un texte sur plusieurs

lignes, il est très commode d'utiliser les guillemets
triples qui conservent le formatage (notamment les
retours à la ligne)

M o e z B e l ha j / L y c é e Ib n R a c hi k - E z z a hr a / N o v e m b r e 2 0 21 9