{
"cells": [
{
"cell_type": "markdown",
"id": "9b20e9f0",
"metadata": {},
"source": [
"# Partie 1: programmer des fonctions de traitement de listes"
]
},
{
"cell_type": "markdown",
"id": "ddb55983",
"metadata": {},
"source": [
"## Liste Python\n",
"On souhaite faire un traitement python sur les notes obtenues au cours des 2 premiers trimestres.\n",
"Créer une liste et mettre les valeurs 10, 8.9, 9.9, 12.3, 11.1\n",
"\n",
"Ecrire: \n",
"\n",
"`notes = [10, 8.9, 9.9, 12.3, 11.1]`\n",
"\n",
"Afficher la liste `notes`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "568507e0",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "c78cdc01",
"metadata": {},
"source": [
"## Ajouter des valeurs\n",
"Ajouter maintenant les notes obtenues lors de la période du 3e trimestre: 12.3, 13.1, 14.5, 20\n",
"\n",
"On utilise la méthode de liste `append`: par exemple, `notes.append(12.3)`, puis `notes.append(13.1)`,...\n",
"\n",
"A la fin, afficher `notes`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d200a655",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "dba25d79",
"metadata": {},
"source": [
"## Somme\n",
"Le calcul de la somme des éléments necessite d'utiliser une boucle bornée et accumuler les valeurs dans une variable, que l'on nomme par exemple, `s`.\n",
"\n",
"Dans une fonction que vous appelerez `somme`: Définir une variable `s` que vous mettrez à 0.\n",
"\n",
"A l'aide d'une boucle bornée, parcourir les éléments de la liste, et ajouter chaque valeur à `s`.\n",
"\n",
"Retourner `s`\n",
"\n",
"Puis afficher la somme des valeurs de `notes`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dd377869",
"metadata": {},
"outputs": [],
"source": [
"def somme(tab):\n",
" \"\"\"calcule la somme de la liste tab\n",
" \"\"\"\n",
" s = 0\n",
" # a completer\n",
" \n",
"somme(notes)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "26569e34",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "6712b7b7",
"metadata": {},
"source": [
"La chaine de caractères dans la fonction `\"\"\"calcule la somme de la liste tab\"\"\"` est un commentaire sur une ou plusieurs lignes. Celle-ci représente le *docstring* de la fonction, et peut être appelé avec la fonction `help`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cbd28d05",
"metadata": {},
"outputs": [],
"source": [
"help(somme)"
]
},
{
"cell_type": "markdown",
"id": "1b67a127",
"metadata": {},
"source": [
"## Moyenne\n",
"Le calcul de la moyenne se fait en ajoutant toutes les valeurs, et en divisant par le nombre de notes\n",
"\n",
"1. Ecrire le script de la fonction `moyenne`, et calculer la somme `s`, puis la moyenne des valeurs de `notes`\n",
"\n",
"\n",
"\n",
"*Aide:* On utilisera la fonction `len(notes)` qui retourne le nombre d'éléments de `notes`.\n",
"\n",
"La fonction `moyenne` va alors retourner $s / len(tab)$\n",
"\n",
"2. Afficher la moyenne de `notes`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c308836c",
"metadata": {},
"outputs": [],
"source": [
"def moyenne(tab):\n",
" \"\"\"calcule la moyenne des valeurs de la liste tab\n",
" \"\"\"\n",
" s = 0\n",
" # a completer\n",
" \n",
"moyenne(notes)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d31252c0",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "fdca1abc",
"metadata": {},
"source": [
"## Max\n",
"1. Dans une fonction `max`. On affecte à la variable `m` la première valeur de la liste. On parcours ensuite les éléments `e`, un par un, à l'aide d'une boucle bornée.\n",
"\n",
"Si l'élément `e` est supérieur à `m`, on affecte à `m` la valeur `e`.\n",
"\n",
"A la fin de la boucle, on retourne la valeur `m`.\n",
"\n",
"2. Tester ensuite:\n",
"\n",
"```\n",
"max(notes)\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cce36204",
"metadata": {},
"outputs": [],
"source": [
"def max(tab):\n",
" m = tab[0]\n",
" # a completer\n",
" \n",
"max(notes)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5f1ceeab",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "466aadb2",
"metadata": {},
"source": [
"## Min\n",
"adapter le script précedent pour rechercher le minimum dans la liste `notes`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "462efd40",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "fb81cf2e",
"metadata": {},
"source": [
"## indice du max\n",
"On cherche l'indice de la position de la valeur max dans une liste. On utilise le script de la fonction `max`, mais cette fois, la boucle bornée se fait sur les indices et non les valeurs de `tab`:\n",
"\n",
"```\n",
"for i in range(len(tab)):\n",
"...\n",
"```\n",
"\n",
"On retourne l'indice de la plus grande valeur, `indice_max`\n",
"\n",
"*Exemple:*\n",
"\n",
"```\n",
">>> indice_du_max(notes)\n",
"8\n",
"```\n",
"\n",
"1. Compléter le script de la fonction `indice_du_max`\n",
"2. Trouver l'indice du max dans `notes`\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ffed8893",
"metadata": {},
"outputs": [],
"source": [
"def indice_du_max(tab):\n",
" m = tab[0]\n",
" indice_max = 0\n",
" for i in range(len(tab)):\n",
" # a completer"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ac826b53",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "ee771d31",
"metadata": {},
"source": [
"## nombre d'occurences\n",
"On cherche à compter le nombre de notes supérieures ou egales à la moyenne 10. Pour cela, on utilise une variable `n` que l'on met à zero en debut de script. Puis à l'aide d'une boucle bornée, on parcourt les éléments de la liste `tab`. Chaque fois que la valeur de `e` est supérieure ou egal à 10.0, on incrémente `n` d'une unité. \n",
"\n",
"On retourne enfin la valeur `n`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "878e187c",
"metadata": {},
"outputs": [],
"source": [
"def nombre_sup_moyenne(tab):\n",
" n = 0\n",
" # a completer"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b922f939",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "7f7fed63",
"metadata": {},
"source": [
"## Rechercher un 20\n",
"On recherche la présence eventuelle d'une note egale à 20 dans la liste `notes`. Le parcours de la liste se fera à l'aide d'une boucle bornée, avec pour variant, le rang `i` de l'élément de liste: `for i in range(len(tab)):`\n",
"\n",
"Si l'élément de liste `tab[i]` vaut 20, ou 20.0, retourner alors l'index `i`.\n",
"\n",
"Sinon, retourner -1.\n",
"\n",
"*Exemple:*\n",
"\n",
"```\n",
"recherche_20(notes)\n",
"# Affiche 8\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f7f28873",
"metadata": {},
"outputs": [],
"source": [
"def recherche_20(tab):\n",
" for i in range(len(tab)):\n",
" # a completer"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "66f22f49",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "07eb80ae",
"metadata": {},
"source": [
"## Rechercher n'importe quelle valeur\n",
"La fonction possède maintenant 2 paramètres: `tab`, la liste de notes, et `val`, la valeur recherchée.\n",
"\n",
"Adapter le script précédent pour rechercher le rang de la valeur `val` si celle-ci se trouve dans la liste `tab`\n",
"\n",
"*Exemple:*\n",
"\n",
"```\n",
"recherche(notes, 20)\n",
"# Affiche 8\n",
"recherche(notes, 19)\n",
"# Affiche -1\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "cca6111f",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "1f7dde07",
"metadata": {},
"source": [
"## Ajouter un test d'assertion\n",
"Comme vous l'imaginez, il ne devrait pas être possible de placer une valeur à chercher inférieure à 0, ou supérieure à 20. Vous allez ajouter un *test d'assertion* pour eviter d'excuter la fonction dans ces 2 cas:\n",
"\n",
"Exemples:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b43eab4c",
"metadata": {},
"outputs": [],
"source": [
"x = 10\n",
"assert x >=0 and x <= 20, \"x doit être compris entre 0 et 20\""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "24f5913f",
"metadata": {},
"outputs": [],
"source": [
"x = 22\n",
"assert x >=0 and x <= 20, \"x doit être compris entre 0 et 20\""
]
},
{
"cell_type": "markdown",
"id": "ccee200a",
"metadata": {},
"source": [
"Vous avez compris le fonctionnement de l'instruction `assert`? Alors: \n",
"\n",
"* Placer cette ligne dans la fonction `recherche`\n",
"* tester les lignes suivantes"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4ec36a18",
"metadata": {},
"outputs": [],
"source": [
"recherche(notes,9.9)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6532ae9b",
"metadata": {},
"outputs": [],
"source": [
"recherche(notes,0)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bf10f472",
"metadata": {},
"outputs": [],
"source": [
"recherche(notes,22)"
]
},
{
"cell_type": "markdown",
"id": "269b52a5",
"metadata": {},
"source": [
"# Partie 2: Créer un module\n",
"Une fois que vous avez programmé toutes ces fonctions, vous allez les placer dans un module:\n",
"\n",
"* Avec un IDE python, comme Pyzo ou Spyder: Ouvrir un nouveau fichier \n",
"* Placer toutes ces fonctions, l'une après l'autre, en sautant 2 lignes entre chacune d'entre elles.\n",
"* sauvegarder le fichier, avec le nom `utilitaire_notes.py`\n",
"\n",
"Ces fonctions pourront être utilisées depuis un autre fichier python. Il suffira d'importer toutes les fonctions en ajoutant la ligne suivante, en debut de script:\n",
"\n",
"`from utilitaire_notes import *`\n",
"\n",
"> A vous de jouer\n",
"\n",
"1. Créer le module `utilitaire_notes.py`\n",
"2. Ouvrir un nouveau notebook, et placer dans la première cellule:\n",
"\n",
"```\n",
"from utilitaire_notes import *\n",
"notes = [10, 8.9, 9.9, 12.3, 11.1]\n",
"somme(notes)\n",
"```\n",
"\n",
"Vous pouvez alors vous assurer que vos fonctions sont bien importées. Testez certaines d'entre elles."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c0a60623",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "1db63f63",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "ef5ddb4c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "ee6f8a83",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.9"
}
},
"nbformat": 4,
"nbformat_minor": 5
}