diff --git a/algorithmes/CREPIER.md b/algorithmes/CREPIER.md index 31450b5..5c2c7d9 100644 --- a/algorithmes/CREPIER.md +++ b/algorithmes/CREPIER.md @@ -10,7 +10,7 @@ Il faut aider Jean-Michel à remettre les crêpes dans le bon ordre ! Pour cela, il va nous falloir : -- Télécharger le fichier [java](crepe-applet1-jnlp.jnlp) et l'exécuter. Si cela ne fonctionne pas, appeller le professeur. +- Télécharger le fichier [java](crepe-applet1-jnlp.jnlp) et l'exécuter. Si cela ne fonctionne pas, appeler le professeur. - Prendre son temps et comprendre comment cela fonctionne. - Mettre en place nos idées. - Retourner les crêpes ! @@ -59,7 +59,7 @@ En commençant avec six (6) crêpes, je peux donc facilement m'en sortir, voilà étape_2 -- On retourne le tout en cliquant sur la crêpe du bas pour inverser la position entre la crepe la plus large qui est en haut, et la crêpe qui se retrouve en bas. +- On retourne le tout en cliquant sur la crêpe du bas pour inverser la position entre la crêpe la plus large qui est en haut, et la crêpe qui se retrouve en bas. étape_3 diff --git a/algorithmes/DICHOTOMIQUE.md b/algorithmes/DICHOTOMIQUE.md index 0ddbae4..272555c 100644 --- a/algorithmes/DICHOTOMIQUE.md +++ b/algorithmes/DICHOTOMIQUE.md @@ -24,9 +24,9 @@ Supposons un tableau tab : tab = [1,2,6,9,12,14,18,21,42] ``` -Si on souhaite chercher un élèment, par exemple 7, en utilisant le [parcours séquentiel](PARCOURS.md) on fonctionne par balayage (avec une boucle for...) et donc parcourir la liste du début à la fin en colparant chaque valeur à l'élèment recherché. +Si on souhaite chercher un élèment, par exemple 7, en utilisant le [parcours séquentiel](PARCOURS.md) on fonctionne par balayage (avec une boucle for...) et donc parcourir la liste du début à la fin en comparant chaque valeur à l'élèment recherché. -Ici par exemple, on effectuerait 9 comparaison pour finir par dire que non, 7 n'est pas présent. +Ici par exemple, on effectuerait 9 comparaisons pour finir par dire que non, 7 n'est pas présent. Dans le cas d'une liste **déjà triée**, la recherche dichotomique permet d'améliorer les performances. @@ -60,13 +60,13 @@ Montrer le nombre d'étapes nécessaires à la réussite de cette recherche. | Recherche Dichotomique | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | log2N | - Quel est le pire des cas ici ? Que l'élèment recherché ne soit pas dans le tableau. -- Le nombre de tours de boucle de la recherche dichotomique est de l'ordrede log2(n) où *n* est la taille de la liste. +- Le nombre de tours de boucle de la recherche dichotomique est de l'ordre de log2(n) où *n* est la taille de la liste. *Explications* Qu'est ce que le ***Logarithme***: -pour faire simple, le logarithme en base n - écrit logn correspond au nombre de division par n successive pour arriver au nombre 0. +pour faire simple, le logarithme en base n - écrit logn correspond au nombre de divisions par n successives pour arriver au nombre 1. ***Exemple :*** @@ -110,27 +110,25 @@ La recherche dichotomique est donc de complexité ***logarithmique***. Pour vérifier que la recherche dichotomique se termine bien, regardons ensemble son code python - on suppose que le tableau en entrée est déjà trié. -````python -def dichotomique (tab, x): -""" -:param tab: tableau contenant différents élèments déjà triés -:param x: élèment recherché -""" - a = 0 # on initialise la borne inférieure - b = len(tab) - 1 # borne supérieure - while a <= b: # tant que la borne inférieure est plus petite ou égale à la borne supérieure - m = (a + b) // 2 # on se place au milieu du tableau - if tab[m] == x: # si l'élément central est l'élément recherché - return True # alors on a terminé - elif tab[m] < x: # si l'élément central est plus petit que l'élément recherché - a = m + 1 # on déplace la borne minimum vers la sous-partie droite du tableau - else: #si l'élement central n'est ni plus petit ni égal à l'élément recherché, donc s'il est >... - b = m - 1 #on déplace la borne supérieure vers la sous-partie gauche - #si après tout ça on ne trouve pas l'élément... - return False - - -```` +```python +def dichotomique(tab, x): + """ + :param tab: tableau contenant différents élèments déjà triés + :param x: élèment recherché + """ + a = 0 # on initialise la borne inférieure + b = len(tab) - 1 # borne supérieure + while a <= b: # tant que la borne inférieure est plus petite ou égale à la borne supérieure + m = (a + b) // 2 # on se place au milieu du tableau + if tab[m] == x: # si l'élément central est l'élément recherché + return True # alors on a terminé + elif tab[m] < x: # si l'élément central est plus petit que l'élément recherché + a = m + 1 # on déplace la borne minimum vers la sous-partie droite du tableau + else: # si l'élément central est plus grand que l'élément recherché + b = m - 1 # on déplace la borne supérieure vers la sous-partie gauche + # si après tout ça on ne trouve pas l'élément... + return False +``` ----------- diff --git a/algorithmes/PARCOURS.md b/algorithmes/PARCOURS.md index 2391dea..418e915 100644 --- a/algorithmes/PARCOURS.md +++ b/algorithmes/PARCOURS.md @@ -16,7 +16,7 @@ On supposera que tous les tableaux traités ici contiennent des nombres. ### Exemples -#### Recherche d'occurence +#### Recherche d'occurrence Si on souhaite savoir si un élément nommé *e* en particulier se trouve dans un tableau *tab* : @@ -56,7 +56,7 @@ def recherche_max(tab): *Complexité linéaire* -Car on parcours toute la liste et donc pour n élèments, on effectuera n comparaisons. +Car on parcourt toute la liste et donc pour n élèments, on effectuera n comparaisons. -------- @@ -73,13 +73,13 @@ def moyenne(tab): *Complexité linéaire* -Car on parcours toute la liste et donc pour n élèments, on effectuera n comparaisons. +Car on parcourt toute la liste et donc pour n élèments, on effectuera n comparaisons. ----------- #### Autres exemples simples : -- Vérifier si une un tableau est rangé par ordre croissant ou décroissant +- Vérifier si un tableau est rangé par ordre croissant ou décroissant - Chercher un mot de plus de n lettres dans une liste de mots... -------- diff --git a/algorithmes/PROPRIETES.md b/algorithmes/PROPRIETES.md index 8647d8e..91bf17c 100644 --- a/algorithmes/PROPRIETES.md +++ b/algorithmes/PROPRIETES.md @@ -41,8 +41,8 @@ $$ - La **complexité d'un algorithme** est une mesure du temps requis par l'algorithme pour accomplir sa tâche, en fonction de la taille des données à traiter. - On dira d'un problème qu'il est aussi complexe que le meilleur algorithme connu pour le résoudre. -- Si la **complexité** est **constante**, alors le temps d'execution sera sensiblement toujours le même, peu importe la taille du tableau traité. -- Si elle est **logarithmique**, alors le temps d'execution augmente très faiblement quand le paramètre croit. +- Si la **complexité** est **constante**, alors le temps d'exécution sera sensiblement toujours le même, peu importe la taille du tableau traité. +- Si elle est **logarithmique**, alors le temps d'exécution augmente très faiblement quand le paramètre croît. - **Complexité** **linéaire** : le nombre d'étapes à effectuer va varier en proportion directe de la taille de l'échantillon à traiter : si l'échantillon croît par un facteur de 10000, la complexité sera accrue elle aussi par un facteur de 10000. - **Complexité Quadratique** : Dans le cadre du tri par insertion, par exemple, quand on double la taille du tableau, le nombre de comparaisons sera lui multiplié par...4. diff --git a/algorithmes/README.md b/algorithmes/README.md index f02a02f..19df85c 100644 --- a/algorithmes/README.md +++ b/algorithmes/README.md @@ -8,7 +8,7 @@ Un algorithme est une séquence finie d’instructions faite pour être exécut - Logique parce que la personne (ou la machine) qui exécute les instructions sera capable de facilement comprendre et exécuter sans erreur ni ambigüité chacune des instructions. -- Non intelligente parce que la personne qui exécute l’algorithme n'aura qu'à suivre toutes les instructions, dans l'ordre pour arriver au résultat sans avoir a comprendre la méthode de solution. +- Non intelligente parce que la personne qui exécute l’algorithme n'aura qu'à suivre toutes les instructions, dans l'ordre pour arriver au résultat sans avoir à comprendre la méthode de solution. diff --git a/algorithmes/TRIS.md b/algorithmes/TRIS.md index f68244b..a9f18b1 100644 --- a/algorithmes/TRIS.md +++ b/algorithmes/TRIS.md @@ -101,7 +101,7 @@ Le tri par insertion est *naturel* dans l'esprit : on parcourt le tableau de la Une preuve de correction de l'algorithme est la propriété *p(i)* : "le tableau est trié jusqu'à la case n°i" : cette propriété est vraie **avant** et **après** chaque tour de boucle : c'est ce qu'on appelle ***Invariant de boucle*** -À l'inverse, le **variant** de boucle est une expression dans la valeur varie à chaque tour de boucle et qui doit justement permettre de mettre fin à la-dite boucle : le variant d'un algorithme de tri sera alors la taile de la liste restante à trier. +À l'inverse, le **variant** de boucle est une expression dans la valeur varie à chaque tour de boucle et qui doit justement permettre de mettre fin à la-dite boucle : le variant d'un algorithme de tri sera alors la taille de la liste restante à trier. ### Complexité @@ -119,9 +119,9 @@ Merci @https://x.com/Limplementeur pour l'illustration ----------------- -## Tri par selection +## Tri par sélection -> Contrairement au tri par insertion, le tri par selection a pour avantage de déplacer moins de valeurs. +> Contrairement au tri par insertion, le tri par sélection a pour avantage de déplacer moins de valeurs. ![selection](assets/selection.gif) @@ -130,7 +130,7 @@ Principe: - On recherche le plus petit élément et on le met à sa place (indice 0 donc) - Puis on recherche le deuxième plus petit et on le met à l'indice 1 - Et on continue comme cela avec tous les éléments -- Il n'est pas necessaire de faire une copie de la liste +- Il n'est pas nécessaire de faire une copie de la liste - Deux éléments égaux ne resteront pas forcément à la même place Supposons le tableau suivant : @@ -186,7 +186,7 @@ Il faut montrer l'invariant : à la fin du tour i de la boucle for, les cases ta #### Exercices -- Ecrire les fonctions +- Écrire les fonctions ```python tri_selection (tab) @@ -198,7 +198,7 @@ et tri_insertion(tab) ``` -qui permettent de trier différement les tableaux donnés en entrée. +qui permettent de trier différemment les tableaux donnés en entrée. Expliquer pourquoi ces algorithmes sont en O(n2 ) avec vos propres mots. diff --git a/programmation/GENERALITES.md b/programmation/GENERALITES.md index 0290cb8..cffa578 100644 --- a/programmation/GENERALITES.md +++ b/programmation/GENERALITES.md @@ -51,7 +51,7 @@ flowchart LR > Un __langage de programmation__ est un langage proche du langage naturel, utilisable par un humain, et exécutable, après traduction par une machine. -___Sans langage de programmation, un humain devrait connaitre et commander la machine en maitrisant son langage, donc écrire des 0 et des 1.___ +___Sans langage de programmation, un humain devrait connaître et commander la machine en maîtrisant son langage, donc écrire des 0 et des 1.___ ```mermaid flowchart LR diff --git a/programmation/chapitre_1/TD.ipynb b/programmation/chapitre_1/TD.ipynb index 2b14c13..9a2d142 100644 --- a/programmation/chapitre_1/TD.ipynb +++ b/programmation/chapitre_1/TD.ipynb @@ -1 +1,410 @@ -{"cells":[{"metadata":{},"cell_type":"markdown","source":"# TD - Premier pas en Python\n\n## 1. La console\n\nLa __console__ est un endroit où l'on peut écrire du code en Python.\n\nLe code sera exécuté immédiatement dès validation de la ligne, c'est-à-dire dès que vous appuyer sur le bouton Run.\n\n### 1.1. À Faire\n\n1. Éxécuter le code suivant (_sans les >>>_) :\n\n```python\n>>> 5 + 2\n```"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"2. Quel est le résultat obtenu ?"},{"metadata":{},"cell_type":"markdown","source":"#### Bilan 1.1\n\n- A travers ce premier exemple, on constate que Python sait faire des calculs !!\n- Lorsque l'on appuie sur le bouton Run, python lit le code 5 + 2, calcule l'opération associée et restitue le résultat."},{"metadata":{},"cell_type":"markdown","source":"### 1.2. À Faire\n\n1. Écrire et exécuter successivement les instructions suivantes (_sans les >>> et ???_) `\n\n```python\n>>> 5 - 2\n???\n>>> 5 * 2\n???\n>>> 5 / 2\n???\n>>> 5 // 2\n???\n>>> 5 % 2\n???\n>>> 5 ** 2\n???\n```"},{"metadata":{},"cell_type":"markdown","source":"2. Quels sont les résultats obtenus ? Compléter le tableau suivant en décrivant ce que fait l'opérateur de l'instruction."},{"metadata":{},"cell_type":"markdown","source":"| Opérateur | Description |\n| :--: | :-- |\n| - | | \n| * | |\n| / | |\n| // | |\n| % | |\n| * | |"},{"metadata":{},"cell_type":"markdown","source":"#### Bilan 1.2\n\n- Python permet l'utilisation des opérateurs arithmétiques usuelles $+, -, *, /$ sur les entiers,\n- Python permet l'utilisation d'opérateurs arithmétiques avec une syntaxe spécifique comme $//, \\%, **$ "},{"metadata":{},"cell_type":"markdown","source":"### 1.3. À Faire\n\nExécuter le code suivant. Que constatez-vous ?\n\n```python\n>>> # 3 + 2\n???\n```"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### 1.4. À Faire\n\n1. En prenant votre âge à votre prochaine date d'anniversaire (en nombre d'années), écrire une instruction qui calcule le nombre de jours équivalents (on considère qu'une année correspond à 365 jours)"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"2. Sachant qu'à mon prochain anniversaire j'aurai 9490 jours, écrire une instruction qui calcule mon âge, en nombre d'années :"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"3. Sachant que mon logement se situe au 256 de la rue (dont je tairais le nom pour ne pas être localisé ;-)) et que toutes les maisons font 12 mètres et demi de longueur, à quelle distance se situe ma maison par rapport au début de la rue ?"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"#### Bilan 1.4\n\n- Outre des entiers, Python permet d'utiliser des nombres décimaux en utilisant le symbole \".\" pour séparer la partie entière et la partie décimale."},{"metadata":{},"cell_type":"markdown","source":"## 2. Les variables\n\nEn informatique, il est indispensable de conserver des informations de natures diverses. Par exemple, votre smartphone enregistre dans sa mémoire votre numéro de téléphone, les numéros de téléphones de vos contacts, vos messages (SMS), vos photos, vos applications, etc. Chacune de ces informations est stockée à un endroit précis dans la mémoire dans ce qu’on appelle une variable.\n\n### 2.1. Définition\n\n> Une __variable__ est un __espace de stockage__ de la mémoire (une case mémoire). Chaque variable est caractérisée par son __nom__, son __type__ et sa __valeur__.\n\n## 3. Valeur des variables\n\n### 3.1. Affecter une valeur à une variable\n\n#### 3.1.1. À Faire\n\nCopier et exécuter les instructions suivantes\n\n```python\n>>> a = 5\n>>> b = 2\n>>> a + b\n???\n```"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"#### Bilan 3.1.1\n\n1. La syntaxe pour déclarer et affecter une valeur a une variable est `nom_de_la_variable = valeur`\n2. Pour les instructions 1 et 2, Le signe `=` indique que la valeur 5 est affectée à la variable `a` et 2 à la variable `b`.\n3. Lorsque Python interprète l'instruction 3, il lit les valeurs associées aux variables et effectue l'opération."},{"metadata":{},"cell_type":"markdown","source":"## 4. Nom des variables\n\nChaque variable possède un nom qui permet d’identifier l’emplacement mémoire correspondant.\n\nDans le langage Python, il y a des règles à respecter pour nommmer les variables. Voici celles qui vous concernent :\n\n- __Règle 1__ : un nom ne peut contenir que des lettres __en minuscule__ (a-z), des chiffres (0 - 9) et le caractère _ (underscore).\n- __Règle 2__ : un nom ne peut pas commencer par un chiffre.\n- __Règle 3__ : les noms sont sensibles à la casse, cela signifie qu’il y a une distinction entre les minuscules et les majuscules : la variable nommée `nsi` est différente de la variable `Nsi`.\n- __Règle 4__ : il est préférable de toujours choisir un nom de variable représentatif : par exemple, si vous voulez stocker le nom d’une personne dans une variable, il est préférable de l’appeler nom plutôt que x.\n- __Règle 5__ : il est préférable de ne pas utiliser de caractères accentués dans le nom d’une variable (nous n’entrerons pas dans le pourquoi du comment)."},{"metadata":{},"cell_type":"markdown","source":"### 4.1. À Faire\n\n1. Quels sont les noms de variables incorrects parmi ceux proposés ? Vous indiquerez pourquoi.\n\n| Noms de variable | Correct ou Incorrect | Pourquoi (si Incorrect) |\n| :--: | :--: | :-- | \n| `prix achat` | | |\n| `prix_achat` | | |\n| `note` | | | \n| `2ndeG` | | |\n| `SecondeG` | | | \n| `Seconde:G`| | |\n| `dix-huit` | | |"},{"metadata":{},"cell_type":"markdown","source":"2. Proposez un nom de variable permettant de stocker :\n\n| Variable | Nom de variable |\n| :-- | :--: |\n| le nombre de personnes aux yeux bleus de Premiere G | |\n| le tarif d’un repas au self | |\n| l’aire d’un triangle (il n’y a qu’une seule figure) | |\n| la note à un devoir d’anglais | |"},{"metadata":{},"cell_type":"markdown","source":"## 5. Type des variables\n\nDans les travaux à faire précédent, nous avons manipulé essentiellement des entiers.\n\nPython gère différents types de variables. \n\nL'objet de cette section est d'expliciter la notion de type et les opérations associées :\n\n- le type __entier__ : il désigne les entiers relatifs (positifs ou négatifs). En Python on parle du type `int` (pour integer qui signifie « entier » en anglais) ;\n- le type __flottant__ : il désigne les nombres décimaux (à virgule). En Python on parle du type `float` (pour floating qui signifie « flottant » en anglais)\n- le type __chaîne de caractères__ : il désigne toute suite ordonnée de caractères. En Python on parle du type `str` (pour string qui signifie « chaîne » en anglais).\n\n### 5.1. À Faire\n\nIndiquez le type des variables permettant de stocker (sur votre smartphone) les informations suivantes :\n\n| Variable | Type identifié |\n| :--: | :-- |\n| le nom d’un contact | |\n| le numéro de téléphone d’un contact | |\n| un SMS | |\n| l’heure du réveil | |\n| le code de votre partage de connexion Wi-Fi | |\n| le pourcentage affiché de batterie restante | |\n| les notes aux deux derniers devoirs de Mathématiques de l'année dernière | |"},{"metadata":{},"cell_type":"markdown","source":"## 5.2. Type entier (int)\n\nPour affecter (on dit aussi assigner) la valeur 17 à la variable nommée `age`\n\n```python\n>>> age = 17\n```\n\nLa fonction `print` affiche la valeur de la variable :\n\n```python\n>>> print(age)\n17\n```\n\nLa fonction `type` renvoie le type de la variable :\n\n```python\n>>> type (age)\n\n```\n"},{"metadata":{},"cell_type":"markdown","source":"## 5.3. Type flottant (float)\n\nPour affecter (on dit aussi assigner) la valeur 1,70 à la variable nommée `taille`\n\n```python\n>>> taille = 1.7\n```\n\nLa fonction `print` affiche la valeur de la variable :\n\n```python\n>>> print(taille)\n1.7\n```\n\nLa fonction `type` renvoie le type de la variable :\n\n```python\n>>> type (taille)\n\n```\nLa notation scientifique est acceptée :\n```python\n>>> taille = 1.7e2 #taille en cm où 1m = 100cm = 10**2cm\n>>> print (taille)\n170.0\n```"},{"metadata":{},"cell_type":"markdown","source":"## 5.4. Type chaine de caractères (str)\n\nPour affecter (on dit aussi assigner) la valeur `lundi` à la variable nommée `jour`\n\n```python\n>>> jour = 'lundi' # autre possibilité jour = \"lundi\"\n```\n\nLa valeur doit être entre guillemet simple (autrement dit côte) ou guillemet double.\n\nLa fonction `print` affiche la valeur de la variable :\n\n```python\n>>> print(jour)\nlundi\n```\n\n```python\n>>> mois = \"septembre\"\n>>> print (jour, mois) # print permet d'afficher plusieurs valeurs à la suite, ne pas oublier la virgule\nlundi septembre\n```\n\nLa fonction `type` renvoie le type de la variable :\n\n```python\n>>> type (jour)\n\n```\n\nLa fonction `len` renvoie la longueur (length) de la chaîne de caractères :\n\n```python\n>>> print(len(jour))\n4\n```"},{"metadata":{},"cell_type":"markdown","source":"### 5.4.1 À Faire\n\nCopier et exécuter les instructions suivantes\n\n```python\n>>> a = \"Je suis\"\n>>> b = \" Yoda \"\n>>> a + b \n???\n>>> b + a\n???\n```"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Bilan 5.4.1\n\nComme vous le voyez, on peut ajouter deux chaînes : c'est une ___concaténation___, la mise bout à bout de plusieurs chaînes de caractères."},{"metadata":{},"cell_type":"markdown","source":"### 5.4.2 À Faire\n\nCopier et exécuter les instructions suivantes\n\n```python\n>>> mot = \"lycée\"\n>>> print(mot[0])\n???\n>>> print(mot[1])\n???\n>>> print(mot[1:4])\n???\n>>> print(mot[2:])\n???\n>>> print(mot[:2])\n???\n>>> print(mot[-1])\n???\n```"},{"metadata":{},"cell_type":"markdown","source":"### Bilan 5.4.2\n\nSelon les résultats obtenus, que permet d'obtenir l'utilisation des crochets sur une variable de type chaine de caractères :\n\n- variable[indice] : ???\n- variable[indice1:indice2] : ???\n- variable[indice:] : ???\n- variable[:indice] : ???\n- variable[-1] : ???\n\nPar convention, on appelle _indice_ les valeurs entre crochets."},{"metadata":{},"cell_type":"markdown","source":"## 5.5 Conversion de type\n\nCependant, on ne peut pas ajouter n'importe quoi.\n\nCopier et exécuter les instructions suivantes :\n\n```python\n>>> a = 'Je mesure '\n>>> b = 1.12\n>>> c = 'm'\n>>> a + b + c\n???\n```"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Cela ne marche pas car les variables ne sont pas du même *type*. Il faut les convertir en utilisant :\n\n- soit la fonction `str(nombre)` qui convertit le nombre en chaîne.\n- soit la fonction `int(chaîne)` qui convertit, si possible, la chaîne en entier.\n- soit la fonction `float(chaîne)` qui convertit, si possible ,la chaîne en flottant.\n\n```python\n>>> str(b)\n???\n>>> a + str(b) + c\n???\n>>> str(b) + c + a\n???\n```"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## 6. Les fonctions mathématiques\n\nPour utiliser les fonctions mathématiques, il faut commencer par importer le module math :\n\n```python\n>>> import math\n```\n\nLa fonction `dir` renvoie la liste des fonctions et données d'un module :\n\n```python\n>>> dir(math)\n['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan',\n'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf',\n'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum',\n'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p',\n'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']\n```\n\nPour appeler une fonction d'un module, la syntaxe est la suivante : `module.fonction(arguments)`\n\nExemple :\n\n```python\n>>> math.sqrt(9)\n3.0\n```\n\nLa fonction `help` affiche l'aide, c'est-à-dire ce que fait la fonction\n\n```python\n>>> help(sqrt)\nHelp on built-in function sqrt in module math:\n\nsqrt(x, /)\n Return the square root of x.\n```"},{"metadata":{},"cell_type":"markdown","source":"## 7. Saisie utilisateur : fonction `input`\n\nCopier et exécuter l'instruction suivante :\n\n```python\n>>> input(\"As-tu un message ? \")\n???\n```"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Bilan : La fonction `input` permet d'obtenir une valeur saisie par l'utilisateur.\n\n___N.B : La valeur saisie est toujours du ___"},{"metadata":{},"cell_type":"markdown","source":"## 6. Exercices"},{"metadata":{},"cell_type":"markdown","source":"### Exercice 1\n\nL’indice de masse corporelle (IMC) est le seul indice validé par l’Organisation mondiale de la santé pour évaluer les éventuels risques pour la santé.\n\nIl s'exprime par la formule `IMC = poids (kg) / taille (m²)`\n\nJe mesure 170cm pour un poids de 3/4 de quintal. \n\n1. Exprimer les différentes données sous forme de variables et l'expression permettant de calculer l'IMC.\n2. Donner les instructions permettant de donner les types des différentes variables et du résultat obtenu."},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Exercice 2\n\nAfficher la taille en octets et en bits d'un fichier de 536 kio.\n\nOn donne : \n\n- 1 kio (1 kibi octet) = 1024 octets !!!\n- 1 octet = 8 bits"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Exercice 3\n\nOn considère le programme Python suivant.\n\n```python\na = 8\nb = 3\na = a - 4\nb = 2 * b\na = a + b\nprint(a)\n```\n\n1. Combien de variables sont utilisées ? Combien de valeurs différentes ont-elles prises au cours de l’exécution du programme ?\n2. Quelle est la valeur finale de la variable `a` ?\n3. Il est possible d’afficher plusieurs valeurs avec la fonction `print`. Par exemple, si on veut afficher les valeurs des variables `a` et `b` on écrit simplement `print(a, b)`. Modifiez la dernière ligne du programme et exécutez-le."},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Exercice 4\n\nOn considère le programme de calcul suivant.\n\n- a prend la valeur 5\n- Multiplier a par 3\n- Soustraire 4 au résultat\n- Elever le résultat au carré\n- Afficher le résultat\n\nÉcrire un programme Python permettant de coder ce programme de calcul. Vérifiez ensuite en l'exécutant."},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Exercice 5\n\nSur un site de vente en ligne, on peut acheter différents articles. Un paquet de farine d'un kg coûte 1,15 € et une boîte de six oeufs coûte 1,50 €.\n\nÉcrire un programme Python qui utilise deux variables pour stocker le nombre de paquets de farine et de boîtes d'oeufs souhaités puis, qui calcule et affiche le prix total à payer pour la commande."},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Exercice 6\n\nÀ partir de deux variables `prenom` et `nom`, afficher les initiales (par exemple LM pour Léa Martin)."},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Exercice 7\n\nL'identifiant d'accès au réseau du lycée est construit de la manière suivante : initiale du prénom puis les 8 premiers caractères du nom.\n\nExemple : Alexandre Lecouturier → alecoutur\n\nA partir des deux variables `prenom` et `nom`, construire l'identifiant."},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Exercice 8\n\nÉcrire un programme qui donne la pointure du pied demandé à l'utilisateur et affiche la taille du pied sachant qu'en France, la pointure correspond à 3/2 de la longueur du pied exprimée en centimètres et à laquelle on a au préalable ajouté un centimètre. (Vous pouvez vérifier votre résultat via ce [site](https://2-grande-taille.com/conversion-pointures)"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Exercice 9\n\n![Triangle rectangle, Source : Wikipedia](https://upload.wikimedia.org/wikipedia/commons/8/85/Triangle_aire.png)\n\nÉcrire un programme qui demande 2 entiers sous la forme \"a, h\" où a et h sont des nombres à 1 seule chiffre représentant respectivement la base et la hauteur d'une triangle rectangle. Afficher l'aire du triangle."},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Exercice 10\n\n![Triangle quelconque, Source : Wikipedia](https://upload.wikimedia.org/wikipedia/commons/thumb/8/8e/Triangle_with_notations.svg/320px-Triangle_with_notations.svg.png)\n\nÉcrire un programme qui demande 3 entiers sous la forme \"a, b, c\" où a, b et c sont des nombres à 1 seule chiffre et calculer l'aire du triangle quelconque formés par ces 3 longueurs.\n\n__N.B : Le calcul de l'aire d'un triangle quelconque s'effectue par l'application de la formule du Héron.__"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"display_name":"Python 3","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.9.7"}},"nbformat":4,"nbformat_minor":2} \ No newline at end of file +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": "# TD - Premier pas en Python\n\n## 1. La console\n\nLa __console__ est un endroit où l'on peut écrire du code en Python.\n\nLe code sera exécuté immédiatement dès validation de la ligne, c'est-à-dire dès que vous appuyer sur le bouton Run.\n\n### 1.1. À Faire\n\n1. Éxécuter le code suivant (_sans les >>>_) :\n\n```python\n>>> 5 + 2\n```" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "2. Quel est le résultat obtenu ?" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "#### Bilan 1.1\n\n- A travers ce premier exemple, on constate que Python sait faire des calculs !!\n- Lorsque l'on appuie sur le bouton Run, python lit le code 5 + 2, calcule l'opération associée et restitue le résultat." + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### 1.2. À Faire\n\n1. Écrire et exécuter successivement les instructions suivantes (_sans les >>> et ???_) `\n\n```python\n>>> 5 - 2\n???\n>>> 5 * 2\n???\n>>> 5 / 2\n???\n>>> 5 // 2\n???\n>>> 5 % 2\n???\n>>> 5 ** 2\n???\n```" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "2. Quels sont les résultats obtenus ? Compléter le tableau suivant en décrivant ce que fait l'opérateur de l'instruction." + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "| Opérateur | Description |\n| :--: | :-- |\n| - | | \n| * | |\n| / | |\n| // | |\n| % | |\n| * | |" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "#### Bilan 1.2\n\n- Python permet l'utilisation des opérateurs arithmétiques usuelles $+, -, *, /$ sur les entiers,\n- Python permet l'utilisation d'opérateurs arithmétiques avec une syntaxe spécifique comme $//, \\%, **$ " + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### 1.3. À Faire\n\nExécuter le code suivant. Que constatez-vous ?\n\n```python\n>>> # 3 + 2\n???\n```" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### 1.4. À Faire\n\n1. En prenant votre âge à votre prochaine date d'anniversaire (en nombre d'années), écrire une instruction qui calcule le nombre de jours équivalents (on considère qu'une année correspond à 365 jours)" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "2. Sachant qu'à mon prochain anniversaire j'aurai 9490 jours, écrire une instruction qui calcule mon âge, en nombre d'années :" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "3. Sachant que mon logement se situe au 256 de la rue (dont je tairais le nom pour ne pas être localisé ;-)) et que toutes les maisons font 12 mètres et demi de longueur, à quelle distance se situe ma maison par rapport au début de la rue ?" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "#### Bilan 1.4\n\n- Outre des entiers, Python permet d'utiliser des nombres décimaux en utilisant le symbole \".\" pour séparer la partie entière et la partie décimale." + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 2. Les variables\n\nEn informatique, il est indispensable de conserver des informations de natures diverses. Par exemple, votre smartphone enregistre dans sa mémoire votre numéro de téléphone, les numéros de téléphones de vos contacts, vos messages (SMS), vos photos, vos applications, etc. Chacune de ces informations est stockée à un endroit précis dans la mémoire dans ce qu’on appelle une variable.\n\n### 2.1. Définition\n\n> Une __variable__ est un __espace de stockage__ de la mémoire (une case mémoire). Chaque variable est caractérisée par son __nom__, son __type__ et sa __valeur__.\n\n## 3. Valeur des variables\n\n### 3.1. Affecter une valeur à une variable\n\n#### 3.1.1. À Faire\n\nCopier et exécuter les instructions suivantes\n\n```python\n>>> a = 5\n>>> b = 2\n>>> a + b\n???\n```" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "#### Bilan 3.1.1\n\n1. La syntaxe pour déclarer et affecter une valeur a une variable est `nom_de_la_variable = valeur`\n2. Pour les instructions 1 et 2, Le signe `=` indique que la valeur 5 est affectée à la variable `a` et 2 à la variable `b`.\n3. Lorsque Python interprète l'instruction 3, il lit les valeurs associées aux variables et effectue l'opération." + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 4. Nom des variables\n\nChaque variable possède un nom qui permet d’identifier l’emplacement mémoire correspondant.\n\nDans le langage Python, il y a des règles à respecter pour nommmer les variables. Voici celles qui vous concernent :\n\n- __Règle 1__ : un nom ne peut contenir que des lettres __en minuscule__ (a-z), des chiffres (0 - 9) et le caractère _ (underscore).\n- __Règle 2__ : un nom ne peut pas commencer par un chiffre.\n- __Règle 3__ : les noms sont sensibles à la casse, cela signifie qu’il y a une distinction entre les minuscules et les majuscules : la variable nommée `nsi` est différente de la variable `Nsi`.\n- __Règle 4__ : il est préférable de toujours choisir un nom de variable représentatif : par exemple, si vous voulez stocker le nom d’une personne dans une variable, il est préférable de l’appeler nom plutôt que x.\n- __Règle 5__ : il est préférable de ne pas utiliser de caractères accentués dans le nom d’une variable (nous n’entrerons pas dans le pourquoi du comment)." + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### 4.1. À Faire\n\n1. Quels sont les noms de variables incorrects parmi ceux proposés ? Vous indiquerez pourquoi.\n\n| Noms de variable | Correct ou Incorrect | Pourquoi (si Incorrect) |\n| :--: | :--: | :-- | \n| `prix achat` | | |\n| `prix_achat` | | |\n| `note` | | | \n| `2ndeG` | | |\n| `SecondeG` | | | \n| `Seconde:G`| | |\n| `dix-huit` | | |" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "2. Proposez un nom de variable permettant de stocker :\n\n| Variable | Nom de variable |\n| :-- | :--: |\n| le nombre de personnes aux yeux bleus de Premiere G | |\n| le tarif d’un repas au self | |\n| l’aire d’un triangle (il n’y a qu’une seule figure) | |\n| la note à un devoir d’anglais | |" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 5. Type des variables\n\nDans les travaux à faire précédent, nous avons manipulé essentiellement des entiers.\n\nPython gère différents types de variables. \n\nL'objet de cette section est d'expliciter la notion de type et les opérations associées :\n\n- le type __entier__ : il désigne les entiers relatifs (positifs ou négatifs). En Python on parle du type `int` (pour integer qui signifie « entier » en anglais) ;\n- le type __flottant__ : il désigne les nombres décimaux (à virgule). En Python on parle du type `float` (pour floating qui signifie « flottant » en anglais)\n- le type __chaîne de caractères__ : il désigne toute suite ordonnée de caractères. En Python on parle du type `str` (pour string qui signifie « chaîne » en anglais).\n\n### 5.1. À Faire\n\nIndiquez le type des variables permettant de stocker (sur votre smartphone) les informations suivantes :\n\n| Variable | Type identifié |\n| :--: | :-- |\n| le nom d’un contact | |\n| le numéro de téléphone d’un contact | |\n| un SMS | |\n| l’heure du réveil | |\n| le code de votre partage de connexion Wi-Fi | |\n| le pourcentage affiché de batterie restante | |\n| les notes aux deux derniers devoirs de Mathématiques de l'année dernière | |" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 5.2. Type entier (int)\n\nPour affecter (on dit aussi assigner) la valeur 17 à la variable nommée `age`\n\n```python\n>>> age = 17\n```\n\nLa fonction `print` affiche la valeur de la variable :\n\n```python\n>>> print(age)\n17\n```\n\nLa fonction `type` renvoie le type de la variable :\n\n```python\n>>> type (age)\n\n```\n" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 5.3. Type flottant (float)\n\nPour affecter (on dit aussi assigner) la valeur 1,70 à la variable nommée `taille`\n\n```python\n>>> taille = 1.7\n```\n\nLa fonction `print` affiche la valeur de la variable :\n\n```python\n>>> print(taille)\n1.7\n```\n\nLa fonction `type` renvoie le type de la variable :\n\n```python\n>>> type (taille)\n\n```\nLa notation scientifique est acceptée :\n```python\n>>> taille = 1.7e2 #taille en cm où 1m = 100cm = 10**2cm\n>>> print (taille)\n170.0\n```" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 5.4. Type chaine de caractères (str)\n\nPour affecter (on dit aussi assigner) la valeur `lundi` à la variable nommée `jour`\n\n```python\n>>> jour = 'lundi' # autre possibilité jour = \"lundi\"\n```\n\nLa valeur doit être entre guillemet simple (autrement dit côte) ou guillemet double.\n\nLa fonction `print` affiche la valeur de la variable :\n\n```python\n>>> print(jour)\nlundi\n```\n\n```python\n>>> mois = \"septembre\"\n>>> print (jour, mois) # print permet d'afficher plusieurs valeurs à la suite, ne pas oublier la virgule\nlundi septembre\n```\n\nLa fonction `type` renvoie le type de la variable :\n\n```python\n>>> type (jour)\n\n```\n\nLa fonction `len` renvoie la longueur (length) de la chaîne de caractères :\n\n```python\n>>> print(len(jour))\n5\n```" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### 5.4.1 À Faire\n\nCopier et exécuter les instructions suivantes\n\n```python\n>>> a = \"Je suis\"\n>>> b = \" Yoda \"\n>>> a + b \n???\n>>> b + a\n???\n```" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Bilan 5.4.1\n\nComme vous le voyez, on peut ajouter deux chaînes : c'est une ___concaténation___, la mise bout à bout de plusieurs chaînes de caractères." + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### 5.4.2 À Faire\n\nCopier et exécuter les instructions suivantes\n\n```python\n>>> mot = \"lycée\"\n>>> print(mot[0])\n???\n>>> print(mot[1])\n???\n>>> print(mot[1:4])\n???\n>>> print(mot[2:])\n???\n>>> print(mot[:2])\n???\n>>> print(mot[-1])\n???\n```" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Bilan 5.4.2\n\nSelon les résultats obtenus, que permet d'obtenir l'utilisation des crochets sur une variable de type chaine de caractères :\n\n- variable[indice] : ???\n- variable[indice1:indice2] : ???\n- variable[indice:] : ???\n- variable[:indice] : ???\n- variable[-1] : ???\n\nPar convention, on appelle _indice_ les valeurs entre crochets." + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 5.5 Conversion de type\n\nCependant, on ne peut pas ajouter n'importe quoi.\n\nCopier et exécuter les instructions suivantes :\n\n```python\n>>> a = 'Je mesure '\n>>> b = 1.12\n>>> c = 'm'\n>>> a + b + c\n???\n```" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Cela ne marche pas car les variables ne sont pas du même *type*. Il faut les convertir en utilisant :\n\n- soit la fonction `str(nombre)` qui convertit le nombre en chaîne.\n- soit la fonction `int(chaîne)` qui convertit, si possible, la chaîne en entier.\n- soit la fonction `float(chaîne)` qui convertit, si possible ,la chaîne en flottant.\n\n```python\n>>> str(b)\n???\n>>> a + str(b) + c\n???\n>>> str(b) + c + a\n???\n```" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 6. Les fonctions mathématiques\n\nPour utiliser les fonctions mathématiques, il faut commencer par importer le module math :\n\n```python\n>>> import math\n```\n\nLa fonction `dir` renvoie la liste des fonctions et données d'un module :\n\n```python\n>>> dir(math)\n['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan',\n'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf',\n'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum',\n'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p',\n'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']\n```\n\nPour appeler une fonction d'un module, la syntaxe est la suivante : `module.fonction(arguments)`\n\nExemple :\n\n```python\n>>> math.sqrt(9)\n3.0\n```\n\nLa fonction `help` affiche l'aide, c'est-à-dire ce que fait la fonction\n\n```python\n>>> help(sqrt)\nHelp on built-in function sqrt in module math:\n\nsqrt(x, /)\n Return the square root of x.\n```" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 7. Saisie utilisateur : fonction `input`\n\nCopier et exécuter l'instruction suivante :\n\n```python\n>>> input(\"As-tu un message ? \")\n???\n```" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Bilan : La fonction `input` permet d'obtenir une valeur saisie par l'utilisateur.\n\n___N.B : La valeur saisie est toujours du ___" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 6. Exercices" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Exercice 1\n\nL’indice de masse corporelle (IMC) est le seul indice validé par l’Organisation mondiale de la santé pour évaluer les éventuels risques pour la santé.\n\nIl s'exprime par la formule `IMC = poids (kg) / taille (m²)`\n\nJe mesure 170cm pour un poids de 3/4 de quintal. \n\n1. Exprimer les différentes données sous forme de variables et l'expression permettant de calculer l'IMC.\n2. Donner les instructions permettant de donner les types des différentes variables et du résultat obtenu." + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Exercice 2\n\nAfficher la taille en octets et en bits d'un fichier de 536 kio.\n\nOn donne : \n\n- 1 kio (1 kibi octet) = 1024 octets !!!\n- 1 octet = 8 bits" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Exercice 3\n\nOn considère le programme Python suivant.\n\n```python\na = 8\nb = 3\na = a - 4\nb = 2 * b\na = a + b\nprint(a)\n```\n\n1. Combien de variables sont utilisées ? Combien de valeurs différentes ont-elles prises au cours de l’exécution du programme ?\n2. Quelle est la valeur finale de la variable `a` ?\n3. Il est possible d’afficher plusieurs valeurs avec la fonction `print`. Par exemple, si on veut afficher les valeurs des variables `a` et `b` on écrit simplement `print(a, b)`. Modifiez la dernière ligne du programme et exécutez-le." + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Exercice 4\n\nOn considère le programme de calcul suivant.\n\n- a prend la valeur 5\n- Multiplier a par 3\n- Soustraire 4 au résultat\n- Elever le résultat au carré\n- Afficher le résultat\n\nÉcrire un programme Python permettant de coder ce programme de calcul. Vérifiez ensuite en l'exécutant." + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Exercice 5\n\nSur un site de vente en ligne, on peut acheter différents articles. Un paquet de farine d'un kg coûte 1,15 € et une boîte de six oeufs coûte 1,50 €.\n\nÉcrire un programme Python qui utilise deux variables pour stocker le nombre de paquets de farine et de boîtes d'oeufs souhaités puis, qui calcule et affiche le prix total à payer pour la commande." + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Exercice 6\n\nÀ partir de deux variables `prenom` et `nom`, afficher les initiales (par exemple LM pour Léa Martin)." + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Exercice 7\n\nL'identifiant d'accès au réseau du lycée est construit de la manière suivante : initiale du prénom puis les 8 premiers caractères du nom.\n\nExemple : Alexandre Lecouturier → alecoutur\n\nA partir des deux variables `prenom` et `nom`, construire l'identifiant." + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Exercice 8\n\nÉcrire un programme qui donne la pointure du pied demandé à l'utilisateur et affiche la taille du pied sachant qu'en France, la pointure correspond à 3/2 de la longueur du pied exprimée en centimètres et à laquelle on a au préalable ajouté un centimètre. (Vous pouvez vérifier votre résultat via ce [site](https://2-grande-taille.com/conversion-pointures)" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Exercice 9\n\n![Triangle rectangle, Source : Wikipedia](https://upload.wikimedia.org/wikipedia/commons/8/85/Triangle_aire.png)\n\nÉcrire un programme qui demande 2 entiers sous la forme \"a, h\" où a et h sont des nombres à 1 seule chiffre représentant respectivement la base et la hauteur d'une triangle rectangle. Afficher l'aire du triangle." + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Exercice 10\n\n![Triangle quelconque, Source : Wikipedia](https://upload.wikimedia.org/wikipedia/commons/thumb/8/8e/Triangle_with_notations.svg/320px-Triangle_with_notations.svg.png)\n\nÉcrire un programme qui demande 3 entiers sous la forme \"a, b, c\" où a, b et c sont des nombres à 1 seule chiffre et calculer l'aire du triangle quelconque formés par ces 3 longueurs.\n\n__N.B : Le calcul de l'aire d'un triangle quelconque s'effectue par l'application de la formule du Héron.__" + }, + { + "metadata": { + "trusted": false + }, + "cell_type": "code", + "source": "", + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/programmation/chapitre_2/TD.ipynb b/programmation/chapitre_2/TD.ipynb index c119c34..12754d7 100644 --- a/programmation/chapitre_2/TD.ipynb +++ b/programmation/chapitre_2/TD.ipynb @@ -146,36 +146,7 @@ { "cell_type": "markdown", "metadata": {}, - "source": [ - "## 5. Cas : Si...Alors...Sinon Si\n", - "\n", - "Dans cette structure on teste plusieurs conditions\n", - "\n", - "```\n", - " if condition1:\n", - " instruction1\n", - " elif condition2:\n", - " instruction2\n", - " instruction3\n", - " elif condition3:\n", - " instruction4\n", - " else:\n", - " instruction5\n", - "```\n", - "\n", - "Exemple :\n", - "\n", - "Imaginons les conditions de passage d'un piéton en fonction du feu de signalisation et du nombre de voitures passantes :\n", - "\n", - "```python\n", - "if feu == 'VERT':\n", - "\tprint('Piéton, vous pouvez passer')\n", - "elif voitures = 0 : # le feu est rouge\n", - " print('Piéton, vous pouvez passer mais attention')\n", - "else: # le feu est rouge et il y a des voitures\n", - "\tprint('Piéton, vous ne pouvez passer')\n", - "```" - ] + "source": "## 5. Cas : Si...Alors...Sinon Si\n\nDans cette structure on teste plusieurs conditions\n\n```\n if condition1:\n instruction1\n elif condition2:\n instruction2\n instruction3\n elif condition3:\n instruction4\n else:\n instruction5\n```\n\nExemple :\n\nImaginons les conditions de passage d'un piéton en fonction du feu de signalisation et du nombre de voitures passantes :\n\n```python\nif feu == 'VERT':\n\tprint('Piéton, vous pouvez passer')\nelif voitures == 0 : # le feu est rouge\n print('Piéton, vous pouvez passer mais attention')\nelse: # le feu est rouge et il y a des voitures\n\tprint('Piéton, vous ne pouvez passer')\n```" }, { "cell_type": "markdown", @@ -516,4 +487,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file diff --git a/programmation/chapitre_4/TD.ipynb b/programmation/chapitre_4/TD.ipynb index 094edc9..3404ad0 100644 --- a/programmation/chapitre_4/TD.ipynb +++ b/programmation/chapitre_4/TD.ipynb @@ -108,53 +108,7 @@ { "cell_type": "markdown", "metadata": {}, - "source": [ - "## 2. Déclaration d'une fonction\n", - "\n", - "Dans un langage de programmation, on utilise ce qu'on appelle des __fonctions__. Une __fonction__ est un ensemble d'instructions qui peut recevoir des __arguments__ et qui peut renvoyer un __résultat__ qui est souvent le contenu d'une ou plusieurs variables.\n", - "\n", - "En Python, on définit une fonction en utilisant l'instruction `def` (de l'anglais define, qui veut dire \"définir\") :\n", - "\n", - "```python\n", - "def nom_de_la_fonction(parametre1, parametre2, ..., parametreN):\n", - " corps_de_la_fonction\n", - "```\n", - "\n", - "- l'instruction `def` est suivie du nom de la fonction ;\n", - "- les __paramètres__ de la fonction sont ensuite écrits entre parenthèses et séparés par des virgules ;\n", - "- il existe des fonctions sans paramètre, les parenthèses sont néanmoins obligatoires et restent vides ;\n", - "- il ne faut pas oublier les __deux points__ après les parenthèses de la première ligne ;\n", - "- le corps de la fonction est un bloc d'instructions qui contient toutes les lignes qui doivent être exécutées lorsque la fonction est appelée. Le corps de la fonction doit nécessairement être __indenté__, c'est-à-dire qu'il doit être décalé d'une tabulation par rapport à l'instruction `def`.\n", - "\n", - "Très souvent, le corps de la fonction se terminera par l'instruction `return` suivie de la ou des valeurs que la fonction doit renvoyer. Si la fonction doit renvoyer plusieurs valeurs, celles-ci sont à séparer par des virgules.\n", - "\n", - "Ainsi, le schéma général d'une fonction Python est :\n", - "\n", - "```python\n", - "def nom_de_la_fonction(parametre1, parametre2, ..., parametreN):\n", - " instructions # sur plusieurs lignes éventuellement\n", - " return valeur1, valeur2, valeur3, etc. # souvent une fonction ne renvoie qu'une valeur\n", - "````\n", - "\n", - "Exemple : Voici la fonction inverse implantée en Python\n", - "\n", - "```python\n", - "def inverse(x):\n", - " y = 1 / x\n", - " return y\n", - "```\n", - "\n", - "que l'on peut aussi écrire plus simplement :\n", - "\n", - "```python\n", - "def inverse(x):\n", - " return 1 / y\n", - "```\n", - "\n", - "Identifiez dans ces deux fonctions écrites différemment : leur nom, leur(s) paramètre(s), leur corps, leur(s) valeur(s) renvoyée(s).\n", - "\n", - "Remarque : il existe des fonctions qui ne renvoient aucune valeur, l'instruction return n'est donc pas utilisée dans le corps de ces fonctions." - ] + "source": "## 2. Déclaration d'une fonction\n\nDans un langage de programmation, on utilise ce qu'on appelle des __fonctions__. Une __fonction__ est un ensemble d'instructions qui peut recevoir des __arguments__ et qui peut renvoyer un __résultat__ qui est souvent le contenu d'une ou plusieurs variables.\n\nEn Python, on définit une fonction en utilisant l'instruction `def` (de l'anglais define, qui veut dire \"définir\") :\n\n```python\ndef nom_de_la_fonction(parametre1, parametre2, ..., parametreN):\n corps_de_la_fonction\n```\n\n- l'instruction `def` est suivie du nom de la fonction ;\n- les __paramètres__ de la fonction sont ensuite écrits entre parenthèses et séparés par des virgules ;\n- il existe des fonctions sans paramètre, les parenthèses sont néanmoins obligatoires et restent vides ;\n- il ne faut pas oublier les __deux points__ après les parenthèses de la première ligne ;\n- le corps de la fonction est un bloc d'instructions qui contient toutes les lignes qui doivent être exécutées lorsque la fonction est appelée. Le corps de la fonction doit nécessairement être __indenté__, c'est-à-dire qu'il doit être décalé d'une tabulation par rapport à l'instruction `def`.\n\nTrès souvent, le corps de la fonction se terminera par l'instruction `return` suivie de la ou des valeurs que la fonction doit renvoyer. Si la fonction doit renvoyer plusieurs valeurs, celles-ci sont à séparer par des virgules.\n\nAinsi, le schéma général d'une fonction Python est :\n\n```python\ndef nom_de_la_fonction(parametre1, parametre2, ..., parametreN):\n instructions # sur plusieurs lignes éventuellement\n return valeur1, valeur2, valeur3, etc. # souvent une fonction ne renvoie qu'une valeur\n````\n\nExemple : Voici la fonction inverse implantée en Python\n\n```python\ndef inverse(x):\n y = 1 / x\n return y\n```\n\nque l'on peut aussi écrire plus simplement :\n\n```python\ndef inverse(x):\n return 1 / x\n```\n\nIdentifiez dans ces deux fonctions écrites différemment : leur nom, leur(s) paramètre(s), leur corps, leur(s) valeur(s) renvoyée(s).\n\nRemarque : il existe des fonctions qui ne renvoient aucune valeur, l'instruction return n'est donc pas utilisée dans le corps de ces fonctions." }, { "cell_type": "markdown", @@ -361,9 +315,7 @@ { "cell_type": "markdown", "metadata": {}, - "source": [ - "## 6. Valeur de paramètre par défaut" - ] + "source": "## 6. Valeur de paramètre par défaut\n\nIl est possible de définir des valeurs par défaut pour les paramètres d'une fonction. Cela permet d'appeler la fonction sans fournir tous les arguments.\n\n```python\ndef saluer(prenom, message=\"Bonjour\"):\n return message + \" \" + prenom + \" !\"\n```\n\nExemples d'appels :\n\n```python\n>>> saluer(\"Alice\")\n'Bonjour Alice !'\n>>> saluer(\"Bob\", \"Salut\")\n'Salut Bob !'\n```\n\n**Remarques** :\n- Les paramètres avec valeur par défaut doivent être placés **après** les paramètres sans valeur par défaut\n- Cela permet de rendre certains paramètres optionnels" }, { "cell_type": "markdown", @@ -496,65 +448,27 @@ { "cell_type": "markdown", "metadata": {}, - "source": [ - "## Exercices\n", - "\n", - "- calcule le min de 2 valeurs passées en paramètre\n", - "- calcule le nombre de voyelles d'une chaine\n", - "- calcule le pgcd de 2 entiers\n", - "- remplace les voyelles par des nombres\n", - "\n", - "- Convertir de Farenheit à Celsius et inversement\n", - "- calculer le discriminant\n", - "- vérification du format d'une plaque d'immatriculation\n", - "- tortue qui trace des formes géomatriques\n", - "\n", - "- différence print / return" - ] + "source": "## Exercices\n\n### Exercice 1\n\nÉcrire une fonction `minimum` qui calcule le minimum de 2 valeurs passées en paramètre.\n\n### Exercice 2\n\nÉcrire une fonction `compter_voyelles` qui calcule le nombre de voyelles d'une chaîne de caractères.\n\n### Exercice 3\n\nÉcrire une fonction `pgcd` qui calcule le PGCD de 2 entiers (algorithme d'Euclide).\n\n### Exercice 4\n\nÉcrire une fonction `remplacer_voyelles` qui remplace les voyelles par des nombres (a→4, e→3, i→1, o→0, u→µ)." }, { "cell_type": "markdown", "metadata": {}, - "source": [ - "### Exercice X\n", - "\n", - "L'énergie cinétique d'un objet de masse $m$ se déplaçant à la vitesse $v$ est:\n", - "\n", - "$$Ec = \\frac{1}{2} m v^{2}$$\n", - "\n", - "Créer une fonction `energie_cinetique` qui calcule sa valeur à partir des paramètres `masse` et `vitesse`." - ] + "source": "### Exercice 5\n\nL'énergie cinétique d'un objet de masse $m$ se déplaçant à la vitesse $v$ est:\n\n$$Ec = \\frac{1}{2} m v^{2}$$\n\nCréer une fonction `energie_cinetique` qui calcule sa valeur à partir des paramètres `masse` et `vitesse`." }, { "cell_type": "markdown", "metadata": {}, - "source": [ - "### Exercice X\n", - "\n", - "Construire une fonction, utilisant le module `random`, qui tire au sort un nombre entier entre deux bornes données en arguments." - ] + "source": "### Exercice 6\n\nConstruire une fonction `tirage_aleatoire`, utilisant le module `random`, qui tire au sort un nombre entier entre deux bornes données en arguments." }, { "cell_type": "markdown", "metadata": {}, - "source": [ - "### Exercice X\n", - "\n", - "Écrire une fonction pour calculer la `factorielle` d'un nombre (un entier non négatif). La fonction accepte le nombre en tant qu'argument. \n", - "\n", - "Exemple: factorielle de 5: 5! = 5x4x3x2x1 = 120" - ] + "source": "### Exercice 7\n\nÉcrire une fonction `factorielle` pour calculer la factorielle d'un nombre (un entier non négatif). La fonction accepte le nombre en tant qu'argument. \n\nExemple: factorielle de 5: 5! = 5x4x3x2x1 = 120" }, { "cell_type": "markdown", "metadata": {}, - "source": [ - "### Exercice X\n", - "\n", - "Écrire une fonction Python qui prend un nombre en paramètre et vérifiez si le nombre est premier ou non. \n", - "\n", - "Remarque: Un nombre premier est un nombre naturel supérieur à 1 et qui n'a pas de diviseur positif autre que 1 et lui-même." - ] + "source": "### Exercice 8\n\nÉcrire une fonction `est_premier` qui prend un nombre en paramètre et vérifie si le nombre est premier ou non. \n\nRemarque: Un nombre premier est un nombre naturel supérieur à 1 et qui n'a pas de diviseur positif autre que 1 et lui-même." }, { "cell_type": "code", @@ -585,4 +499,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file