Cours Essentiel de Programmation Python
Cours Essentiel de Programmation Python
FORMATION PYTHON
Pour
1 L'essentiel du cours les
lycé
2 Exercices Algorithme ens
3 Exercices Python
4 Astuces et Remarques
Centre Formakt_Bac
Contact:
+216-55-530-162
[Link]@[Link]
1
Python est un langage de programmation. Il est l’un des langages de programmation les
plus intéressants du moment. Python est souvent utilisé en exemple lors de l’apprentissage de
la programmation.
Python est un langage de programmation interprété, c’est-à-dire qu’il n’est pas nécessaire de
le compiler avant de l’exécuter. Si vous avez touché un peu la programmation, vous verrez
que ce langage possède une certaine poésie. Les programmeurs s’amusent souvent à trouver
la manière la plus jolie/efficace d’écrire une suite d’instruction. Rares sont ceux qui critiquent
ac
la logique Python contrairement à JavaScript par exemple.
16 _b
Que fait Python ?
kt
Python est à la fois simple et puissant, il vous permet d’écrire des scripts très simples mais
53 ma
2
grâce à ses nombreuses bibliothèques, vous pouvez travailler sur des projets plus
ambitieux.
55 or
*Web : Aujourd’hui Python combiné avec le framework Django est un très bon choix
0
:F
*Système : Python est également souvent utilisé par les admins système pour créer des
tâches dites répétitives ou simplement de maintenance. D’ailleurs si vous voulez créer des
nt bo
langages ?
ge
Python est un langage facile à apprendre et son code est plus lisible, il est donc plus facile à
Pa
maintenir. Il est parfois jusqu’à 5 fois plus concises que langage Java par exemple, ce qui
augmente la productivité du développeur et réduit mécaniquement le nombre de bugs.
Python est également utilisé dans les milieux scientifiques, par exemple la bioinformatique.
Des librairies sont disponibles pour ce domaine comme le module biopython.
Il existe également des bibliothèques facilitant la création de jeux vidéo ebn2D et 3D,
exemple pyGame.
ac
ou faux)
list : Les tableaux
16 _b
Structure de contrôle conditionnelle :
kt
Si Cond alors Résultat
53 ma
Structure de contrôle itérative
2
On va voir ensemble les boucles : Pour, Tant que et répéter et découvrir la différence entre
55 or
eux.
0
:F
Les sous-programmes :
Les modules : Fonction et procédure
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
Algorithme Python
Exemples :
Ecrire(‘python’)
ac
print (’’ python ’’) le programme donne : python
16 _b
Pour renvoier deux messages écrits avec des commandes print() distinctes sur la même ligne,
on utilise le syntaxe suivant :
kt
print (’’ formation ’’, end = ’’)
53 ma
print (’’ python ’’)
2
Dans ce cas le programme donne formationpython
55 or
2. Affectation :
0
:F
Si on veut créer une variable x de type entier et on veut lui donner la valeur 2, on utilise les
syntaxes donnés par le tableau suivant :
ac ok
nt bo
Algorithme Python
t:
Co ce
x2 x=2
Fa
Cette opération est dite affectation : C’est-à-dire mettre la valeur 2 dans la variable x (on dit
x reçoit 2 ou x prend la valeur 2).
Pa
Pour afficher un message, il faut l’écrire entre deux côtes ‘’, en informatique il y’a
différence d’écrire : Ecrire(x) et Ecrire (‘x’) ainsi que print(x) et print(‘x’)
Dans le premier cas (sans apostrophes) signifie qu’on veut afficher le contenu de la
variable x donc le programme affiche 2 alors que avec les deux apostrophes le
programme affichera la lettre x tel qu’elle est écrite.
3. Saisie de donnée :
Pour donner l’accès à l’utilisateur de saisir des donnés par le clavier, on doit utiliser les
instructions suivantes :
Algorithme Python
lire(a) a=input()
Exemples :
ac
Algorithme Python
16 _b
Ecrire (‘Donner ton prénom’) print(‘Donner ton prénom’)
kt
lire(p) p=input()
53 ma
2
Python nous a permis de diminuer le nombre des lignes et de combiner l’affichage du
55 or
message avec le saisi du donné.
Et donc ça sera : p=input (‘Donner ton prénom’)
0
:F
print(’’Donner un entier’’)
n = input ()
ac ok
nt bo
t:
Co ce
Exercice :
Fa
Avec une division euclidienne sur 10, le nombre d’unités présente le reste de
la division alors que le nombre de dizaine présente le quotient
ac
Pour obtenir le reste et le quotient en informatique, on utilise les commandes
suivantes :
16 _b
kt
Algorithme Python
53 ma
2
Quotient : x div 10 55 or x // 10
Reste : x mod 10 x % 10
0
:F
Correction de l’exercice
ac ok
nt bo
Algorithme :
t:
Debut Chiffres2
Co ce
Lire (n)
u n mod 10
ge
d n div 10
Pa
s u+d
Ecrire (s)
Fin Chiffres2
Python
Mais pourquoi nous avons écrire int avant la commande input() ???
ac
C’est parce que la fonction input retourne par défaut une chaine de caractères
Donc, on doit convertir la valeur saisie en type entier pour qu’on puisse
16 _b
appliquer par la suite les opérations nécessaires (la somme et la division)
kt
Voir cet exemple
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
ge
Le programme affiche un message d’erreur : car on ne peut pas sommer une chaine de caractère à un
entier.
Pa
Exemple : a 18
ac
16 _b
kt
53 ma
2
55 or
0
:F
Exercice :
ac ok
Nous utiliserons le même principe que l’exercice précèdent mais avec une division
euclidienne sur 100 au lieu de 10.
ge
Pa
Correction de l’exercice
Algorithme :
Début Somme_chiffres
Lire (n)
c n div 100
u n mod 10
sc+d+u
ac
Ecrire (‘’La somme des chiffres’’, c, ‘‘,’’, d, ’’et’’, u, ‘’est’’, s)
16 _b
Fin Somme_chiffres
kt
Python:
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
ac
Arrondi(x) round(x) Donne l’entier le x = 2.5 donne 2
16 _b
plus proche du réel x x = 2.51 donne 3
pow(x,y) pow(x,y) Donne x puissance y pow (2,3) 8
kt
Aléa (x,y) randint(x,y) Donne un entier from random
53 ma
aléatoire entre x et y import*
2
x = randint (0,10)
55 or
donne un entier
0
entre 0 et 10
:F
x = uniform (0,10)
donne un réel
nt bo
entre 0 et 10
t:
Co ce
Fa
ge
Pa
1. Forme simple
Algorithme Python
Si Condition alors Résultat if Condition :
Fin Si Résultat
ac
Exercice :
16 _b
Ecrire un programme qui permet de faire calculer la racine carrée d’un réel x
kt
Correction de l’exercice
53 ma
2
Algorithme : 55 or
Début racine
Ecrire (''Donner un réel '')
0
:F
Lire(x)
Si x ≥ 0 alors écrire(''La racine carrée est ='' , racine_carrée(x) )
ac ok
Fin Si
Fin racine
nt bo
TDO
t:
Co ce
Python :
ge
Pa
sqrt est une fonction prédéfinie dans python qui nous a permis de calculer la
racine carrée d’un réel.
ac
16 _b
kt
53 ma
2
55 or
Lorsque vous appuyez sur Entrée après les deux points, vous remarquerez que
le curseur se déplace vers la droite. Cet espace est appelé indentation, tant que
0
:F
Exercice :
ge
Ecrire un programme qui permet de vérifier la parité d’un entier (en utilisant la forme simple)
Correction de l’exercice
Pa
Algorithme :
Début parité
Ecrire (''Donner un entier '')
Lire(n)
Si x mod2 = 0 alors Ecrire(n,’est pair’ )
Fin Si
Si x mod 2 0 alors Ecrire(n,’est impair’)
Fin Si
Fin parite
TDO
Objet Type/Nature Rôle
n Entier Donné
Python :
ac
Les symboles de comparaison :
16 _b
Algorithme Python
=
kt
= ==
>=
53 ma
2
<=
!=
55 or
0
:F
2ème méthode de correction
ac ok
Début parité
Ecrire(''Donner un entier '')
nt bo
Lire (n)
t:
Co ce
message ← ''Pair''
Si n mod 2 ≠ 0 alors
Fa
message ← ''impair''
ge
FinSi
Ecrire(n, " est ",message)
Pa
Fin parité
TDO
Objet Type/Nature Rôle
n Entier Donné
message Chaine de message qui contient
caractères l’information sur la
parité de n
Python :
2. Forme alternative
Algorithme Python
Si Condition alors Résultat 1 if Condition :
Sinon Résultat 2 Résultat1
Fin Si else :
Résultat 2
ac
16 _b
Exemple
kt
Si x >= 0 alors écrire(‘’Positif’’)
53 ma
Sinon écrire (‘’négatif’’)
2
Sin Si
55 or
0
:F
Exercice :
Ecrire un programme qui permet de vérifier la parité d’un entier (en utilisant la forme
ac ok
alternative)
nt bo
Correction de l’exercice
t:
Co ce
Algorithme :
Fa
Début parité
Ecrire (''Donner un entier '')
ge
Lire(n)
Si x mod2 = 0 alors Ecrire(n,’est pair’ )
Pa
TDO
Objet Type/Nature Rôle
n Entier Donné
Python :
3. Forme généralisée
Algorithme Python
Si Condition alors Résultat 1 if Condition :
Sinon si Condition 2 alors Résultat 2 Résultat1
Sinon Si Condition 3 alors Résultat 3 elif condition 2 :
. Résultat 2
. elif condition 3 :
. Résultat 3
ac
Sinon si Condition n-1 alors Résultat n-1 .
Sinon Résultat n .
16 _b
Fin Si .
elif condition n-1 :
kt
Résultat n-1
else :
53 ma
2
55 or Résultat n
0
:F
On n’écrit jamais une condition avec sinon (else)
ac ok
Exercice :
nt bo
Ecrire un programme qui permet de saisir une moyenne (moy) puis affiche la décision
correspondante :
t:
Co ce
CONTROLE si 9moy<10
REDOUBLE si moy < 9
ge
Pa
Correction de l’exercice
Algorithme :
Début décision
Écrire(''Donner une moyenne'')
Lire(moy)
Si moy>=10 alors message ← ''ADMIS''
Sinon Si moy>=9 alors message ← ''CONTROLE''
TDO
Objet Type/Nature Rôle
moy Réel Donné
message Chaine de Message qui contient
caractères la décision
Python :
ac
16 _b
kt
53 ma
2
55 or
Exercice :
0
:F
Ecrire un programme qui permet de saisir un entier n contenant 3 chiffres puis affiche si le
nombre est cubique ou non.
ac ok
Un nombre est dit cubique s’il est égal à la somme des cubes de ses chiffres.
Exemple 153est cubique puisque 13+53+33 = 153
nt bo
t:
Co ce
Correction de l’exercice
Fa
Algorithme :
Début cubique
ge
c n div 100
d (n div 100) mod 10
u n mod 10
s c3 + d3 + u3
Si s=n alors Ecrire (n, ‘Cubique ‘)
Sinon Ecrire(n, ‘ n est pas cubique’)
Fin Si
Fin cubique
TDO
Objet Type/Nature Rôle
n Entier Donné
c Entier le nombre de
centaine de n
d Entier le nombre de dizaine
de n
u Entier le nombre d’unités
de n
s Entier la somme des cubes
des chiffres de n
Python :
ac
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
Chaque caractère a un code ASCII (American Standard Code for Information Interchange)
’A’ 65 ’a’ 97
’A’ < ’a’, car le code ASCII de ’A’ est inférieur au code ASCII de ’a’
ac
ch = '''python '''
16 _b
ch=''python''
kt
ch = '' '' ''python '' '' ''
53 ma
2
ch = ' ' ou ch = str () chaîne vide 55 or
ch [1] donne ‘ y ’
0
:F
L’outil ch[i] tel que les i sont indices des caractères numérotés de 0 à long (ch) – 1, nous
permet d’accéder en mode lecture à chaque caractère de la chaine
ac ok
Ch[id : if ]
Fa
id : indice de début
if : indice de fin – 1
ge
ch = ’python’
Pa
ch[-2 :] donne ’ on ’
4. Concaténation et multiplication
’ formation ’+’ python ’ donne ’ formationpython ’
Ch = ’ a ’ * 5 donne ch = ’aaaaa’
5. Les méthodes
ord(x) Code ASCII du caractère x Ord (’A’) donne 65
Ord (’a’) donne 97
chr(x) Caractère dont le code ASCII est x Chr(65) ’A’
Chr(97) ’a’
len (ch) Taille de la chaîne Len (’python’) donne 6
int (ch) Convertir une chaîne en un nombre entier Int(’120’) donne 120
float(ch) Convertir une chaîne en un nombre réel int(’12.50’) donne 12.50
Str (objet) Convertir l’objet en une chaîne Str (120) donne ’120’
Str (12.50) donne ’12.50’
ac
max (ch) Caractère ayant le code ASCII le plus max (’python’) donne ’y’
min (ch) élevé ou le plus faible
16 _b
[Link]() Convertir ch en majuscule ’python’.upper() donne ’PYTHON’
[Link]() Convertir ch en miniscule ’PYTHON’.lower() donne ’python’
kt
[Link]() Convertir le 1er caractère de ch en ’python’.capitalize() donne ’Python’
majuscule
53 ma
Convertir le 1er caractère de chaque mot ’formation python’.title() donne ’Formation
2
[Link]()
de ch en majuscule Python’
55 or
[Link](n,ch) Centrer ch dans une chaîne de n caractère ’python’.center(10,’*’) donne ’ **python**
car ’
0
:F
[Link](ch1 Remplace tous le n occurrence de ch1 par ’informatique’.replace(’i’,’I’) donne
,ch2,n) ch2 dans la chaîne ch ’InformatIque’
’informatique’.replace(’i’,’I’,1) donne
ac ok
’Informatique’
[Link](ch1,d,f) Compter le nombre d’occurrence de ch1 ’informatique’.count(’i’) donne 2
nt bo
[Link](ch1,d,f) Retourne la 1ère position de ch1 dans une ’informatique’.find (’i’) donne 0
portion de caractère de ch ’informatique’.find (’i’,1,10) donne 8
Fa
ac
Ch= ’2info2’
16 _b
n = valeur (ch)
n = erreur
kt
Sous_chaîne (ch,id,if) Ch [id :if] Retourne une partie de la ch = 'informatique'
53 ma
id : indice de début chaîne ch à partir de la ch2 = ch[2:5]
2
if : indice de fin -1 position id jusqu’à la position print(ch2)
if -1 le programme affiche :
55 or
for
0
ch = 'informatique'
:F
Effacer (ch, d, f) Efface des caractères de la
chaîne ch à partir de la ch2 = ch[:4] + ch[7:]
Ch[:d]+ch[f :]
position d jusqu’à la position print (ch2)
ac ok
Exercice
Fa
Ecrire un programme qui permet de saisir une adresse mail de la façon suivante :
pré[Link]@[Link] puis affiche chaque partie seule.
ge
Exemple : [Link]@[Link]
Pa
Prénom : formakt
Nom : bac
Serveur : gmail
Extension : com
ac
Le programme doit être exécutable pour n’importe quelle personne.
16 _b
kt
L’idée est d’utiliser les positions du caractère « . » et « @ », c’est claire que quel que
53 ma
2
soit le prénom de l’utilisateur de notre programme commence dès le début de l’e-
mail jusqu’à la position du caractère « . »
55 or
Correction de l’exercice
0
:F
Algorithme :
ac ok
Début email
nt bo
Écrire(''Donner un email'')
Lire(ch)
t:
prenom sous_chaine(ch,0,pos(‘.’,ch))
Co ce
Ecrire(‘Prénom :’,prenom)
nom sous_chaine(ch,pos(‘.’,ch)+1,pos(‘@’,ch))
Fa
Ecrire(‘Nom :’,nom)
Effacer (ch, 0, pos(‘@’,ch)+1)
ge
TDO
Objet Type/Nature Rôle
ch chaine de caractères Donnée
prenom chaine de caractères sous chaine de l’e-mail qui contient le
prénom
Python :
ac
16 _b
kt
53 ma
2
55 or
0
:F
Exercice :
ac ok
Ecrire un programme qui permet de saisir un entier n contenant minimum 4 chiffres et qui
nt bo
L’entier n est composé au minimum de 4 chiffres, c’est-à-dire il peut être composé de 4 chiffres
exactement ou de plus que 4 chiffres. Donc le programme doit être exécutable pour tous les cas.
En plus la variable s est de type str, ainsi que la variable p va poser un problème de syntaxe puisque
on ne peut pas multiplier un caractère par un autre caractère.
Correction de l’exercice
Algorithme :
Début magique
Écrire(''Donner un entier'')
Lire(n)
ch convch(n)
s valeur(ch[0])+valeur(ch[1])
p valeur (ch[long(ch)-2])* valeur(ch[long(ch)-1])
si p=s alors Ecrire(n, ‘est magique’)
ac
sinon Ecrire (n, ‘est non magique’)
Fin Si
16 _b
Fin magique
kt
TDO
53 ma
Objet Type/Nature Rôle
2
n Entier Donné
ch Chaine de
55 or
caractères
0
:F
Python :
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
Algorithme Python
Pour i de 0 à n-1 faire for i in range (n) :
Traitement à répéter Traitement à répéter
Fin Pour
ac
Exemple
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
Remarque
nt bo
E
t:
Co ce
Fa
Si vous tapez sur entrée après les deux points, le curseur se déplace vers la droite, tant que
nous gardons cet espace, les instructions seront répétées.
Pa
Notion du compteur
ac
Cette notion du compteur sera très utile pour parcourir une chaine de caractères (caractère par
16 _b
caractère).
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
Dans le cas d’une chaine donnée par l’utilisateur qu’on le ne sait pas d’avance, on utilise ce
code pour parcourir la chaine.
Exercice :
Ecrire un programme qui permet de calculer la somme de 5 entiers donnés.
ac
Etape n°1 :
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
Etape n°2 :
ge
Pa
L’étape de calcul de la somme est répété 5 fois, à chaque fois on met à jour la valeur de la
somme après chaque entier ajouté par l’utilisateur
ac
Etape n°3 :
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
Ce message d’erreur concerne la variable s qu’est à l’intérieur, on effet pour i = 0, s n’est pas
nt bo
encore définie.
t:
Co ce
Etape n°4 :
Fa
ge
Pa
La variable s doit être initialiser avant la boucle for, sinon chaque itération on remet cette
variable à 0.
Etape n°5 :
ac
16 _b
kt
53 ma
2
55 or
Correction de l’exercice
0
:F
Algorithme :
Début somme
ac ok
s0
nt bo
Pour i de 0 à 4 faire
Ecrire(‘Donner un entier’)
t:
Co ce
Lire(n)
s s+n
Fa
Fin Pour
Ecrire(s)
ge
Fin somme
Pa
TDO
Objet Type/Nature Rôle
n Entier Donné
s Entier La somme de 5
entiers
i Entier compteur
Exercice :
Ecrire un programme qui permet de calculer la somme des chiffres d’un entier composé de 3
chiffres (sans utiliser mod et div).
Correction de l’exercice
Algorithme :
Début somme_chiffres
s0
Ecrire(‘Donner un entier’)
Lire(n)
ac
ch convch(n)
s valeur(ch[0])+valeur(ch[1])+valeur(ch[2])
16 _b
Ecrire(s)
kt
Fin somme_chiffres
53 ma
TDO
2
Objet Type/Nature 55 or Rôle
n Entier Donné
ch chaine de
0
:F
caractères
s Entier La somme des
chiffres de n
ac ok
nt bo
Python :
t:
Co ce
Fa
ge
Pa
Il faut convertir (ch[0]) , ch[1] et ch[2] en entier sinon nous sommes entrain de
reconstruire ch.
Exercice :
Ecrire un programme qui permet de calculer la somme des chiffres d’un entier quelconque
Correction de l’exercice
Algorithme :
Début somme_chiffres
s0
Ecrire(‘Donner un entier’)
Lire(n)
ac
ch convch(n)
16 _b
Pour i de 0 à long(ch)-1 faire
s s+ valeur(ch[i])
kt
Fin Pour
Ecrire(s)
53 ma
2
Fin somme_chiffres 55 or
TDO
Objet Type/Nature Rôle
0
:F
n Entier Donné
ch chaine de
ac ok
caractères
s Entier La somme des
nt bo
chiffres de n
i Entier Compteur
t:
Co ce
Fa
Python :
ge
Pa
Exercice :
Ecrire un programme qui permet de calculer le nombre des espaces dans une chaine de
caractères donnée.
Correction de l’exercice
Algorithme :
Début nb_espace
nb 0
Ecrire(‘Donner une chaine de caractère’)
Lire(ch)
Pour i de 0 à long(ch)-1 faire
si ch[i]= ‘ ‘alors nb nb+1
Fin Si
Fin Pour
ac
Ecrire (‘Le nb d espace est ‘,nb)
Fin nb_espace
16 _b
kt
TDO
Objet Type/Nature Rôle
53 ma
nb Entier le nombre des
2
espaces
ch chaine de Donnée
55 or
caractères
0
:F
Python :
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
Vous ne pouvez pas modifier le contenu d’ une chaîne existante. En d’ autres termes, vous ne
pouvez pas utiliser l ' opérateur [ ] dans la partie gauche d ' une instruction d ' affectation.
Essayez par exemple d ' exécuter le petit script suivant (qui cherche intuitivement à remplacer
une lettre dans une chaîne) :
ac
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
Le résultat attendu par le programmeur qui a écrit ces instructions est « pithon » (avec un i au
lieu de y). Mais contrairement à ses attentes, ce script lève une erreur du genre : TypeError:
nt bo
ch ‘’python’’
ge
ch[1] ‘’i’’
Pa
ch se tranforme en ‘’pithon’’
Exercice :
Ecrire un programme qui permet de remplacer ‘y’ dans ‘python’ par ‘i’.
Correction de l’exercice
Python :
Exercice :
ac
Ecrire un programme qui permet de concaténer n caractères/chaines de caractères pour
former une chaine de caractères.
16 _b
kt
53 ma
Le résultat obtenu par cet exercice est une nouvelle chaine différente de celle d’origine.
2
Correction de l’exercice
55 or
0
Algorithme :
:F
Début concaténation
ac ok
ch ‘’
Pour i de 0 à n-1 faire
t:
Co ce
ch1 ch1+ c
Fin Pour
ge
Ecrire (ch)
Pa
Fin concaténation
TDO
Objet Type/Nature Rôle
n Entier le nombre des
chaines
ch chaine de la somme des
caractères chaines
c chaine de Donnée
caractères
Pythone :
Comme nous avons vu pour l’exercice du calcul de la somme des 5 entiers, un message
d’erreur s’affiche. En effet pour la première itération (i=0) la nouvelle chaine ch1 n’est
ac
pas encore définie. Afin de résoudre ce problème nous devons initialiser ch1 à une
valeur qui n’affecte pas le résultat souhaité (La valeur 0 pour les entiers dans le calcul
16 _b
d’une somme)
kt
Ch1 sera initialisé à une chaine vide.
53 ma
2
55 or
0
:F
ac ok
Autre méthode :
ac
Nous pouvons modifier les espaces dans ch par une autre méthode dont l’algorithme est le
16 _b
suivant :
kt
Ecrire (‘’Donner une chaine’’)
53 ma
2
lire (ch)
ch ''''
55 or
Pour i de 0 à long(ch) – 1 faire
0
:F
Sinon
ch2 ch2 + ch[i]
t:
Co ce
Fin Si
Fa
Fin Pour
ge
Exercice :
Pa
Ecrire un programme qui permet de changer le caractère de la position donnée par ‘_’.
Exemple : ch=’python’ et la position est 3, on aura py_hon
Correction de l’exercice
Algorithme :
Début modification
ac
Python
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
Il a à noter qu’avec cette méthode le programme remplace tous les caractères identiques au
nt bo
ac
16 _b
kt
53 ma
Ce résultat est obtenu le fait que nous avons comparé ch[i] par ch[pos-1] qu’est un caractère.
2
Pour répondre au besoin de cet exercice, il faut qu’on remplace juste le caractère trouvé dans
55 or
la position pos. Pour cela on doit utiliser pos-1 et non pas ch[pos-1].
0
Algorithme :
:F
Début modification
ac ok
si i = pos-1 alors
ch2 ch2 + ''_''
ge
sinon
ch2 ch2+ch[i]
Pa
Fin Si
Fin Pour
Fin modification
TDO
Objet Type/Nature Rôle
ch Chaine de Donnée
caractères
pos Entier Donnée
ac
16 _b
kt
53 ma
Exercice :
2
Ecrire un programme qui permet de changer le caractère espace par son nombre
d’occurrence.
55 or
Exemple : ch = ‘Salut tout le monde’, on aura salut1tout2le3monde
0
:F
Correction de l’exercice
ac ok
Algorithme :
nt bo
Début chang_occ
t:
Co ce
nb 0
ch2 '' ''
ge
nb nb+1
ch2 ch2 + convch(nb)
sinon
ch2 ch2+ch[i]
Fin Si
Fin Pour
Ecrire (ch)
Fin chang_occ
TDO
Objet Type/Nature Rôle
ch Chaine de Donnée
caractères
nb Entier nombre d’occurrence
d’un espace
ch2 Chaine de La chaine modifiée
caractères
Python :
ac
16 _b
kt
53 ma
2
55 or
0
:F
Indication : le code ASCII de 'a' est 97 et le code ASCII de 'A' est 65.
t:
Co ce
Fa
ge
Pa
Changer les caractères d’une chaine donnée par leurs codes ASCII
ac
16 _b
Exercice :
kt
Ecrire un programme qui permet de calculer la factorielle d’un entier donnée
53 ma
6 ! = 1*2*3*4*5*6
2
55 or
Correction de l’exercice
0
:F
Algorithme :
Début factorielle
ac ok
f 1
t:
f f*(i+1)
Fa
Fin Pour
Fin factorielle
ge
TDO
Pa
Méthode 2
Remarques
ac
16 _b
kt
for compteur in range (début, fin , #Méthode 1
53 ma
p) 1 for i in range (2):
2
2 print (i)
NB : compteur variant entre le programme affiche :
55 or
[début..fin-1] et pas = p 0
0
1
:F
#Méthode 2
1 for i in range (1,10,2) :
ac ok
2 print(i)
le programme affiche :
nt bo
1
3
t:
Co ce
5
7
Fa
9
#Méthode 3
1 for i in range (1,5):
ge
2 print(i)
le programme affiche :
Pa
1
2
3
4
Le compteur de la boucle Pour commence par défaut par 0, mais on peut également imposer
la valeur de départ du compteur.
ac
Méthode 3 :
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
Exercice :
ge
Ecrire un programme qui permet de vérifier si un entier est diviseur d’un autre.
Pa
Correction de l’exercice
Algorithme :
Début diviseur
Ecrire (‘Donner uu entier’)
Lire (x)
Ecrire (‘Donner un entier’)
Lire(y)
TDO
Objet Type/Nature Rôle
x Entier Donné
y Entier Donné
Python :
ac
Exercice :
16 _b
Ecrire un programme qui permet d’afficher les diviseurs d’un entier donné.
kt
Correction de l’exercice
53 ma
2
Algorithme :
55 or
Début diviseur
Ecrire (‘Donner uu entier’)
0
:F
Lire (x)
Pour i de 1 à x faire
ac ok
Fin Si
Fin Pour
t:
Co ce
Fin diviseur
TDO
Fa
i Entier Compteur
Pa
Python :
Exercice :
ac
Ecrire un programme qui permet de calculer la somme des diviseurs d’un entier donné.
16 _b
Correction de l’exercice
kt
53 ma
Algorithme :
2
Début diviseur
55 or
Ecrire (‘Donner uu entier’)
0
Lire (x)
:F
s0
Pour i de 1 à x faire
ac ok
Fin Pour
t:
Fin diviseur
Fa
TDO
Objet Type/Nature Rôle
ge
x Entier Donné
s Entier La somme des
Pa
diviseurs de x
i Entier Compteur
Python :
Exercice :
Ecrire un programme qui permet de calculer le nombre des diviseurs d’un entier donné.
ac
Correction de l’exercice
16 _b
Algorithme :
kt
Début diviseur
Ecrire (‘Donner uu entier’)
53 ma
Lire (x)
2
nb 0 55 or
Pour i de 1 à x faire
si x mod i = 0 alors nb nb+1
0
:F
Fin Si
Fin Pour
ac ok
TDO
t:
Co ce
i Entier Compteur
Python :
Pa
Début premier
Ecrire (‘Donner un entier’)
Lire (n)
nb 0
Pour i de 0 à n-1 faire
si n mod (i+1) = 0 alors nb nb+1
ac
Fin Si
16 _b
Fin Pour
Ecrire(‘Le nombre des diviseurs de’ ,x,’ est’ , nb)
kt
Si nb = 2 alors Ecrire(n, ‘est premier’)
53 ma
Sinon Ecrire (n,’n est pas premier’)
2
Fin Si 55 or
Fin premier
0
:F
TDO
Objet Type/Nature Rôle
n Entier Donné
ac ok
i Entier Compteur
t:
Co ce
Python :
Fa
ge
Pa
Méthode 2 :
Algorithme :
Début premier
Ecrire (‘Donner un entier’)
Lire (n)
nb 0
Pour i de 2 à n-1 faire
si n mod i = 0 alors nb nb+1
Fin Si
Fin Pour
Ecrire(‘Le nombre des diviseurs de’ ,x,’ est’ , nb)
Si nb = 0 alors Ecrire(n, ‘est premier’)
Sinon Ecrire (n,’n est pas premier’)
Fin Si
ac
Fin premier
TDO
16 _b
Objet Type/Nature Rôle
n Entier Donné
kt
nb Entier Le nombre des
53 ma
diviseurs de ,
2
i Entier 55 or Compteur
Python :
0
:F
ac ok
nt bo
t:
Co ce
Fa
ge
La boucle while répète le bloc d’instruction lorsque la condition d’entrée est vérifiée et
retourne après une itération pour vérifier encore. L’itération s’arrête lorsque la condition n’est
plus vérifiée
Algorithme Python
Tant que condition d’entrée faire while condition d’entrée :
Traitement à répéter Traitement à répéter
Fin Tant que
Boucle infinie
ac
16 _b
Tant que la condition d’entrée est vraie la boucle ne s’arrête pas.
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
3. Boucle répéter
Sans faire une vérification pour la première itération, la boucle répéter refait le bloc
ac
d’instruction jusqu’à la condition de sortie sera vérifiée, dans ce cas on n’aura plus de
répétition
16 _b
En algorithme, la boucle répéter s’écrit :
kt
Répéter
53 ma
2
Traitement à répéter 55 or
Jusqu’à condition de sortie
0
:F
Le traitement se répète si la condition de sortie n’est pas vérifiée et il s’arrête au cas contraire.
En pratique, python n’a pas une instruction prédéfinie qui remplace directement la boucle
ac ok
Répéter (le langage de programmation Pascal par exemple, a une insctruction directe de la
boucle répéter, c’est repeat Traitement until condition)
nt bo
On doit construire un bloc d’instruction qui fait le même rôle de la boucle Répéter en utilisant
t:
Co ce
la boucle while :
Fa
Méthode n°1 :
ge
La boucle répéter ne nécessite pas une condition d’entrée autrement dit elle est toujours vraie,
pour cela nous procédons comme suit :
Pa
La boucle répéter s’arrête lorsqu’une condition de sortie est vérifiée, pour cette méthode
l’instruction jusqu’à est remplacée par une combinaison de deux instructions : if et break
Break : C’est une instruction permet de sortir de toute itération (for, while...) qui la contient.
Son effet est limité à un seul niveau d'imbrication.
ac
16 _b
kt
53 ma
2
55 or
Lorsque la variable i atteint la valeur 5, la boucle répéter s’arrête.
0
:F
Méthode n°2 :
Devant le while, on met une condition qui est vérifiée pour qu’on peut entrer à la boucle
ac ok
directement, c’est comme la boucle répéter qui n’a pas en théorique une condition d’entrée
nt bo
Donc on affecte à une variable booléenne True et on compare test avec True dans la condition
d’entrée de while.
t:
Co ce
Fa
ge
Pa
Le principe ici c’est d’affecter à la variable test une autre valeur (test = False) lorsque la
condition de sortie est vérifiée, donc dans l’itération suivante, test sera false et on ne peut
entrer dans la boucle car on a : while test == True, qui n’est pas maintenant vérifiée donc la
boucle s’arrête.
La même chose si on affecte à la variable test la valeur False au début et on la change avec
True si la condition de sortie est vérifiée :
ac
16 _b
kt
53 ma
2
C’est aussi la boucle Répéter, le même principe
55 or
Autre écriture équivalente :
0
:F
En programmation,
ac ok
est équivalente à :
nt bo
t:
Aussi,
Co ce
Fa
est équivalente à :
ge
Pa
Donc on peut écrire en pratique la boucle Répéter par les 2 façons équivalente suivantes :
Ou
Algorithme Python
Répéter test = True
Traitement à répéter while test :
Jusqu’à condition de sortie Traitement à répéter
if condition de sortie :
ac
test = False
Exemple en Algorithme
16 _b
i0
kt
Répéter
53 ma
2
ii+1 55 or
Jusqu’à i = 5
0
:F
Le même exemple en Python :
ac ok
nt bo
t:
Co ce
Fa
ge
Algorithme Python
Ecrire (‘’Donner votre note) 1 moy = float(input ('donner votre note'))
Lire (moy) 2 while (moy <0 or moy>20):
Tant que (moy<0) ou (moy>20) faire 3 print('Erreur, donner votre note)
Ecrire (‘’Donner votre note)
Fin tant que
Répéter 1 test=True
La condition d’entrée pour la boucle tant que est opposée à la condition de sortie de la boucle
répéter.
Exercice PGCD :
Ecrire un programme qui permet de calculer le pgcd de 2 entiers a et b par la méthode de
différence.
Exemple : a=15 et b=27
ac
pgcd(15,27)= pgcd(15,27-15)=pgcd(15,12)=pgcd(15-12,12)=pgcd(3,12)=pgcd(3 ,12-
3)=pgcd(3,9)=pgcd(3,9-3)=pgcd(3,6)=pgcd(3,6-3)=pgcd(3,3)=3
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
Début PGCD
Ecrire (‘Donner a)
Lire (a)
Ecrire(‘Donner b’)
Lire(b)
Répéter
si a>b alors a a-b
sinon b b-a
jusqu’à a=b
Ecrire(a)
Fin PGCD
TDO
Objet Type/Nature Rôle
a Entier Donné
b Entier Donné
Python :
ac
16 _b
kt
53 ma
2
55 or
0
:F
Algorithme :
nt bo
Début PGCD
Ecrire (‘Donner a)
t:
Co ce
Lire (a)
Ecrire(‘Donner b’)
Fa
Lire(b)
Tant que ab faire
si a>b alors a a-b
ge
sinon b b-a
Pa
TDO
Objet Type/Nature Rôle
a Entier Donné
b Entier Donné
Python :
ac
Exercice nombre parfait :
16 _b
Ecrire un programme qui permet d’afficher tous les nombres parfaits entre m et n tel que
2<m<n.
kt
On dit qu’un nombre est parfait s’il est égal à la somme de tous ses diviseurs autre que lui-
53 ma
même.
2
55 or
0
:F
Etape n°1 :
Pour tester si un entier n donné est parfait ou non .On procède comme suit :
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
Les diviseurs d’un entier quelconque autre que lui-même sont inférieurs à sa moitié, donc
pour optimiser le nombre d’itération.
Ceci n'est qu'une partie de l'exercice, car l'exercice nous a demandé d'afficher tous les
nombres parfaits entre deux entiers donnés m et n.
Correction de l’exercice
ac
Algorithme :
16 _b
Début parfait
Répéter
kt
Ecrire(‘Donner m’)
Lire(m)
53 ma
Ecrire(‘Donner n’)
2
Lire(n)
jusqu’à 2<m<n
55 or
Pour i de m à n faire
0
s 0
:F
Fin Si
Fin Pour
nt bo
Si s= I alors Ecrire(i)
Fin Si
t:
Co ce
Fin Pour
Fin p&arfait
Fa
TDO
ge
n Entier Donné
s Entier La somme des
diviseurs
i Entier Compteur
j Entier Compteur
Python :
ac
16 _b
Exercice Palindrome :
Ecrire un programme qui permet de saisir un mot composé de 10 caractères au maximum
kt
puis vérifié si ce mot est palindrome (Se lit dans les deux sens)
53 ma
Exemples : ELLE, RADAR, REVER, DVD ,…
2
55 or
Méthode 1 :
0
:F
L’idée est de tester les caractères deux à deux comme montre la figure suivante :
ac ok
nt bo
t:
Co ce
Fa
ge
ac
au milieu de ch)
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
ch1=’amelia’ et ch2=’ayaari’.
t:
Co ce
Dans le cas de ch1 le programme affiche Non palindrome ce qu’est vrai alors qu’il affiche
Fa
La boucle Pour est inefficace dans ce cas, car elle prend en compte le résultat de la
vérification des deux derniers caractères (dans le cas de ‘ayaari’). On a besoin d'une boucle
« de haute dignité », une fois qu'il rencontre deux caractères différents, on sort de la boucle
ac
Le code présenté dans la figure ci-dessus n’affiche pas si ch est palindrome ou non. Pour cela
16 _b
nous introduisons une variable test de type booléen qui servira par la suite pour l’affichage du
message.
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
Attend ! Avant de passer à exécuter ce code la variable i n’est pas encore définit !!!!!!
compteur.
Pa
Imaginons que nous avons saisir un mot palindrome ? Quand la boucle répéter s’arrête ?
Bah oui, dans ce cas la boucle est infinie et une erreur de type Index out of range nous
dérangera.
ac
16 _b
Correction de l’exercice avec la boucle tant que
kt
53 ma
Algorithme :
2
Début palindrome
55 or
Répéter
0
:F
l ← long(mot)
i ← -1
nt bo
Répéter
t:
i ← i+1
Co ce
FinSi
Fin Palindrome
TDO
Objet Type/Nature Rôle
mot Chaine de caractère Chaine donnée
l entier Longueur de la chaine
i entier compteur
test booléen vérification
Python :
ac
16 _b
kt
Méthode 2 : Chaine inverse
Algorithme :
53 ma
2
Début palindrome
Ecrire(‘Donner la chaine à vérifier ‘)
55 or
Lire(ch)
0
ch_inv ‘’
:F
Fin Pour
Ecrire(ch_inv)
nt bo
Fin Si
Fin palindrome
Fa
TDO
ge
caractère
ch)inv chaine de l’inverse de ch
caractères
i Entier Compteur
Python :
Exercice Etoiles :
Ecrire un programme qui permet d’afficher chacune des 2 figures suivantes pour un nombre
de ligne n donné.
Exemple pour n =5
ac
16 _b
* *
kt
** ***
53 ma
2
*** 55 or *****
**** *******
0
:F
***** *********
Figure1 Figure 2
ac ok
Figure 1 :
nt bo
#Méthode 1 :
t:
Co ce
Algorithme :
Fa
Début figure1
Ecrire(‘Donner le nombre des lignes‘)
ge
Lire(n)
Pour i de 1 à n faire
Pa
Ecrire(‘*’ * i)
Fin Pour
Fin figure1
TDO
Objet Type/Nature Rôle
n Entier Donné
i Entier Compteur
Python :
#Méthode 2 :
ac
Algorithme :
16 _b
Début figure1
kt
Ecrire(‘Donner le nombre des lignes‘)
Lire(n)
53 ma
ch ‘’
2
Pour i de 1 à n faire
ch ch + ‘*’
55 or
Ecrire (ch)
0
:F
Fin Pour
Fin figure1
ac ok
TDO
Objet Type/Nature Rôle
nt bo
n Entier Donné
ch Chaine de chaine contienne les
t:
Co ce
i Entier Compteur
Python :
ge
Pa
#Méthode 3 :
Démarche et idées
ac
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Algorithme :
Fa
Début figure1
Ecrire(‘Donner le nombre des lignes‘)
ge
Lire(n)
Pour i de 1 à n faire
Pa
TDO
Objet Type/Nature Rôle
n Entier Donné
i Entier Compteur
j Entier Compteur
Python :
ac
16 _b
Figure 2
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Algorithme :
Co ce
Début figure2
Fa
Pour i de 1 à n faire
Pour j de 01à n-i faire
Pa
Ecrire(‘ ’ ,end=’’)
Fin Pour
Pour k de 1 à 2*i -1 faire
Ecrire(‘*’,end=’’)
Fin Pour
Fin Pour
Fin figure2
TDO
Objet Type/Nature Rôle
n Entier Donné
i Entier Compteur
j Entier Compteur
k Entier Compteur
Python :
ac
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
Les Tableaux
1. Définition
Une liste est une structure de données qui contient une série de valeurs. Python autorise la
construction de liste contenant des valeurs de types différents (par exemple entier et chaîne de
caractères), ce qui leur confère une grande flexibilité. Une liste est déclarée par une série de
valeurs (n'oubliez pas les guillemets, simples ou doubles, s'il s'agit de chaînes de caractères)
séparées par des virgules, et le tout encadré par des crochets. En voici quelques exemples :
Exemple
T= [5,'Bonjour',4,9.5,8]
ac
print (T)
16 _b
En programmation, Dans les tableaux on ne peut pas stocker que des donnés de
même type.
kt
53 ma
2
55 or
2. Utilisation
0
:F
Un des gros avantages d'une liste est que vous pouvez appeler ses éléments par leur position.
Ce numéro est appelé indice (ou index) de la liste.
ac ok
Soyez très attentifs au fait que les indices d'une liste de n éléments commence à 0 et se
t:
Co ce
animaux = ['girafe','tigre','singe','souris']
print (animaux[0])
'girafe'
ge
print (animaux[1])
'tigre'
Pa
animaux[3]
'souris'
Par conséquent, si on appelle l'élément d'indice 4 de notre liste, Python renverra un message
d'erreur :
1 animaux[4]
le programme affiche :
Traceback (innermost last):
3 ani1 + ani2
le programme affiche :
['girafe', 'tigre', 'singe', 'souris']
ac
4 ani1 * 3
16 _b
le programme affiche
['girafe', 'tigre', 'girafe', 'tigre', 'girafe', 'tigre']
kt
L'opérateur + est très pratique pour concaténer deux listes.
53 ma
2
Vous pouvez aussi utiliser la méthode .append() lorsque vous souhaitez ajouter un seul
élément à la fin d'une liste.
55 or
Dans l'exemple suivant nous allons créer une liste vide :
0
:F
1 a = []
ac ok
2a
nt bo
Le programme affiche :
t:
Co ce
[]
Fa
puis lui ajouter deux éléments, l'un après l'autre, d'abord avec la concaténation :
1 a = a + [15]
ge
2 print (a)
Pa
le programme affiche :
[15]
3 a = a + [-5]
4 print (a)
le programme affiche :
[15, -5]
1 [Link](13)
2 print (a)
le programme affiche :
[15, -5, 13]
3 [Link](-3)
4 print (a)
le programme affiche :
[15, -5, 13, -3]
Dans l'exemple ci-dessus, nous ajoutons des éléments à une liste en utilisant l'opérateur de
concaténation + ou la méthode. append (). Nous vous conseillons dans ce cas précis d'utiliser
la méthode. append() dont la syntaxe est plus élégante.
ac
16 _b
kt
53 ma
2
Il faut initialiser le tableau T à vide d’abord.
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
En cas général, pour remplir des tableaux de taille quelconque, on va utiliser la boucle Pour
ac
La méthode append() ou la concaténation de deux tableaux sont des méthodes pratiques, en
16 _b
algorithme on remplit un tableau de la manière suivante :
kt
Debut remplissage
53 ma
Répéter
2
Ecrire(‘’Donner la taille du tableau’’)
55 or
Lire(n)
0
:F
Ecrire(‘’donner T[‘’,i,’’]’’)
t:
Co ce
Lire(T[i])
Fa
Fin Pour
Fin remplissage
ge
TDO
Pa
Mais, on doit donner des valeurs de 0 (ou autre) à tous les éléments du tableau car, on ne peut
affecter une valeur à T[i] qui n’est pas encore définie.
ac
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
La structure de données principale dans NumPy est le ndarray, qui est un nom abrégé pour
un tableau à N dimensions. Lorsque vous travaillez avec NumPy, les données d'un ndarray
sont simplement appelées un tableau. Il s'agit d'un tableau de taille fixe en mémoire qui
contient des données du même type, telles que des nombres entiers ou des valeurs chaines.
ac
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
Exercice :
ge
suivante :
T2[i]= somme des carrées des chiffres de T1[i]
Exemple : T1[2]= 254 alors T2[2]= 22+52+42 = 45
Correction de l’exercice
Algorithme :
Début Ex1_tableau
Répéter
Ecrire(‘Donner la taille du tableau’)
Lire(N1)
Jusqu’à 1<N1<100
Pour i de 0 à N1-1 faire
Répéter
Lire(T1[i])
Jusqu’à 100 T1[i]999
Fin Pour
Pour i de 0 à N1-1 faire
u=T1[i] mod 10
d = (T1[i] mod 100)div 10
c = T1[i] div 100
T2[i] = u2 + d2 + c2
Fin Pour
ac
Ecrire(T2)
Fin Ex1_tableau
16 _b
TDO
kt
Objet Type/Nature Rôle
N1 Entier Taille du tableau
53 ma
2
T1 tab1 Tableau des entiers
i Entier Compteur
55 or
T2 tab2 Tableau des entiers
TDNT
0
:F
Type
tab1=Tableau de 100 entiers naturels de 3 chiffres
tab2=Tableau de 100 entiers naturels
ac ok
Python :
nt bo
t:
Co ce
Fa
ge
Pa
ac
16 _b
kt
53 ma
2
55 or
0
:F
Exercice:
nt bo
(4<n<20), cherche et affiche la longueur de la chaîne la plus longue puis affiche toutes les
chaînes ayant cette longueur
Fa
Correction de l’exercice
ge
Algorithme :
Pa
Début Ex2_tableau
Répéter
Ecrire(‘Donner la taille du tableau’)
Lire(n)
Jusqu’à 4<N1<20
Pour i de 0 à n-1 faire
Lire(T[i])
Fin Pour
maxi long(T[0])
TDO
Objet Type/Nature Rôle
n Entier Taille du tableau
T tab Tableau de n chaînes
de caractères
ac
i Entier Compteur
maxi Entier La longueur
16 _b
maxiamel
kt
TDNT
Type
53 ma
2
tab=Tableau de 20chaine de caractères
55 or
Python :
0
:F
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
Sous-Programme
Les sous-programmes sont ainsi le moyen pour le programmeur de définir ses propres
instructions et opérateurs. On appelle généralement fonction un sous-programme qui retourne
un résultat et peut donc être utilisé comme une fonction. C’est le cas de la fonction cube ci-
avant. On appelle procédure un sous-programme qui ne retourne pas de valeur. Une
procédure se comporte donc comme une instruction.
● Les sous programmes permettent de ne pas répéter plusieurs fois une même séquence
d’instructions au sein du programme.
ac
● Un sous programmes peut être intégré à un autre programme, ou elle pourra être rangée
16 _b
dans une bibliothèque d’outils ou il pourra être utilisé par n’importe quel programme.
kt
Un sous-programme peut-être une procédure ou une fonction.
53 ma
2
55 or
Sous-programme Syntaxe
0
:F
1. Procédure
ac ok
Début
Fa
………..
……….. Traitement
ge
Fin
Pa
Exemple :
Début
Répéter
Lire (n)
Fin
Si le contenu d’une une variable globale dans une procédure change en passant par le
traitement, on écrit « @ » avant la variable dans l’entête de la déclaration de la procédure (on
appelle ça passage par variable) sinon on n’écrit rien (on appelle ça passage par valeur)
ac
On appelle une procédure dans le programme principal au-dessus de la déclaration du sous-
programme ou dans un autre sous-programme.
16 _b
Exemple :
kt
Saisie (n)
53 ma
2
En général la syntaxe de l’appel d’une procédure est :
55 or
nom_procédure (paramètres effectifs)
0
:F
Exemple Python :
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
2. Fonction
On appelle un algorithme en tant que fonction, tout traitement qui a pour objectif le calcul ou
la détermination d’un seul résultat, retourne une seule variable comme résultat final.
Fonction nom_fonction (Liste des paramètres formels : Type) : Type du résultat retourné
Début
………..
Traitement
………..
Retourner nom_variable contenant le résultat calculé
Fin
Exemple
p somme (n)
ac
Écrire (p)
16 _b
Remarque : p est une autre variable qui reçoit le résultat de la fonction
kt
53 ma
p nom_procédure (paramètre formel)
2
En pratique, on peut utiliser des procédures en tant que fonction, cela est nécessaire lorsqu’on
55 or
va utiliser le résultat de la procédure dans un autre sous-programme en suite.
0
:F
Exemple :
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
Exemple :
ac
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Exemple :
{Déclaration}
ge
Début
s0
Pour i de 1 à x faire
Si x mod i = 0 alors
ss+1
Fin Si
Fin Pour
Retourner s
Fin
{Appel}
Lire (n)
p Somme (n)
Écrire (p)
ac
Ou on peut afficher la somme comme ça : Écrire (Somme (n))
16 _b
Exemple Python :
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
La notion des paramètres formels et effectifs est valable aussi pour les procédures.
Variable locale
Une variable locale est une variable déclarée dans un sous-programme. Elle n’est accessible
que depuis ce sous-programme.
Remarque : Un paramètre est l’équivalent d’une variable locale initialisée lors de l’appel du
sous-programme alors qu’une variable locale est une variable qui est initialisée dans le sous-
programme et ne sera pas accessible de l’extérieur de ce sous-programme.
Variable globale
Une variable globale est une variable qui est potentiellement accessible de plusieurs sous-
programmes. Une variable est donc dite globale si sa portée inclut plusieurs sous-
programmes.
ac
Application avec sous-programme :
16 _b
kt
Exercice :
53 ma
2
Élaborer un programme qui permet de saisir un vecteur T par n chaînes de caractères (4< n
<20), cherche et affiche la longueur de la chaîne la plus longue puis affiche toutes les chaînes
55 or
ayant cette longueur.
0
:F
Correction Théorique :
ac ok
Début
t:
Co ce
Répéter
Fa
Lire (n)
ge
Fin
Début
Pour i de 0 à n – 1 faire
Lire (T[i])
Fin Pour
Fin
T.D.O.L
Début
ac
Pour i de 1 à n-1 faire
16 _b
Si long(T[i]) > maxi alors
kt
maxi T[i]
53 ma
2
Fin Si 55 or
Fin Pour
0
:F
Retourner maxi
Fin
ac ok
T.D.O.L
nt bo
i entier compteur
maxi entier La longueur maximale des chaines du tableau
Fa
ge
Début
Pa
Ecrire(T[i])
Fin Si
Fin Pour
Fin
T.D.O.L
Programme principal
Début
Saisie (n)
Remplissage (n,T)
ac
Affichage (n,T)
16 _b
Fin
kt
T.D.N.T
53 ma
Type
2
Tab = tableau de 19 chaines 55 or
T.D.O.G
0
Objet T/N Rôle
:F
n entier donnée
T Tab Tableau de chaines
ac ok
ac
16 _b
kt
53 ma
2
55 or
0
:F
ac ok
nt bo
t:
Co ce
Fa
ge
Pa
The algorithm must iterate through the string, and for each character, check if it is a space. If it is, the algorithm replaces it with an underscore or appends the current count of encountered spaces to the result. This guarantees the targeted transformation without altering other characters. Ensuring accuracy requires careful handling of indices and counters to maintain correct positioning and counts .
A function that determines the length of the longest string iterates over an array of strings, comparing each string’s length to find and return the maximum. Integrating such a function centralizes the logic for this specific task, making the main program simpler and more readable by delegating complexity to the function. This also improves maintainability, as changes are localized to the function itself, and facilitates reusability across different programs needing the same logic .
Procedures perform actions but do not return values; they are used to encapsulate and repeat sequences of instructions, making code maintenance easier and improving readability. Functions, on the other hand, compute and return values, allowing their results to be directly used within expressions. Using procedures can simplify code by avoiding redundancy, while functions facilitate calculations and data transformations within a program, enhancing modularity and clarity .
The initialization issue in loops can be resolved by ensuring variables are initialized before the loop begins. For summing integers or concatenating strings, the variable that accumulates the result should be initialized to zero or an empty string respectively, before entering the loop. This prevents errors or incorrect results due to reinitialization at each iteration .
Global variables are accessible from multiple sub-programs, promoting shared state across the program, which can be advantageous for maintaining consistent data but risks unintended interactions and makes debugging harder. Local variables, confined to their sub-program, offer more control and reduce potential side effects, promoting modularity and reducing the impact of changes, crucial for maintaining complex algorithms in larger codebases by containing complexity and preventing external interference .
Improved error handling when concatenating strings involves initializing the destination string to an empty value before the loop begins. This ensures that any concatenation starts from an empty baseline, preventing undefined or unpredictable behavior if the variable were uninitialized. Proper initialization eliminates runtime errors related to use of undefined data, thus stabilizing program execution and making the code more robust against faulty inputs or logic .
Procedures encapsulate repetitive tasks, allowing them to be defined once and reused multiple times, thus reducing code duplication and enhancing program efficiency. For example, input validation or specific calculations like summing a series of numbers can be abstracted within a procedure, making the main program cleaner and more efficient by avoiding repetition and centralizing logic for easier maintenance .
The iteration logic should iterate through the string while checking each character’s index against the specified positions. If a match is found, the character is replaced while preserving other characters unaltered. This requires carefully controlling the loop’s boundary conditions and ensuring that replacements do not affect non-target positions. Efficiency can be enhanced by combining checks and replacements in minimal passes, thereby reducing complexity and runtime .
The algorithm multiplies sequential numbers from 1 to the target number using a loop, initializing the result to one, reflecting on iterative problem-solving by decomposing the problem into repetitive multiplication steps. This approach is straightforward, leveraging a stepwise accumulation of results to solve the factorial problem iteratively, illustrating a fundamental technique in algorithm development that breaks complex operations into repeatable and manageable units .
Converting characters to integers is crucial in algorithms for summing the digits of an integer, as it allows the numerical manipulation needed for the summation. In these algorithms, character representations of digits must be converted to their integer equivalents, often using functions that map character encodings to numeric values, ensuring accurate calculations without rebuilding the string inadvertently .