Un algorithme se compose de trois grandes parties :
les informations dont on a besoin au départ ;
la succession d'instructions à appliquer ;
la réponse que l'on obtient à l'arrivée.
La succession d'instructions n'est pas toujours détaillée explicitement au sein de l'algorithme, mais parfois dans une autre partie, à travers ce que l'on appelle des fonctions ou des procédures (voir le paragraphe 8).
Cela permet de découper l'algorithme en plusieurs sous-algorithmes et de le rendre plus facile à comprendre.
Par souci de clarté, un algorithme doit éviter de comporter plusieurs fois la même série d'instructions. Pour éviter cela on utilise, quand on le peut, les boucles ou les fonctions et procédures.
On fait appel à la procédure au lieu de ré-écrire les mêmes instructions.
Cela permet aussi d'avoir des algorithmes et des programmes plus lisibles.
En programmation les trois grandes parties d'un algorithme deviennent :
les informations dont on a besoin au départ : les entrées ou la lecture
la succession d'instructions à appliquer : le traitement
la réponse que l'on obtient à l'arrivée : les sorties ou l'écriture
Une variable est une information contenue dans une « boîte », que le programme va repérer par son nom. Pour avoir accès au contenu de la boîte, il suffit de la désigner par son nom. Le contenu de cette « boîte » dépend du type de variable. Il y a plusieurs types de variables:
numérique : entier, réel : ou sont entiers ; sont réels
texte : caractère, chaîne : ou (caractères) « » (chaîne)
booléen : ne peut prendre que deux valeurs : ou
Affecter une valeur à une variable, c'est donner une valeur à cette variable.
Le signe = en programmation ne correspond pas au signe « = » en mathématiques. Il signifie qu'on attribue une valeur à une variable. C'est pourquoi on utilise une autre notation.
Pour agir sur les variables, on utilise des opérateurs qui dépendent du type de variables.
numériques : + - * (multiplier) / (diviser) ^ (puissance)
texte : & + (met bout à bout deux chaînes)
logiques (booléen): « et » « ou » « non » On utilise aussi de nombreuses fonctions prédéfinies.
Un test permet de choisir une action suivant une condition.
Structures d'un test:
Si « condition est vraie » alors action1 fin de si
Si « condition est vraie » alors action1 Sinon action2 fin de si
n général une condition est une comparaison, elle est vraie ou fausse. La condition peut aussi être une variable de type booléen. On peut utiliser des opérateurs : « égal à » « différent de » « plus petit que » …
// Paramètres à définir
a = 5
b = 3
// Tests
if a > b:
print("a est plus grand que b")
else:
print("b est plus grand ou égale à a")
Une itération sert à répéter une même action.
On connaît le nombre de fois où l'action devra être répétée. Une fois la répétition finie, le programme continue. On doit décrire ce que l'on appelle un « compteur de boucle » :
début : premier nombre
fin : dernier nombre
pas : de combien on augmente à chaque fois (ou 1 par défaut) .
Les boucles, les boucles... une longue histoire d'amour pour les informaticiens feignants que nous sommes... En effet, elles sont super utile pour répéter des taches ! C'est justement leur but.
Petit exemple : vous préférer écrire lequel des deux codes ?
print(1)
print(3)
print(5)
print(7)
print(9)
...
print(999)
ou
for i in range(1, 1000, 2):
print(i)
Y'a de quoi hésiter...
Analysons le code :
Il fait lignes et permet d'afficher lignes (on pourrait faire bien plus... Que c'est monstrueux !)
Si on écrit range(1, 999, 2)
, on remarque que l'affichage s'arrête à , donc le terme affiché dans range est exclu
On remarque qu'on a range(début, fin, pas)
.
Une boucle « Tant que » sert à répéter une même action, jusqu'à ce qu'une condition se réalise.
On ne sait pas à l'avance le nombre de fois que la boucle sera répétée, sinon on préfère utiliser la boucle POUR.
Exemple pour
On a un jeu de dé et on aimerait savoir à partir de combien de lancer, on obtient un double . Pour cela, on utilisera une boucle TANT QUE à la place d'une boucle POUR, car on ne sait pas par avance quand le programme doit s'arrêter mais plutôt une condition.
/ Librairie
import random as rand
// Initialisation
de1 = rand.randint(1,6)
de2 = rand.randint(1,6)
temps = 1
// Boucle
while de1 != 6 and de2 != 6:
de1 = rand.randint(1,6)
de2 = rand.randint(1,6)
temps += 1
// Afficher le résultat
print(temps)
Exemple pour Terminale
Pour renvoyer l'indice d'une suite quand la suite atteint une certaine valeur, on utilisera la boucle TANT QUE (while).
Soit et .
Pour connaître l'indice lorsque la suite dépasse la valeur par exemple, on utilisera la boucle TANT QUE.
// Initialisation
u = 5
i = 0
// Boucle
while u < 1000000:
u = 6*i + 2*u // u_(n+1) = 6*n + 2*u_(n)
i += 1
// Afficher le résultat
print(i)
Un événement lance le bloc qui lui est lié. C'est à dire la série d'instructions (briques) qui est collée dessous. On peut utiliser aussi différents événements à l'intérieur d'un même script. Il suffit de séparer des blocs d'actions à exécuter en fonction de l'événement. Dans ce cas, le bloc qui interrompt est exécuté, puis le bloc interrompu reprend là où il s'était arrêté.
Le programme en cours d'exécution peut aussi lancer un événement, en utilisant les messages. Cet événement ne dépend pas d'une action extérieure (clavier, souris,…) mais de l'exécution du programme.
Ce sont des variables particulières. Elles sont utilisées pour stocker plusieurs variables de même type. Un tableau est un ensemble de valeurs portant le même nom de variable et repérées par un nombre appelé indice. Pour désigner un élément du tableau, on fait figurer le nom du tableau, suivi de l’indice de l’élément, entre crochets.
Attention, dans la plupart des langages de programmation, les indices des tableaux commencent à , et non à . C'est le cas de Python3. Dans un tableau nommé , le er élément est alors . Pour Scratch les indices des listes commencent à .
Un tableau doit être vu comme ceci :
T = [T0, T1, T2, T3, T4, T5]
Il s'agit d'un tableau de taille (il contient éléments).
Sur python, pour accéder à la valeur par exemple, il faut rentrer :
>>> T[3]
T3
Attention à ne pas dépasser, sinon la console vous renvoie une erreur ! Par exemple :
Traceback (most recent call last):
File "", line 1, in
La partie « tableaux multidimensionnels » qui suit ne concerne pas le logiciel Scratch. Les tableaux multidimensionnels sont utilisés pour faciliter la lecture (damier, image) ou tableau de tableaux : ce sont des tableaux dont chaque élément est lui-même un tableau.
Comme auparavant, pour accéder à un élément, on utilise des crochets. Par exemple pour un tableau , si on veut accéder à la position , on fait
Un tableau multidimensionnel doit être vu comme ceci :
T = [ [T00, T01, T02, T03],
[T10, T11, T12, T13],
[T20, T21, T22, T23] ]
Il s'agit d'un tableau bidimensionnel, ou bien d'un tableau de dimension , de taille .
Remarquez qu'il s'agit d'un tableau contenant des tableaux : il y a tableaux dans le tableau qui englobe le tout.
Mais on remarque que cette représentation est très intuitif ! En effet, si on fait :
>>> print(T[1])
[T10, T11, T12, T13]
Et si on veut accéder à une case, on fait :
>>> print(T[1][3])
T13
On accède bien à la case voulue ! En utilisant les commandes propre au tableau, cela marche comme des coordonnées.
Prenons un exemple concret :
>>> T = [[5,3,3,5],[2,4,3,1],[7,6,9,3]]
>>> T[1][3]
1
Nous voilà prêt à coder un jeu de dames !
Les fonctions et procédures sont des « morceaux de programme » que l'on peut appeler en leur indiquant des paramètres. On réutilise souvent la même partie d'un programme. Au lieu de ré-écrire cette partie, on en fait une fonction ou une procédure.
Une fonction python qui détermine si un triangle est rectangle :
def est_rectangle(a,b,c):
a2 = a*a
b2 = b*b
c2 = c*c
if a2 + b2 == c2 or a2 + c2 == b2 or b2 + c2 == a2:
return True
else:
return False
---------- Console ----------
>>> est_rectangle(5,4,3)
True
>>> est_rectangle(5,5,3)
False