Afficher en version longue
Rédiger le cours
Moon Arrows Sun
Arrows

L'algorithmique et la programmation

Un programme range des valeurs, fait des choix et répète : quelques instructions suffisent pour écrire les premiers algorithmes.

Un digicode s'ouvre avec un code à quatre chiffres. Les essayer tous, de \(0000\) à \(9999\), fait \(10^4 = 10 \ 000\) essais : à une seconde chacun, près de trois heures.

Répéter, s'arrêter au bon code, compter les essais : un programme le fait avec une variable, un test et une boucle.

Un chiffre de plus, et la machine met dix fois plus longtemps : le coût d'un algorithme se compte.

Variables et affectation

Variable informatique

Une variable est un nom associé à une valeur ; lui donner une valeur est une affectation, notée \(=\) en Python.

n = 7
prix = 12.5
nom = "Ada"
majeur = True

Le signe \(=\) n'est pas une égalité : c'est une action, qui range une valeur dans une variable.

Exemple : \(n\) contient \(7\), puis on exécute l'instruction \(n = n + 1\).

La variable n avant et après l'instruction n = n + 1 : elle contenait 7, elle contient 8
\(n\)
\(n\)
\(7\)
avant après n = n + 1
\(8\)
La variable n avant et après l'instruction n = n + 1 : elle contenait 7, elle contient 8 - support à compléter
\(n\)
\(n\)
\(7\)
avant après n = n + 1

Types de variables

Type
Nom en Python
Exemple
Entier
int
\(7\)
Flottant (nombre à virgule)
float
\(12.5\)
Chaîne de caractères
str
"Ada"
Booléen
bool
True ou False
Les quatre types de variables au programme

Un flottant est une valeur approchée : deux calculs égaux peuvent donner des flottants différents.

Instruction conditionnelle

Une instruction conditionnelle n'exécute un bloc que si une condition est vraie ; ce bloc est repéré par l'indentation (décalage vers la droite).

if n % 2 == 0:
    print("n est pair")
else:
    print("n est impair")

L'opérateur % donne le reste de la division euclidienne, et == teste l'égalité - à ne pas confondre avec l'affectation \(=\).

Exemple : le programme exécuté avec \(n = 7\).

Le schéma de l'instruction conditionnelle pour n = 7 : la condition est fausse, le programme affiche n est impair n = 7 n % 2 == 0 ? vrai faux n est pair n est impair Le schéma de l'instruction conditionnelle pour n = 7 : la condition est fausse, le programme affiche n est impair - support à compléter n = 7 n % 2 == 0 ? vrai faux n est pair n est impair

Boucles

Boucle bornée

Une boucle bornée répète un bloc un nombre de fois connu à l'avance : for en Python.

Somme des entiers de \(1\) à \(100\) :

somme = 0
for k in range(1, 101):
    somme = somme + k
print(somme)

range(1, 101) parcourt les entiers de \(1\) à \(100\) : la borne de droite est exclue.

Boucle non bornée

Une boucle non bornée répète un bloc tant qu'une condition reste vraie : while en Python.

Première puissance de \(2\) qui dépasse \(1\,000\) :

p = 1
n = 0
while p <= 1000:
    p = p * 2
    n = n + 1
print(n, p)

Si la condition ne progresse pas à chaque tour, la boucle ne s'arrête jamais.

Fonctions

Fonction en programmation

Une fonction est un bloc d'instructions nommé, qui reçoit des paramètres et renvoie un résultat.

def est_multiple(a, b):
    return a % b == 0

print(est_multiple(35, 7))

L'instruction return renvoie une valeur et met fin à la fonction ; sans return, rien n'est renvoyé.

Deux algorithmes du programme

Plus grand multiple inférieur à une borne

Pour deux entiers naturels \(a\) et \(b\), on cherche le plus grand multiple de \(a\) inférieur ou égal à \(b\) :

def plus_grand_multiple(a, b):
    m = 0
    while m + a <= b:
        m = m + a
    return m

Exemple : avec \(a = 7\) et \(b = 30\), la fonction renvoie \(28\).

Une droite graduée : quatre bonds de 7 mènent à 28 ; le cinquième dépasserait b = 30
\(0\)
\(b = 30\)
\(7\)
\(7\)
\(7\)
\(7\)
\(28\)
Une droite graduée : quatre bonds de 7 mènent à 28 ; le cinquième dépasserait b = 30 - support à compléter
\(0\)
\(b = 30\)

Encadrement de \(\sqrt{2}\) par balayage

Le balayage avance par pas réguliers jusqu'à dépasser la valeur cherchée. Ici le pas vaut \(10^{-n}\) :

def encadrer_racine_de_2(n):
    pas = 10 ** (-n)
    x = 1
    while x * x <= 2:
        x = x + pas
    return x - pas, x

Elle renvoie deux décimaux distants de \(10^{-n}\) qui encadrent \(\sqrt{2}\).

Exemple : avec \(n = 2\), la fonction renvoie \(1.41\) et \(1.42\).

Le balayage de 1.40 à 1.43 au pas de 0.01 : le carré de 1.41 reste sous 2, celui de 1.42 le dépasse, et racine de 2 est entre les deux
\(1.40\)
\(1.41\)
\(1.42\)
\(1.43\)
\(x\)
\(x^2\)
\(1.9600\)
\(1.9881\)
\(2.0164\)
\(2.0449\)
\(\sqrt{2}\)
Le balayage de 1.40 à 1.43 au pas de 0.01 : le carré de 1.41 reste sous 2, celui de 1.42 le dépasse, et racine de 2 est entre les deux - support à compléter
\(1.40\)
\(1.41\)
\(1.42\)
\(1.43\)
\(x\)
\(x^2\)