Copy of Intro.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[]},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"code","source":["#@title Copyright 2023 Diarra Yacouba (Diarray). Double-click for license information.\n","# Licensed under the Apache License, Version 2.0 (the \"License\");\n","# you may not use this file except in compliance with the License.\n","# You may obtain a copy of the License at\n","#\n","# https://www.apache.org/licenses/LICENSE-2.0\n","#\n","# Unless required by applicable law or agreed to in writing, software\n","# distributed under the License is distributed on an \"AS IS\" BASIS,\n","# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n","# See the License for the specific language governing permissions and\n","# limitations under the License."],"metadata":{"id":"RwrDW7UDcZy3","cellView":"form"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## **Welcome to Colab Mr Sanogo🥳**\n","**Colab est une variante des notebooks Jupyter avec de superbes modules complémentaires dignes de Google. Il s'agit d'un excellent environnement de travail pour les data scientists et les ingénieurs en Machine learning. Qui plus est gratuit et ouvert à n'importe qui avec un evironnement de travail déjà prêt. C'est pour cela que je l'ai choisi, bien que on va aussi utiliser VS code quelque fois, nos sessions seront sur des notebooks comme celui ci, ils serviront de résumé de sessions dont on parlait la dernière fois. Vous pouvez le considérer comme une sorte de sous-système Unix bien structuré axé sur la science des données et en forme de Notebook.**"],"metadata":{"id":"elfehiJkeHF_"}},{"cell_type":"markdown","source":["## Commande Unix sur Colab\n","Les utilitaires de base Unix comme \"cd\", \"ls\", \"pwd\" et bien d'autres existent également sur colab et vous permettront d'executer des commandes un peu comme l'example ci dessous."],"metadata":{"id":"nd00Cf8ziLqn"}},{"cell_type":"code","execution_count":null,"metadata":{"id":"64YeVprAV6ZI","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703353309407,"user_tz":0,"elapsed":381,"user":{"displayName":"Yacouba Diarra","userId":"00245906525885207981"}},"outputId":"f21c785c-4ff4-4496-a820-cbf4049d25f1"},"outputs":[{"output_type":"stream","name":"stdout","text":["\u001b[0m\u001b[01;36mbin\u001b[0m@                        \u001b[01;34mdatalab\u001b[0m/  \u001b[01;36mlib\u001b[0m@     \u001b[01;34mmedia\u001b[0m/                    \u001b[01;34mproc\u001b[0m/        \u001b[01;36msbin\u001b[0m@  \u001b[01;34mtools\u001b[0m/\n","\u001b[01;34mboot\u001b[0m/                       \u001b[01;34mdev\u001b[0m/      \u001b[01;36mlib32\u001b[0m@   \u001b[01;34mmnt\u001b[0m/                      \u001b[01;34mpython-apt\u001b[0m/  \u001b[01;34msrv\u001b[0m/   \u001b[01;34musr\u001b[0m/\n","\u001b[01;34mcontent\u001b[0m/                    \u001b[01;34metc\u001b[0m/      \u001b[01;36mlib64\u001b[0m@   NGC-DL-CONTAINER-LICENSE  \u001b[01;34mroot\u001b[0m/        \u001b[01;34msys\u001b[0m/   \u001b[01;34mvar\u001b[0m/\n","cuda-keyring_1.0-1_all.deb  \u001b[01;34mhome\u001b[0m/     \u001b[01;36mlibx32\u001b[0m@  \u001b[01;34mopt\u001b[0m/                      \u001b[01;34mrun\u001b[0m/         \u001b[30;42mtmp\u001b[0m/\n"]}],"source":["!ls -F --color / # permet d'afficher le contenu d'un repertoire sur les sytèmes basés sur Unix, ici le root \"/\""]},{"cell_type":"markdown","source":["## ~ == /content\n","Par défaut quand vous créerez un notebook et commencerez à l'editer vous serrez dans le repertoire **/content**. Vous pouvez le voir comme votre \"home\" sur colab"],"metadata":{"id":"hFWfKAKri8Du"}},{"cell_type":"code","source":["!pwd # Retourne le chemin du repertoire courant"],"metadata":{"id":"O-UCrTQRbUOQ","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703353592134,"user_tz":0,"elapsed":459,"user":{"displayName":"Yacouba Diarra","userId":"00245906525885207981"}},"outputId":"343ad107-b5a1-4aeb-f195-695d07787ab8"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["/content\n"]}]},{"cell_type":"markdown","source":["## Explorez l'interface colab\n","Vous pourrez découvrir colab plus tard pour le moment retour à nos moutons **Python**"],"metadata":{"id":"e60E1dnCj-dG"}},{"cell_type":"code","source":["print(\"Hello world!\") # Affichera \"Bonjour le monde\""],"metadata":{"id":"zW5tolamj8BY","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703353662068,"user_tz":0,"elapsed":402,"user":{"displayName":"Yacouba Diarra","userId":"00245906525885207981"}},"outputId":"ad20ff12-6df3-412c-c22b-b1e3b0d7084f"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Hello world!\n"]}]},{"cell_type":"markdown","source":["## Welcome to python\n","Félicitation vous venez de renouer avec python en executant ce qui est sans doute la première ligne de code tapée par tous les programmers moderne, le fameux \"Hello world\" program. On reviendra sur ce Hello world code après pour le moment quelques infos utiles sur python.\n","**Python** est un langage interpreté, de haut niveau, non typé ou à faible typage très largement utilisé aujourd'hui dans presque tous les domaine due à sa syntaxe très humaine, sa flexibilité et sa commaunauté enorme. Nous travaillerons avec la version 3.10.12 de python. Elle devrait largement faire notre affaire, la dernière version stable est la 3.12.1"],"metadata":{"id":"uWRTMP0RlTRv"}},{"cell_type":"code","source":["!python --version"],"metadata":{"id":"-7F82qq8k1F4","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703353683953,"user_tz":0,"elapsed":371,"user":{"displayName":"Yacouba Diarra","userId":"00245906525885207981"}},"outputId":"9a40c6a0-1df2-43ef-e1bf-fb53907a25ef"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Python 3.10.12\n"]}]},{"cell_type":"markdown","source":["## Quiz time!\n","* C'est quoi la programmation?\n","* C'est quoi un langage de programmation compilé?\n","* C'est quoi un compilateur?\n","* C'est quoi un langage de programmation Interprêté?\n","* Qu'est ce qu'un interpreteur?\n","* C'est quoi un langage de programmation typé?\n","* C'est quoi un langage de programmation non typé?\n","* C'est quoi un algorithme?\n","* C'est quoi un langage de haut-niveau (optionnelle)?\n","* C'est quoi un langage de bas niveau (optionnelle)?\n","* C'est quoi les entrées/sorties dans un programme (optionnelle)?\n","\n","\n","\n"],"metadata":{"id":"vytIdk4bnTMb"}},{"cell_type":"markdown","source":["## Interpreté?\n","Pour faire simple, **interpreté** signifie que les codes python sont executer ligne par ligne au **runtime** par un autre programme qu'on appelle un **interpreteur**. Ce qui veut dire que dans un programme python comme celui ci dessous par example une ligne donnée sera toujous exécuter avant celle qui la suit et après celle qui la precède! Simple n'est ce pas?"],"metadata":{"id":"9B9SfEBGoh9G"}},{"cell_type":"code","source":["# Par ailleurs les textes après \"#\" sont ce qu'on appelle des commentaires\n","# Ils sont ignoré par l'interpreteur et ne sont utiles qu'à nous programmer. On reviendra à ça aussi un peu plus tard dans le programme\n","print(\"Hello\") # Affichera \"Hello\"\n","print(\"World!\") # Affichera \"World!\""],"metadata":{"id":"YGU_BAEilNBn","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703450579088,"user_tz":0,"elapsed":45,"user":{"displayName":"Abdou Sanogo","userId":"15881326114181600761"}},"outputId":"66fbbcc1-c15c-4ffe-bd0d-477f0517a1c3"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Hello\n","World!\n"]}]},{"cell_type":"markdown","source":["## Non typé?\n","Pour faire encore plus simple, cela signifie simplement que en python quand on crée des variables on a pas besoin de préciser de quel type entité s'agit il et qu'on peut changer le contenu d'une variable n'importe comment sans problème. On reviendra à cela un peu plus tard dans le notebook, pour le moment retournons à cet affaire bizarre de **bonjour le monde** 😂"],"metadata":{"id":"eFQJMMbarg-6"}},{"cell_type":"markdown","source":["## Entrée/Sortie\n","Les **Entrées/Sorties** sont une notion très courante en programmation et ils definissent la manière dont un programme va interagir avec le milieu extérieur. Le terme **entrée** caractérise tout ce qui permet à un programme de pouvoir recevoir des informations du monde extérieur. En python ce processus est géré par la fonction **input** qui veut dire entrée en Français justement. Et les sorties sont géré par la fonction **print** qui veut dire afficher en Français. C'est quoi les fonctions? Ne vous inquitez pas on y reviendra aussi!"],"metadata":{"id":"dioD8-3us9jf"}},{"cell_type":"code","source":["input(\"Donnez moi un nombre entre 0 et 100: \") # Cette ligne va suspendre le programme jusqu'a ce que vous donniez une entrée\n","print(\"Bien reçu merci!\") # Cette ligne va vous afficher le message qui est écrit à l'interieur."],"metadata":{"id":"5wbgUUQSrdlU","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703450794341,"user_tz":0,"elapsed":49126,"user":{"displayName":"Abdou Sanogo","userId":"15881326114181600761"}},"outputId":"dcf3a347-3234-42ce-be10-21e33b106da8"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Donnez moi un nombre entre 0 et 100: 13\n","Bien reçu merci!\n"]}]},{"cell_type":"markdown","source":["## Les variables!\n","Attendez, il y a un truc qui va pas dans le programme précedent, **où** est donc passé le chiffre que vous avez donné après l'exécution de la cellule. C'est là le problème, il a tout simplement été perdu car on ne l'a pas affecté à une variable. Mais donc c'est quoi une variable? **Alright, here we go!**<br/>\n","Vous pouvez pensez aux variable comme des recipients pour stocker des trucs qu'on va pouvoir modifier, afficher ou supprimer autant qu'on veut dans notre programme. En python pour créer une variable il suffit de mettre le nom de cette dernière suivi du signe égal (=) et de l'élément que l'on veut mettre dans la variable, cela s'appelle une affectation. Exemple:\n","```\n","var = 10\n","```\n","Numéro 10 Leo Messi 😂, non je plaisant CR7 est plus inspirant mais Messi est meilleur <br/>\n","Cette syntax est la conséquence du fait que python n'est pas un langage typé, sinon il faudrait ajouter le type de la variable. Exemple avec le langage C:\n","```\n","int var; // Declaration\n","var = 10; // Affectation\n","// ou alors\n","int var = 10; // Declaration et affectation\n","```\n","Le mot clé **int** signifie **integer** qui veut dire entier en Français, avec ce genre de langage appélé langage à fort typage on doit préciser le type d'une variable à chaque fois qu'on la crée et en plus si on veut changer son contenu après on ne peut y mettre que des éléments qui ont le même type, c'est-à-dire par exemple que **var** ne pourrait contenir que des entiers dans le futur. Heureusement python nous épargne ça 🥳. Dans la cellule suivante on va sauver le nombre que vous donnerez moussallion!\n"],"metadata":{"id":"_eKrYUR0vscr"}},{"cell_type":"code","source":["var = 10 # Crée la variable du nom de var contenant le nombre 10\n","print(var) # Affiche \"10\"\n","var = input(\"Donnez moi un nombre entre 0 et 100: \") # Change le contenu de var avec ce que vous allez donner\n","print(\"Vous avez donnez le nombre: \", var) # Affiche le nombre réçu"],"metadata":{"id":"_EhRlOeRvmCL","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703523466006,"user_tz":0,"elapsed":6539,"user":{"displayName":"Abdou Sanogo","userId":"15881326114181600761"}},"outputId":"99595280-7347-47cd-a645-b935e4bcf939"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["10\n","Donnez moi un nombre entre 0 et 100: 77\n","Vous avez donnez le nombre:  77\n"]}]},{"cell_type":"markdown","source":["## Mais alors il y a des types en python?\n","**Bien sûr que si**, une erreur que les débutants font souvent est de penser que les types n'esxitent pas dans les langages non typés. Détrompez-vous, ils existent mais c'est juste que grâce à la dynamicité de l'interpreteur, nous programmers n'auront pas à le preciser nous même. L'interpreteur le fera à notre place. Il existent énormément de type de données en python, c'est un des langages qui en a le plus même. On a des entiers (**int**), des réels (**float**), des chaînes de caractères (str) et bien d'autres, vous pourrez utiliser la classe **type** comme callable si vous voulez connaître le type d'une variable.<br/>\n","**Class**? **Callable**? ne vous inquietez pas on parlera de tout ça un peu plus tard"],"metadata":{"id":"pEgfQvR02_hi"}},{"cell_type":"code","source":["# Comme vous le voyez les variables subsiste entre les cellules ce qui veut dire\n","# que vous pouvez créer une variable dans une cellule et l'utiliser dans une autre\n","print(var, type(var)) # Affichera le contenu de var et \"<class str>\"\n","var =10.0        # Changer le contenu de var pour y mettre 10.0\n","print(var, type(var)) # Affichera le contenu de var et \"<class float>\"\n","var = 10              # Changer le contenu de var pour y mettre 10 sans virgule\n","print(var, type(var)) # Affichera le contenu de var et \"<class int>\""],"metadata":{"id":"Z14rdvSY2xz3","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703523557393,"user_tz":0,"elapsed":271,"user":{"displayName":"Abdou Sanogo","userId":"15881326114181600761"}},"outputId":"92d925ca-64ed-40a6-f6fb-0f9633c12175"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["10 <class 'int'>\n","10.0 <class 'float'>\n","10 <class 'int'>\n"]}]},{"cell_type":"markdown","source":["## Dynamicité des variables!\n","Comme vous le constatez on peut mettre n'importe quoi dans la même variable sans probème merci **Python** 😌. Il est important de notez que chaque affectation écrase la précedente valeur et donc une variable ne peut contenir qu'un seul objet à la fois. On va régler cela quand on verra les types de données un peu plus complexes.<br/>\n","**Mais attendez Capitaine, quelque chose est bizarre**, je croyais que **str** ça voulait dire chaîne de caractère? Dans ce cas pourquoi ça dit que 77 est un **str** en haut. C'est un nombre 77, il devrait être soit int soit float n'est ce pas?<br/>\n","**Effectivement moussaillon**, tu as raison. La raison de cela est que en programmation les functions ont ce que l'on des **types de retour** qui sont les types de données retourné par une fonction et même des **type de paramatres** qui sont les types des données qu'on donne à la fonction. Mais bon on parlera de tout ça quand on fera la session sur les fonctions. Ce qu'il faut comprendre pour le moment c'est que la fonction **input** que l'on a utilisé pour recupérer la valeur \"77\" va toujours retourné des élément de type **str**. On dit que son type de retour est un **str**, mais pas de panique jeune marin, python gardera sa simplicité. Pour corriger ce problème nous allons juste utiliser l'une des classes \"**int**\" ou \"**float**\" comme callable pour convertir notre variable et lui donner son vrai type!"],"metadata":{"id":"M01BMtkGA8SE"}},{"cell_type":"code","source":["var = input(\"Donnez un nombre entre 0 et 100 et il sera converti en float: \")\n","var = int(var) # Convertir en float\n","print(var, type(var)) # Affichera le contenu de var et \"<class float>\""],"metadata":{"id":"J9Q4XsKKA5bp","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703523580381,"user_tz":0,"elapsed":3908,"user":{"displayName":"Abdou Sanogo","userId":"15881326114181600761"}},"outputId":"ee90252d-63d9-4cfb-c22d-9a0ffc578c53"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Donnez un nombre entre 0 et 100 et il sera converti en float: 77\n","77 <class 'int'>\n"]}]},{"cell_type":"markdown","source":["## Operateurs arithmétiques!\n","Ok donc dans un programme on peut créer et afficher des variables et recupérer des entrées, mais c'est tout?<br/>\n","**Bien sûr que non**! En général dans un programme on manipule les variables de tout type n'importe comment et comme on veut. Donc naturellement si on prend le cas particulier des nombres, on peut faire toutes les opérations qu'on fait dans la vrai vie avec des nombre comme l'**addition** (+), la **soustraction** (-), la **division** (/), la **multiplication** (* )<br/>\n","et le **reste de la division entière** (%). Ces derniers sont des operateurs basiques que vous retrouverez généralement avec les même symboles dans la plupart des langages de programmation par convention. Mais c'est pas tout car python fournit d'autre operateurs arithmétiques comme la **division entière** (//) et la **puissance** (**)"],"metadata":{"id":"YXOD_jz6zTai"}},{"cell_type":"code","source":["print(var % 2) # Affichera le reste de division de 77 par 2\n","print(var // 2) # Affichera le quotien de la division entière de 77 par 2\n","var2 = var**2  # Créer une nouvelle variable pour stocker 77 au carré\n","print(var2)     # Affichera le contenu de cette variable"],"metadata":{"id":"2ttVQjD0F1Xl"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Operateurs d'incrémentationet d'affectation!\n","**Python** offre également une large pallete d'operateurs d'incrémentation un pour chaque operateur arithémetique enfaîte et même d'autres encore, on sait déja que le signe \"=\" fait l'affectation donc laissez moi vous présenter **(+=)** qui affecte en incrémentant. Par exemple:\n","```\n","var += 1 # equivaut à: var = var + 1\n","# et pareil pour toute les opération arithmétiques vu précedemment\n","var //= 2 # equivaut à: var = var // 2\n","```\n","On utilisera beaucoup ces operateurs dans les boucles **tant que** donc on y reviendra dans les prochains chapitres. Ce qu'il faut retenir c'est que incrémenter un variable c'est changer sa valeur d'un certain pas par rapport à elle même. Ok?\n"],"metadata":{"id":"lX5JiDJT9fHe"}},{"cell_type":"code","source":["var *= 2 # var = var * 2\n","print(var) # Comme vous le constatez la valeur de var à changer!"],"metadata":{"id":"mQ0T-267_iAN","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703356766613,"user_tz":0,"elapsed":320,"user":{"displayName":"Yacouba Diarra","userId":"00245906525885207981"}},"outputId":"ec198f37-839a-4049-8e88-e5af0ca6af10"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["154\n"]}]},{"cell_type":"markdown","source":["## Operateur logiques et booléens!\n","**Python** possède aussi des opérateurs logique, ces derniers retourne ce qu'on appelle des booléens c'est-à-dire soit **Vrai** soit **Faux** (**True/False**). **Attention** ces valeur là ne sont pas des variables, on en parlera un peu plus en détail quand on parlera des types de données. Pour le moment ce que l'on doit savoir c'est que les opérateurs logique retournent ce types de valeur et on verra ce qu'on fait avec des booléens quand on parlera de condition plus tard dans ce notebook.<br/>\n","En attendant parmis les operateurs logique on peut citer le ET (**and**), le OU (**or**) et le PAS pour la négation (**not**). Il existe également des **opérateurs d'identité** que certains considère souvent comme des opérateurs logique le EST (**is**) et N'EST PAS (**is not**).<br/>\n","Plein d'autres opérateurs retournent des booléens tels que les **opérateurs de comparaison** qu'on verra dans la prochaine section mais également des **operateurs de contenance** qu'on verra un peu plus tard dans le programme et des **operateurs de manipulation de Bytes** et d'autres encore."],"metadata":{"id":"tpWbzhK59S3P"}},{"cell_type":"code","source":["boolean = True\n","print(boolean is True) # Perform l'operation d'identité avec variable boolean, Attention ceci est différent de la comparaison d'égalité\n","print(boolean or False) # Le ET logic\n","print(True + True + 1) # Qu'est ce que ça veut selon vous?"],"metadata":{"id":"roX5UbR68wQH","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703357661723,"user_tz":0,"elapsed":408,"user":{"displayName":"Yacouba Diarra","userId":"00245906525885207981"}},"outputId":"a355bdd0-2239-4c09-e37b-380e9b275cc8"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["True\n","True\n","3\n"]}]},{"cell_type":"markdown","source":["## Les operateurs de comparaison!\n","Naturellement les opérateurs classique de comparaison mathématiques sont là et agissent de manière différente en fonction des type de données qu'il manipule. Concentrons nous les nombres d'abord, la **comparaison d'égalité (==)**, la **comparaison de différence (!=)**, la **comparaison de superiorité (> | >=)**, la **comparaison d'inferiorité (< | <=)**.<br/>\n","Chacun d'entre eux retournera une valeur de vérité booleen donc soit Vrai ou Faux"],"metadata":{"id":"NDht1uZjKLUk"}},{"cell_type":"code","source":["print(boolean == True)\n","print(var == var2)\n","boolean = 0 == 0\n","print(boolean)"],"metadata":{"id":"mzugi1r2JnH3","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703357855944,"user_tz":0,"elapsed":5,"user":{"displayName":"Yacouba Diarra","userId":"00245906525885207981"}},"outputId":"5f542f0e-cd21-46ab-99ae-4215605bdb16"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["False\n","False\n","True\n"]}]},{"cell_type":"markdown","source":["## Les conditions!\n","Ok on a des booléens mais il servent à quoi concretement?<br/>\n","Très bien voilà qui nous amène à la dernière section de ce chapitre les **structures conditionnelles**. Pour écrire des programmes capable de s'adapter en cas d'incerticude les structures conditionnelles sont indispensable, c'est pour ils existent dans tous les langages de programmation, parce que dans la vraie vie on ne contôle pas toujours tout. Les **structures conditionnelles** ne sont rien de plus que des closes qu'on utilise pour que notre programme puisse avoir quoi faire dans différents scenarios. C'est comme dans la vie de tous les jours les \"**si**\", \"**sinon si**\" et \"**sinon**\" (**if, elif, else**) et devinez quoi?<br/>\n","**Oui exactement**, elles marchent avec des booléens. Une mot clés d'une structure conditionnelle comme le **if** par exemple évalue une condition donnée et attend que cette évaluation lui retourne une valeur de vérité soit **True** soit **False**. Avant d'executer un bout de code appélé **block**. Ce block doit être un peu espacé par rapport à la ligne de la condition, on appelle ça l'indentation et python est très stricte sur ça, c'est son **péché mignon** 😂.<br/>\n","En gros les structures condionnelles ce sont juste des **blocks de code** écrit de manière à ce qu'il ne soit exécuté que si une certaine condition est evalué comme étant vrai:\n","```\n","if taille < 170:\n","  print(\"Vous êtes court\")\n","elif taille > 180:\n","  print(\"Vous êtes grand\")\n","else:\n","  print(\"Vous êtes un homme de taille normal\")\n","```"],"metadata":{"id":"dsjv2A0NMSsV"}},{"cell_type":"code","source":["if var < var2:\n","  print(var, \"est inferieur à \", var2)\n","\n","if True:\n","  print(\"Ce texte s'affichera toujours car la condition est toujours vrai!\")"],"metadata":{"id":"hsBJ7cQNMKVK"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Et à propos de la Condition?\n","Vous vous demandez peut-être ce qu'il se passerait si la condition juste après le mot clé n'est ni vrai ni faux? Parce que dans la vrai vie il y a des cas comme ça.<br/>\n","Et bien que en programmation on evitera cela la plupart du temps, **python** a une strategie super pour ce cas. En python toute condition qui n'est pas explicitement fausse est considérer comme vrai. Check this out!"],"metadata":{"id":"VWY_JFFtSaj2"}},{"cell_type":"code","source":["if 77:\n","  print(\"C'est pas faux donc supposons que c'est vrai jusqu'à preuve du contraire!\")"],"metadata":{"id":"6F6kjKZnSJuM","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703358380706,"user_tz":0,"elapsed":7,"user":{"displayName":"Yacouba Diarra","userId":"00245906525885207981"}},"outputId":"f5c5a60f-98ae-4c40-f7e1-23de84ff74d5"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["C'est pas faux donc supposons que c'est vrai jusqu'à preuve du contraire!\n"]}]},{"cell_type":"markdown","source":["## Voilà c'est la fin de notre première session!\n","Vous trouverez si dessous un petit challenge à essayer avant la prochiane session!"],"metadata":{"id":"0upGtGPUTxxj"}},{"cell_type":"markdown","source":["## Homework!\n","Avec ce que vous avez appris durant cette session, essayer de faire un programme qui va demander en entrée des trois nombres **a, b et c** en assumant **ax² + bx + c** et résout l'équation du second dégré formé puis affiche les résultats. **Simple n'est ce pas?**"],"metadata":{"id":"BLkgQsAFUGEI"}},{"cell_type":"code","source":["## Votre code ici!\n","a = float(input(\"Veuillez entre le nombre a: \"))\n","b = float(input(\"Veuillez entre le nombre b: \"))\n","c = float(input(\"Veuillez entre le nombre c: \"))\n","delta = b ** 2 - 4 * a * c\n","print(\"la valeur de delta est: \",delta)\n","if delta < 0:\n","  print(\"Delta n'a pas de solution réelle\")\n","elif delta == 0:\n","  x=(-b)/(2 * a)\n","  print(\"La solution est: \", x)\n","else:\n","  # pour cette partie si tu pouvais m'explique cette partie par ce que j'ai regarde sur\n","  #   internet (math.sqrt) et format\n","\n","  ## Réponse de Yacouba:\n","  ## Je m'attendais exactement à ça, c'était un fait expres de ne pas en avoir parlé parmi les opérateurs\n","  ## De comment faire racine d'un nombre en python, le but était de voir un peu votre capacité à raisonner mathématiquement avec les informations que vous avez maintenant\n","  ## Quoi qu'il en soit nous reviendront sur ce truc avec les math.sqrt dans le chapitre trois mais pour le moment ce que j'attendais\n","  ## c'est que vous trouviez une autre solution pour faire la racine d'un nombre. Par exemple, si vous vous rappelez de la définition de la racine d'un nombre\n","  ## On dit que c'est le nombre à la puissance 0.5. Donc on peut simplement utilier ça d'abord en attendant d'introduire les fonctions peut-être lors de la prochaine session\n","\n","  # x1 = (-b - math.sqrt(delta))/(2 * a)  # Vous allez décommentez ces lignes là quand cette affaire de math.sqrt sera plus claire!\n","  # x2 = (-b + math.sqrt(delta))/(2 * a)  # En attendant cette solution fera l'affaire!\n","\n","  x1 = (-b - delta**0.5)/(2 * a)\n","  x2 = (-b + delta**0.5)/(2 * a)\n","\n","  print(\"Les solutions sont:\", format (x1, \".2f\"), \"et\", format(x2, \".2f\")) # Interessant on reviendra sur cet affaire de format aussi plus tard. Great job!"],"metadata":{"id":"iggno4VZU8sp","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1703525291177,"user_tz":0,"elapsed":10432,"user":{"displayName":"Abdou Sanogo","userId":"15881326114181600761"}},"outputId":"7ea08e17-2f86-40be-b1b1-15418d442f47"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Veuillez entre le nombre a: 2\n","Veuillez entre le nombre b: 3\n","Veuillez entre le nombre c: 1\n","la valeur de delta est:  1.0\n","Les solutions sont: -1.00 et -0.50\n"]}]},{"cell_type":"markdown","source":["## Switch case in python! (optionnelle)\n","Donc il y'a un autre concept pas si important dont je tenais à parler. C'est les statements **switch/case** qui existent dans énormement de langages de programmation mais qui n'avait pas équivalent python jusqu'à la version 3.10 de python justement. Mais pour être complet quand on parle de structures conditionnelle dans la programmation en générale, il faut en parler!<br/>\n","Pour faire simple les switch/case sont juste une autre manière de faire des stuctures conditionnelle optimisé pour les cas la condition est basée sur une variable à valeur discrète et finie. Par exemple, supposons qu'on a une variable qui peut prendre que trois valeurs: \"jour\", \"soir\" et \"nuit\". basiquement un switch/case statement sert à ce genre de cas, on peut évidemment faire ça avec des if et else if aussi mais le dans la plupart des langages le switch/case est codé et compilé pour contenir moins d'instruction que les structures classiques avec ce genre de cas, donc il sera plus efficace algorithmiquement parlant mais est-ce aussi cas en python? Question! 😂 Même si certains affirment qu'il serait environ **86**% plus efficace ça reste relatif. On parlera encore de ça surement si on le temps de parlé de complexité algorithmique. Mais en bref voilà comment ça présenterait en C:\n","\n","```\n","switch (expression)\n","​{\n","    case constant1:\n","      // statements\n","      break;\n","\n","    case constant2:\n","      // statements\n","      break;\n","    .\n","    .\n","    .\n","    default:\n","      // default statements\n","}\n","```\n","En python depuis la version 3.10, le statement à un équivalent le **match/case**, même si beaucoup se demandent les dévéloppeurs n'ont pas juste fait pour répondre au démandes des pythonistas car contrairement à tous les autres mots clés python **match** et **case** sont toujous utilisable comme nom de variable, donc ils sont en quelque sorte des **pseudo keywords** mais **never mind, ça fait notre affaire**"],"metadata":{"id":"Io8h0jMO6RVJ"}},{"cell_type":"code","source":["time = \"jou4r\"\n","match time:\n","  case \"jour\":\n","    print(\"Bonjour\")\n","  case \"soir\":\n","    print(\"Bonsoir\")\n","  case \"nuit\":\n","    print(\"Bonne nuit\")\n","  case _:   # En python le default case correspont à underscore\n","    print(\"???\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"HMDBCpkT_ZAh","executionInfo":{"status":"ok","timestamp":1703508683355,"user_tz":0,"elapsed":316,"user":{"displayName":"Yacouba Diarra","userId":"00245906525885207981"}},"outputId":"5626b060-45de-4e03-b273-ce6a8841d49e"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["???\n"]}]},{"cell_type":"markdown","source":["## Homework2 (optionnelle)\n","Implementez un serveur de calcul avec les notions acquis dans ce notebook!<br/>\n","Le code que vous allez implementer devrait pouvoir demander à utilisateur de fournir le nom de l'opération qu'il souhaite éffectuer (addition, reste, division entière, puissance etc...). Vous êtes libre d'implementer le cas pour autant d'opération que vous le souhaiter. Puis le code demandera les entrées nécesaaire pour exécuter ladite operation et affichera le resultat de l'opération. Vous êtes libre d'utiliser les stuctures conditionnelle classiques ou le **match/case** statement.\n"],"metadata":{"id":"5aTNljEvC5uh"}},{"cell_type":"code","source":[],"metadata":{"id":"JWnmGDAYB4ot"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":[],"metadata":{"id":"AS9ZRphgScAu"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":[],"metadata":{"id":"XV71PFOuScuE"},"execution_count":null,"outputs":[]}]}