Algorithmique:
Variables et Affectation:
- Un algorithme est une suite finie d'instructions à appliquer dans un ordre déterminé à un nombre fini de données pour arriver en un nombre fini d'étapes à un certain résultat: les instructions doivent être compréhensibles.
-
Une variable est désignée par un nom, elle contient une valeur (celle-ci peut être :
un nombre, un mot, une liste de valeurs, ...).
- Une affectation correspond à donner une valeur à la variable (cette valeur peut être le résultat d'un calcul).
La conception d'un programme (ou d'une partie) s'envisage en trois phases:
• Phase 1: il faut entrer les objets et les données que le logiciel doit utiliser = les entrées;
• Phase 2: le logiciel va traiter les informations = le traitement;
• Phase 3: restitution des résultats cherchés = les sorties.
Caractéristiques d'un Algorithme:
Un bon algorithme doit avoir quatre principes:
• Principe 1:L'algorithme doit se terminer après un nombre fini d'étapes;
• Principe 2: Chaque étape de l'algorithme doit être clairement définie ;
• Principe 3: L'algorithme doit avoir des entrées (données initiales) et des sorties (résultats) ;
• Principe 4: L'algorithme doit être optimisé pour utiliser le moins de ressources possible (temps, mémoire).
Représentation des Algorithmes:
Les algorithmes peuvent être représentés de différentes manières :
• Pseudocode: Une description textuelle des étapes de l'algorithme, proche du langage naturel.
• Organigrammes: Des diagrammes visuels utilisant des symboles pour représenter les étapes et les flux de l'algorithme.
Exemples d'Algorithmes Simples
Algorithme de la somme de deux nombres :
Pseudocode :
1. Lire le nombre A
2. Lire le nombre B
3. Calculer la somme S = A + B
4. Afficher la somme S
Organigramme :
[Début] --> [Lire A] --> [Lire B] --> [Calculer S = A + B] --> [Afficher S]
A retenir:Variables: Initialisation: ... prend la valeur ... Entrées: Saisir ... Traitement: Sortie: Afficher... |
Explications: → On cite les variables utilisées en donnant leur type. → On donne une valeur à la variable, on n'est pas obligé de demander à l'utilisateur de "rentrer" cette dernière. → On demande à l'utilsateur de donner des valeurs qui seront stockées dans les variables. → On donne les instructions qui permettent à partir des données d'arriver au résultat. → On affiche le contenu de la variable représentant le résultat. |
Exemple:
Calculer la moyenne de trois notes:
Variables:
Entrées: Saisir
Traitement: Sortie: Afficher m |
Explications: → On annonce les quatres variables: les trois notes et la moyenne. → On demande à l'utilsateur de donner les trois notes qui seront stockées dans les variables a, b et c. → On donne les instructions qui permettent à partir des données d'arriver au résultat: l'instruction "m prend la valeur (a+b+c)/3" permet de lancer le calcul puis d'affecter à la variable m le résultat de ce calcul.
|
Instructions conditionnelles:
Une structure alternative est une structure du type:- Dans le premier cas, si la condition est remplie alors on effectue l’instruction.
- Dans le second cas, si la condition est remplie, on effectue l’instruction 1 sinon on effectue l’instruction 2.
On va dire à l’algorithme d’exécuter des instructions que si une certaine condition est réalisée.
Exemple:Variables: A et B sont des nombres réels Entrées: Saisir A et B
Traitement et Sortie: FinSi |
Questions et solutions:
|
Les boucles:
Une boucle permet de répéter une instruction (ou une liste d’instructions) plusieurs fois.
Il y a principalement deux types de boucles:
• Les boucles pour répéter une instruction un certain nombre de fois, il s’agit de la boucle "Pour (variable) allant de ... à ...";
• Les boucles pour répéter une instruction jusqu'à une condition d’arrêt, il s’agit de la boucle "Tant que".
-
Dans le premier cas, La boucle "pour" permet de répéter une instruction un nombre donné de fois.
Elle se caractérise par le fait que l’on connait à l’avance le nombre d’itérations que l’on doit effectuer.
-
Dans le second cas, La boucle "tant que" permet d’effectuer des itérations tant qu’une certaine condition est verifiée.
On ne connait pas le nombre d’itérations à effectuer, mais à chaque itération, on vérifie si la condition est vraie ou fausse, dès que cette condition est fausse, on sort de la boucle.
-
⚠ Si on connait le nombre d’itérations à effectuer dans la boucle, on utilisera la boucle "pour".
-
⚠ Si la poursuite dans la boucle est dépendante d’une condition, on utilisera de péférence une boucle "Tant que".
Boucle "Pour":
Pour (variable) allant de ... à ... faire instruction Fin Pour Exemple: Algorithme qui permet de calculer la somme des entiers de 1 à N, N étant donné par l'utilisateur. |
Boucle "Tant que": Tant que condition faire instruction Fin tant que Exemple: Algorithme qui permet d'afficher les nombres entiers naturels dont le cube est inférieur à 5000. |
Les fonctions :
des outils pour organiser le code
Une fonction est comme un outil spécialisé.
Elle permet de regrouper un ensemble d'instructions qui effectuent une tâche précise (par exemple: une fonction "calculer_aire_cercle" qui pourrait calculer l'aire d'un cercle en fonction de son rayon). L'avantage des fonctions ?
Elles rendent le code plus lisible, plus réutilisable et plus facile à maintenir.
Pourquoi utiliser des fonctions ?
- Modularité : On découpe un problème complexe en sous-problèmes plus simples, chacun étant géré par une fonction.
- Réutilisabilité : Une fois créée, une fonction peut être utilisée à plusieurs endroits dans un programme.
- Lisibilité : Les fonctions rendent le code plus facile à comprendre en le structurant.
Les éléments d'une fonction :
- Nom : Chaque fonction a un nom qui décrit sa tâche.
- Paramètres : Ce sont les données que tu fournis à la fonction pour qu'elle puisse travailler.
- Corps : C'est l'ensemble des instructions que la fonction exécute.
- Retour : La valeur que la fonction renvoie à la fin de son exécution.
Les listes :
DES CONTENEURS POUR STOCKER DES DONNEES
Une liste est un peu comme une boîte dans laquelle on peut ranger plusieurs éléments.
Ces éléments peuvent être de différents types :
des nombres, des chaînes de caractères, d'autres listes, etc.
L'avantage des listes?
Les listes sont très utiles pour stocker des collections de données et les manipuler facilement.
Les caractéristiques principales d'une liste :
- Ordre : Les éléments d'une liste sont rangés dans un ordre précis. Le premier élément a l'indice 0, le deuxième l'indice 1, et ainsi de suite.
- Mutabilité : On peut modifier une liste après sa création : ajouter des éléments, en supprimer, ou changer leur valeur.
- Hétérogénéité : Une liste peut contenir des éléments de différents types : des nombres, des mots, d'autres listes, etc.
Opérations courantes sur les listes :
- Accès à un élément : On utilise l'indice pour accéder à un élément spécifique de la liste. Par exemple, pour accéder au troisième élément d'une liste nommée "ma_liste", on écrirait quelque chose comme "ma_liste[2]".
- Ajout d'un élément : On peut ajouter un élément à la fin de la liste ou à une position spécifique.
- Suppression d'un élément : On peut supprimer un élément en connaissant son indice ou sa valeur.
- Modification d'un élément : On peut changer la valeur d'un élément à une position donnée.
Exemple :
calculer la moyenne d'une liste de notes
Calculer la moyenne des notes d'un élève.
Comment procéder en utilisant un algorithme, des fonctions et des listes :
-
Créer une liste de notes:
notes = [12, 15, 18, 14] -
Créer une fonction pour calculer la somme des éléments d'une liste:
def calculer_somme(liste): somme = 0 for note in liste: somme = somme + note return somme -
Calculer la moyenne:
somme_des_notes = calculer_somme(notes) nombre_de_notes = len(notes) moyenne = somme_des_notes / nombre_de_notes print("La moyenne est :", moyenne)