Algorithme & Programmation Python

2ème TI — Code Reference Sheet

# Section P.

1 Démarche de résolution 2

2 Structures simples — Entrée / Sortie / Affectation 2

3 Types de données & Opérations 3

4 Chaînes de caractères 3

5 Vecteurs 4

6 Structures conditionnelles 4

7 Structures itératives — Boucles 5

8 Fonctions 6

9 Procédures & Passage de paramètres 7

10 Programmes complets 8
1 — Démarche de résolution de problèmes
Tout problème se décompose en 3 étapes avant d'écrire l'algorithme :

Données Ce que le programme reçoit en entrée

Traitement Ce que le programme calcule

Résultat Ce que le programme affiche ou retourne

TDO — Tableau de Déclaration des Objets : déclarer chaque variable avec son nom et type.

Objet | Type/Nature
---------|------------
Lo | Réel
La | Réel
S | Réel
P | Réel

2 — Structures simples : Entrée / Sortie / Affectation

Entrée — Lire() / input()

Algorithme Python

Lire(n) -- entier n = int(input())

Lire(x) -- réel x = float(input())
Lire(ch) -- chaîne ch = input()

■■ input() retourne TOUJOURS une chaîne — entourer de int() ou float() selon le type.

Sortie — Ecrire() / print()

Algorithme Python

Ecrire('Bonjour') print('Bonjour')
Ecrire(n) print(n)
Ecrire('Valeur : ', n) print('Valeur : ', n)

Affectation
Algorithme Python

x <- 5 x = 5
a <- x + 3 a = x + 3
x <- x - 2 x = x - 2

■■ = en Python est affectation. == est comparaison. En algo, <- est affectation, = est comparaison.

Permutation (échange de deux variables)

Algorithme Python

z <- a z = a
a <- b a = b
b <- z b = z
3 — Types de données & Opérations
Type Algo Python Exemple

Entier Entier int 5, -3, 0

Réel Réel float 3.14, -2.5

Booléen Booléen bool Vrai/Faux → True/False

Caractère Caractère str "A", "z"

Chaîne Chaîne str "Bonjour"

Opérations arithmétiques
Opération Algo Python Exemple

Addition + + 5+2=7

Soustraction - - 5-2=3

Multiplication * * 5 * 2 = 10

Division réelle / / 5 / 2 = 2.5

Division entière (DIV) DIV // 5 // 2 = 2

Modulo (MOD) MOD % 5%2=1

Puissance X^n ** 5 ** 2 = 25

Fonctions prédéfinies sur les réels

int(3.7) -> 3 # partie entière (tronque)

round(3.49) -> 3 # arrondi
round(3.51) -> 4
abs(-5) -> 5 # valeur absolue
from math import sqrt
sqrt(25) -> 5.0 # racine carrée

4 — Chaînes de caractères

Fonctions prédéfinies

ch = "Bonjour papa"

len(ch) -> 12 # longueur

[Link]() -> "BONJOUR PAPA" # majuscules
[Link]("jour") -> 3 # position, -1 si absent
str(42) -> "42" # nombre -> chaîne
int("42") -> 42 # chaîne -> nombre
[Link]() -> False # est-ce numérique ?

Découpage (Slicing) — ch[d:f]

 ch = "Bonjour papa"
# B o n j o u r p a p a
# 0 1 2 3 4 5 6 7 8 9 10 11

ch[0] -> "B" # un seul caractère

ch[:3] -> "Bon" # du début jusqu'à 3 (exclu)
ch[3:] -> "jour papa" # de 3 jusqu'à la fin
ch[3:7] -> "jour" # de 3 jusqu'à 7 (exclu) = indices 3,4,5,6
ch[::3] -> "Bjra" # un caractère sur 3

■■ Règle : [d:f] va de d jusqu'à f-1. f est TOUJOURS exclu.

ASCII — ord() et chr()

ord("A") -> 65 # A=65, Z=90

ord("a") -> 97 # a=97, z=122
chr(65) -> "A"
chr(97) -> "a"

# Itérer sur les caractères d'une chaîne :

for i in range(len(ch)):
print(ch[i], ord(ch[i]))
5 — Vecteurs (tableaux 1D)
Algorithme Python

-- Déclaration : from numpy import array

T : tableau de 5 entiers T = array([int()] * 5)

-- Accès : # Accès :
T[0] -- premier élément T[0] # premier élément
T[4] -- dernier élément T[4] # dernier élément

-- Modifier : # Modifier :
T[2] <- 100 T[2] = 100

■■ Index 0-based : 5 éléments → indices 0,1,2,3,4. T[5] serait hors limites.

Remplir un vecteur

from numpy import array

T = array([int()] * 5)

for i in range(5):
T[i] = int(input(f"T[{i}] = "))

Afficher un vecteur

for i in range(5):
print(f"T[{i}] = {T[i]}")

6 — Structures conditionnelles

Si simple — if/else
Algorithme Python

Si n % 2 = 0 alors if n % 2 == 0:
Ecrire("pair") print("pair")
Sinon else:
Ecrire("impair") print("impair")
Fin Si

Si généralisé — if/elif/else
Algorithme Python

Si n > 0 alors if n > 0:

Ecrire("positif") print("positif")
Sinon Si n < 0 alors elif n < 0:
Ecrire("négatif") print("négatif")
Sinon else:
Ecrire("nul") print("nul")
Fin Si

Selon / match-case — une variable, valeurs exactes discrètes

Algorithme Python

Selon jour faire match jour:

1 : Ecrire("Dimanche") case 1: print("Dimanche")
2 : Ecrire("Lundi") case 2: print("Lundi")
3 : Ecrire("Mardi") case 3: print("Mardi")
Sinon : Ecrire("Autre") case _: print("Autre")
Fin Selon

■■ Selon/match : sélecteur doit être discret (int, char, bool) — jamais float. case _ = Sinon par défaut.

Opérateurs logiques

if x >= 5 and x <= 20: # ET -- x appartient [5,20]

if a == 0 or b == 0: # OU
if not (n % 2 == 0): # NON
7 — Structures itératives : Boucles

Situation Boucle à utiliser

Nombre de répétitions CONNU Pour … Faire (for)

Inconnu + AU MOINS 1 fois (validation saisie) Répéter … Jusqu'à (while not)

Inconnu + PEUT NE PAS s'exécuter Tant que … Faire (while)

1. Pour … Faire — for in range()

Algorithme Python

-- Afficher 1 à 5 : # Afficher 1 à 5 :
Pour i de 1 à 5 Faire for i in range(1, 6): # Vf exclu!
Ecrire(i) print(i)
Fin Pour
# Avec pas de 2 :
-- Avec pas de 2 : for i in range(0, 10, 2):
Pour i de 0 à 8 pas 2 Faire print(i)
Ecrire(i) # -> 0, 2, 4, 6, 8
Fin Pour

■■ range(Vi, Vf) : Vf est TOUJOURS exclu. range(1,6) donne 1,2,3,4,5.

2. Répéter … Jusqu'à — while not

Algorithme Python

-- Valider saisie : # Valider saisie :

Répéter while not (4 <= N <= 20):
Ecrire("N = "), Lire(N) N = int(input("N = "))
Jusqu'à (4 <= N <= 20)

■■ Condition de SORTIE : on quitte quand elle est vraie. S'exécute AU MOINS une fois.

3. Tant que … Faire — while

Algorithme Python

-- Extraire les chiffres : # Extraire les chiffres :

S <- 0 S = 0
Tant que X > 0 Faire while X > 0:
S <- S + X MOD 10 S = S + X % 10
X <- X DIV 10 X = X // 10
Fin Tant que

■■ Condition d'ENTRÉE : on vérifie AVANT d'entrer. Peut ne pas s'exécuter si condition fausse dès le départ.

Compteur dans Répéter / Tant que — initialiser AVANT la boucle

i = 0 # initialiser AVANT
while i < 5:
print(i)
i = i + 1 # avancer DANS la boucle
8 — Fonctions
Une fonction retourne EXACTEMENT une valeur. Sert au calcul. Toujours passage par valeur.

Syntaxe
Algorithme Python

Fonction NomF(pf1: type1): TypeResult def NomF(pf1):

Début <traitement>
<traitement> return résultat
Retourner résultat
Fin

Exemple 1 — Factorielle
Algorithme Python

Fonction Fact(n: Entier): Entier def Fact(n):

Début f = 1
f <- 1 for i in range(1, n+1):
Pour i de 1 à n Faire f = f * i
f <- f * i return f
Fin Pour
Retourner f
Fin
# Appel :
-- Appel : x = Fact(5) # x = 120
x <- Fact(5) -- x = 120

Exemple 2 — Booléen : tester si pair

Algorithme Python

Fonction EstPair(n: Entier): Booléen def EstPair(n):

Début return n % 2 == 0
Retourner (n MOD 2 = 0)
Fin # EstPair(4) -> True

Exemple 3 — Fonction appelant une autre fonction

# C(N,P) = N! / (P! x (N-P)!)

def Fact(n):
f = 1
for i in range(1, n+1):
f = f * i
return f

def Combi(N, P):

return Fact(N) // (Fact(P) * Fact(N - P))

# Combi(5, 2) -> 10

■■ Fact() est écrite une seule fois mais appelée 3 fois dans Combi().
 9 — Procédures & Passage de paramètres
Une procédure ne retourne rien. Sert à afficher ou modifier. Peut utiliser @ (passage par variable).

Syntaxe
Algorithme Python

Procédure NomP(pf1: type1) def NomP(pf1):

Début <traitement>
<traitement> # pas de return
Fin

-- Appel : # Appel :
NomP(param) NomP(param)

Passage par valeur — paramètre LU seulement

Algorithme Python

Procédure Afficher(n: Entier) def Afficher(n):

Début print(n)
Ecrire(n)
Fin
# pas de @
-- n est seulement lu -- pas de @ # original inchangé

Passage par variable (@) — paramètre MODIFIÉ

Algorithme Python

Procédure Saisir(@n: Entier) def Saisir():

Début n = int(input("n = "))
Répéter while not (n > 0):
Ecrire("n = "), Lire(n) n = int(input("n = "))
Jusqu'à (n > 0) return n
Fin
# En Python : return
-- @ car Lire(n) modifie n # remplace le @

Règle : quand mettre @ ?

Paramètre apparaît à GAUCHE de <- ? -> OUI -> @

Paramètre est dans Lire() ? -> OUI -> @
Paramètre est seulement lu/affiché ? -> NON -> pas de @

Exemples :
Ecrire(n) -- lu -- pas de @
n <- n + 1 -- modifié -- @
Lire(n) -- modifié -- @
Pour i de 1 à n -- lu -- pas de @

■■ Les fonctions utilisent TOUJOURS le passage par valeur — jamais de @.

10 — Programmes complets

Programme 1 — Somme des chiffres d'un entier

def SommeChiffres(X):
S = 0
while X > 0:
S = S + X % 10 # extraire dernier chiffre
X = X // 10 # supprimer dernier chiffre
return S

# Appel
n = int(input("n = "))
print("Somme des chiffres =", SommeChiffres(n))
# SommeChiffres(453) -> 12 (4+5+3)

Programme 2 — Poids d'un nom (somme codes ASCII)

def Poids(nom):
P = 0
for i in range(len(nom)):
P = P + ord(nom[i]) # ord() -> code ASCII
return P

# Poids("AMINE") -> 65+77+73+78+69 = 362

print(Poids("AMINE")) # 362

Programme 3 — Recherche dans un vecteur

def Chercher(x, T, n):

i = 0
while (x != T[i]) and (i < n-1):
i = i + 1
return x == T[i] # True si trouvé

# Chercher(5, T, 8) -> True si 5 est dans T

Programme 4 — Programme principal modulaire complet

# Modules
def SaisirN():
N = int(input("N = "))
while not (4 <= N <= 20):
N = int(input("N = "))
return N

def RemplirT(N):
T = []
for i in range(N):
[Link](input(f"Nom {i} = ").upper())
return T

def Poids(nom):
P = 0
for i in range(len(nom)):
P = P + ord(nom[i])
return P

def GenererP(T, N):

P = []
for i in range(N):
[Link](Poids(T[i]))
return P

def Afficher(T, P, N):

for i in range(N):
print(f"{T[i]} son poids = {P[i]}")

# Programme principal
N = SaisirN()
T = RemplirT(N)
P = GenererP(T, N)
Afficher(T, P, N)

Lycée Secondaire — 2ème TI — Algorithme & Programmation Python