Apprendre Python en 1 heure - Cours Complet Débutant (4K)

00:00:01 Bienvenue dans ce cours de Junior pour

00:00:02 apprendre à coder en Python. Ce cours

00:00:03 est destiné aux débutants, donc vous

00:00:04 n'avez besoin de rien savoir pour

00:00:06 pouvoir le suivre. Pas besoin de

00:00:07 connaissances en programmation, ni même

00:00:09 en Python, et pas besoin non plus d'être

00:00:10 fort en maths. On va partir de la base

00:00:12 en commençant par installer tout ce dont

00:00:13 vous avez besoin pour commencer à coder

00:00:14 en Python. Ensuite, on voit tous les

00:00:16 concepts de base de la programmation qui

00:00:17 vous donneront des fondations solides

00:00:19 pour continuer votre apprentissage en

00:00:20 Python. En plus, on va faire plusieurs

00:00:22 projets et exercices concrets ensemble

00:00:24 pour assimiler la théorie de manière

00:00:25 durable avec de la pratique. À la fin de

00:00:27 ce cours, vous serez capable de vous

00:00:28 orienter dans la direction où vous

00:00:29 voulez avec Python. Vous pourrez par

00:00:31 exemple apprendre à faire des sites web

00:00:33 avec le développement web back-end, vous

00:00:35 orienter vers la data science ou bien

00:00:36 vers l'apprentissage machine, faire de

00:00:38 l'automatisation ou même coder des jeux

00:00:39 vidéo. Python vous permettra de faire

00:00:42 bien plus que ça. Il est utilisé partout

00:00:43 et c'est le langage le plus populaire en

00:00:45 2024 et ce depuis des années d'après

00:00:46 plusieurs classements. Et même si vous

00:00:48 décidez de passer à un autre langage de

00:00:50 programmation après, Python est parfait

00:00:51 pour commencer à apprendre à coder et

00:00:53 comprendre les bases. Donc démarrons

00:00:54 sans plus tarder. Mais avant de

00:00:55 commencer et comme d'habitude, je vais

00:00:57 vous demander de liker cette vidéo et

00:00:58 vous abonner à cette chaîne si vous

00:01:01 voulez plus de tutoriels de ce genre.

00:01:02 Pour pouvoir coder en Python, on va

00:01:04 devoir installer Python sur votre

00:01:06 machine et un éditeur de texte pour

00:01:08 pouvoir écrire du code.

00:01:09 Pour Python, rendez-vous sur le site

00:01:12 officiel de Python python.org ou suivez

00:01:14 le lien en description.

00:01:16 Une fois sur le site,

00:01:18 appuyez sur downloads et téléchargez la

00:01:20 dernière version de Python.

00:01:22 Une fois le téléchargement fini,

00:01:23 rendez-vous dans votre explorateur de

00:01:25 fichiers et double-cliquez sur le

00:01:27 fichier que vous venez de télécharger.

00:01:29 Si vous êtes sur Windows, faites bien

00:01:32 attention à ajouter python.exe au passe.

00:01:33 Ça permettra à votre ordinateur de

00:01:39 Ensuite, cliquez sur installer

00:01:40 maintenant

00:01:42 et suivez le processus d'installation.

00:01:44 Après quelques secondes, Python a fini

00:01:46 de s'installer et vous pouvez fermer la

00:01:50 Ensuite, on va avoir besoin d'un éditeur

00:01:53 de texte. Pour ça, on va choisir Visual

00:01:54 Studio Code. Pour installer Visual

00:01:55 Studio Code, rendez-vous sur

00:01:57 code.visualstudio.com.

00:01:58 Encore une fois, je vous mets le lien en

00:02:00 description.

00:02:01 Une fois sur le site, vous pouvez

00:02:03 télécharger l'installateur pour Mac,

00:02:06 Windows ou Linux. Nous, on va prendre

00:02:08 celui pour Windows. Le téléchargement se

00:02:09 lance.

00:02:10 Quand le téléchargement est fini,

00:02:12 rendez-vous dans l'explorateur de

00:02:13 fichiers et double-cliquez sur ce que

00:02:16 vous venez de télécharger.

00:02:18 L'installateur se lance. Acceptez les

00:02:19 conditions d'utilisation.

00:02:22 Appuyez sur suivant, suivant, suivant,

00:02:24 installer. Et si tout s'est bien passé,

00:02:26 vous devriez voir cet écran. Appuyez sur

00:02:30 terminer et Visual Studio Code se lance.

00:02:32 Visual Studio Code est un environnement

00:02:33 de développement intégré complet qui

00:02:34 permet de développer dans à peu près

00:02:36 tous les langages et pour ça, il

00:02:38 fonctionne avec des extensions. Comme on

00:02:40 veut interagir avec Python,

00:02:42 on va devoir installer l'extension

00:02:43 Python.

00:02:44 Rendez-vous dans la partie extension à

00:02:46 gauche de Visual Studio Code

00:02:48 et tapez Python.

00:02:49 Choisissez la première extension

00:02:51 développée par Microsoft et appuyez sur

00:02:53 installer. Une fois l'installation de

00:02:55 l'extension Python fini,

00:02:57 allez dans fichier,

00:02:59 faites nouveau fichier

00:03:01 et choisissez Python.

00:03:02 On va sauver ce fichier en allant dans

00:03:04 file et puis save ou en appuyant sur

00:03:06 contrôle S. Et je vais appeler mon

00:03:09 fichier hello barre en bas world suivi

00:03:12 de l'extension point py, l'extension

00:03:14 point py étant celle réservée aux

00:03:15 fichiers Python. Le hello world est le

00:03:16 programme typique qu'on fait à chaque

00:03:18 fois qu'on apprend un nouveau langage.

00:03:20 En Python, on peut coder un hello world

00:03:22 avec la fonction print. La fonction

00:03:23 print est une fonction qu'on va utiliser

00:03:25 très souvent et qui permet d'afficher

00:03:28 des valeurs. C'est le mot print suivi de

00:03:29 parenthèses.

00:03:31 Dans ces parenthèses, on va mettre des

00:03:34 simples ou des doubles guillemets

00:03:37 avec une phrase ici hello, {virgule}

00:03:38 world.

00:03:39 Une fois que vous avez écrit ça, vous

00:03:41 pouvez appuyer sur le bouton play pour

00:03:44 lancer votre programme Python.

00:03:46 Si tout s'est bien passé, en bas de

00:03:47 votre écran, vous devriez voir la phrase

00:03:50 hello world s'afficher.

00:03:51 Et voilà, c'est tout ce dont vous avez

00:03:53 besoin pour commencer à créer des

00:03:55 programmes en Python et suivre ce

00:03:57 tutoriel.

00:03:58 On a vu comment afficher du texte en

00:04:00 Python avec la fonction print et

00:04:01 maintenant on va voir comment afficher

00:04:03 d'autres types de valeurs, à savoir des

00:04:04 entiers.

00:04:05 On peut afficher des entiers en Python

00:04:07 en fournissant la valeur du nombre

00:04:09 directement à la fonction print. En

00:04:10 lançant notre programme, on voit que la

00:04:12 valeur 3 a été affichée dans le

00:04:14 terminal.

00:04:16 Ces entiers sont sujets aux mêmes règles

00:04:18 qu'en maths. Ça veut dire qu'on peut

00:04:21 effectuer dessus des additions,

00:04:24 des soustractions.

00:04:27 On peut aussi les multiplier

00:04:37 faire la division entière. Donc ici, la

00:04:39 division entière de 3 par 2, ça sera pas

00:04:42 1,5 mais 1 car on garde juste l'entier.

00:04:44 On peut avoir le reste de la division

00:04:46 entière avec le signe modulo qui est

00:04:48 représenté par le signe pourcentage. Ces

00:04:50 opérations arithmétiques ont le même

00:04:52 ordre de priorité qu'en maths.

00:04:56 Ça veut dire que si on a 4 x 3 + 2,

00:05:00 on va d'abord faire 4 x 3, 12,

00:05:03 auquel on va ajouter 2 pour faire 14. Et

00:05:08 ça sera pas 4 x 3 + 2, ça veut dire 4 x

00:05:09 5, 20.

00:05:12 Donc on a bien 4 x 3, 12, auquel on va

00:05:14 ajouter 2

00:05:16 pour avoir 14.

00:05:20 Si on voulait avoir 4 x 3 + 2,

00:05:22 on devrait mettre ces 3 + 2 entre

00:05:25 parenthèses et là, on aurait bien 4 x 5,

00:05:27 ça veut dire 20. Ça c'est pour les

00:05:28 nombres entiers, mais on a aussi les

00:05:29 nombres décimaux qui ne sont pas du même

00:05:32 type que les entiers.

00:05:33 Pour voir le type d'une valeur, on

00:05:35 utilise une autre fonction qui est la

00:05:38 fonction type. Comme print, elle s'écrit

00:05:41 avec le mot type suivi de parenthèses et

00:05:42 puis la valeur pour laquelle on veut

00:05:44 savoir quel est le type. On voit que

00:05:46 pour les entiers,

00:05:49 ils sont du type int pour integer,

00:05:50 entier en anglais. Et pour les nombres

00:05:52 décimaux,

00:05:54 ils sont du type float pour nombre

00:05:56 flottant.

00:05:59 Tant qu'on y est, on peut voir que notre

00:06:01 phrase hello world

00:06:04 était de type str pour string ou chaîne

00:06:06 de caractères en français. On a vu

00:06:08 ensemble comment afficher des valeurs en

00:06:10 Python. On a vu les trois premiers types

00:06:12 de chaînes de caractères, d'entiers et

00:06:14 de nombres décimaux. On a aussi vu les

00:06:16 différents opérateurs arithmétiques et

00:06:18 l'ordre de priorité des opérations. On a

00:06:20 vu la fonction type qui permet de savoir

00:06:21 quel est le type d'une valeur. On va

00:06:23 maintenant voir un concept important qui

00:06:26 est les variables.

00:06:27 Pour le moment, on a juste écrit nos

00:06:29 valeurs en dur en les fournissant

00:06:31 directement à la fonction print ou type.

00:06:32 Ce serait quand même pratique de pouvoir

00:06:34 sauver ces valeurs pour les réutiliser

00:06:36 plus tard et les manipuler.

00:06:38 Et c'est ce à quoi servent les

00:06:39 variables.

00:06:40 Vous pouvez voir les variables comme des

00:06:42 boîtes dans lesquelles on met des

00:06:43 valeurs pour pouvoir les réutiliser

00:06:45 après. Donc pour déclarer des variables

00:06:48 en Python, on utilise une typologie qui

00:06:50 s'appelle le snake case qui est

00:06:52 simplement un ou plusieurs mots séparés

00:06:55 par des barres en bas. Donc par exemple,

00:06:56 on peut déclarer notre première variable

00:07:00 en écrivant ma barre en bas variable. On

00:07:01 peut donner n'importe quelle valeur à

00:07:04 cette variable. Disons par exemple 42.

00:07:06 On peut ensuite afficher le contenu de

00:07:08 cette variable en faisant print de ma

00:07:10 variable. Si on lance le programme

00:07:11 Python, on voit bien qu'on a la valeur

00:07:13 42 d'affichée. Écrire le nom d'une

00:07:16 variable s'appelle déclarer une variable

00:07:18 et lui donner une valeur s'appelle lui

00:07:20 assigner une valeur. Ici, on a déclaré

00:07:22 la variable ma variable et on lui a

00:07:25 assigné la valeur 42. On peut réassigner

00:07:27 une valeur à une variable en lui donnant

00:07:30 une nouvelle valeur. Par exemple, ma

00:07:32 variable ne va plus être égale à 42,

00:07:34 mais elle va être égale à hello world

00:07:36 qui est même d'un autre type.

00:07:38 Si on lance le programme, on voit bien

00:07:39 que maintenant ma variable contient la

00:07:42 valeur hello world.

00:07:43 On a vu les types nombre entier, nombre

00:07:45 flottant et chaîne de caractères. Et ça

00:07:47 va nous être utile maintenant parce

00:07:48 qu'en Python, on ne peut pas mélanger

00:07:50 n'importe quel type de variable. Prenons

00:07:51 par exemple deux types de variables, la

00:07:53 première variable qu'on va appeler mon

00:07:55 entier

00:07:56 et la deuxième variable qu'on va appeler

00:07:58 ma string.

00:08:00 Imaginons qu'on veuille écrire hello

00:08:01 world

00:08:04 suivi de la valeur 42.

00:08:05 On peut se dire qu'on peut écrire ma

00:08:08 string plus mon entier.

00:08:10 Mais si on lance le programme en Python,

00:08:11 on voit qu'on a une erreur qui nous dit

00:08:13 qu'on peut concaténer que des strings

00:08:15 avec des strings. Et là, on a essayé de

00:08:19 concaténer une string avec un entier.

00:08:21 Pour ça, on peut faire ce qu'on appelle

00:08:23 un cast. On peut caster mon entier en

00:08:25 string

00:08:27 en utilisant une autre fonction qui est

00:08:29 la fonction str. Tout ce qu'on fournit à

00:08:32 la fonction str sera transformé en

00:08:34 string. Et donc dans notre exemple, on

00:08:36 se retrouve avec deux strings, la string

00:08:38 hello world et 42 qui n'est plus un

00:08:39 entier, mais bien une chaîne de

00:08:40 caractères.

00:08:42 Si on lance le programme, on voit qu'on

00:08:44 a hello world suivi de 42 et on a plus

00:08:46 d'erreur. On peut aussi transformer 42

00:08:48 en string directement

00:08:50 dans la déclaration de variable en lui

00:08:52 assignant le résultat de la fonction

00:08:55 string qu'on a appliqué à 42.

00:08:56 Il faut faire cependant attention parce

00:08:58 que maintenant, disons qu'on veuille

00:09:00 ajouter 1

00:09:02 à 42 pour avoir 43.

00:09:03 Maintenant que ce n'est plus un entier,

00:09:05 mais une string,

00:09:07 on va avoir une nouvelle erreur qui est

00:09:09 qu'on ne peut pas ajouter un entier à

00:09:12 une string. Si on caste 1 en string,

00:09:14 donc lançons le programme

00:09:16 et on se retrouve avec 421 parce qu'en

00:09:18 fait, on a

00:09:19 la string

00:09:23 42 à laquelle on a ajouté 1, 421.

00:09:25 Les mêmes règles s'appliquent sur les

00:09:28 flottants. Donc si je déclare mon float

00:09:32 et que je lui assigne la valeur 1,2,

00:09:35 on va ici de nouveau avoir un entier. On

00:09:36 peut facilement effectuer des opérations

00:09:39 arithmétiques entre des entiers et des

00:09:40 flottants.

00:09:41 À savoir que le résultat d'une opération

00:09:43 arithmétique entre un entier et un

00:09:45 flottant donnera toujours un flottant.

00:09:48 Ici, on a 43,2

00:09:50 qui est de type

00:09:52 float.

00:09:53 Mais en ce qui concerne les chaînes de

00:09:55 caractères,

00:09:56 c'est la même chose que pour les

00:09:59 entiers, à savoir que ma string plus

00:10:01 float va nous renvoyer une erreur qui

00:10:02 dit qu'on ne peut pas concaténer des

00:10:04 strings avec des floats.

00:10:06 Pour ça, encore une fois, la fonction

00:10:08 STR vient à la rescousse et en

00:10:11 transformant notre float en string, on

00:10:13 voit qu'on a Hello World 1,2.

00:10:15 En Python, il existe des fonctions pour

00:10:18 transformer des types en un autre, pour

00:10:21 chaque type. Donc, on a vu le type STR

00:10:23 string, mais il existe aussi la fonction

00:10:26 int pour transformer des floats en

00:10:28 entiers. Donc là, on a transformé notre

00:10:31 float en 1,2 en entier 1, et on peut

00:10:32 aussi transformer un entier en nombre

00:10:34 décimal avec la fonction float. On va

00:10:37 ici lui fournir mon entier 42 et on voit

00:10:39 qu'on a 42.0

00:10:46 car notre entier est devenu un float.

00:10:47 Si ça vous semble complexe, je vous

00:10:49 conseille d'expérimenter avec ce que

00:10:51 vous savez déjà, c'est-à-dire les trois

00:10:54 types entier, string et float,

00:10:56 la fonction print et la fonction type

00:10:58 qui permet de savoir de quel type est

00:11:00 une valeur.

00:11:02 Maintenant qu'on sait manipuler les

00:11:04 types de base entier, float et string,

00:11:06 qu'on sait aussi les écrire sur la

00:11:07 sortie standard, on va apprendre comment

00:11:09 lire les valeurs que l'utilisateur nous

00:11:12 fournit avec une nouvelle fonction qui

00:11:14 est la fonction input.

00:11:16 La fonction input prend en paramètre, ça

00:11:18 veut dire qu'on peut lui mettre dedans

00:11:21 une chaîne de caractères qui représente

00:11:23 ce qui va s'afficher dans le terminal,

00:11:24 par exemple la question qu'on veut poser

00:11:26 à l'utilisateur. Si on lui demande quel

00:11:33 et qu'on lance le programme,

00:11:35 on voit que Python nous demande quel est

00:11:38 votre âge, disons 20 ans.

00:11:41 Voilà, là il s'est rien passé, parce

00:11:42 qu'en fait, pour récupérer le résultat

00:11:45 de la fonction input, on doit déclarer

00:11:47 une variable âge dans laquelle on met la

00:11:49 fonction input.

00:11:51 On a aussi vu qu'on avait pas d'espace

00:11:53 entre la question et la valeur. Pour ça,

00:11:55 il suffit de rajouter un espace à la fin

00:11:57 de notre question dans la chaîne de

00:11:59 caractères.

00:12:01 On va afficher le contenu de la variable

00:12:02 âge, et si tout va bien, on devrait

00:12:04 récupérer la valeur qu'on vient de

00:12:06 fournir.

00:12:08 Donc, quel est votre ? On va mettre 20.

00:12:10 Et on voit que Python affiche bien la

00:12:12 valeur 20 avec la fonction print.

00:12:15 Maintenant, on sait lire et écrire. Il y

00:12:16 a cependant une chose à laquelle on doit

00:12:17 faire attention, et c'est le type de la

00:12:19 variable âge. Donc là, on a un âge, on

00:12:21 peut se dire qu'on a un entier, mais en

00:12:24 fait, si on regarde,

00:12:30 est de type string, car tout ce que

00:12:32 Python lit dans l'entrée standard est

00:12:34 par définition une string. Si quand

00:12:35 Python nous demande "Quel est votre ?"

00:12:38 et qu'on lui dit "Je ne sais pas.",

00:12:40 eh ben, pas de problème, âge contiendra

00:12:42 "Je ne sais pas." D'ailleurs, la

00:12:43 fonction print permet d'afficher

00:12:45 plusieurs choses. Pour que ce soit plus

00:12:47 clair, on va afficher le contenu de la

00:12:49 variable âge suivi de son type. Donc,

00:12:51 recommençons. Quel est votre ? Je ne

00:12:53 sais pas.

00:12:55 On voit qu'on a la chaîne de caractères

00:12:56 "Je ne sais pas." et qu'elle est bien du

00:12:57 type string.

00:13:00 Pour que âge soit considéré comme un

00:13:02 entier et non pas comme une string, on a

00:13:04 déjà vu la fonction pour transformer un

00:13:07 type en un entier,

00:13:09 et c'est la fonction int.

00:13:11 On peut l'utiliser sur la fonction input

00:13:13 pour que âge soit directement transformé

00:13:18 ou casté de string vers entier.

00:13:20 Vérifions ça. Donc, on lance le

00:13:22 programme. Maintenant, si on tape "Je ne

00:13:24 sais pas.",

00:13:26 on va avoir une erreur,

00:13:27 car Python n'arrive pas à transformer la

00:13:30 phrase "Je ne sais pas." en un entier.

00:13:32 Donc, en relançant notre programme, on

00:13:34 va lui dire "Quel est votre ?" On va lui

00:13:35 fournir 20,

00:13:37 et là on a bien 20 qui est de type

00:13:38 entier.

00:13:40 Ça veut dire que maintenant, on peut lui

00:13:42 ajouter par exemple 1,

00:13:44 et que 20

00:13:48 auquel on ajoute 1 deviendra bien 21.

00:13:49 Maintenant qu'on sait tout ça, on va

00:13:52 créer notre premier projet en Python qui

00:13:53 est un convertisseur de degrés Celsius

00:13:55 vers les degrés Fahrenheit qui sont

00:13:57 utilisés aux États-Unis par exemple.

00:13:58 L'énoncé du projet est simple, on va

00:14:00 demander à l'utilisateur de rentrer des

00:14:03 degrés Celsius et on va lui afficher des

00:14:05 degrés en Fahrenheit. Pour ça, on va

00:14:09 devoir utiliser la fonction input

00:14:11 et la fonction print, et je vous invite

00:14:13 à trouver la formule pour transformer

00:14:15 des degrés Celsius en Fahrenheit sur

00:14:17 Google. Voilà, donc vous pouvez mettre

00:14:19 la vidéo en pause et on se retrouve une

00:14:21 fois que vous avez terminé. J'espère que

00:14:23 vous avez vraiment mis la vidéo en pause

00:14:24 et que vous avez au moins essayé de

00:14:26 faire ce projet.

00:14:27 Maintenant, on va faire la solution

00:14:30 ensemble. Ces degrés seront des nombres,

00:14:32 on peut décider de ne prendre que des

00:14:33 entiers, mais pour avoir un programme

00:14:35 plus complet, on va utiliser des

00:14:37 flottants.

00:14:39 Donc, on caste le résultat de la

00:14:41 fonction input en float pour avoir des

00:14:42 nombres décimaux.

00:14:44 Et la question qu'on va poser à

00:14:46 l'utilisateur, c'est

00:14:49 "Entrez des degrés

00:14:50 Celsius."

00:14:52 Maintenant qu'on a nos degrés Celsius,

00:14:55 on va les transformer en Fahrenheit.

00:14:56 Donc, on va déclarer une nouvelle

00:14:57 variable qui s'appelle Fahrenheit, et

00:15:00 donc j'ai chargé la formule sur Google,

00:15:01 et la formule pour transformer des

00:15:05 Celsius en Fahrenheit est Celsius

00:15:08 x 9 / 5

00:15:11 + 32. On va ensuite afficher le contenu

00:15:13 de notre valeur Fahrenheit et lancer le

00:15:14 programme.

00:15:16 Notre programme nous demande d'entrer

00:15:19 des degrés Celsius, on va entrer 36,

00:15:21 et notre programme nous renvoie 96,8.

00:15:23 Pour vérifier que c'est correct, on va

00:15:25 se rendre sur Google

00:15:28 et on va taper "Combien font

00:15:31 36 degrés Celsius

00:15:35 en ?" On voit que 96,8 degrés Fahrenheit

00:15:37 équivalent bien à 36 degrés Celsius. On

00:15:39 peut un peu améliorer notre programme en

00:15:40 voyant qu'on a oublié de mettre un

00:15:42 accent à degrés.

00:15:44 Il nous manque aussi un espace avant les

00:15:46 deux points.

00:15:47 Et puis là, notre programme est très

00:15:49 brut, il nous renvoie juste la valeur de

00:15:50 la variable Fahrenheit.

00:15:52 Pour rendre ça un peu plus sympa, on va

00:15:54 mettre On va utiliser la fonction print

00:15:56 de manière un peu plus avancée en lui

00:15:57 passant plusieurs paramètres et en

00:15:59 disant que

00:16:05 Celsius

00:16:28 On peut lancer notre programme.

00:16:31 On va reprendre 36, on voit que 36

00:16:34 degrés Celsius équivalent bien à 96,8

00:16:35 degrés Fahrenheit.

00:16:38 Et on va juste retirer l'espace ici, car

00:16:39 quand on sépare des valeurs par des

00:16:41 virgules dans la fonction print, Python

00:16:43 ajoute automatiquement des espaces.

00:16:46 Donc, relançons pour vérifier. 36,

00:16:48 et on voit que 36 degrés Celsius

00:16:50 équivalent bien à 96,8 degrés

00:16:52 Fahrenheit. Félicitations, vous avez

00:16:56 fini votre premier projet en Python.

00:16:57 On a vu comment représenter le type

00:16:59 chaîne de caractères, nombres décimaux

00:17:00 et nombres entiers. Maintenant, on va

00:17:02 voir un nouveau type qui est le type

00:17:03 booléen. Le type booléen permet

00:17:05 d'afficher des valeurs qui sont soit de

00:17:06 vraies, soit de fausses. Il peut prendre

00:17:09 deux valeurs possibles, soit le mot-clé

00:17:11 réservé true, soit false. Comme le reste

00:17:13 des types en Python, il a une fonction

00:17:14 qui permet de transformer d'autres types

00:17:16 d'objets en booléen, c'est la fonction

00:17:18 bool. Dans la logique booléenne, tout

00:17:21 type d'objet qui est égal à zéro, nul ou

00:17:23 un ensemble vide sera considéré comme

00:17:24 fausse, et tout le reste sera considéré

00:17:26 comme vrai. Prenons quelques exemples

00:17:29 avec la valeur -20,

00:17:32 qui en booléen sera considéré comme

00:17:34 vrai. On peut aussi prendre la valeur

00:17:37 42.0, un nombre décimal qui lui aussi

00:17:39 sera considéré comme vrai, ou bien une

00:17:41 chaîne de caractères non nulle, comme

00:17:43 par exemple ABC,

00:17:45 qui elle aussi sera évaluée à vrai.

00:17:46 Maintenant, si on prend une chaîne de

00:17:49 caractères vide,

00:17:50 elle sera évaluée à fausse, car c'est un

00:17:52 ensemble vide,

00:17:55 ainsi que zéro, le nombre entier,

00:17:59 et 0.0 pour avoir un float qui lui aussi

00:18:00 est faux. En programmation, quand on

00:18:01 parle de valeurs qui peuvent être

00:18:03 interprétées comme vraies ou fausses,

00:18:05 bien qu'elles ne soient pas les valeurs

00:18:07 booléennes directes true et false,

00:18:12 on parle de valeurs truthy ou falsy.

00:18:14 On a vu les opérateurs arithmétiques,

00:18:16 voyons maintenant les opérateurs de

00:18:18 comparaison. Il existe six opérateurs de

00:18:20 comparaison qui permettent de comparer

00:18:22 tout type d'objet en Python.

00:18:24 On a l'opérateur

00:18:26 strictement plus petit que, plus petit

00:18:29 ou égal à, strictement plus grand que,

00:18:31 plus grand ou égal à,

00:18:34 différent ou égal.

00:18:36 À noter que l'opérateur de comparaison

00:18:38 égal est composé de deux signes égal, il

00:18:40 n'est pas à confondre avec un égal

00:18:42 simple qui est réservé à l'assignation

00:18:43 de variable. Voyons quelques exemples

00:18:45 ensemble pour mettre ça en pratique. Si

00:18:47 on fait print 2 est strictement plus

00:18:49 petit que 3, Python nous dit que la

00:18:51 comparaison est vraie. Maintenant, si on

00:18:54 dit 2 est strictement plus petit que 1,

00:18:55 là, Python nous dit que c'est faux. Pour

00:18:58 voir si 2 est différent de 1, c'est

00:18:59 pareil, Python nous dit que c'est vrai,

00:19:01 2 n'est pas égal à 1.

00:19:03 Par contre, si on essaie de voir si 2

00:19:05 est égal à 1, Python nous dit que c'est

00:19:06 faux.

00:19:08 Est-ce que 2 est plus grand ou égal à ?

00:19:09 Oui.

00:19:11 Est-ce qu'il est strictement plus grand

00:19:13 que ? Oui. Par contre, est-ce qu'il est

00:19:15 plus petit ou égal à ? Non. En Python,

00:19:17 on peut aussi mettre plusieurs

00:19:19 opérateurs de comparaison les uns à la

00:19:20 suite de l'autre. Par exemple, on peut

00:19:23 dire 1 est strictement plus petit que 2,

00:19:25 qui lui-même est strictement plus petit

00:19:26 que 3,

00:19:29 et tout ça sera interprété comme vrai.

00:19:31 En Python, on a aussi deux opérateurs

00:19:34 logiques qui sont and et or qui

00:19:35 permettent d'associer plusieurs

00:19:37 conditions entre elles, les unes à la

00:19:39 suite des autres. Avec le mot or qui

00:19:41 veut dire ou,

00:19:42 il faudra que ou bien la condition

00:19:45 gauche, ou bien la condition droite soit

00:19:46 vraie pour que l'ensemble soit vrai. Et

00:19:49 pour le mot and qui veut dire et, il

00:19:50 faut que les deux conditions, celle de

00:19:52 gauche et celle de droite, s'avère pour

00:19:54 que l'ensemble soit considéré comme

00:19:55 vrai.

00:19:57 Maintenant qu'on a vu le type booléen,

00:19:58 les opérateurs logiques et les

00:20:01 opérateurs de comparaison, on va pouvoir

00:20:02 rentrer dans le vif du sujet avec notre

00:20:04 première structure de contrôle qui est

00:20:07 la condition if. If permet d'exécuter du

00:20:09 code si et seulement si la condition est

00:20:10 validée.

00:20:12 On va évaluer une condition et exécuter

00:20:15 un bloc de code si la condition est

00:20:17 vraie. Ce bloc de code est indenté, ça

00:20:19 veut dire qu'il commence pas à la ligne

00:20:21 directement, il y a des espaces, ça peut

00:20:22 être autant d'espaces que vous voulez ou

00:20:24 autant de tabulation que vous voulez,

00:20:25 mais il faut juste que ce nombre

00:20:26 d'espaces ou de tabulation soit

00:20:29 consistant dans tout votre code. Ici,

00:20:30 j'ai deux espaces, ça fonctionne,

00:20:32 j'aurais pu en avoir quatre. Mais si

00:20:34 j'en ai quatre ici, il faut que j'en ai

00:20:35 quatre tout le long de mon bloc et des

00:20:37 autres blocs en Python. Donc par

00:20:40 exemple, si la condition 2 est plus

00:20:41 petit que 3,

00:20:47 Et si je lance mon code, on voit qu'on a

00:20:49 bien affiché "C'est vrai." Par contre,

00:20:51 si la condition devient fausse, 4 est

00:20:53 plus petit que 3, c'est faux, et donc on

00:20:54 va jamais passer dans ce bloc. Pour

00:20:56 illustrer tout ça, prenons l'exemple

00:20:57 d'un programme qui demande à

00:21:07 Une fois qu'il a entré son mot de passe,

00:21:08 on va tester si son mot de passe est

00:21:10 bien le mot de passe qu'on sait qu'il a,

00:21:13 ici 1 2 3 4 5 6. Donc si

00:21:16 mot de passe est bien égal à 1 2 3 4 5

00:21:18 6,

00:21:20 alors on lui affiche

00:21:21 "C'est bon."

00:21:23 Testons notre programme.

00:21:26 Quel est votre mot de ? 1 2 3 4 5 6.

00:21:27 Notre programme affiche bien que c'est

00:21:29 bon.

00:21:32 Ensuite, on va lui dire que

00:21:40 Si on lance et que cette fois-ci on met

00:21:42 un autre mot de passe,

00:21:43 on voit qu'il a bien affiché "Le

00:21:45 programme est terminé." mais qu'il est

00:21:47 pas rentré dans le bloc qui dit que

00:21:48 c'est bon.

00:21:51 Par contre, si on met 1 2 3 4 5 6,

00:21:53 il rentre dans le bloc et il affiche

00:21:55 quoi qu'il arrive cette cette ligne-là

00:21:57 qui n'est pas indentée et qui sera donc

00:21:58 exécutée parce qu'elle n'est pas dans le

00:22:00 code dans lequel on rentre seulement si

00:22:01 la condition est validée. Maintenant,

00:22:03 que faire si le mot de passe n'est pas ?

00:22:04 Lui dire simplement que le programme est

00:22:06 terminé sans lui dire que son mot de

00:22:07 passe est mauvais ne suffit pas. On

00:22:09 pourrait lui dire que si c'est pas le

00:22:11 cas, on lui affiche "Le mot de passe

00:22:16 Pour ça, on met un autre mot qui est le

00:22:18 mot-clé else. Else ne prend pas de

00:22:21 condition, c'est simplement un bloc de

00:22:23 code qui va être exécuté si aucune autre

00:22:25 condition n'a été remplie. Donc là, on

00:22:27 va lui dire

00:22:28 "Le mot de passe n'est

00:22:31 pas bon."

00:22:32 Ici, je vois qu'en faisant mon

00:22:33 copier-coller, j'ai pris un espace en

00:22:35 trop, je vais le retirer pour garder la

00:22:36 cohérence et avoir deux espaces à chaque

00:22:37 fois.

00:22:39 Donc relançons notre programme. Quel est

00:22:42 votre mot de ? Je mets 1 2 3

00:22:43 et là, on voit qu'on est pas rentré dans

00:22:44 la première condition, mais on est

00:22:47 rentré dans le else et notre programme

00:22:48 affiche "Le mot de passe n'est pas bon."

00:22:49 Maintenant, disons qu'on veut afficher

00:22:51 un message "Le mot de passe entré est

00:22:53 trop court." Pour ça, on peut faire un

00:22:54 if

00:22:56 qui regarde la longueur de la chaîne de

00:22:58 caractères, ici de notre mot de passe,

00:23:01 et on peut faire ça avec la fonction len

00:23:02 dans laquelle on passe notre mot de

00:23:05 passe. Si d'abord on affiche

00:23:08 ce que vaut la longueur, la length de

00:23:10 passe avec cette fonction len,

00:23:13 on voit qu'ici si on met 1 2 3, on a 3

00:23:14 parce que la chaîne de caractères est

00:23:15 composée de trois lettres. Maintenant

00:23:17 qu'on a ça, on peut lui dire que si la

00:23:19 longueur de 3 est strictement inférieure

00:23:23 à 6, on peut afficher "Le mot de passe

00:23:29 Réessayons, je tape 1 2 3

00:23:30 et là, on voit que le programme nous a

00:23:32 dit "Le mot de passe est trop court, le

00:23:33 mot de passe n'est pas bon." et puis le

00:23:35 programme est terminé. Et c'est un peu

00:23:37 c'est un peu redondant d'avoir la phrase

00:23:38 "Et le mot de passe est trop court et le

00:23:40 mot de passe n'est pas bon." Ça serait

00:23:41 mieux que notre programme nous dise l'un

00:23:42 ou l'autre, mais là, si on regarde ce

00:23:44 qui se passe, on rentre notre notre mot

00:23:47 de passe qui est 1 2 3 de longueur 3.

00:23:49 En évaluant cette première condition, le

00:23:51 mot la longueur du mot de passe est bien

00:23:53 inférieure à 6, donc il va rentrer ici,

00:23:54 puis il va tester cette condition qui

00:23:56 sera fausse et il va donc passer dans le

00:23:59 else et aussi nous afficher ça. Pour

00:24:01 éviter d'avoir plein de if comme ça, il

00:24:03 y a un troisième et dernier mot-clé qui

00:24:05 est le mot-clé elif

00:24:07 qui est la contraction de else et if et

00:24:08 qui nous permet de tester plusieurs

00:24:11 conditions dans un bloc de if elif else.

00:24:13 Dans notre cas, je vais transformer ce

00:24:15 if-là en elif

00:24:17 qui nous permettra de ne rentrer que

00:24:19 dans une de ces conditions. Donc

00:24:21 recommençons. Si je lance mon programme,

00:24:24 je mets 1 2 3,

00:24:25 on voit qu'il nous a juste écrit "Notre

00:24:26 programme est trop court." parce qu'il

00:24:28 est rentré dans ce bloc. On voit qu'il a

00:24:29 été satisfait par cette première

00:24:31 condition et il nous a donc exécuté ce

00:24:32 bloc-là.

00:24:34 Et comme else veut dire sinon, il n'a

00:24:36 pas eu besoin de faire quelque chose

00:24:37 d'autre vu qu'il a été déjà satisfait

00:24:39 par cette condition. Dans les exemples

00:24:40 qu'on a vu ensemble, on avait toujours

00:24:42 des blocs d'une seule ligne, on n'est

00:24:43 pas limité à une seule ligne. Si

00:24:45 maintenant je mets

00:24:49 "Mais il n'est pas très

00:24:52 sécurisé."

00:24:54 Si je rentre le mot de passe, je mets 1

00:24:56 2 3 4 5 6,

00:24:58 on a les deux phrases, tout le bloc va

00:25:00 être exécuté ici et pas seulement une

00:25:02 seule ligne. En plus, on peut mettre des

00:25:05 if dans des if. Donc disons ici

00:25:08 que un des deux cas, on est le cas où le

00:25:16 est égale à 0, on va lui afficher "Il

00:25:19 faut écrire

00:25:24 Et sinon,

00:25:26 on va lui afficher "Le mot de passe est

00:25:27 trop court." Donc là, si on exécute

00:25:29 notre programme et qu'on ne rentre rien,

00:25:31 la longueur de notre de notre chaîne de

00:25:34 caractères, de notre mot de passe sera 0

00:25:35 et le programme nous dit "Il faut écrire

00:25:36 quelque chose." Maintenant, si on

00:25:38 relance notre programme et qu'on tape un

00:25:40 mot de passe d'une longueur strictement

00:25:42 inférieure à 6 mais qui n'est pas 0,

00:25:44 comme par exemple 1 2 3 4 qui sera de

00:25:46 longueur 4,

00:25:48 il va rentrer ici, il va se dire "OK, la

00:25:49 longueur du mot de passe est inférieure

00:25:51 à 6." Puis dans ce bloc, il va voir que

00:25:52 la longueur du mot de passe n'est pas

00:25:54 égale à 0, donc cette condition n'est

00:25:56 pas satisfaite, alors il va rentrer dans

00:25:58 le else, le sinon, et afficher "Le mot

00:26:00 de passe est trop court." Et c'est ce

00:26:01 qu'il a fait ici. Comme la longueur

00:26:04 était de 4, il est rentré ici, il n'est

00:26:05 pas rentré là, mais il est bien rentré

00:26:08 ici. Il n'est pas rentré dans ceux-là

00:26:09 parce que la condition ici était déjà

00:26:11 satisfaite.

00:26:12 On va maintenant pouvoir passer au

00:26:14 deuxième projet de ce tutoriel en Python

00:26:15 qui est un programme qui donne une

00:26:18 mention à l'utilisateur à partir d'une

00:26:20 note moyenne qu'il nous fournit. Prenons

00:26:21 par exemple la moyenne du bac. On va

00:26:23 demander à l'utilisateur de rentrer la

00:26:25 moyenne qu'il a eu au bac sur 20. On va

00:26:27 lui donner la mention assez bien si sa

00:26:29 moyenne est supérieure ou égale à 12 et

00:26:31 inférieure à 14, la mention bien si sa

00:26:33 moyenne est supérieure ou égale à 14 et

00:26:35 strictement inférieure à 16, la mention

00:26:36 très bien si sa moyenne est supérieure

00:26:38 ou égale à 16 et strictement inférieure

00:26:40 à 18 et les félicitations du jury si sa

00:26:42 note est supérieure à 18. Je vous laisse

00:26:44 mettre la vidéo en pause et penser à

00:26:45 comment vous pourriez réaliser ce

00:26:47 programme et on se retrouve juste après

00:26:52 Voilà, j'espère que vous avez fini, que

00:26:53 vous avez au moins essayé de réaliser ce

00:26:55 programme par vous-même. Donc on va

00:26:56 résoudre le problème ensemble. On va

00:26:58 commencer par déclarer une variable

00:26:59 moyenne

00:27:02 et on va demander à notre utilisateur

00:27:09 On sait que la fonction input nous

00:27:11 renvoie des chaînes de caractères et

00:27:12 nous on va travailler avec des nombres

00:27:14 décimaux,

00:27:15 donc on peut déjà transformer cette

00:27:17 chaîne de caractères en float pour avoir

00:27:18 une moyenne qui est un nombre décimal.

00:27:19 Ensuite, on va avoir plusieurs

00:27:21 conditions dans lesquelles on va rentrer

00:27:22 en fonction de la moyenne de

00:27:24 l'utilisateur. Donc si sa moyenne est

00:27:26 supérieure ou égale à 12 et inférieure à

00:27:28 14, on va afficher la mention assez

00:27:35 Si sa moyenne est comprise

00:27:37 entre 14 inclus

00:27:41 et 16, on va afficher la mention bien.

00:27:48 et 18,

00:27:50 on va afficher

00:28:02 on va afficher "Les félicitations du

00:28:10 Et sinon,

00:28:13 on affiche "Pas de mention."

00:28:15 Essayons notre programme

00:28:18 avec une moyenne de 14,

00:28:20 on a bien la mention bien.

00:28:22 Avec une moyenne de 19, on a les

00:28:24 félicitations du jury et avec une

00:28:25 moyenne

00:28:28 de 11,1, on a pas de mention. Voici une

00:28:30 version minimale du projet. On pourrait

00:28:31 aller plus loin en m'ajoutant de la

00:28:34 gestion d'erreur au cas où l'utilisateur

00:28:36 nous rentre une note supérieure à 20 ou

00:28:38 inférieure à 0. Imaginons qu'il entre 21

00:28:39 de moyenne, on va lui donner les

00:28:41 félicitations du jury alors que c'est

00:28:43 pas possible d'avoir 21 sur 20. Si

00:28:45 l'utilisateur n'entre pas de nombre mais

00:28:46 entre une chaîne de caractères par

00:28:47 exemple, on va avoir une erreur sur la

00:28:49 fonction float. Ça serait bien de gérer

00:28:51 float différemment et de rajouter une

00:28:52 autre condition pour la gestion

00:28:54 d'erreur. Mais sinon, c'est tout pour ce

00:28:55 projet. Et voilà, vous savez maintenant

00:28:56 comment utiliser la première structure

00:28:59 de contrôle, les conditions avec if,

00:29:00 elif et else. On va maintenant voir une

00:29:02 autre structure de contrôle, les

00:29:03 boucles, mais avant ça, on va voir

00:29:04 comment mettre plusieurs éléments dans

00:29:07 une séquence avec les listes.

00:29:09 En Python, les listes sont des tableaux

00:29:11 ou ensembles qui peuvent contenir tout

00:29:12 type d'objets. On peut déclarer une

00:29:15 liste en utilisant les symboles crochets

00:29:17 ou bien avec la fonction list. Une fois

00:29:19 qu'on a une liste, on peut mettre un ou

00:29:22 plusieurs objets dedans. On sépare les

00:29:24 éléments d'une liste avec des virgules

00:29:25 et on peut afficher une liste avec la

00:29:29 fonction print. Donc faisons print de ma

00:29:31 liste et on voit que Python affiche

00:29:33 notre liste exactement comme on l'a

00:29:34 déclarée. On peut aussi obtenir un

00:29:36 élément spécifique de la liste en

00:29:38 utilisant son indice entre crochets.

00:29:40 Disons qu'on veut le premier élément de

00:29:41 notre liste. En informatique, on

00:29:43 commence toujours à compter à 0, donc on

00:29:45 peut accéder au premier élément de notre

00:29:47 liste en tapant le nom de notre variable

00:29:50 ma liste puis par exemple zéro entre

00:29:51 crochets. Et Python nous affiche bien le

00:29:53 premier élément de la liste. On peut

00:29:54 aussi changer un élément de la liste et

00:29:56 écraser sa valeur en lui assignant une

00:29:58 nouvelle valeur à l'indice qu'on veut.

00:30:01 Par exemple ma liste de zéro égale un.

00:30:02 Si on affiche la liste, on voit que

00:30:04 l'élément zéro a bien été modifié avec

00:30:06 notre nouvelle valeur un. En plus d'un

00:30:07 élément individuel, on peut aussi

00:30:09 accéder à un sous-ensemble de notre

00:30:11 liste en utilisant les crochets

00:30:13 dans lesquels on met l'indice de début

00:30:15 deux points et puis l'indice de fin. Par

00:30:16 exemple pour avoir les trois premiers

00:30:19 éléments d'une liste, on peut faire

00:30:22 crochet de zéro jusqu'à trois non

00:30:24 inclus.

00:30:25 Et Python nous renvoie bien les trois

00:30:26 premiers éléments de la liste. Les

00:30:28 listes sont des objets en Python qui ont

00:30:30 une série d'attributs et de méthodes

00:30:31 qu'on peut utiliser. Reprenons notre

00:30:34 liste et ajoutons-lui un point à la fin

00:30:35 et on voit une liste avec plein

00:30:37 d'attributs et de méthodes. Pour ajouter

00:30:38 un élément à une liste, on a par exemple

00:30:40 la méthode append. On peut l'utiliser en

00:30:42 prenant notre liste et en tapant point

00:30:44 append et puis en lui passant l'élément

00:30:46 qu'on veut rajouter entre parenthèses.

00:30:48 On peut par exemple ajouter le nombre

00:30:51 1337 à notre liste.

00:30:53 On voit que la liste contient maintenant

00:30:55 cinq éléments et que 1337 s'est ajouté

00:30:57 en fin de la liste. On a aussi la

00:30:59 méthode remove qui permet de supprimer

00:31:01 un élément d'une liste.

00:31:02 On peut l'utiliser en faisant point

00:31:04 remove sur une liste avec l'élément

00:31:06 qu'on veut supprimer entre parenthèses.

00:31:08 Pour voir si un élément se trouve dans

00:31:09 une liste, on peut utiliser le mot clé

00:31:13 in. Par exemple print de B in

00:31:17 une liste qui contient les éléments A, B

00:31:19 et C, on verra true car la lettre B se

00:31:22 trouve bien dans notre liste.

00:31:23 Voyons maintenant une nouvelle structure

00:31:25 de contrôle avec les boucles. Une boucle

00:31:27 permet de répéter un bloc de code

00:31:28 plusieurs fois.

00:31:30 Le premier type de boucle qu'on va voir

00:31:32 est ce qu'on appelle une boucle while.

00:31:35 Elle est composée du mot while suivi

00:31:36 d'une condition

00:31:38 puis deux points et un bloc qu'on veut

00:31:40 répéter. C'est un peu comme un if sauf

00:31:41 qu'on va répéter ce qui est dans notre

00:31:43 boucle tant que la condition est vraie.

00:31:45 Prenons par exemple une variable I pour

00:31:47 indice à laquelle on va assigner la

00:31:49 valeur zéro. On peut avoir une boucle

00:31:53 while qui va boucler tant que I est plus

00:31:55 petit que cinq. Dans notre boucle, on va

00:31:58 afficher I avec print et puis surtout ne

00:32:01 pas oublier d'incrémenter ou ajouter un

00:32:03 à chaque passage de la boucle. Pour

00:32:05 incrémenter de un à notre variable I, on

00:32:10 va faire I égale I plus un

00:32:12 qu'on peut aussi écrire plus simplement

00:32:16 avec I plus égale un. Attention, si on

00:32:18 oublie d'ajouter un à chaque passage

00:32:19 dans la boucle, on va se retrouver avec

00:32:21 ce qu'on appelle une boucle infinie.

00:32:22 Comme son nom l'indique, c'est une

00:32:23 boucle qui ne se finit jamais et on va

00:32:25 devoir fermer notre programme de force

00:32:27 pour pouvoir en sortir. Par exemple, je

00:32:28 vais retirer l'incrément et vous allez

00:32:30 voir ce qui se passe. On a la valeur

00:32:32 initiale de I qui est zéro qui s'affiche

00:32:34 à l'infini. Pour fermer un programme qui

00:32:35 est parti en boucle infinie, pas de

00:32:37 panique, il suffit simplement de lui

00:32:39 envoyer un signal d'interruption. On

00:32:40 peut lui envoyer ce signal avec le

00:32:44 raccourci contrôle suivi de la lettre C.

00:32:45 Revenons maintenant à notre code et

00:32:47 ajoutons la ligne I plus égale un. Quand

00:32:49 on exécute notre code, on voit bien

00:32:51 qu'il affiche zéro, un, deux, trois,

00:32:53 quatre puis qu'il s'arrête normalement.

00:32:55 Donc voici globalement comment

00:32:57 fonctionne une boucle while.

00:32:59 Voyons maintenant les boucles for.

00:33:01 Les boucles for permettent de répéter un

00:33:04 bloc de code ou itérer pour chaque

00:33:06 élément d'un objet itérable comme par

00:33:08 exemple une string ou une liste.

00:33:10 Concrètement, on peut avoir une boucle

00:33:12 for en tapant

00:33:15 for lettre in et puis une liste composée

00:33:18 des lettres A, B et C. Quand on affiche

00:33:21 notre lettre avec print de lettre, on

00:33:23 voit que Python nous a affiché l'élément

00:33:24 pour chaque passage dans la boucle. Mais

00:33:26 que faire si on veut passer un certain

00:33:27 nombre de fois dans une ? On ne doit

00:33:30 faire for I in cinq car cinq n'est pas

00:33:31 un objet itérable, c'est juste un

00:33:33 nombre, pas un ensemble d'éléments. Pour

00:33:35 ça, on doit utiliser une fonction qui

00:33:37 est la fonction range. J'ai une vidéo

00:33:38 complète sur la fonction range que je

00:33:40 vous invite à consulter en suivant le

00:33:41 lien en description. Mais dans son

00:33:43 utilisation la plus simple, on peut

00:33:46 utiliser une boucle for range en faisant

00:33:49 for I in range de cinq et en faisant

00:33:51 print de I. Python nous affiche bien

00:33:53 zéro, un, deux, trois, quatre sans qu'on

00:33:54 doive incrémenter quoi que ce soit

00:33:56 manuellement comme dans la boucle while

00:33:57 qu'on a vu juste avant. Et voilà, vous

00:33:58 savez maintenant comment utiliser les

00:34:00 boucles en Python.

00:34:01 On peut donc voir notre troisième

00:34:03 projet. On va faire une version super

00:34:05 simple uniquement avec les concepts

00:34:06 qu'on a vu dans cette vidéo et les deux

00:34:08 vidéos précédentes. L'énoncé du jeu du

00:34:09 pendu est le suivant. On a un mot

00:34:11 mystère que l'utilisateur doit deviner.

00:34:13 Le joueur possède sept vies. À chaque

00:34:15 tour, on lui demande d'entrer une

00:34:16 lettre. Si la lettre se trouve dans le

00:34:18 mot, alors on affiche le mot avec cette

00:34:20 lettre en clair. Si cette lettre ne se

00:34:21 trouve pas dans le mot, le joueur perd

00:34:23 une vie et la partie s'arrête soit quand

00:34:25 le joueur n'a plus de vie, soit quand il

00:34:26 a trouvé le mot. Voilà, comme

00:34:27 d'habitude, c'est le moment de mettre la

00:34:29 vidéo en pause et d'essayer de faire ce

00:34:31 projet par vous-même

00:34:32 et on se retrouve juste après avec ma

00:34:34 solution.

00:34:36 OK, j'espère que vous avez réussi à

00:34:37 faire votre propre version du jeu du

00:34:39 pendu. Sinon, je vous propose la mienne.

00:34:40 Je vais commencer par déclarer une

00:34:43 variable qui contient un nombre entier,

00:34:44 le nombre de vies de l'utilisateur.

00:34:46 Ensuite, on a le mot mystère. On va

00:34:48 choisir le mot Python et puis on a une

00:34:50 chaîne de caractères pour le mot que

00:34:52 l'utilisateur va voir à l'écran. Au

00:34:54 début, il sera composé uniquement de

00:34:56 barres en bas de la même taille que le

00:34:57 mot mystère.

00:34:59 Pour ça, on peut faire le symbole barre

00:35:02 en bas multiplié par la longueur du mot

00:35:04 mystère. On va ensuite avoir une boucle.

00:35:06 Cette boucle sera une boucle while qui

00:35:08 va continuer tant que le nombre de vies

00:35:11 de l'utilisateur sera supérieur à zéro

00:35:13 et que le mot mystère ne sera pas égal à

00:35:15 notre mot public. À chaque passage dans

00:35:16 la boucle, on demande une lettre à

00:35:19 l'utilisateur avec la fonction input à

00:35:20 laquelle on passe la chaîne de

00:35:22 caractères "Entrer une lettre". Ensuite,

00:35:23 on peut voir si la lettre que

00:35:25 l'utilisateur vient d'entrer se trouve

00:35:26 dans notre mot mystère

00:35:28 en faisant if

00:35:29 lettre

00:35:32 in mot mystère. Si c'est le cas, on va

00:35:34 boucler sur le mot mystère en récupérant

00:35:39 ses indices avec for I in range de len

00:35:41 du mot mystère. Et si la lettre du mot

00:35:43 mystère de I est égale à la lettre que

00:35:45 l'utilisateur a entrée, alors on la

00:35:48 remplace dans notre mot public

00:35:51 en faisant mot public égale mot public

00:35:53 deux points I

00:35:55 plus la lettre

00:35:58 plus mot public de I plus un deux

00:36:00 points. Ça nous permet de conserver la

00:36:02 première partie du mot public,

00:36:04 d'ajouter la lettre et puis d'avoir la

00:36:06 suite du mot public. Si à l'inverse la

00:36:08 lettre n'était pas dans le mot mystère,

00:36:10 alors l'utilisateur perd une vie, on

00:36:13 fait nombre de vies moins égale un. Et

00:36:14 en fonction de ce qui s'est passé, on va

00:36:16 avoir un if, elif, else. Donc on va

00:36:19 faire if mot public est égal à mot

00:36:22 mystère, alors on affiche

00:36:23 print

00:36:25 "Le mot est"

00:36:27 et puis soit mot mystère, soit mot

00:36:29 public car à ce moment-là, ils sont

00:36:31 égaux. Sinon si

00:36:34 elif le nombre de vies de l'utilisateur

00:36:36 est égal à zéro,

00:36:37 alors on lui affiche un message pour

00:36:40 dire qu'il a perdu. Sinon, ça veut dire

00:36:43 que le jeu continue. Donc sinon else, on

00:36:45 affiche le nombre de vies que euh qu'il

00:36:48 reste à l'utilisateur

00:36:50 et l'état du mot avec les lettres en

00:36:52 clair qu'il a déjà trouvé. Donc on peut

00:36:54 maintenant essayer notre jeu du pendu.

00:36:55 On va se tromper sept fois pour voir si

00:36:57 on peut perdre une partie.

00:36:59 On va réussir 100 % du temps pour voir

00:37:01 si on peut gagner une partie. Puis on va

00:37:04 jouer normalement, parfois se tromper,

00:37:05 parfois trouver des lettres pour

00:37:07 finalement gagner.

00:37:09 Si vous voulez améliorer votre jeu du

00:37:11 pendu, je vous donne quelques pistes

00:37:12 d'amélioration. Vous pouvez utiliser la

00:37:15 fonction native enumerate pour notre

00:37:16 boucle for. Vous pouvez aussi vous

00:37:18 renseigner sur l'instruction break qui

00:37:20 permet de sortir d'une boucle. On peut

00:37:22 donc remplacer la condition de sortie de

00:37:24 notre while par true et boucler en

00:37:27 permanence et puis avoir des breaks dans

00:37:29 nos ifs en fin de bloc pour éviter

00:37:31 d'avoir les mêmes conditions dans while

00:37:33 et dans nos ifs. On peut aussi vérifier

00:37:36 les lettres que l'utilisateur entre en

00:37:37 vérifiant que ce soit bien une lettre

00:37:40 déjà, qu'elles soient en minuscule

00:37:41 et puis on pourrait aussi avoir une

00:37:43 liste qui contient les lettres que

00:37:45 l'utilisateur a déjà rentrées

00:37:46 contre laquelle on pourrait tester la

00:37:48 nouvelle lettre, voir si la nouvelle

00:37:51 lettre se trouve dans la liste ou pas et

00:37:52 éventuellement boucler tant que la

00:37:54 lettre qu'il rentre ne répond pas à

00:37:55 toutes ces conditions. Puis finalement,

00:37:57 vous pouvez aller bien plus loin en

00:37:59 améliorant l'aspect visuel du programme

00:38:01 en affichant par exemple un bonhomme en

00:38:03 caractère ASCII ou bien carrément une

00:38:05 interface graphique de votre choix. Mais

00:38:06 quoi qu'il en soit, bravo, vous avez

00:38:08 codé votre premier jeu. Et maintenant,

00:38:09 on va voir un concept clé de la

00:38:12 programmation, les fonctions.

00:38:13 Quand on code des programmes plus

00:38:15 complexes, on se retrouve vite avec des

00:38:16 centaines ou des milliers de lignes de

00:38:18 code. On va avoir besoin de segmenter ce

00:38:19 code en sous-programmes pour pouvoir s'y

00:38:20 retrouver. On va donc utiliser les

00:38:22 fonctions pour séparer la logique de

00:38:24 notre code, mieux les maintenir et

00:38:25 pouvoir les réutiliser à plusieurs

00:38:26 endroits. On a déjà utilisé des

00:38:28 fonctions natives fournies par Python

00:38:29 comme print et input par exemple.

00:38:31 Maintenant, on va coder des fonctions

00:38:32 par nous-mêmes. On peut déclarer une

00:38:35 fonction en utilisant le mot def pour

00:38:37 define. On va ensuite donner un nom à

00:38:38 notre fonction comme on le fait avec les

00:38:40 variables. Donc créons une fonction qui

00:38:42 s'appelle ma barre en bas fonction.

00:38:44 Après le nom, on va ajouter des

00:38:46 parenthèses pour pouvoir passer ce qu'on

00:38:47 appelle des paramètres. On verra ça plus

00:38:49 en détail juste après mais pour vous

00:38:50 expliquer rapidement, c'est des

00:38:52 variables qu'on va passer à la fonction

00:38:54 qu'on va pouvoir utiliser à l'intérieur

00:38:55 de notre fonction comme quand on passait

00:38:56 une chaîne de caractères à la fonction

00:38:58 print. On a ensuite les symboles deux

00:39:00 points, un retour à la ligne et on va

00:39:02 indenter notre code comme on le faisait

00:39:05 avec if, while et for qu'on a déjà vu

00:39:06 ensemble. Tout le code qu'on va taper là

00:39:08 et qui sera indenté appartiendra donc à

00:39:09 la fonction. Maintenant, on va écrire du

00:39:11 code dans le corps de notre fonction. On

00:39:14 peut déclarer une variable ma variable

00:39:16 égale un et puis faire un print par

00:39:20 exemple print de ma variable est et puis

00:39:22 on ajoute ma variable. Pour sortir de

00:39:23 notre fonction et continuer d'écrire

00:39:24 notre programme, on fait deux retours à

00:39:26 la ligne et on sort de l'indentation. On

00:39:27 peut maintenant appeler notre fonction

00:39:29 en tapant son nom suivi de parenthèses.

00:39:32 Donc tapons ma fonction parenthèse

00:39:33 ouvrante parenthèse fermante. Lançons

00:39:35 notre programme et Python nous affiche

00:39:38 bien ma variable est un.

00:39:39 Maintenant, ça serait bien qu'on puisse

00:39:40 changer la valeur de de variable ma

00:39:42 variable en passant une autre valeur

00:39:44 quand on appelle notre fonction. C'est

00:39:45 ce qu'on appelle les paramètres. Pour

00:39:47 ça, on doit modifier notre fonction en

00:39:48 ajoutant ma variable dans les

00:39:50 parenthèses. On peut maintenant retirer

00:39:51 la ligne où on déclarait la variable. On

00:39:53 relance notre programme et là, on voit

00:39:54 qu'on a une erreur. C'est parce que

00:39:56 Python s'attend à recevoir un paramètre

00:39:57 entre parenthèses quand on appelle notre

00:39:59 fonction, alors qu'on ne lui en a pas

00:40:01 donné. Pour régler ça, on va lui passer

00:40:03 une valeur, disons 42, qu'on met entre

00:40:05 parenthèses quand on l'appelle. Si on

00:40:06 relance notre programme, on voit

00:40:08 maintenant qu'on a la phrase "ma

00:40:10 variable est 42" qui s'affiche

00:40:12 correctement. Ici, on passe un seul

00:40:13 paramètre à la fonction. Mais une

00:40:15 fonction peut recevoir zéro paramètre

00:40:17 comme on avait vu juste avant, ou bien

00:40:18 autant de paramètres qu'on veut. Elle

00:40:19 peut aussi avoir des paramètres

00:40:21 optionnels et pour ça, on assigne une

00:40:23 valeur par défaut au paramètre qu'on

00:40:24 veut rendre optionnel dans la

00:40:26 déclaration de fonction. Disons qu'on

00:40:28 voulait que ma variable soit égale à 5

00:40:29 par défaut si on ne lui passe pas de

00:40:31 valeur. On peut l'appeler en lui passant

00:40:34 un paramètre, gardons 42, mais on peut

00:40:35 aussi l'appeler sans paramètre et elle

00:40:38 prendra la valeur 5 par défaut. Si on

00:40:39 lance notre programme, on voit qu'on a

00:40:40 plus d'erreur car Python comprend que

00:40:42 cette fonction peut recevoir soit zéro,

00:40:44 soit un paramètre. Et on a bien

00:40:47 d'afficher "ma variable est 42" dans le

00:40:49 premier cas, et on a "ma variable est 5"

00:40:50 quand on a rien passé en paramètre dans

00:40:52 le deuxième cas.

00:40:54 Une fonction peut aussi recevoir un

00:40:55 nombre indéfini de paramètres avec le

00:40:58 symbole étoile et le mot args, ou même

00:41:00 deux symboles étoile et le mot kwargs

00:41:02 pour keyword arguments. Si on ne sait

00:41:03 pas combien de paramètres on va avoir,

00:41:05 on peut ajouter le symbole étoile avant

00:41:07 le nom de la variable qu'on a entre

00:41:08 parenthèses dans la définition de

00:41:09 fonction. Maintenant, si on appelle

00:41:10 notre fonction en lui passant les

00:41:14 valeurs 4, 3, 2 et 1, on voit qu'on a

00:41:15 pas d'erreur. Notre fonction affiche

00:41:17 bien les quatre paramètres. Vous pouvez

00:41:19 voir args comme une liste. D'ailleurs,

00:41:21 si on print le type de args avec la

00:41:24 fonction print de type de args, Python

00:41:26 nous dit que args est de type tuple. Les

00:41:28 tuples sont des types d'ensembles qui

00:41:30 sont un peu différents des listes et on

00:41:32 verra ça plus tard dans ce tutoriel. On

00:41:33 peut aussi avoir des arguments nommés

00:41:36 avec deux étoiles suivies du mot kwargs.

00:41:38 Pour ça, on va ajouter un nom à chaque

00:41:40 paramètre qu'on passe à notre fonction.

00:41:43 Ajoutons donc 4 en toutes lettres et

00:41:46 puis égale la valeur 4, 3 en toutes

00:41:50 lettres égale 3, 2 égale 2 et 1 égale 1.

00:41:51 On voit qu'on a un nouveau type d'objet

00:41:53 de type dict pour dictionnaire. C'est

00:41:54 aussi un nouveau type d'objet qui nous

00:41:56 permet d'avoir des paires clé-valeur et

00:41:58 on voit ça ensemble juste après dans

00:41:59 cette vidéo.

00:42:00 Les fonctions qu'on a codé jusqu'à

00:42:02 maintenant ne renvoient pas de valeur.

00:42:03 Si vous vous souvenez, avec la fonction

00:42:05 input, on pouvait récupérer la valeur en

00:42:07 l'assignant à une variable. On avait par

00:42:10 exemple âge égale input et puis la

00:42:11 question qu'on lui posait entre

00:42:12 parenthèses, et on pouvait assigner la

00:42:14 valeur qu'on récupérait à âge. Pour

00:42:15 pouvoir récupérer une ou plusieurs

00:42:17 valeurs dans notre fonction, on utilise

00:42:19 le mot return. On va donc créer une

00:42:21 nouvelle fonction qui fait la somme de

00:42:22 deux nombres qu'on lui passe. On va donc

00:42:24 faire def suivi du nom de notre

00:42:27 fonction, ici somme, suivi de

00:42:28 parenthèses dans lesquelles on met deux

00:42:31 paramètres A et B. Dans le corps de

00:42:32 notre fonction, on va taper le mot

00:42:35 return suivi de A plus B. On peut

00:42:37 maintenant appeler notre fonction et

00:42:39 récupérer la somme en l'assignant à une

00:42:43 variable en faisant S égale somme

00:42:45 et puis en lui passant 4 et 5 entre

00:42:46 parenthèses. On peut donc faire print de

00:42:48 S pour afficher le contenu de la

00:42:50 variable S. Si on lance notre programme,

00:42:52 on voit bien qu'on a la valeur 9 qui

00:42:53 s'affiche. On peut aussi appeler notre

00:42:55 fonction directement dans le print avec

00:42:57 print entre parenthèses somme entre

00:43:00 parenthèses 5, 4 puis on ferme les

00:43:01 parenthèses. Relançons le programme et

00:43:03 on voit que rien n'a changé, on a

00:43:04 toujours la valeur 9 qui s'affiche. En

00:43:06 Python, on peut retourner plusieurs

00:43:07 valeurs, donc on peut modifier notre

00:43:08 fonction somme qu'on avait fait juste

00:43:10 avant. Et en plus de l'addition, on va

00:43:12 lui renvoyer les deux paramètres. Donc

00:43:16 on a return A plus B, virgule A, virgule

00:43:17 B. Maintenant, si on relance notre

00:43:18 programme, on voit que print nous

00:43:21 affiche bien les trois valeurs.

00:43:22 Une notion importante quand on travaille

00:43:24 avec des fonctions, elle a notion de

00:43:26 scope. On peut traduire scope par portée

00:43:28 et c'est des endroits dans notre code où

00:43:29 certaines variables seront connues

00:43:31 seulement localement. Voyons ça

00:43:32 concrètement en déclarant deux

00:43:34 fonctions, fonction une et fonction

00:43:35 deux. Dans le corps de ces fonctions, on

00:43:37 va avoir des blocs similaires. Dans les

00:43:38 deux fonctions, on va avoir une

00:43:40 assignation de variable A et puis on va

00:43:42 afficher le contenu de la variable A.

00:43:44 Dans la fonction une, on assigne 1 à la

00:43:47 variable A et puis on fait print

00:43:49 fonction une A égale suivi de la

00:43:51 variable A. Dans la fonction deux, on

00:43:54 fait pareil sauf qu'on a A égale 2 et on

00:43:57 fait print fonction deux A égale A.

00:43:58 Maintenant, on va essayer d'afficher le

00:44:00 contenu de la variable A dans le

00:44:01 programme principal. Si on lance notre

00:44:03 programme, on voit que Python nous dit

00:44:04 que la variable A n'est pas définie.

00:44:06 C'est parce que lorsqu'on déclare ces

00:44:08 variables dans notre fonction, seules

00:44:09 les fonctions ont accès à cette

00:44:10 variable. La portée de la variable est

00:44:12 limitée localement à la fonction dans

00:44:13 laquelle elle est définie. On peut aussi

00:44:14 déclarer des variables de manière

00:44:16 globale, ce qu'on peut faire en

00:44:18 déclarant une autre variable A tout en

00:44:20 haut de notre programme dans laquelle on

00:44:21 met la valeur zéro. Si maintenant on

00:44:23 relance notre programme, on voit que

00:44:26 chaque fonction a sa valeur locale de A,

00:44:27 mais il y a aussi une valeur globale de

00:44:29 A qui est zéro et là, notre programme

00:44:31 principal la connaît aussi. Vu que A est

00:44:33 maintenant globale, on peut supprimer

00:44:35 l'assignation dans la première fonction

00:44:37 par exemple et là, même s'il y a pas

00:44:40 d'assignation de A dans la fonction,

00:44:42 notre fonction va se reposer sur la

00:44:44 variable globale A et l'utiliser par

00:44:45 défaut. Si on relance notre programme,

00:44:47 on voit que dans la fonction un, A est

00:44:49 maintenant égale à zéro. Donc revoyons

00:44:50 tous les éléments qui composent une

00:44:52 fonction avant de passer à notre

00:44:53 quatrième projet qu'on va faire

00:44:54 ensemble.

00:44:56 On a le mot def qui permet de définir

00:44:59 une fonction. On a ensuite le nom de la

00:45:00 fonction qui respecte les mêmes règles

00:45:02 que pour les variables, à savoir le

00:45:04 snake case, des mots en minuscules

00:45:06 séparés par de underscore, barre en bas.

00:45:07 Puis on a des parenthèses dans laquelle

00:45:09 on peut passer des paramètres autant

00:45:10 qu'on veut, soit zéro, soit une infinité

00:45:12 de paramètres. On a les symboles deux

00:45:14 points, un retour à la ligne avec une

00:45:16 indentation d'espace ou de tabulation.

00:45:17 Puis le corps de notre fonction qui

00:45:19 possède son propre scope et qui est la

00:45:21 logique de notre fonction.

00:45:22 Voilà, on peut maintenant passer au

00:45:24 quatrième projet de cette formation. On

00:45:26 va coder une version simplifiée de la

00:45:27 fonction range. Recoder les fonctions

00:45:28 standard d'un langage est une bonne

00:45:30 pratique car ça nous permet de mieux le

00:45:31 comprendre. Dans la vidéo précédente, on

00:45:33 a utilisé la fonction range pour pouvoir

00:45:34 boucler un certain nombre de fois avec

00:45:36 la boucle for. On va donc coder une

00:45:39 fonction simple range qui ne prend qu'un

00:45:41 paramètre N et qui renvoie une liste qui

00:45:44 contient N éléments de zéro à N moins 1.

00:45:46 En réalité, la fonction range est plus

00:45:47 complexe, elle prend plus de paramètres

00:45:49 que ça et elle ne renvoie pas exactement

00:45:50 une liste. C'est pour ça qu'on fait la

00:45:52 version simplifiée de range, la fonction

00:45:54 simple range. Donc je vous laisse

00:45:55 essayer de faire votre propre fonction

00:45:57 range. Je vous invite encore une fois à

00:45:58 mettre la vidéo en pause et on se

00:46:00 retrouve dans quelques secondes pour la

00:46:01 faire ensemble.

00:46:03 Pour coder une fonction simple range, on

00:46:04 utilise le mot def pour définir notre

00:46:07 fonction, puis le nom simple barre en

00:46:09 bas range, des parenthèses dans laquelle

00:46:11 on va fournir le seul paramètre qu'on va

00:46:13 avoir, N. Dans le corps de notre

00:46:15 fonction, on va déclarer deux variables.

00:46:17 La première, ça serait une liste vide

00:46:19 avec L égale et puis des crochets. Puis

00:46:21 on va aussi avoir une variable I qui va

00:46:23 nous servir d'indice dans laquelle on va

00:46:25 mettre la valeur zéro. On aura une

00:46:27 boucle while qui va boucler tant que I

00:46:29 est plus petit que N. Et dans le corps

00:46:31 de notre boucle while, on va ajouter

00:46:33 l'élément I à notre liste à chaque

00:46:35 passage dans la boucle. On doit ensuite

00:46:36 incrémenter I de 1 pour ne pas partir en

00:46:38 boucle infinie. Et à la fin de notre

00:46:40 fonction, on renvoie notre liste L qui

00:46:43 devrait contenir N éléments de zéro à N

00:46:45 moins 1. Testons notre fonction en

00:46:47 l'appelant avec print de simple range à

00:46:48 laquelle on passe la valeur 5 en

00:46:50 paramètre. Quand on lance notre

00:46:51 programme, on voit bien qu'on a une

00:46:54 liste qui contient 5 nombres de zéro à

00:46:56 4. Comme je vous dis, la vraie fonction

00:46:58 native range est plus compliquée que ça.

00:46:59 Vous pouvez aller voir sa définition de

00:47:01 fonction et éventuellement lui rajouter

00:47:02 plus de fonctionnalités pour qu'elle

00:47:04 soit plus utile.

00:47:05 On a vu les listes qui permettent

00:47:07 d'avoir plusieurs objets dans un seul

00:47:08 ensemble. Maintenant, on va voir

00:47:10 d'autres types de collections ensemble,

00:47:11 les tuples, les sets et les

00:47:12 dictionnaires. Donc commençons avec les

00:47:14 tuples. On peut déclarer un tuple en

00:47:16 utilisant des parenthèses. Les tuples

00:47:17 sont immutables, ça veut dire que

00:47:18 contrairement aux listes, on ne peut pas

00:47:20 les modifier. Si on fait nombre à la

00:47:23 position 5 égale 6, on aura une erreur.

00:47:24 On peut utiliser des fonctions comme len

00:47:27 sur un tuple et on peut aussi voir si un

00:47:29 élément se trouve dans un tuple avec le

00:47:31 mot-clé in. Tuple nous donne accès à

00:47:33 deux méthodes, index et count. Index

00:47:35 permet de connaître l'indice d'un

00:47:36 élément qu'on lui passe entre

00:47:37 parenthèses s'il se trouve dans le

00:47:39 tuple. Et count nous permet de compter

00:47:40 combien de fois un élément se trouve

00:47:42 dans le tuple. Les différences entre une

00:47:44 liste et un tuple sont donc que les

00:47:45 tuples sont plus rapides que les listes

00:47:47 car ils sont immutables contrairement

00:47:48 aux listes qu'on peut modifier

00:47:50 facilement. Mais on va aussi avoir

00:47:51 tendance à mettre des éléments de même

00:47:53 type dans une liste, alors qu'on va

00:47:54 souvent utiliser les tuples comme des

00:47:56 structures avec des types d'objets

00:47:57 différents. Par exemple, si on veut

00:47:59 déclarer un ensemble de nombres, on aura

00:48:00 le réflexe de faire une liste. Mais si

00:48:02 on veut un ensemble qui n'est pas un

00:48:03 dictionnaire et dans lequel on a

00:48:05 plusieurs types de variables différentes

00:48:07 comme les détails d'un étudiant par

00:48:09 exemple, on aura tendance à utiliser un

00:48:10 tuple.

00:48:12 Voyons maintenant les sets. Les sets

00:48:13 sont des ensembles qu'on déclare avec

00:48:15 des accolades. Ils n'ont pas d'ordre

00:48:17 précis et on ne peut pas les modifier

00:48:19 car ils sont immutables. On a donc pas

00:48:20 de doublons dans un set et on ne peut

00:48:21 pas les modifier avec une simple

00:48:23 assignation comme on le ferait avec une

00:48:24 liste par exemple. Prenons un set de

00:48:26 nombres avec plusieurs nombres dans le

00:48:28 désordre et avec des doublons. En

00:48:29 l'affichant avec print, on voit que

00:48:31 Python a changé l'ordre de notre set en

00:48:34 0 1 2 3 4 et qu'il a retiré les doublons

00:48:35 2 et 3. Avec les sets, comme avec les

00:48:37 listes, on peut utiliser la fonction len

00:48:39 qui fonctionne également, ainsi que le

00:48:40 mot in pour vérifier si un élément se

00:48:41 trouve dans notre set. La différence

00:48:43 avec les listes, c'est que comme les

00:48:44 sets n'ont pas d'ordre, on ne peut pas

00:48:46 accéder à un élément précis en lui

00:48:48 passant un indice. Si on fait nombre de

00:48:50 2, Python va nous renvoyer une erreur.

00:48:51 On ne peut pas non plus changer les

00:48:52 valeurs d'un set comme on le fait avec

00:48:54 les listes en assignant une valeur à un

00:48:55 indice. Mais heureusement, on a les

00:48:57 méthodes add et remove pour faire plus

00:48:59 ou moins la même chose. Nombre add de 5

00:49:01 ajoutera bien l'entier 5 à notre set de

00:49:03 nombres et on peut aussi retirer un

00:49:05 élément précis avec nombre.remove et

00:49:07 puis lui passer un élément en paramètre.

00:49:09 La méthode pop sur un set permet aussi

00:49:11 de retirer le premier élément du set.

00:49:13 des méthodes de comparer deux sets entre

00:49:15 eux, union, intersection et différence.

00:49:17 L'union est ce qui sera contenu dans les

00:49:19 deux sets. Donc si on fait set 1 union

00:49:22 set 2, on a tous les éléments qui se

00:49:24 trouvent dans set 1 ou dans set 2.

00:49:25 L'intersection est ce qui se trouve en

00:49:28 commun dans les deux sets. Set 1

00:49:30 intersection set 2 nous donnera que les

00:49:32 éléments qui sont et dans set 1 et dans

00:49:34 set 2. Et différence est ce qu'on trouve

00:49:36 dans le set 1 mais pas dans le set 2.

00:49:38 Set 1 différence set 2 nous donnera que

00:49:41 les éléments qui sont exclusifs à 71.

00:49:42 Pour voir les autres méthodes de 7 et en

00:49:44 Python en général, on peut utiliser la

00:49:46 fonction dire à laquelle on passe notre

00:49:47 objet pour voir toutes les méthodes et

00:49:49 attributs d'un objet. La fonction help

00:49:51 permet aussi d'avoir l'aide de base de

00:49:53 Python pour un type d'objet.

00:49:55 Finalement, voyons les dictionnaires.

00:49:56 Les dictionnaires sont des types

00:49:58 d'ensemble clé valeur. Ils ont un ordre

00:49:59 précis et on peut les modifier avec une

00:50:01 simple assignation mais ils ne peuvent

00:50:02 pas avoir de clé en doublon. On peut

00:50:03 déclarer un dictionnaire avec des

00:50:05 accolades comme un 7 sauf qu'on va lui

00:50:07 passer un ensemble clé deux points

00:50:09 valeur. Donc déclarons un dictionnaire

00:50:11 de nombre. Pour accéder à une valeur, on

00:50:12 utilise la clé comme on le ferait avec

00:50:14 l'indice numérique dans une liste sauf

00:50:16 que là on l'a nommé avec une clé. Donc

00:50:18 si on fait nombre crochet et puis qu'on

00:50:20 lui passe la clé un entre guillemets, on

00:50:22 aura bien l'entier un. Pour voir toutes

00:50:22 les méthodes et attributs d'un

00:50:24 dictionnaire, on peut utiliser la

00:50:25 fonction dire. Donc faisons dire de

00:50:26 nombre et on voit par exemple qu'on a la

00:50:29 fonction get. On utilise la fonction get

00:50:30 pour obtenir un élément dans un

00:50:31 dictionnaire. C'est comme utiliser la

00:50:33 clé entre crochets sauf que si on donne

00:50:35 une mauvaise clé entre crochets, Python

00:50:37 va nous renvoyer une erreur et crasher

00:50:38 violemment avec key error, erreur de

00:50:40 clé. Alors qu'avec get, Python va

00:50:41 essayer de récupérer la valeur pour la

00:50:43 clé donnée et il renverra none s'il ne

00:50:45 trouve pas la valeur pour la clé. On

00:50:46 peut aussi lui passer une valeur en

00:50:48 deuxième position en paramètre. Ça

00:50:49 deviendra la valeur qu'il renverra par

00:50:50 défaut s'il ne trouve pas la clé dans le

00:50:51 dictionnaire. C'est donc une bonne

00:50:53 pratique d'utiliser get plutôt que faire

00:50:55 des try except par exemple. On peut

00:50:57 aussi modifier ou ajouter une nouvelle

00:50:59 paire de clés avec la méthode update ce

00:51:01 qui revient à utiliser l'assignation.

00:51:04 Par exemple, nombre 5 égale 5 est

00:51:07 équivalent à nombre update 6 égale 6. On

00:51:08 peut aussi utiliser la méthode pop pour

00:51:10 retirer un élément d'un dictionnaire en

00:51:12 lui passant une clé. Par exemple, nombre

00:51:14 pop de 3 retirera notre paire clé valeur

00:51:16 qui a la clé 3. On peut aussi récupérer

00:51:18 toutes les clés d'un dictionnaire avec

00:51:19 la méthode keys. Donc si on fait nombre

00:51:21 point keys, on récupère toutes les clés.

00:51:23 Pareil pour les valeurs avec la méthode

00:51:25 values. Si on fait nombre point values,

00:51:26 on a toutes les valeurs de notre

00:51:28 dictionnaire. Et items nous renvoie une

00:51:30 sorte de liste qui contient des tuples

00:51:32 qui eux-mêmes contiennent les clés et

00:51:33 les valeurs pour chaque élément de notre

00:51:35 dictionnaire.

00:51:36 Une classe, c'est comme la

00:51:38 représentation d'un objet dans le monde

00:51:40 réel. D'ailleurs en programmation, on

00:51:41 utilise souvent le mot objet pour parler

00:51:43 d'une classe. Les classes en Python

00:51:45 permettent de regrouper des données et

00:51:47 des fonctions dans une structure facile

00:51:49 à réutiliser. C'est comme un moule, un

00:51:50 modèle ou un plan qui va nous permettre

00:51:52 de créer des versions d'un objet. Et les

00:51:54 objets qu'on crée avec des classes sont

00:51:56 appelés des instances. Donc le concept

00:51:57 de classe est central dans la

00:52:00 programmation orientée objet ou POO et

00:52:01 faire de la programmation orientée

00:52:03 objet, ça veut dire utiliser des classes

00:52:04 dans notre code. Et on s'est déjà servi

00:52:06 de la POO et des méthodes sur des objets

00:52:08 quand on a utilisé point append ou point

00:52:10 remove sur des collections par exemple.

00:52:11 Mais maintenant on va faire notre propre

00:52:13 classe. Disons qu'on va lui faire un

00:52:14 modèle pour créer des voitures

00:52:16 Cybertrucks de la marque Tesla. On va

00:52:18 donc avoir une classe comme ça. On

00:52:19 commence avec le mot classe qui permet

00:52:21 de créer une classe. C'est comme le mot

00:52:22 def qui permet de créer des fonctions

00:52:24 mais pour les classes. Cybertruck est le

00:52:26 nom de notre classe. La convention de

00:52:28 nommage veut qu'on utilise le Pascal

00:52:30 case donc des mots qui commencent par

00:52:31 des majuscules. Par exemple, on peut

00:52:34 écrire mon Cybertruck ou ma voiture.

00:52:35 Ensuite, on a trois attributs de classe

00:52:37 qui définissent les instances qu'on va

00:52:39 créer. On a l'attribut marque, on va

00:52:41 mettre Tesla. Dans modèle, on va mettre

00:52:43 Cybertruck et dans l'année, on va mettre

00:52:44 2023. Et voilà, maintenant on peut créer

00:52:47 des Cybertrucks. Donc faisons Cybertruck

00:52:49 égale Cybertruck avec un C majuscule et

00:52:51 des parenthèses et on peut accéder aux

00:52:52 attributs de la classe avec le nom de la

00:52:55 variable et puis point marque, modèle ou

00:52:56 année. Donc pour afficher la marque de

00:52:58 notre Cybertruck, on fait print

00:53:00 Cybertruck.marque. Mais maintenant ça

00:53:01 serait bien que notre Cybertruck soit

00:53:03 capable de faire quelque chose. Donc on

00:53:04 va lui ajouter la capacité de klaxonner

00:53:06 avec une fonction ou une méthode de

00:53:08 classe qu'on va appeler klaxonner. Dans

00:53:09 notre classe, on crée une fonction

00:53:12 klaxonner qui fait print "Tut tut".

00:53:13 Maintenant, pour que la méthode soit

00:53:14 valide, on doit lui passer une variable

00:53:16 en paramètre. Cette variable est une

00:53:18 référence vers l'instance en cours et

00:53:20 par convention, on l'appelle self. On

00:53:21 reparle du mot self juste après. Donc

00:53:22 maintenant on peut faire

00:53:24 Cybertruck.klaxonner et on a bien "Tut

00:53:26 tut" qui s'affiche. On peut aussi

00:53:27 ajouter ou modifier des attributs et des

00:53:29 méthodes à nos objets après leur

00:53:30 instanciation en lui assignant des

00:53:32 choses. Reprenons notre Cybertruck. Si

00:53:34 c'est un Cybertruck qui date en fait de

00:53:36 2024 plutôt que 2023, on peut faire

00:53:39 Cybertruck.année égale 2024 et à partir

00:53:41 de maintenant quand on print

00:53:43 Cybertruck.année, on aura 2024 et plus

00:53:46 2023. On peut aussi utiliser la fonction

00:53:47 dire sur notre Cybertruck et sur tous

00:53:49 les objets en Python d'ailleurs pour

00:53:50 avoir tous les attributs de classe. Donc

00:53:53 print dire de Cybertruck affichera tous

00:53:54 les attributs auxquels on a accès avec

00:53:56 l'instance de Cybertruck.

00:53:57 Mais donc c'est bien de pouvoir créer

00:53:59 des Cybertrucks mais ça serait mieux de

00:54:00 pouvoir créer différents types de

00:54:02 voitures de manière modulaire en leur

00:54:03 passant les paramètres qu'on veut. Et

00:54:05 pour ça, on utilise ce qu'on appelle un

00:54:06 constructeur. Donc changeons le nom de

00:54:08 notre classe de Cybertruck en voiture

00:54:10 puis on va déclarer le constructeur avec

00:54:12 une méthode spéciale init. Init permet

00:54:14 de déclarer un constructeur. C'est une

00:54:15 méthode spéciale qui est appelée

00:54:16 lorsqu'on crée une nouvelle instance de

00:54:18 la classe. Elle initialise l'instance de

00:54:19 l'objet et les attributs de la classe

00:54:20 qu'on lui passe en paramètre. Et donc

00:54:22 pour créer d'autres types de voitures en

00:54:23 passant les attributs marque, modèle et

00:54:25 année comme on veut, on va utiliser des

00:54:27 paramètres. On commence par self comme

00:54:28 pour notre méthode klaxonner et puis on

00:54:30 va lui passer marque, modèle et année.

00:54:32 Et plutôt que de les avoir en dur, on va

00:54:33 changer les trois attributs qu'on avait

00:54:36 en self.marque égale marque, self.modèle

00:54:39 égale modèle et self.année égale année.

00:54:40 Et grâce à ce constructeur, on peut

00:54:41 maintenant créer des instances de la

00:54:43 classe voiture en lui passant des

00:54:44 paramètres nommés. Donc changeons la

00:54:46 classe de notre Cybertruck en voiture et

00:54:48 on va lui passer marque Tesla, modèle

00:54:49 Cybertruck et dans l'année, on va mettre

00:54:51 2023. Mais on peut aussi créer des

00:54:52 voitures totalement différentes. Faisons

00:54:54 par exemple une Toyota Corolla avec

00:54:56 Corolla égale voiture, marque Toyota,

00:54:58 modèle Corolla, année 2022. On peut

00:55:00 faire klaxonner nos voitures ou afficher

00:55:02 leurs attributs. Ce sont deux instances

00:55:03 indépendantes qui viennent de la même

00:55:05 classe avec des attributs différents. On

00:55:06 pourrait ajouter plein de

00:55:07 fonctionnalités à notre classe voiture

00:55:08 comme une vitesse et puis des méthodes

00:55:11 pour accélérer, décélérer et freiner. Et

00:55:12 avec ça, on aurait la base pour une

00:55:14 voiture dans un jeu vidéo de course par

00:55:15 exemple. Mais pour le moment, reparlons

00:55:16 du paramètre self qu'on a passé dans le

00:55:18 constructeur, dans notre méthode de

00:55:19 classe et qu'on doit passer dans toutes

00:55:20 les méthodes de classe en Python. Cette

00:55:22 variable self sert de référence à

00:55:23 l'instance qu'on est en train

00:55:25 d'utiliser. Et donc Python aura besoin

00:55:26 d'avoir cette valeur en premier

00:55:27 paramètre de ses méthodes pour savoir de

00:55:29 quelle instance on parle. D'ailleurs, on

00:55:30 peut aussi appeler une méthode de classe

00:55:32 avec une version plus explicite en

00:55:34 faisant voiture.klaxonner

00:55:36 et puis en lui passant notre instance

00:55:37 Cybertruck par exemple. Et là ça

00:55:38 correspond mieux à la déclaration de

00:55:39 méthode qu'on avait dans notre classe

00:55:41 voiture et ça permet de mieux comprendre

00:55:42 pourquoi on a besoin de la variable

00:55:44 self.

00:55:45 Comme exercice, je vais vous proposer de

00:55:47 faire votre propre machine à pizza. Donc

00:55:49 on va faire une classe pizza et vous

00:55:50 pouvez faire ce que vous voulez avec.

00:55:51 Par exemple, dans le constructeur, on

00:55:53 peut prendre une base qui est blanche ou

00:55:55 rouge. On peut prendre un diamètre pour

00:55:57 la taille de la pizza et puis un type de

00:55:58 pizza comme calzone par exemple. Puis on

00:56:00 peut avoir une méthode pour ajouter des

00:56:02 ingrédients, une méthode pour l'amener à

00:56:04 une certaine table ou bien une méthode

00:56:06 pour la livrer à un client. Donc voilà,

00:56:07 n'hésitez pas à être créatif, il y a pas

00:56:08 vraiment de bonnes ou mauvaises

00:56:10 réponses. Le but c'est d'implémenter un

00:56:12 constructeur avec des attributs et au

00:56:14 moins une méthode de classe. Je vous

00:56:16 laisse mettre cette vidéo en pause et on

00:56:17 se retrouve en quelques secondes pour

00:56:19 une implémentation de la classe pizza.

00:56:20 Donc voilà, j'espère que vous avez mis

00:56:22 la vidéo en pause. Maintenant, je vais

00:56:23 vous proposer une implémentation de la

00:56:25 classe pizza. Donc on commence avec le

00:56:27 mot clé classe. On appelle notre classe

00:56:29 pizza. Puis dans le constructeur, on va

00:56:31 avoir self, la base de la pizza qui sera

00:56:34 blanche ou tomatée, le prix, le

00:56:37 diamètre, son style classique, calzone,

00:56:39 stromboli ou autre et les ingrédients

00:56:41 qu'on veut sur notre pizza.

00:56:43 Donc pour chaque attribut, on fait self.

00:56:45 Donc on a self.base égale base,

00:56:47 self.prix égale prix, self.diamètre

00:56:49 égale diamètre, self.style égale style

00:56:51 et self.ingrédient égale ingrédient. On

00:56:53 va faire une première méthode qui sert à

00:56:54 ajouter des ingrédients qu'on va appeler

00:56:56 ajouter ingrédient qui prend en

00:56:58 paramètre self et le nouvel ingrédient

00:56:59 qu'on va ajouter. Avant d'ajouter

00:57:00 l'ingrédient, on va vérifier que

00:57:02 l'ingrédient n'est pas ananas parce que

00:57:03 si c'est des ananas, on va lever une

00:57:05 erreur qui dit "Les ananas ne vont pas

00:57:07 sur les pizzas." Sinon, on prend notre

00:57:08 attribut ingrédient et on ajoute le

00:57:10 nouvel ingrédient. Aussi, à chaque

00:57:11 nouvel ingrédient ajouté, on va

00:57:13 augmenter le prix d'un euro. Donc on

00:57:15 fait self.prix égale self.prix plus un.

00:57:17 Ensuite, on a une méthode pour servir

00:57:18 une pizza à une table qui prend en

00:57:20 paramètre l'instance de la pizza avec

00:57:22 self et puis la table et qui affiche

00:57:24 avec la fonction print "J'amène la pizza

00:57:25 à la table" et puis le numéro de la

00:57:27 table. Pareil pour la livraison, on a

00:57:28 une méthode qui permet de livrer qui

00:57:30 prend la pizza avec l'objet self et

00:57:32 l'adresse à laquelle on va livrer et qui

00:57:34 affiche "Je livre la pizza à l'adresse"

00:57:35 et puis l'adresse. Maintenant, on va

00:57:37 demander à l'utilisateur quelle base il

00:57:39 veut. Pour ça, on crée une variable base

00:57:41 et on utilise la fonction input pour

00:57:43 demander "Quelle base ? Tomate ou ?"

00:57:45 Pareil pour la taille, on crée une

00:57:46 variable taille et puis on demande

00:57:48 "Quelle taille ? Moyenne ou ?" Pour le

00:57:50 style, on demande "Quel style ?" et on

00:57:52 lui propose classique, calzone,

00:57:53 stromboli ou autre. Pour les

00:57:54 ingrédients, il devra taper ses

00:57:56 ingrédients séparés par des virgules.

00:57:57 Donc on a la taille moyenne ou grande.

00:57:59 Par défaut, on va partir du principe que

00:58:01 la taille sera moyenne donc 30 cm. Mais

00:58:02 si la personne veut une pizza qui est

00:58:05 grande, on fait passer le diamètre à 34.

00:58:06 Pour les ingrédients, on prend les

00:58:08 ingrédients et on split, ça veut dire on

00:58:10 sépare sur les virgules. Comme ça, la

00:58:12 liste d'ingrédients qu'il a mis séparés

00:58:13 par des virgules donnera une liste

00:58:15 d'ingrédients individuels. Pour le prix,

00:58:17 on part d'une base de 5 euros et puis on

00:58:19 ajoute un euro par ingrédient ce qu'on

00:58:20 peut faire en utilisant la taille de la

00:58:22 liste d'ingrédients. Donc on peut créer

00:58:23 notre instance de pizza en faisant pizza

00:58:26 égale pizza en lui passant la base, le

00:58:28 diamètre, le style, les ingrédients et

00:58:29 le prix. Maintenant, on va tester notre

00:58:31 fonction pour ajouter des ingrédients.

00:58:33 On va ajouter des olives. Donc on va

00:58:34 regarder le la liste d'ingrédients et le

00:58:36 prix de la pizza avant et après l'ajout.

00:58:38 Puis on va essayer de livrer la pizza au

00:58:40 9 rue du Bois. On va servir la pizza à

00:58:42 la table 13. Puis on va demander si la

00:58:44 personne veut ajouter des ananas pour

00:58:45 tester notre erreur. Donc on lui demande

00:58:47 oui ou non. Et si la personne répond

00:58:49 oui, on va ajouter l'ananas ce qui

00:58:51 devrait lever une erreur. Lançons notre

00:58:52 programme pour tester tout ça. "Quelle

00:58:54 base ?" On va mettre tomate. "Quelle

00:58:57 taille ?" On va mettre moyenne. "Quel

00:58:59 style ?" On va choisir classique. "Quels

00:59:00 ingrédients ?" Je vais mettre tomate,

00:59:02 ail et aubergine séparés par des

00:59:04 virgules et des espaces. Quand j'appuie

00:59:05 sur entrée, le reste de mon programme

00:59:07 s'exécute. Donc on voit que avant

00:59:08 d'ajouter des olives, j'avais trois

00:59:10 ingrédients sur ma pizza et elle coûtait

00:59:12 8 euros. Et en ajoutant des olives, j'en

00:59:13 ai quatre et elle coûte maintenant 9

00:59:14 euros. On voit que la fonction pour

00:59:16 livrer fonctionne bien car ça affiche

00:59:18 "Je livre la pizza à l'adresse 9 rue du

00:59:20 Bois." Pareil pour la méthode servir qui

00:59:22 permet d'amener une pizza à une table.

00:59:23 "J'amène la pizza à la table 13." Et

00:59:24 puis maintenant le programme nous

00:59:26 demande si on veut ajouter des ananas.

00:59:27 On va répondre oui. Et là on a bien une

00:59:29 erreur de type TypeError. "Les ananas ne

00:59:31 vont pas sur les pizzas." Et voilà,

00:59:32 c'est tout pour la base des classes.

00:59:33 mais il y a plein d'autres concepts de

00:59:35 POO que je vous invite à découvrir avec

00:59:36 Python.

00:59:37 Et voilà, c'est tout pour cette

00:59:39 formation d'une heure en Python. Vous

00:59:40 avez maintenant les bases qui vont vous

00:59:41 permettre de vous lancer dans la

00:59:43 programmation, mais il y a encore plein

00:59:44 de concepts importants à apprendre en

00:59:45 Python avec lesquels vous pourrez

00:59:47 améliorer vos connaissances. Et pour ça,

00:59:49 vous trouverez des vidéos sur Python au

00:59:51 format long ainsi que des shorts sur

00:59:52 cette chaîne. Je vous invite donc à vous

00:59:54 abonner pour ne rien rater et de me dire

00:59:55 en commentaire les sujets pour lesquels

Apprendre Python en 1 heure - Cours Complet Débutant (4K)

Transcription horodatee