├── .gitignore ├── FAQ.ipynb ├── Final Capstone Projects ├── Final Capstone Project Ideas.ipynb └── Projects-Solutions │ └── Solution Links.md ├── Jupyter (iPython) Notebooks Guide.ipynb ├── Mon bloc note.ipynb ├── Mon premier bloc note.ipynb ├── Partie10_Décorateurs ├── Approfondissements sur les décorateurs .ipynb └── Decorateurs.ipynb ├── Partie11_Générateurs ├── Iterators and Generators Homework - Solution.ipynb ├── Iterators and Generators Homework.ipynb └── Iterators and Generators.ipynb ├── Partie12_Projet_Final ├── .ipynb_checkpoints │ └── Projet final-checkpoint.ipynb └── Projet final.ipynb ├── Partie1_Python_Notions_de_Base ├── Affichage et sortie écran.ipynb ├── Controle de connaissances sur les objets et les structures de données.ipynb ├── Les Sets et les Booléens.ipynb ├── Les chaines de caractères.ipynb ├── Les dictionnaires.ipynb ├── Les fichiers.ipynb ├── Les listes.ipynb ├── Les nombres.ipynb ├── Solutions du controle de connaissances sur les objets et les structures de données.ipynb └── Tuples.ipynb ├── Partie2_Python_Déclarations ├── Boucles for.ipynb ├── Boucles while.ipynb ├── Contrôle des connaissances.ipynb ├── Enchainement d'opérateurs logiques.ipynb ├── Introduction aux instructions Python.ipynb ├── Les directives if, elif, et else.ipynb ├── Listes en compréhension.ipynb ├── Opérateurs logiques.ipynb ├── Range().ipynb └── Solutions du contrôle des connaissances.ipynb ├── Partie3_Méthodes_et_Fonctions ├── Controle de connaissances sur les fonctions et les méthodes.ipynb ├── Les expressions lambda.ipynb ├── Les fonctions.ipynb ├── Les instructions imbriquées et le "Scope".ipynb ├── Les méthodes.ipynb └── Solution du controle de connaissances sur les fonctions et les méthodes.ipynb ├── Partie4_Premier_Projet ├── 1 - Présentation du premier project.ipynb ├── 2 - Premier Projet d'étape - Feuille de route détaillée.ipynb ├── 3 - Solution de la feuille de route du jeu de Morpion.ipynb └── Pas utilisé dans la version en ligne - Solution du jeu de Morpion.ipynb ├── Partie5_Programmation_Orientée_Objet ├── Programmation Orientée Objet - Contrôle de connaissances - Solution.ipynb ├── Programmation Orientée Objet - Contrôle de connaissances.ipynb └── Programmation Orientée Objet.ipynb ├── Partie6_Erreurs_et_Exceptions ├── Gestion des erreurs et des exceptions - Controle de connaissances.ipynb ├── Gestion des erreurs et des exceptions - Solution du controle de connaissances.ipynb └── Gestion des erreurs et des exceptions.ipynb ├── Partie7_Deuxième_Projet ├── .ipynb_checkpoints │ └── Milestone Project 2 - Développer un jeu de Blackjack-checkpoint.ipynb ├── Milestone Project 2 - Développer un jeu de Blackjack.ipynb └── Milestone Project 2 Solution.ipynb ├── Partie8_Modules_et_Paquets ├── .ipynb_checkpoints │ └── Modules et Paquets-checkpoint.ipynb └── Modules et Paquets.ipynb ├── Partie9_Fonctions_Intégrées ├── .ipynb_checkpoints │ ├── All() et any()-checkpoint.ipynb │ ├── Controle de connaissances sur les fonctions intégrées-checkpoint.ipynb │ └── Solutions du controle de connaissances sur les fonctions intégrées-checkpoint.ipynb ├── All() et any().ipynb ├── Complex.ipynb ├── Controle de connaissances sur les fonctions intégrées.ipynb ├── Enumerate.ipynb ├── Filter.ipynb ├── Map.ipynb ├── Solutions du controle de connaissances sur les fonctions intégrées.ipynb └── Zip.ipynb └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Dictionaries-checkpoint.ipynb 3 | 4 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Files-checkpoint.ipynb 5 | 6 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Lists-checkpoint.ipynb 7 | 8 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Numbers-checkpoint.ipynb 9 | 10 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Print Formatting-checkpoint.ipynb 11 | 12 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Sets and Booleans-checkpoint.ipynb 13 | 14 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Strings-checkpoint.ipynb 15 | 16 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Objects and Data Structures Assessment Test-checkpoint.ipynb 17 | 18 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Objects and Data Structures Assessment Test-Solution-checkpoint.ipynb 19 | 20 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Tuples-checkpoint.ipynb 21 | 22 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Variable Assignment-checkpoint.ipynb 23 | 24 | Partie2_Python_Déclarations/.ipynb_checkpoints/Chained Comparison Operators-checkpoint.ipynb 25 | 26 | Partie2_Python_Déclarations/.ipynb_checkpoints/Comparison Operators-checkpoint.ipynb 27 | 28 | Partie2_Python_Déclarations/.ipynb_checkpoints/For Loops-checkpoint.ipynb 29 | 30 | Partie2_Python_Déclarations/.ipynb_checkpoints/Introduction to Python Statements-checkpoint.ipynb 31 | 32 | Partie2_Python_Déclarations/.ipynb_checkpoints/List Comprehensions-checkpoint.ipynb 33 | 34 | Partie2_Python_Déclarations/.ipynb_checkpoints/Range()-checkpoint.ipynb 35 | 36 | Partie2_Python_Déclarations/.ipynb_checkpoints/Statements Assessment Test - Solutions-checkpoint.ipynb 37 | 38 | Partie2_Python_Déclarations/.ipynb_checkpoints/Statements Assessment Test-checkpoint.ipynb 39 | 40 | Partie2_Python_Déclarations/.ipynb_checkpoints/While loops-checkpoint.ipynb 41 | 42 | Partie2_Python_Déclarations/.ipynb_checkpoints/If, elif, and else Statements-checkpoint.ipynb 43 | 44 | Partie3_Méthodes_et_Fonctions/.ipynb_checkpoints/Functions-checkpoint.ipynb 45 | 46 | Partie3_Méthodes_et_Fonctions/.ipynb_checkpoints/Lambda expressions-checkpoint.ipynb 47 | 48 | Partie3_Méthodes_et_Fonctions/.ipynb_checkpoints/Methods-checkpoint.ipynb 49 | 50 | Partie3_Méthodes_et_Fonctions/.ipynb_checkpoints/Nested Statements and Scope-checkpoint.ipynb 51 | 52 | Partie3_Méthodes_et_Fonctions/.ipynb_checkpoints/Functions and Methods Homework-checkpoint.ipynb 53 | 54 | Partie3_Méthodes_et_Fonctions/.ipynb_checkpoints/Functions and Methods Homework - Solutions-checkpoint.ipynb 55 | 56 | Partie4_Premier_Projet/.ipynb_checkpoints/Milestone Project 1 - Advanced Solution-checkpoint.ipynb 57 | 58 | Partie4_Premier_Projet/.ipynb_checkpoints/Milestone Project 1- Assignment-checkpoint.ipynb 59 | 60 | Partie4_Premier_Projet/.ipynb_checkpoints/Milestone Project 1- Walkthrough Steps Workbook-checkpoint.ipynb 61 | 62 | Partie4_Premier_Projet/.ipynb_checkpoints/Milestone Project 1- Complete Walkthrough Solution-checkpoint.ipynb 63 | 64 | Partie5_Programmation_Orientée_Objet/.ipynb_checkpoints/Object Oriented Programming Homework -Assignment-checkpoint.ipynb 65 | 66 | Partie5_Programmation_Orientée_Objet/.ipynb_checkpoints/Object Oriented Programming Homework -Solution-checkpoint.ipynb 67 | 68 | Partie5_Programmation_Orientée_Objet/.ipynb_checkpoints/Object Oriented Programming-checkpoint.ipynb 69 | 70 | Partie6_Erreurs_et_Exceptions/.ipynb_checkpoints/Errors and Exceptions Homework - Solution-checkpoint.ipynb 71 | 72 | Partie6_Erreurs_et_Exceptions/.ipynb_checkpoints/Errors and Exceptions Homework-checkpoint.ipynb 73 | 74 | Partie6_Erreurs_et_Exceptions/.ipynb_checkpoints/Errors and Exceptions Handling-checkpoint.ipynb 75 | 76 | Partie7_Deuxième_Projet/.ipynb_checkpoints/Milestone Project 2 - Assignment-checkpoint.ipynb 77 | 78 | Partie7_Deuxième_Projet/.ipynb_checkpoints/Milestone Project 2 Solution-checkpoint.ipynb 79 | 80 | Partie8_Modules_et_Paquets/.ipynb_checkpoints/Modules and Packages-checkpoint.ipynb 81 | 82 | Partie9_Fonctions_Intégrées/.ipynb_checkpoints/All() and any()-checkpoint.ipynb 83 | 84 | Partie9_Fonctions_Intégrées/.ipynb_checkpoints/Complex-checkpoint.ipynb 85 | 86 | Partie9_Fonctions_Intégrées/.ipynb_checkpoints/Enumerate-checkpoint.ipynb 87 | 88 | Partie9_Fonctions_Intégrées/.ipynb_checkpoints/Filter-checkpoint.ipynb 89 | 90 | Partie9_Fonctions_Intégrées/.ipynb_checkpoints/Map-checkpoint.ipynb 91 | 92 | Partie9_Fonctions_Intégrées/.ipynb_checkpoints/Reduce-checkpoint.ipynb 93 | 94 | Partie9_Fonctions_Intégrées/.ipynb_checkpoints/Zip-checkpoint.ipynb 95 | 96 | Partie10_Décorateurs/.ipynb_checkpoints/Decorators Homework-checkpoint.ipynb 97 | 98 | Partie10_Décorateurs/.ipynb_checkpoints/Decorators-checkpoint.ipynb 99 | 100 | Partie11_Générateurs/.ipynb_checkpoints/Iterators and Generators Homework - Solution-checkpoint.ipynb 101 | 102 | Partie11_Générateurs/.ipynb_checkpoints/Iterators and Generators Homework-checkpoint.ipynb 103 | 104 | Partie11_Générateurs/.ipynb_checkpoints/Iterators and Generators-checkpoint.ipynb 105 | 106 | Partie12_Projet_Final/.ipynb_checkpoints/Final Capstone Project-checkpoint.ipynb 107 | 108 | Partie13_Modules_Avancés/.ipynb_checkpoints/Datetime-checkpoint.ipynb 109 | 110 | Final Capstone Projects/.ipynb_checkpoints/Final Capstone Project Ideas-checkpoint.ipynb 111 | 112 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Les dictionnaires-checkpoint.ipynb 113 | 114 | Final Capstone Projects/.ipynb_checkpoints/Final Capstone Project Ideas-checkpoint.ipynb 115 | 116 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Les fichiers-checkpoint.ipynb 117 | 118 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Solutions du controle de connaissances sur les objets et les structures de données-checkpoint.ipynb 119 | 120 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Les nombres-checkpoint.ipynb 121 | 122 | Partie1_Python_Notions_de_Base/.ipynb_checkpoints/Controle de connaissances sur les objets et les structures de données-checkpoint.ipynb 123 | 124 | Partie5_Programmation_Orientée_Objet/.ipynb_checkpoints/Programmation Orientée Objet-checkpoint.ipynb 125 | 126 | Partie5_Programmation_Orientée_Objet/.ipynb_checkpoints/Programmation Orientée Objet - Contrôle de connaissances - Solution-checkpoint.ipynb 127 | 128 | Partie4_Premier_Projet/.ipynb_checkpoints/2 - Premier Projet d'étape - Feuille de route détaillée-checkpoint.ipynb 129 | 130 | Partie4_Premier_Projet/.ipynb_checkpoints/3 - Solution de la feuille de route du jeu de Morpion-checkpoint.ipynb 131 | 132 | Partie4_Premier_Projet/.ipynb_checkpoints/1 - Présentation du premier project-checkpoint.ipynb 133 | 134 | Final Capstone Projects/.ipynb_checkpoints/Final Capstone Project Ideas-checkpoint.ipynb 135 | 136 | Final Capstone Projects/.ipynb_checkpoints/Final Capstone Project Ideas-checkpoint.ipynb 137 | 138 | Partie14_Objets_Avancés/Advanced Sets.ipynb 139 | 140 | .ipynb_checkpoints/Advanced Dictionaries-checkpoint.ipynb 141 | -------------------------------------------------------------------------------- /FAQ.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Foire aux questions" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "1. Où puis-je trouver les blocs-notes Jupyter du cours?\n", 15 | "\n", 16 | "Vous pouvez les trouver ici." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "2. Comment puis-je télécharger les blocs-notes?\n", 24 | "\n", 25 | "Cliquez sur le bouton de téléchargement en haut à droite de la page nbviewer. Sinon, pour télécharger tout à la fois, vous pouvez accéder à la page GitHub ici, puis cliquer sur le bouton de téléchargement pour télécharger tous les fichiers du portable (.ipynb) sur votre ordinateur (comprimé sous forme de fichier zip, vous devez le décompresser)." 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": { 31 | "collapsed": true 32 | }, 33 | "source": [ 34 | "3. Comment puis-je savoir où sont enregistrés mes blocs-notes ?\n", 35 | "\n", 36 | "Pour connaitre le dossier dans lequel un bloc-note est enregistré, il suffit de taper la commande : pwd dans une cellule. Cela va afficher votre répertoire de travail." 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "4. Comment puis-je modifier l'emplacement où les blocs-notes sont enregistrés?\n", 44 | "\n", 45 | "Vous devez pour cela changer le répertoire dans lequel vous démarrez Jupyter. Utilisez cd dans le terminal ou à l'invite de commandes pour passer au répertoire souhaité." 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "5. Comment puis-je ouvrir des fichiers .ipynb? Quel programme dois-je choisir?\n", 53 | "\n", 54 | "Les fichiers avec pour extension .jpynb sont des fichiers de bloc-notes Jupyter, pour pouvoir les ouvrir vous devez avoir installé Python et le système Jupyter. \n", 55 | "Consultez la leçon sur la préparation de votre environnement de travail pour plus de détails sur l'installation de Python et du système Jupyter. Une fois que vous avez Python et le système Jupyter installé vous êtes prêt à ouvrir les blocs-notes en procédant comme ci dessous :\n", 56 | "\n", 57 | " 1. Ouvrez d'abord votre Invite de commande (cmd sur une machine Windows, le terminal sur Mac ou Linux).\n", 58 | " 2. Ensuite dans votre terminal / invite de commande tapez pwd et appuyez sur Entrée (cela va afficher votre répertoire de travail)\n", 59 | " 3. Prenez note de ce répertoire, c'est à cet endroit que vous devez enregistrer vos fichiers .ipynb (ou le dossier contenant vos fichiers .ipynb)\n", 60 | " 4. Une fois que vos fichiers ipynb ou le dossier contenant ces fichiers est dans l'emplacement affiché à partir de l'étape pwd, retournez à votre terminal et tapez Jupyter notebook et appuyez sur Entrée.\n", 61 | " 5. Après l'étape 4, vous devriez avoir un onglet de votre navigateur ouvert avec la racine des fichiers du système Jupyter présenté à l'intérieur de celui-ci.\n", 62 | " 6. Cliquez sur votre bloc-notes (ou allez dans votre dossier de blocs-notes) affiché dans l’onglet du navigateur et celui-ci s'ouvrira dans un nouvel onglet avec ce bloc-notes que vous avez sélectionné.\n", 63 | " 7. Vous devriez maintenant pouvoir ouvrir les fichiers blocs-notes sans difficulté.\n" 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": {}, 69 | "source": [ 70 | "6. Comment afficher les conseils? Comment afficher les « DocStrings » pour les fonctions? etc...\n", 71 | "\n", 72 | "Vous pouvez utiliser Shift + Tab quand vous positionnez le curseur après un objet ou une fonction pour que iPython révèle la chaîne de caractères ou plus d'informations." 73 | ] 74 | }, 75 | { 76 | "cell_type": "markdown", 77 | "metadata": {}, 78 | "source": [ 79 | "7. Comment utiliser l’auto-complétion ?\n", 80 | "\n", 81 | "Vous pouvez utiliser la touche de tabulation pour taper automatiquement le nom des méthodes, des objets ou des fonctions. Si plusieurs options sont disponibles, elles s’affichent et vous pourrez choisir celle que vous retenez." 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": null, 87 | "metadata": { 88 | "collapsed": true 89 | }, 90 | "outputs": [], 91 | "source": [] 92 | } 93 | ], 94 | "metadata": { 95 | "anaconda-cloud": {}, 96 | "kernelspec": { 97 | "display_name": "Python [default]", 98 | "language": "python", 99 | "name": "python3" 100 | }, 101 | "language_info": { 102 | "codemirror_mode": { 103 | "name": "ipython", 104 | "version": 3 105 | }, 106 | "file_extension": ".py", 107 | "mimetype": "text/x-python", 108 | "name": "python", 109 | "nbconvert_exporter": "python", 110 | "pygments_lexer": "ipython3", 111 | "version": "3.5.2" 112 | } 113 | }, 114 | "nbformat": 4, 115 | "nbformat_minor": 0 116 | } 117 | -------------------------------------------------------------------------------- /Jupyter (iPython) Notebooks Guide.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Guide to Using Jupyter Notebooks\n", 8 | "In this lecture we will be going over the basics of the Jupyter (previously called iPython Notebooks).\n", 9 | "\n", 10 | "For a complete User Manual check out the [Bryn Mawr College Computer Science Guide](http://jupyter.cs.brynmawr.edu/hub/dblank/public/Jupyter%20Notebook%20Users%20Manual.ipynb).\n", 11 | "\n", 12 | "Most of the breakdown will actually occur in the presentation corresponding to this Notebook. So please refer to either the presentation or the full User Manual linked above." 13 | ] 14 | } 15 | ], 16 | "metadata": { 17 | "kernelspec": { 18 | "display_name": "Python 2", 19 | "language": "python", 20 | "name": "python2" 21 | }, 22 | "language_info": { 23 | "codemirror_mode": { 24 | "name": "ipython", 25 | "version": 2 26 | }, 27 | "file_extension": ".py", 28 | "mimetype": "text/x-python", 29 | "name": "python", 30 | "nbconvert_exporter": "python", 31 | "pygments_lexer": "ipython2", 32 | "version": "2.7.11" 33 | } 34 | }, 35 | "nbformat": 4, 36 | "nbformat_minor": 0 37 | } 38 | -------------------------------------------------------------------------------- /Mon bloc note.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Mon premier bloc note\n", 8 | "voici du texte" 9 | ] 10 | }, 11 | { 12 | "cell_type": "code", 13 | "execution_count": 1, 14 | "metadata": { 15 | "collapsed": false 16 | }, 17 | "outputs": [ 18 | { 19 | "data": { 20 | "text/plain": [ 21 | "4" 22 | ] 23 | }, 24 | "execution_count": 1, 25 | "metadata": {}, 26 | "output_type": "execute_result" 27 | } 28 | ], 29 | "source": [ 30 | "2+2" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 2, 36 | "metadata": { 37 | "collapsed": false 38 | }, 39 | "outputs": [ 40 | { 41 | "name": "stdout", 42 | "output_type": "stream", 43 | "text": [ 44 | "Bonjour tout le monde !\n" 45 | ] 46 | } 47 | ], 48 | "source": [ 49 | "print(\"Bonjour tout le monde !\")" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": { 56 | "collapsed": true 57 | }, 58 | "outputs": [], 59 | "source": [] 60 | } 61 | ], 62 | "metadata": { 63 | "anaconda-cloud": {}, 64 | "kernelspec": { 65 | "display_name": "Python [default]", 66 | "language": "python", 67 | "name": "python3" 68 | }, 69 | "language_info": { 70 | "codemirror_mode": { 71 | "name": "ipython", 72 | "version": 3 73 | }, 74 | "file_extension": ".py", 75 | "mimetype": "text/x-python", 76 | "name": "python", 77 | "nbconvert_exporter": "python", 78 | "pygments_lexer": "ipython3", 79 | "version": "3.5.2" 80 | } 81 | }, 82 | "nbformat": 4, 83 | "nbformat_minor": 1 84 | } 85 | -------------------------------------------------------------------------------- /Mon premier bloc note.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Le titre\n", 8 | "le détail" 9 | ] 10 | }, 11 | { 12 | "cell_type": "code", 13 | "execution_count": 3, 14 | "metadata": { 15 | "collapsed": false 16 | }, 17 | "outputs": [ 18 | { 19 | "name": "stdout", 20 | "output_type": "stream", 21 | "text": [ 22 | "Bonjour tout le monde !\n" 23 | ] 24 | } 25 | ], 26 | "source": [ 27 | "print(\"Bonjour tout le monde !\")" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": null, 33 | "metadata": { 34 | "collapsed": true 35 | }, 36 | "outputs": [], 37 | "source": [] 38 | } 39 | ], 40 | "metadata": { 41 | "anaconda-cloud": {}, 42 | "kernelspec": { 43 | "display_name": "Python [default]", 44 | "language": "python", 45 | "name": "python3" 46 | }, 47 | "language_info": { 48 | "codemirror_mode": { 49 | "name": "ipython", 50 | "version": 3 51 | }, 52 | "file_extension": ".py", 53 | "mimetype": "text/x-python", 54 | "name": "python", 55 | "nbconvert_exporter": "python", 56 | "pygments_lexer": "ipython3", 57 | "version": "3.5.2" 58 | } 59 | }, 60 | "nbformat": 4, 61 | "nbformat_minor": 1 62 | } 63 | -------------------------------------------------------------------------------- /Partie10_Décorateurs/Approfondissements sur les décorateurs .ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Approfondissements sur les décorateurs \n", 8 | "\n", 9 | "## Projet personnel sur les décorateurs (optionnel)\n", 10 | "\n", 11 | "Ce projet est facultatif, vous ne rencontrerez sans doute pas de décorateurs avant longtemps dans votre carrière de codeur. \n", 12 | "\n", 13 | "Consultez d'abord le Framework Web [Flask](http://flask.pocoo.org/). Vous pouvez utiliser Flask pour créer des pages Web avec Python (il suffit pour cela de connaitre un petit peu HTML et CSS) et il utilise beaucoup de décorateurs dans son propre code ! Vous pouvez en apprendre plus sur comment ils utilisent les [décorateurs](http://flask.pocoo.org/docs/0.10/patterns/viewdecorators/). Ne vous inquiétez pas si vous ne comprenez pas tout sur Flask, le point principal de ce travail facultatif est que vous compreniez comment les décorateurs sont employés dans le cadre Web. De cette façon, si vous décidez de devenir un Dévelopeur Python «Full-Stack» pour le Web, vous ne resterez pas longtemps perplexe devant les décorateurs. \n", 14 | "\n", 15 | "Vous pouvez également consulter [Django](https://www.djangoproject.com/) un autre (et plus populaire) framework web pour Python qui est un peu plus complexe.\n", 16 | "\n", 17 | "## Quelques informations supplémentaires:\n", 18 | "### framework\n", 19 | "\n", 20 | "Un **framework** est un type de bibliothèque logicielle qui fournit des fonctionnalités génériques qui peuvent être utilisées par le programmeur pour créer des applications plus efficacement. Flask et Django sont de bons exemples de frameworks destinés au développement web.\n", 21 | "\n", 22 | "### API\n", 23 | "Un framework est plus qu'une simple bibliothèque ou Interface Applicative de Programme (*Application Program Interface ou API*). Une API est un logiciel que le développeur peut utiliser dans son application. Un framework est plus large : votre application entière est structurée autour du framework (c'est-à-dire qu'elle fournit le cadre autour duquel vous construisez votre logiciel).\n", 24 | "\n", 25 | "## Bravo !" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": { 32 | "collapsed": true 33 | }, 34 | "outputs": [], 35 | "source": [] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": null, 40 | "metadata": { 41 | "collapsed": true 42 | }, 43 | "outputs": [], 44 | "source": [] 45 | } 46 | ], 47 | "metadata": { 48 | "anaconda-cloud": {}, 49 | "kernelspec": { 50 | "display_name": "Python [default]", 51 | "language": "python", 52 | "name": "python3" 53 | }, 54 | "language_info": { 55 | "codemirror_mode": { 56 | "name": "ipython", 57 | "version": 3 58 | }, 59 | "file_extension": ".py", 60 | "mimetype": "text/x-python", 61 | "name": "python", 62 | "nbconvert_exporter": "python", 63 | "pygments_lexer": "ipython3", 64 | "version": "3.5.2" 65 | } 66 | }, 67 | "nbformat": 4, 68 | "nbformat_minor": 0 69 | } 70 | -------------------------------------------------------------------------------- /Partie11_Générateurs/Iterators and Generators Homework - Solution.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Devoir sur les iterateurs et les générateurs \n", 8 | "## Solutions\n", 9 | "\n", 10 | "### 1er problème\n", 11 | "\n", 12 | "Créer un générateur qui génère les carrés de nombres jusqu'à un certain nombre N." 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 1, 18 | "metadata": { 19 | "collapsed": true 20 | }, 21 | "outputs": [], 22 | "source": [ 23 | "def gensquares(N):\n", 24 | " for i in range(N):\n", 25 | " yield i ** 2" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "metadata": { 32 | "collapsed": false 33 | }, 34 | "outputs": [ 35 | { 36 | "name": "stdout", 37 | "output_type": "stream", 38 | "text": [ 39 | "0\n", 40 | "1\n", 41 | "4\n", 42 | "9\n", 43 | "16\n", 44 | "25\n", 45 | "36\n", 46 | "49\n", 47 | "64\n", 48 | "81\n" 49 | ] 50 | } 51 | ], 52 | "source": [ 53 | "for x in gensquares(10):\n", 54 | " print (x)" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "### 2ième problème\n", 62 | "\n", 63 | "Créez un générateur qui donne «n» nombres aléatoires entre un nombre de départ et un nombre d'arrivée (qui sont les pramètres d'entrée).\n", 64 | "Remarque: utilisez la bibliothèque random.\n", 65 | "\n", 66 | "Par exemple:" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 3, 72 | "metadata": { 73 | "collapsed": false 74 | }, 75 | "outputs": [ 76 | { 77 | "data": { 78 | "text/plain": [ 79 | "6" 80 | ] 81 | }, 82 | "execution_count": 3, 83 | "metadata": {}, 84 | "output_type": "execute_result" 85 | } 86 | ], 87 | "source": [ 88 | "import random\n", 89 | "\n", 90 | "random.randint(1,10)" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": 4, 96 | "metadata": { 97 | "collapsed": true 98 | }, 99 | "outputs": [], 100 | "source": [ 101 | "def rand_num(départ,arrivée,n):\n", 102 | " \n", 103 | " for i in range(n):\n", 104 | " yield random.randint(départ, arrivée)" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 6, 110 | "metadata": { 111 | "collapsed": false 112 | }, 113 | "outputs": [ 114 | { 115 | "name": "stdout", 116 | "output_type": "stream", 117 | "text": [ 118 | "8\n", 119 | "5\n", 120 | "1\n", 121 | "3\n", 122 | "7\n", 123 | "1\n", 124 | "3\n", 125 | "9\n", 126 | "2\n", 127 | "9\n", 128 | "3\n", 129 | "1\n" 130 | ] 131 | } 132 | ], 133 | "source": [ 134 | "for num in rand_num(1,10,12):\n", 135 | " print (num)" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": {}, 141 | "source": [ 142 | "### 3ième problème\n", 143 | "\n", 144 | "Utilisez la fonction iter () pour convertir la chaîne ci-dessous" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": 7, 150 | "metadata": { 151 | "collapsed": false 152 | }, 153 | "outputs": [ 154 | { 155 | "name": "stdout", 156 | "output_type": "stream", 157 | "text": [ 158 | "b\n" 159 | ] 160 | } 161 | ], 162 | "source": [ 163 | "s = 'bonjour'\n", 164 | "\n", 165 | "s = iter(s)\n", 166 | "\n", 167 | "print (next(s))" 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "### 4ième problème\n", 175 | "\n", 176 | "Expliquez un cas d'utilisation pour un générateur en utilisant une déclaration yield plutôt que d'utiliser une fonction normale avec une instruction de retour.\n", 177 | "\n", 178 | "**If the output has the potential of taking up a large amount of memory and you only intend to iterate through it, you would want to use a generator. (Multiple answers are acceptable here!)**" 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "### Crédits supplémentaires !\n", 186 | "Pouvez-vous expliquer ce que *gencomp* est dans le code ci-dessous?\n", 187 | "(Note: Nous n'avons jamais couvert cela en cours ! Vous devrez faire quelques appels à Google et Stack Overflow !)" 188 | ] 189 | }, 190 | { 191 | "cell_type": "code", 192 | "execution_count": 18, 193 | "metadata": { 194 | "collapsed": false 195 | }, 196 | "outputs": [ 197 | { 198 | "name": "stdout", 199 | "output_type": "stream", 200 | "text": [ 201 | "4\n", 202 | "5\n" 203 | ] 204 | } 205 | ], 206 | "source": [ 207 | "ma_liste = [1,2,3,4,5]\n", 208 | "\n", 209 | "gencomp = (item for item in ma_liste if item > 3)\n", 210 | "\n", 211 | "for item in gencomp:\n", 212 | " print (item)" 213 | ] 214 | }, 215 | { 216 | "cell_type": "markdown", 217 | "metadata": {}, 218 | "source": [ 219 | "Conseil google: generator comprehension !\n", 220 | "\n", 221 | "# Beau boulot !" 222 | ] 223 | } 224 | ], 225 | "metadata": { 226 | "anaconda-cloud": {}, 227 | "kernelspec": { 228 | "display_name": "Python [default]", 229 | "language": "python", 230 | "name": "python3" 231 | }, 232 | "language_info": { 233 | "codemirror_mode": { 234 | "name": "ipython", 235 | "version": 3 236 | }, 237 | "file_extension": ".py", 238 | "mimetype": "text/x-python", 239 | "name": "python", 240 | "nbconvert_exporter": "python", 241 | "pygments_lexer": "ipython3", 242 | "version": "3.5.2" 243 | } 244 | }, 245 | "nbformat": 4, 246 | "nbformat_minor": 0 247 | } 248 | -------------------------------------------------------------------------------- /Partie11_Générateurs/Iterators and Generators Homework.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Devoir sur les iterateurs et les générateurs \n", 8 | "\n", 9 | "### 1er problème\n", 10 | "\n", 11 | "Créer un générateur qui génère les carrés de nombres jusqu'à un certain nombre N." 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 2, 17 | "metadata": { 18 | "collapsed": true 19 | }, 20 | "outputs": [], 21 | "source": [ 22 | "def gencarres(N):\n", 23 | " pass" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 3, 29 | "metadata": { 30 | "collapsed": false 31 | }, 32 | "outputs": [ 33 | { 34 | "ename": "TypeError", 35 | "evalue": "'NoneType' object is not iterable", 36 | "output_type": "error", 37 | "traceback": [ 38 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 39 | "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", 40 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mgencarres\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 41 | "\u001b[0;31mTypeError\u001b[0m: 'NoneType' object is not iterable" 42 | ] 43 | } 44 | ], 45 | "source": [ 46 | "for x in gencarres(10):\n", 47 | " print (x)" 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": {}, 53 | "source": [ 54 | "### 2ième problème\n", 55 | "\n", 56 | "Créez un générateur qui donne «n» nombres aléatoires entre un nombre de départ et un nombre d'arrivée (qui sont les pramètres d'entrée).\n", 57 | "Remarque: utilisez la bibliothèque random.\n", 58 | "\n", 59 | "Par exemple:" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": 6, 65 | "metadata": { 66 | "collapsed": false 67 | }, 68 | "outputs": [ 69 | { 70 | "data": { 71 | "text/plain": [ 72 | "6" 73 | ] 74 | }, 75 | "execution_count": 6, 76 | "metadata": {}, 77 | "output_type": "execute_result" 78 | } 79 | ], 80 | "source": [ 81 | "import random\n", 82 | "\n", 83 | "random.randint(1,10)" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 7, 89 | "metadata": { 90 | "collapsed": true 91 | }, 92 | "outputs": [], 93 | "source": [ 94 | "def rand_num(départ,arrivée,n):\n", 95 | " pass" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 9, 101 | "metadata": { 102 | "collapsed": false 103 | }, 104 | "outputs": [ 105 | { 106 | "name": "stdout", 107 | "output_type": "stream", 108 | "text": [ 109 | "6\n", 110 | "7\n", 111 | "6\n", 112 | "9\n", 113 | "9\n", 114 | "4\n", 115 | "3\n", 116 | "7\n", 117 | "8\n", 118 | "1\n", 119 | "6\n", 120 | "1\n" 121 | ] 122 | } 123 | ], 124 | "source": [ 125 | "for num in numéro_aléatoire(1,10,12):\n", 126 | " print (num)" 127 | ] 128 | }, 129 | { 130 | "cell_type": "markdown", 131 | "metadata": {}, 132 | "source": [ 133 | "### 3ième problème\n", 134 | "\n", 135 | "Utilisez la fonction iter () pour convertir la chaîne ci-dessous" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": 1, 141 | "metadata": { 142 | "collapsed": false 143 | }, 144 | "outputs": [], 145 | "source": [ 146 | "s = 'bonjour'\n", 147 | "\n", 148 | "# le code ici" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "### 4ième problème\n", 156 | "\n", 157 | "Expliquez un cas d'utilisation pour un générateur en utilisant une déclaration yield plutôt que d'utiliser une fonction normale avec une instruction de retour." 158 | ] 159 | }, 160 | { 161 | "cell_type": "markdown", 162 | "metadata": {}, 163 | "source": [] 164 | }, 165 | { 166 | "cell_type": "markdown", 167 | "metadata": {}, 168 | "source": [ 169 | "### Crédits supplémentaires !\n", 170 | "Pouvez-vous expliquer ce que *gencomp* est dans le code ci-dessous?\n", 171 | "(Note: Nous n'avons jamais couvert cela en cours ! Vous devrez faire quelques appels à Google et Stack Overflow !)" 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": 4, 177 | "metadata": { 178 | "collapsed": false 179 | }, 180 | "outputs": [ 181 | { 182 | "name": "stdout", 183 | "output_type": "stream", 184 | "text": [ 185 | "4\n", 186 | "5\n" 187 | ] 188 | } 189 | ], 190 | "source": [ 191 | "ma_liste = [1,2,3,4,5]\n", 192 | "\n", 193 | "gencomp = (item for item in ma_liste if item > 3)\n", 194 | "\n", 195 | "for item in gencomp:\n", 196 | " print (item)" 197 | ] 198 | }, 199 | { 200 | "cell_type": "markdown", 201 | "metadata": {}, 202 | "source": [ 203 | "Conseil google: generator comprehension !\n", 204 | "\n", 205 | "# Beau boulot !" 206 | ] 207 | } 208 | ], 209 | "metadata": { 210 | "anaconda-cloud": {}, 211 | "kernelspec": { 212 | "display_name": "Python [default]", 213 | "language": "python", 214 | "name": "python3" 215 | }, 216 | "language_info": { 217 | "codemirror_mode": { 218 | "name": "ipython", 219 | "version": 3 220 | }, 221 | "file_extension": ".py", 222 | "mimetype": "text/x-python", 223 | "name": "python", 224 | "nbconvert_exporter": "python", 225 | "pygments_lexer": "ipython3", 226 | "version": "3.5.2" 227 | } 228 | }, 229 | "nbformat": 4, 230 | "nbformat_minor": 0 231 | } 232 | -------------------------------------------------------------------------------- /Partie1_Python_Notions_de_Base/Les Sets et les Booléens.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Les Sets et les Booléens\n", 8 | "\n", 9 | "Il reste deux autres types d'objets Python que nous devons rapidement voir. Les Sets et les Booléens.\n", 10 | "\n", 11 | "## Sets\n", 12 | "\n", 13 | "Les Sets sont des collections non triées d'éléments *unique*. Nous pouvons les créer avec la fonction set().\n", 14 | "Voyons comment les utiliser." 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 1, 20 | "metadata": { 21 | "collapsed": true 22 | }, 23 | "outputs": [], 24 | "source": [ 25 | "x = set()" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 3, 31 | "metadata": { 32 | "collapsed": true 33 | }, 34 | "outputs": [], 35 | "source": [ 36 | "# Nous pouvons ajouter des éléments avec la méthode add\n", 37 | "x.add(1)" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 4, 43 | "metadata": { 44 | "collapsed": false 45 | }, 46 | "outputs": [ 47 | { 48 | "data": { 49 | "text/plain": [ 50 | "{1}" 51 | ] 52 | }, 53 | "execution_count": 4, 54 | "metadata": {}, 55 | "output_type": "execute_result" 56 | } 57 | ], 58 | "source": [ 59 | "# Visualiser le contenu\n", 60 | "x" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "Remarquez les accolades. Il ne faut pourtant pas confondre avec un dictionnaire ! Vous pouvez au mieux trouver une analogie avec un dictionnaire qui ne contiendrait que des clefs.\n", 68 | "\n", 69 | "Nous avons dit que les éléments d'un set sont uniques. Que se passe-t-il quand on essaie d'ajouter quelque chose qui existe déjà dans le set ?\n" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": 5, 75 | "metadata": { 76 | "collapsed": true 77 | }, 78 | "outputs": [], 79 | "source": [ 80 | "# Ajouter un élement différent\n", 81 | "x.add(2)" 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": 6, 87 | "metadata": { 88 | "collapsed": false 89 | }, 90 | "outputs": [ 91 | { 92 | "data": { 93 | "text/plain": [ 94 | "{1, 2}" 95 | ] 96 | }, 97 | "execution_count": 6, 98 | "metadata": {}, 99 | "output_type": "execute_result" 100 | } 101 | ], 102 | "source": [ 103 | "# Visualiser le contenu\n", 104 | "x" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 7, 110 | "metadata": { 111 | "collapsed": true 112 | }, 113 | "outputs": [], 114 | "source": [ 115 | "# Essaye d'ajouter un élément déjà présent\n", 116 | "x.add(1)" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 9, 122 | "metadata": { 123 | "collapsed": false 124 | }, 125 | "outputs": [ 126 | { 127 | "data": { 128 | "text/plain": [ 129 | "{1, 2}" 130 | ] 131 | }, 132 | "execution_count": 9, 133 | "metadata": {}, 134 | "output_type": "execute_result" 135 | } 136 | ], 137 | "source": [ 138 | "# Visualiser le contenu\n", 139 | "x" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "Remarquez qu'il n'y a pas eu l'ajout d'un autre élément 1 ici. C'est parce que le set ne contient que des éléments uniques ! Il est possible d'intégrer une liste avec des éléments dupliqués dans un set pour isoler les éléments distincts.\n", 147 | "Par exemple : " 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": 10, 153 | "metadata": { 154 | "collapsed": true 155 | }, 156 | "outputs": [], 157 | "source": [ 158 | "# Crée une liste avec des éléments dupliqués\n", 159 | "l = [1,1,2,2,3,4,5,6,1,1]" 160 | ] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "execution_count": 12, 165 | "metadata": { 166 | "collapsed": false 167 | }, 168 | "outputs": [ 169 | { 170 | "data": { 171 | "text/plain": [ 172 | "{1, 2, 3, 4, 5, 6}" 173 | ] 174 | }, 175 | "execution_count": 12, 176 | "metadata": {}, 177 | "output_type": "execute_result" 178 | } 179 | ], 180 | "source": [ 181 | "# Redéfinie en set pour isoler les éléments uniques\n", 182 | "set(l)" 183 | ] 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "metadata": {}, 188 | "source": [ 189 | "## Booléens\n", 190 | "\n", 191 | "Python intègre des variables logiques ou Booléens (avec des noms True et False prédéfinis qui ne sont en fait qu'une représentation des entiers 1 et 0). Il existe aussi un objet indéfini appelé None.\n", 192 | "\n", 193 | "Voyons quelques petits exemples rapides de Booléens (nous irons plus en détails un peu plus tard dans le cours)." 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": 13, 199 | "metadata": { 200 | "collapsed": true 201 | }, 202 | "outputs": [], 203 | "source": [ 204 | "# Définir un objet avec le type Booléen\n", 205 | "a = True" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": 16, 211 | "metadata": { 212 | "collapsed": false 213 | }, 214 | "outputs": [ 215 | { 216 | "data": { 217 | "text/plain": [ 218 | "True" 219 | ] 220 | }, 221 | "execution_count": 16, 222 | "metadata": {}, 223 | "output_type": "execute_result" 224 | } 225 | ], 226 | "source": [ 227 | "# Visualiser\n", 228 | "a" 229 | ] 230 | }, 231 | { 232 | "cell_type": "markdown", 233 | "metadata": {}, 234 | "source": [ 235 | "Nous pouvons aussi utiliser les opérateurs de comparaison pour créer un booléen. Nous verrons ces opérateurs en détail plus tard dans le cours." 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": 17, 241 | "metadata": { 242 | "collapsed": false 243 | }, 244 | "outputs": [ 245 | { 246 | "data": { 247 | "text/plain": [ 248 | "False" 249 | ] 250 | }, 251 | "execution_count": 17, 252 | "metadata": {}, 253 | "output_type": "execute_result" 254 | } 255 | ], 256 | "source": [ 257 | "# La sortie produite est un booléen\n", 258 | "1 > 2" 259 | ] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": {}, 264 | "source": [ 265 | "Nous pouvons utiliser None pour réserver l'espace d'un objet booléen dont on ne connait pas encore la valeur" 266 | ] 267 | }, 268 | { 269 | "cell_type": "code", 270 | "execution_count": 18, 271 | "metadata": { 272 | "collapsed": true 273 | }, 274 | "outputs": [], 275 | "source": [ 276 | "# Réserver l'espace avec None\n", 277 | "b = None" 278 | ] 279 | }, 280 | { 281 | "cell_type": "markdown", 282 | "metadata": {}, 283 | "source": [ 284 | "C'est tout !\n", 285 | "Vous avez maintenant les connaissances de base concernant les différents types d'objets et de structures de données Python. Étape suivante, le test de connaissances pour valider cette partie !" 286 | ] 287 | } 288 | ], 289 | "metadata": { 290 | "anaconda-cloud": {}, 291 | "kernelspec": { 292 | "display_name": "Python [default]", 293 | "language": "python", 294 | "name": "python3" 295 | }, 296 | "language_info": { 297 | "codemirror_mode": { 298 | "name": "ipython", 299 | "version": 3 300 | }, 301 | "file_extension": ".py", 302 | "mimetype": "text/x-python", 303 | "name": "python", 304 | "nbconvert_exporter": "python", 305 | "pygments_lexer": "ipython3", 306 | "version": "3.5.2" 307 | } 308 | }, 309 | "nbformat": 4, 310 | "nbformat_minor": 0 311 | } 312 | -------------------------------------------------------------------------------- /Partie1_Python_Notions_de_Base/Tuples.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Les tuples\n", 8 | "\n", 9 | "Les tuples (que l'on peut trouver traduits en français par le terme n-uples) dans Python sont très similaires à des listes. Toutefois, contrairement aux listes ces objets sont *immuables* ce qui veut dire tout simplement qu'ils ne sont pas modifiables. Ils sont utilisés pour présenter des valeurs qui ne doivent pas évoluer, comme les jours de la semaine, des dates dans un calendrier.\n", 10 | "\n", 11 | "Dans cette section, vou aurez un aperçu rapide des points suivants :\n", 12 | "\n", 13 | " 1.) Créer un Tuple\n", 14 | " 2.) Les méthodes de base de manipulation des Tuples\n", 15 | " 3.) Immuabilité\n", 16 | " 4.) Quand utiliser des Tuples\n", 17 | " \n", 18 | "Vous pouvez déjà imaginer comment utiliser les Tuples en vous basant sur ce que vous avez appris à propos des listes. Vous pouvez les traiter de façon identique, avec la seule différence qui est de ne pas pouvoir les modifier. \n", 19 | "\n", 20 | "## Créer des Tuples\n", 21 | "\n", 22 | "Pour créer un Tuple il suffit d'utiliser des () en séparant les éléments par des virgules. Par exemple :" 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": 2, 28 | "metadata": { 29 | "collapsed": true 30 | }, 31 | "outputs": [], 32 | "source": [ 33 | "# Il est possible de créer un Tuple avec différents types\n", 34 | "t = (1,2,3)" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 3, 40 | "metadata": { 41 | "collapsed": false 42 | }, 43 | "outputs": [ 44 | { 45 | "data": { 46 | "text/plain": [ 47 | "3" 48 | ] 49 | }, 50 | "execution_count": 3, 51 | "metadata": {}, 52 | "output_type": "execute_result" 53 | } 54 | ], 55 | "source": [ 56 | "# On peut en obtenir la taille avec len comme pour les listes\n", 57 | "len(t)" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 7, 63 | "metadata": { 64 | "collapsed": false 65 | }, 66 | "outputs": [ 67 | { 68 | "data": { 69 | "text/plain": [ 70 | "('un', 2)" 71 | ] 72 | }, 73 | "execution_count": 7, 74 | "metadata": {}, 75 | "output_type": "execute_result" 76 | } 77 | ], 78 | "source": [ 79 | "# Il est possible d'avoir des éléments de type différents\n", 80 | "t = ('un',2)\n", 81 | "\n", 82 | "# Afficher\n", 83 | "t" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 8, 89 | "metadata": { 90 | "collapsed": false 91 | }, 92 | "outputs": [ 93 | { 94 | "data": { 95 | "text/plain": [ 96 | "'un'" 97 | ] 98 | }, 99 | "execution_count": 8, 100 | "metadata": {}, 101 | "output_type": "execute_result" 102 | } 103 | ], 104 | "source": [ 105 | "# On peut utiliser des index comme nous l'avons fait dans les listes\n", 106 | "t[0]" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 9, 112 | "metadata": { 113 | "collapsed": false 114 | }, 115 | "outputs": [ 116 | { 117 | "data": { 118 | "text/plain": [ 119 | "2" 120 | ] 121 | }, 122 | "execution_count": 9, 123 | "metadata": {}, 124 | "output_type": "execute_result" 125 | } 126 | ], 127 | "source": [ 128 | "# On peut aussi accéder à rebours comme avec les listes\n", 129 | "t[-1]" 130 | ] 131 | }, 132 | { 133 | "cell_type": "markdown", 134 | "metadata": {}, 135 | "source": [ 136 | "## Les Méthodes de base des Tuples\n", 137 | "\n", 138 | "Les Tuples ont eux aussi un certain nombre de méthodes par défaut, un peu moins nombreuses que pour les listes.\n", 139 | "Regardons de plus près deux d'entre elles :" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 11, 145 | "metadata": { 146 | "collapsed": false 147 | }, 148 | "outputs": [ 149 | { 150 | "data": { 151 | "text/plain": [ 152 | "0" 153 | ] 154 | }, 155 | "execution_count": 11, 156 | "metadata": {}, 157 | "output_type": "execute_result" 158 | } 159 | ], 160 | "source": [ 161 | "# La methode .index permet d'ajouter une valeur de retourner le numéro d'index\n", 162 | "t.index('un')" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 12, 168 | "metadata": { 169 | "collapsed": false 170 | }, 171 | "outputs": [ 172 | { 173 | "data": { 174 | "text/plain": [ 175 | "1" 176 | ] 177 | }, 178 | "execution_count": 12, 179 | "metadata": {}, 180 | "output_type": "execute_result" 181 | } 182 | ], 183 | "source": [ 184 | "# La méthode .count permet de compter le nombre de fois qu'une valeur est présente dans le Tuple\n", 185 | "t.count('un')" 186 | ] 187 | }, 188 | { 189 | "cell_type": "markdown", 190 | "metadata": {}, 191 | "source": [ 192 | "## Immuabilité\n", 193 | "\n", 194 | "On n'insistera jamais assez sur le fait que les Tuples sont immuables. \n", 195 | "Voici quelques exemple pratiques pour enfoncer le clou :" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 13, 201 | "metadata": { 202 | "collapsed": false 203 | }, 204 | "outputs": [ 205 | { 206 | "ename": "TypeError", 207 | "evalue": "'tuple' object does not support item assignment", 208 | "output_type": "error", 209 | "traceback": [ 210 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 211 | "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", 212 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0;34m'un autre'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 213 | "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" 214 | ] 215 | } 216 | ], 217 | "source": [ 218 | "t[0]= 'un autre'" 219 | ] 220 | }, 221 | { 222 | "cell_type": "markdown", 223 | "metadata": {}, 224 | "source": [ 225 | "À cause de l'immuabilité, un Tuple ne peu pas être étendu. Une fois qu'il a été créé on ne peut plus rien lui ajouter.\n" 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": 14, 231 | "metadata": { 232 | "collapsed": false 233 | }, 234 | "outputs": [ 235 | { 236 | "ename": "AttributeError", 237 | "evalue": "'tuple' object has no attribute 'append'", 238 | "output_type": "error", 239 | "traceback": [ 240 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 241 | "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", 242 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'non plus'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 243 | "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'" 244 | ] 245 | } 246 | ], 247 | "source": [ 248 | "t.append('non plus')" 249 | ] 250 | }, 251 | { 252 | "cell_type": "markdown", 253 | "metadata": {}, 254 | "source": [ 255 | "## Quand doit-on utiliser des Tuples\n", 256 | "\n", 257 | "Vous devez être en train de vous demander, \"pourquoi donc utiliser des Tuples qui ont moins bien équipées en méthodes à disposition ?\". Pour être tout à fait honnête, les Tuples ne sont pas autant utilisés que les listes en preogrammation, mais ils sont utiles quand on a besoin de cette qualité d'imuabilité. Si dans votre programme un objet qui est utilisé dans plusieurs parties et vous devez vous assurerqu'il n'est pas modifié, alors la solution est d'utiliser un Tuple. C'est une manière simple et efficace de s'assurer de l'intégrité des données.\n", 258 | "\n", 259 | "Vous êtes maintenant capables de créer et utiliser des Tuples dans vos programmes, ansi que de tirer parti du fait qu'ils sont non modifiables.\n", 260 | "\n", 261 | "La suite avec les fichiers !" 262 | ] 263 | } 264 | ], 265 | "metadata": { 266 | "anaconda-cloud": {}, 267 | "kernelspec": { 268 | "display_name": "Python [default]", 269 | "language": "python", 270 | "name": "python3" 271 | }, 272 | "language_info": { 273 | "codemirror_mode": { 274 | "name": "ipython", 275 | "version": 3 276 | }, 277 | "file_extension": ".py", 278 | "mimetype": "text/x-python", 279 | "name": "python", 280 | "nbconvert_exporter": "python", 281 | "pygments_lexer": "ipython3", 282 | "version": "3.5.2" 283 | } 284 | }, 285 | "nbformat": 4, 286 | "nbformat_minor": 0 287 | } 288 | -------------------------------------------------------------------------------- /Partie2_Python_Déclarations/Contrôle des connaissances.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Contrôle des connaissances\n", 10 | "\n", 11 | "Voyons un peu ce que vous avez appris !" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "_____\n", 19 | "**Utilisez les instructions for, split(), et if pour créer un code qui va n'afficher que les mots qui commencent par 'c' dans cette phrase :**" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 3, 25 | "metadata": { 26 | "collapsed": true 27 | }, 28 | "outputs": [], 29 | "source": [ 30 | "st = \"Cet exercice consiste à afficher uniquement les mots commencent par la lettre c\"" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 1, 36 | "metadata": { 37 | "collapsed": false 38 | }, 39 | "outputs": [], 40 | "source": [ 41 | "# Votre code" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "______\n", 49 | "**Utilisez range() pour afficher les nombres pairs de 0 à 10.**" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 2, 55 | "metadata": { 56 | "collapsed": false 57 | }, 58 | "outputs": [], 59 | "source": [ 60 | "# Votre code" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "___\n", 68 | "**Utilisez la compréhension de liste pour créer la liste des nombres divisibles par 3 compris entre 1 et 50.**" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 3, 74 | "metadata": { 75 | "collapsed": false 76 | }, 77 | "outputs": [ 78 | { 79 | "data": { 80 | "text/plain": [ 81 | "[]" 82 | ] 83 | }, 84 | "execution_count": 3, 85 | "metadata": {}, 86 | "output_type": "execute_result" 87 | } 88 | ], 89 | "source": [ 90 | "# Votre code\n", 91 | "[]" 92 | ] 93 | }, 94 | { 95 | "cell_type": "markdown", 96 | "metadata": {}, 97 | "source": [ 98 | "_____\n", 99 | "**Dans la chaine suivante, vérifiez le nombre de lettre de chaque mot et si celui-ci est pair, affichez le mot aveec \"pair !\"**" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": 6, 105 | "metadata": { 106 | "collapsed": true 107 | }, 108 | "outputs": [], 109 | "source": [ 110 | "st = 'Affichez chaque mot de cette phrase dont le nombre de lettres est pair'" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 4, 116 | "metadata": { 117 | "collapsed": true 118 | }, 119 | "outputs": [], 120 | "source": [ 121 | "# Votre code" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "**Écrire un programme qui affiche les nombres entiers de 1 à 100. Pour les multiples de trois afficher \"Fizz\" à la place du nombre et pour les multiples de cinq afficher \"Buzz\". Pour les nombres qui sont à la fois des multiples de trois et de cinq afficher \"FizzBuzz\". **" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": null, 134 | "metadata": { 135 | "collapsed": false 136 | }, 137 | "outputs": [], 138 | "source": [ 139 | "# Votre code" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "____\n", 147 | "**Utilisez la compréhension de liste pour créer la liste des cinq premières lettres de chaque mot dans la chaine ci dessous :**" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": 1, 153 | "metadata": { 154 | "collapsed": true 155 | }, 156 | "outputs": [], 157 | "source": [ 158 | "st = \"Création d'une liste des cinq premières lettres de chaque mot de cette chaine de caractères\"" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 2, 164 | "metadata": { 165 | "collapsed": true 166 | }, 167 | "outputs": [], 168 | "source": [ 169 | "# Votre code" 170 | ] 171 | }, 172 | { 173 | "cell_type": "markdown", 174 | "metadata": {}, 175 | "source": [ 176 | "### Bravo !" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": null, 182 | "metadata": { 183 | "collapsed": true 184 | }, 185 | "outputs": [], 186 | "source": [] 187 | } 188 | ], 189 | "metadata": { 190 | "anaconda-cloud": {}, 191 | "kernelspec": { 192 | "display_name": "Python [default]", 193 | "language": "python", 194 | "name": "python3" 195 | }, 196 | "language_info": { 197 | "codemirror_mode": { 198 | "name": "ipython", 199 | "version": 3 200 | }, 201 | "file_extension": ".py", 202 | "mimetype": "text/x-python", 203 | "name": "python", 204 | "nbconvert_exporter": "python", 205 | "pygments_lexer": "ipython3", 206 | "version": "3.5.2" 207 | } 208 | }, 209 | "nbformat": 4, 210 | "nbformat_minor": 0 211 | } 212 | -------------------------------------------------------------------------------- /Partie2_Python_Déclarations/Enchainement d'opérateurs logiques.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Enchainement d'opérateurs logiques\n", 8 | "\n", 9 | "Une fonctionnalité intéressante de Python est la faculté de *chainer* des comparateurs logiques pour réaliser un test complexe. Vous pouvez utiliser ces comparateur chainés comme un racourci pour des expressions booléennes plus complexes.\n", 10 | "\n", 11 | "Dans ce cours nous allons apprendre comment chainer les tests logiques et nous allons également voir deux opérateurs indispensables \"et\" **and** et \"ou\" **or**.\n", 12 | "\n", 13 | "Voyons quelques exemples :" 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": 1, 19 | "metadata": { 20 | "collapsed": false 21 | }, 22 | "outputs": [ 23 | { 24 | "data": { 25 | "text/plain": [ 26 | "True" 27 | ] 28 | }, 29 | "execution_count": 1, 30 | "metadata": {}, 31 | "output_type": "execute_result" 32 | } 33 | ], 34 | "source": [ 35 | "1 < 2 < 3" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "La ligne de code précédente vérifie si 1 est inférieur à 2 **ET** si 2 est inférieur à 3. On aurait également pu l'écrire avec une instruction **and** en Python :" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": 2, 48 | "metadata": { 49 | "collapsed": false 50 | }, 51 | "outputs": [ 52 | { 53 | "data": { 54 | "text/plain": [ 55 | "True" 56 | ] 57 | }, 58 | "execution_count": 2, 59 | "metadata": {}, 60 | "output_type": "execute_result" 61 | } 62 | ], 63 | "source": [ 64 | "1<2 and 2<3" 65 | ] 66 | }, 67 | { 68 | "cell_type": "markdown", 69 | "metadata": {}, 70 | "source": [ 71 | "Le **and** est utilisé pour s'assurer que les deux test logiques sont vrais de sorte que le test complet sera vrai.\n", 72 | "Voyons un autre exemple :" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": 3, 78 | "metadata": { 79 | "collapsed": false 80 | }, 81 | "outputs": [ 82 | { 83 | "data": { 84 | "text/plain": [ 85 | "True" 86 | ] 87 | }, 88 | "execution_count": 3, 89 | "metadata": {}, 90 | "output_type": "execute_result" 91 | } 92 | ], 93 | "source": [ 94 | "1 < 3 > 2" 95 | ] 96 | }, 97 | { 98 | "cell_type": "markdown", 99 | "metadata": {}, 100 | "source": [ 101 | "Ces tests vérifient que 3 est plus grand que les deux autres nombres, on peut donc utiliser **and** pour l'écrire aussi de cette manière :" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 4, 107 | "metadata": { 108 | "collapsed": false 109 | }, 110 | "outputs": [ 111 | { 112 | "data": { 113 | "text/plain": [ 114 | "True" 115 | ] 116 | }, 117 | "execution_count": 4, 118 | "metadata": {}, 119 | "output_type": "execute_result" 120 | } 121 | ], 122 | "source": [ 123 | "1<3 and 3>2" 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": {}, 129 | "source": [ 130 | "Il est important de noter que Python vérifie les deux instances de comparaisons. On peut aussi utiliser **or** pour écrire des tests en Python.\n", 131 | "Par exemple :" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": 5, 137 | "metadata": { 138 | "collapsed": false 139 | }, 140 | "outputs": [ 141 | { 142 | "data": { 143 | "text/plain": [ 144 | "True" 145 | ] 146 | }, 147 | "execution_count": 5, 148 | "metadata": {}, 149 | "output_type": "execute_result" 150 | } 151 | ], 152 | "source": [ 153 | "1==2 or 2<3" 154 | ] 155 | }, 156 | { 157 | "cell_type": "markdown", 158 | "metadata": {}, 159 | "source": [ 160 | "Remarquez que le résultat est vrai, parce qu'avec l'opérateur **or**, nous avons besoin que l'un **ou** l'autre des tests soit vrai.\n", 161 | "Regardons un autre exemple pour bien assimiler :" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": 6, 167 | "metadata": { 168 | "collapsed": false 169 | }, 170 | "outputs": [ 171 | { 172 | "data": { 173 | "text/plain": [ 174 | "True" 175 | ] 176 | }, 177 | "execution_count": 6, 178 | "metadata": {}, 179 | "output_type": "execute_result" 180 | } 181 | ], 182 | "source": [ 183 | "1==1 or 100==1" 184 | ] 185 | }, 186 | { 187 | "cell_type": "markdown", 188 | "metadata": {}, 189 | "source": [ 190 | "Bravo !\n", 191 | "Vous devez maintenant avoir bien compris comment utiliser les opérateurs **and** et **or** ainsi qu'être capable de lire du code de tests de comparaison chainés.\n", 192 | "\n", 193 | "Il ne vous reste plus qu'à faire le test de cette section pour valider votre apprentissage !" 194 | ] 195 | } 196 | ], 197 | "metadata": { 198 | "anaconda-cloud": {}, 199 | "kernelspec": { 200 | "display_name": "Python [default]", 201 | "language": "python", 202 | "name": "python3" 203 | }, 204 | "language_info": { 205 | "codemirror_mode": { 206 | "name": "ipython", 207 | "version": 3 208 | }, 209 | "file_extension": ".py", 210 | "mimetype": "text/x-python", 211 | "name": "python", 212 | "nbconvert_exporter": "python", 213 | "pygments_lexer": "ipython3", 214 | "version": "3.5.2" 215 | } 216 | }, 217 | "nbformat": 4, 218 | "nbformat_minor": 0 219 | } 220 | -------------------------------------------------------------------------------- /Partie2_Python_Déclarations/Introduction aux instructions Python.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Introduction aux instructions Python\n", 12 | "\n", 13 | "Dans cette leçon nous allons faire une rapide introduction aux instructions Python. Nous mettrons l'accent sur les différences entre Python et d'autres langages comme C++.\n", 14 | "\n", 15 | "Il y a deux raisons pour procéder de la sorte dans l'apprentissage des instructions Python.\n", 16 | "\n", 17 | " 1.) Si vous connaissez déjà un autre langage, cela va accélérer votre apprentissage de Python.\n", 18 | " 2.) Apprendre de cette manière vous aidera à comprendre d'autres langages dans le futur." 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "slideshow": { 25 | "slide_type": "slide" 26 | } 27 | }, 28 | "source": [ 29 | "## Python par rapport aux autres langages\n", 30 | "\n", 31 | "Créons une déclaration simple pour faire :\n", 32 | "\"Si a est plus grand que b, assigner 2 à a et 4 à b\"\n", 33 | "\n", 34 | "Regardez ces deux blocs d'instructions *if* (nous apprendrons comment construire des blocs if plus tard). \n", 35 | "\n", 36 | "**Version 1 (Autres langages)**\n", 37 | "\n", 38 | " if (a>b){\n", 39 | " a = 2;\n", 40 | " b = 4;\n", 41 | " }\n", 42 | " \n", 43 | "**Version 2 (Python)** \n", 44 | "\n", 45 | " if a>b:\n", 46 | " a = 2\n", 47 | " b = 4" 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": {}, 53 | "source": [ 54 | "Vous remarquerez que Python est moins chargé et bien plus lisible que la première version. Comment Python gère-t-il cela ?\n", 55 | "\n", 56 | "Regardons les différences principales :\n", 57 | "\n", 58 | "Python n'utilise ni () ni {} en prenant en compte deux facteurs principaux : le *deux point* et les *espaces*. L'instruction se termine par deux points, et l'indentation permet de mettre en évidence ce qui sera exécuté.\n", 59 | "\n", 60 | "Une autre différence majeure est l'absence de point virgule avec Python. Le point virgule est utilisé pour signaler la fin d'un instruction dans de nombreux langages, mais en Python, la fin de ligne signale aussi la fin d'une instruction.\n", 61 | "\n", 62 | "Pour terminer cette introduction rapide des différences, regardons de plus près la syntaxe indentée de Python par rapport à d'autres langages :\n", 63 | "\n", 64 | "## Indentation\n", 65 | "\n", 66 | "Voici quelques lignes de pseudo-code pour présenter l'usage des espaces et de l'indentation en Python :\n", 67 | "\n", 68 | "**Autres langages**\n", 69 | "\n", 70 | " if (x)\n", 71 | " if (y)\n", 72 | " ligne-de-code;\n", 73 | " else\n", 74 | " autre-ligne-de-code;\n", 75 | " \n", 76 | "**Python**\n", 77 | " \n", 78 | " if x:\n", 79 | " if y:\n", 80 | " ligne-de-code\n", 81 | " else:\n", 82 | " autre-ligne-de-code" 83 | ] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "metadata": {}, 88 | "source": [ 89 | "Notez comment Python est piloté par l'indentation de code et les espaces. Cela signifie que la lisibilité du code est une partie essentielle de la conception du langage Python.\n", 90 | "\n", 91 | "Maintenant nous allons nous plonger plus profond en apprenant à coder ce type d'instructions en Python !" 92 | ] 93 | }, 94 | { 95 | "cell_type": "markdown", 96 | "metadata": { 97 | "collapsed": true 98 | }, 99 | "source": [ 100 | "## C'est le moment de commencer à coder !" 101 | ] 102 | } 103 | ], 104 | "metadata": { 105 | "anaconda-cloud": {}, 106 | "kernelspec": { 107 | "display_name": "Python [default]", 108 | "language": "python", 109 | "name": "python3" 110 | }, 111 | "language_info": { 112 | "codemirror_mode": { 113 | "name": "ipython", 114 | "version": 3 115 | }, 116 | "file_extension": ".py", 117 | "mimetype": "text/x-python", 118 | "name": "python", 119 | "nbconvert_exporter": "python", 120 | "pygments_lexer": "ipython3", 121 | "version": "3.5.2" 122 | } 123 | }, 124 | "nbformat": 4, 125 | "nbformat_minor": 0 126 | } 127 | -------------------------------------------------------------------------------- /Partie2_Python_Déclarations/Les directives if, elif, et else.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Les directives if,elif et else\n", 8 | "\n", 9 | "La directive Python *if* va nous permettre de dire au programme d'exécuter différentes actions en fonction du résultats à certain tests.\n", 10 | "\n", 11 | "\n", 12 | "Nous pouvons imaginer que nous demandons à l'ordinateur :\n", 13 | "\"Hé, si ceci se produit, exécute cette action\"\n", 14 | "\n", 15 | "Nous pouvons développer cette idée plus loin avec les directives *elif* et *else*, qui vont nous permettre de dire à l'ordinateur :\n", 16 | "\n", 17 | "\"Ohé, si ceci se produit, fait cela. Autrement, si cet autre cas se produit, fait plutôt ceci. Sinon-- aucun de ces cas ne s'est produit, fait donc cette action.\"\n", 18 | "\n", 19 | "Allons-y et jetons un coup d'oeil à la syntaxe des directives if pour avoir une idée plus précise de tout ça :\n", 20 | "\n", 21 | " if cas1:\n", 22 | " exécute action1\n", 23 | " elif cas2:\n", 24 | " exécute action2\n", 25 | " else: \n", 26 | " exécute action 3" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "## Premier exemple\n", 34 | "\n", 35 | "Regardons un exemple simple :" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 2, 41 | "metadata": { 42 | "collapsed": false 43 | }, 44 | "outputs": [ 45 | { 46 | "name": "stdout", 47 | "output_type": "stream", 48 | "text": [ 49 | "C'est vrai !\n" 50 | ] 51 | } 52 | ], 53 | "source": [ 54 | "if True:\n", 55 | " print (\"C'est vrai !\")" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "Ajoutons un sinon (else) :" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 3, 68 | "metadata": { 69 | "collapsed": false 70 | }, 71 | "outputs": [ 72 | { 73 | "name": "stdout", 74 | "output_type": "stream", 75 | "text": [ 76 | "Ceci va être affiché chaque fois que x n'est pas vrai\n" 77 | ] 78 | } 79 | ], 80 | "source": [ 81 | "x = False\n", 82 | "\n", 83 | "if x:\n", 84 | " print ('x est vrai !')\n", 85 | "else:\n", 86 | " print (\"Ceci va être affiché chaque fois que x n'est pas vrai\")" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "### Branchements multiples\n", 94 | "\n", 95 | "Maintenant, regardons jusqu'où nous pouvons aller avec if, elif, et else !\n", 96 | "\n", 97 | "Nous allons écrire une structure imbriquée. Remarquez comment le if, elif et else sont alignés. Cela devrait vous aider à comprendre quel if est en relation avec quel elif ou else.\n", 98 | "\n", 99 | "Nous allons revoir aussi la syntaxe des tests logiques avec Python." 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": 8, 105 | "metadata": { 106 | "collapsed": false 107 | }, 108 | "outputs": [ 109 | { 110 | "name": "stdout", 111 | "output_type": "stream", 112 | "text": [ 113 | "Bienvenue à la banque!\n" 114 | ] 115 | } 116 | ], 117 | "source": [ 118 | "loc = 'Banque'\n", 119 | "\n", 120 | "if loc == 'Magasin Auto':\n", 121 | " print ('Bienvenue au Magasin Auto!')\n", 122 | "elif loc == 'Banque':\n", 123 | " print ('Bienvenue à la banque!')\n", 124 | "else:\n", 125 | " print (\"Où es-tu?\")" 126 | ] 127 | }, 128 | { 129 | "cell_type": "markdown", 130 | "metadata": {}, 131 | "source": [ 132 | "Remarquez comment les directives if imbriquées sont vérifiées jusqu'à ce qu'un booléen True va permettre au code qui suit de s'exécuter. Vous devez aussi noter que vous pouvez ajouter autant de elif que nécessaire avant de terminer la série avec un else.\n", 133 | "\n", 134 | "Voyons deux autres exemples simples pour les directives if, elif et else :" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 9, 140 | "metadata": { 141 | "collapsed": false 142 | }, 143 | "outputs": [ 144 | { 145 | "name": "stdout", 146 | "output_type": "stream", 147 | "text": [ 148 | "Bienvenue Sammy!\n" 149 | ] 150 | } 151 | ], 152 | "source": [ 153 | "personne = 'Sammy'\n", 154 | "\n", 155 | "if personne == 'Sammy':\n", 156 | " print ('Bienvenue Sammy!')\n", 157 | "else:\n", 158 | " print (\"Bienvenue, quel est ton nom ?\" )" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 11, 164 | "metadata": { 165 | "collapsed": false 166 | }, 167 | "outputs": [ 168 | { 169 | "name": "stdout", 170 | "output_type": "stream", 171 | "text": [ 172 | "Bienvenue Georges!\n" 173 | ] 174 | } 175 | ], 176 | "source": [ 177 | "personne = 'Georges'\n", 178 | "\n", 179 | "if personne == 'Sammy':\n", 180 | " print ('Bienvenue Sammy!')\n", 181 | "elif personne =='Georges':\n", 182 | " print (\"Bienvenue Georges!\")\n", 183 | "else:\n", 184 | " print (\"Bienvenue, quel est ton nom ?\" )" 185 | ] 186 | }, 187 | { 188 | "cell_type": "markdown", 189 | "metadata": {}, 190 | "source": [ 191 | "## Indentation\n", 192 | "\n", 193 | "Il est très important de comprendre comment fonctionne l'indentation est utilisée avec Python pour maintenir la structure et l'organisation de votre code.\n", 194 | "\n", 195 | "Nous reviendrons sur ce sujet quand nous allons commencer à construire des fonctions !" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": null, 201 | "metadata": { 202 | "collapsed": true 203 | }, 204 | "outputs": [], 205 | "source": [] 206 | } 207 | ], 208 | "metadata": { 209 | "anaconda-cloud": {}, 210 | "kernelspec": { 211 | "display_name": "Python [default]", 212 | "language": "python", 213 | "name": "python3" 214 | }, 215 | "language_info": { 216 | "codemirror_mode": { 217 | "name": "ipython", 218 | "version": 3 219 | }, 220 | "file_extension": ".py", 221 | "mimetype": "text/x-python", 222 | "name": "python", 223 | "nbconvert_exporter": "python", 224 | "pygments_lexer": "ipython3", 225 | "version": "3.5.2" 226 | } 227 | }, 228 | "nbformat": 4, 229 | "nbformat_minor": 0 230 | } 231 | -------------------------------------------------------------------------------- /Partie2_Python_Déclarations/Listes en compréhension.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Listes en compréhension\n", 10 | "\n", 11 | "En plus des opérations séquencielles et des méthodes de liste, Python possède une fonctionnalité avancée appelée compréhension de liste.\n", 12 | "\n", 13 | "Les listes en compréhension nous permettent de construire des listes en utilisant une notation différente.\n", 14 | "C'est essentiellement une façon d'écrire une boucle incluse entre des crochets sur une seule ligne.\n", 15 | "\n", 16 | "Voici un exemple simple:\n", 17 | "\n", 18 | "## Exemple 1" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": 1, 24 | "metadata": { 25 | "collapsed": true 26 | }, 27 | "outputs": [], 28 | "source": [ 29 | "# Extraire chaque lettre de la chaine\n", 30 | "liste = [x for x in 'exemple']" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 3, 36 | "metadata": { 37 | "collapsed": false 38 | }, 39 | "outputs": [ 40 | { 41 | "data": { 42 | "text/plain": [ 43 | "['e', 'x', 'e', 'm', 'p', 'l', 'e']" 44 | ] 45 | }, 46 | "execution_count": 3, 47 | "metadata": {}, 48 | "output_type": "execute_result" 49 | } 50 | ], 51 | "source": [ 52 | "# Affichage\n", 53 | "liste" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "C'était l'idée de base des listes de compréhension. Si vous êtes familiers de notation mathématique, vous devriez reconnaitre cet exemple : x^2 : x in { 0,1,2...10} \n", 61 | "\n", 62 | "Intéressons nous maintenant à d'autres exemples de listes de compréhension avec Python :\n", 63 | "## Exemple 2" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 4, 69 | "metadata": { 70 | "collapsed": true 71 | }, 72 | "outputs": [], 73 | "source": [ 74 | "# Liste crée à partir d'un range() de carrés\n", 75 | "lst = [x**2 for x in range(0,11)]" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 5, 81 | "metadata": { 82 | "collapsed": false 83 | }, 84 | "outputs": [ 85 | { 86 | "data": { 87 | "text/plain": [ 88 | "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]" 89 | ] 90 | }, 91 | "execution_count": 5, 92 | "metadata": {}, 93 | "output_type": "execute_result" 94 | } 95 | ], 96 | "source": [ 97 | "lst" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "## Exemple 3\n", 105 | "Voyons comment ajouter une instruction if" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 6, 111 | "metadata": { 112 | "collapsed": true 113 | }, 114 | "outputs": [], 115 | "source": [ 116 | "# Vérification de nombres pairs\n", 117 | "lst = [x for x in range(11) if x % 2 == 0]" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": 7, 123 | "metadata": { 124 | "collapsed": false 125 | }, 126 | "outputs": [ 127 | { 128 | "data": { 129 | "text/plain": [ 130 | "[0, 2, 4, 6, 8, 10]" 131 | ] 132 | }, 133 | "execution_count": 7, 134 | "metadata": {}, 135 | "output_type": "execute_result" 136 | } 137 | ], 138 | "source": [ 139 | "lst" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "## Exemple 4\n", 147 | "On peut faire aussi des calculs plus compliqués :" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": 9, 153 | "metadata": { 154 | "collapsed": false 155 | }, 156 | "outputs": [ 157 | { 158 | "data": { 159 | "text/plain": [ 160 | "[32.0, 50.0, 68.18, 94.1]" 161 | ] 162 | }, 163 | "execution_count": 9, 164 | "metadata": {}, 165 | "output_type": "execute_result" 166 | } 167 | ], 168 | "source": [ 169 | "# Conversion de Celsius en Fahrenheit\n", 170 | "celsius = [0,10,20.1,34.5]\n", 171 | "\n", 172 | "fahrenheit = [ ((float(9)/5)*temp + 32) for temp in celsius ]\n", 173 | "\n", 174 | "fahrenheit" 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "## Exemple 5\n", 182 | "On peut également imbriquer des listes de compréhension, par exemple :" 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": 10, 188 | "metadata": { 189 | "collapsed": false 190 | }, 191 | "outputs": [ 192 | { 193 | "data": { 194 | "text/plain": [ 195 | "[0, 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561, 10000]" 196 | ] 197 | }, 198 | "execution_count": 10, 199 | "metadata": {}, 200 | "output_type": "execute_result" 201 | } 202 | ], 203 | "source": [ 204 | "lst = [ x**2 for x in [x**2 for x in range(11)]]\n", 205 | "lst" 206 | ] 207 | }, 208 | { 209 | "cell_type": "markdown", 210 | "metadata": {}, 211 | "source": [ 212 | "Plus loin dans le cours, nous verrons la notion de générateurs.\n", 213 | "Vous devriez maintenant être à l'aise pour lire et écrire des listes de compréhensions simples." 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": null, 219 | "metadata": { 220 | "collapsed": true 221 | }, 222 | "outputs": [], 223 | "source": [] 224 | } 225 | ], 226 | "metadata": { 227 | "anaconda-cloud": {}, 228 | "kernelspec": { 229 | "display_name": "Python [default]", 230 | "language": "python", 231 | "name": "python3" 232 | }, 233 | "language_info": { 234 | "codemirror_mode": { 235 | "name": "ipython", 236 | "version": 3 237 | }, 238 | "file_extension": ".py", 239 | "mimetype": "text/x-python", 240 | "name": "python", 241 | "nbconvert_exporter": "python", 242 | "pygments_lexer": "ipython3", 243 | "version": "3.5.2" 244 | } 245 | }, 246 | "nbformat": 4, 247 | "nbformat_minor": 0 248 | } 249 | -------------------------------------------------------------------------------- /Partie2_Python_Déclarations/Opérateurs logiques.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Opérateurs logiques, ou de comparison\n", 8 | "\n", 9 | "Dans cette lecture nous allons découvrir les opérateurs de comparaison avec Python. Ces opérateurs vont nous permettre de comparer des variables et de produire un Bouléen Vrai (True) ou Faux (False) en fonction du résultat.\n", 10 | "\n", 11 | "Si vous avez quelques souvenirs de vos cours de mathématiques, ces opérateurs ne devraient vous poser aucun soucis.\n", 12 | "\n", 13 | "Nous allons commencer avec un tableau de comparaison entre ces opérateurs et ensuite découvrir quelques exemples :\n", 14 | "\n", 15 | "## Tableau de comparison des opérateurs\n", 16 | "\n", 17 | "\n", 18 | "\n", 19 | "\n", 20 | "\n", 21 | "\n", 22 | "\n", 23 | "\n", 24 | "\n", 25 | "\n", 26 | "\n", 27 | "\n", 28 | "\n", 29 | "\n", 30 | "\n", 31 | "\n", 32 | "\n", 33 | "\n", 34 | "\n", 35 | "\n", 36 | "\n", 37 | "\n", 38 | "\n", 39 | "\n", 40 | "\n", 41 | "\n", 42 | "\n", 43 | "\n", 44 | "\n", 45 | "\n", 46 | "\n", 47 | "\n", 48 | "\n", 49 | "\n", 50 | "\n", 51 | "
OpérateurDescriptionExemple
==Si les valeurs des deux opérandes sont égales, alors la condition est vraie. (a == b) n'est pas vrai.
!=Si les valeurs des deux opérandes ne sont pas égales, alors la condition est vraie.(a != b) est vrai
>Si la valeur de l'opérande gauche est supérieure à celle de droite, alors la condition est vraie. (a > b) n'est pas vrai.
<Si la valeur de l'opérande gauche est inférieure à celle de droite, alors la condition est vraie. (a < b) est vrai.
>=Si la valeur de l'opérande gauche est supérieure ou égale à celle de droite, alors la condition est vraie. (a >= b) n'est pas vrai.
<=Si la valeur de l'opérande gauche est inférieure ou égale à celle de droite, alors la condition est vraie.. (a <= b) est vrai.
" 52 | ] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": {}, 57 | "source": [ 58 | "Voyons maintenant quelques exemples rapides pour chacun.\n", 59 | "\n", 60 | "#### Égalité" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 11, 66 | "metadata": { 67 | "collapsed": false 68 | }, 69 | "outputs": [ 70 | { 71 | "data": { 72 | "text/plain": [ 73 | "True" 74 | ] 75 | }, 76 | "execution_count": 11, 77 | "metadata": {}, 78 | "output_type": "execute_result" 79 | } 80 | ], 81 | "source": [ 82 | "2 == 2" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": 12, 88 | "metadata": { 89 | "collapsed": false 90 | }, 91 | "outputs": [ 92 | { 93 | "data": { 94 | "text/plain": [ 95 | "False" 96 | ] 97 | }, 98 | "execution_count": 12, 99 | "metadata": {}, 100 | "output_type": "execute_result" 101 | } 102 | ], 103 | "source": [ 104 | "1 == 0" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "#### Différent" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": 13, 117 | "metadata": { 118 | "collapsed": false 119 | }, 120 | "outputs": [ 121 | { 122 | "data": { 123 | "text/plain": [ 124 | "True" 125 | ] 126 | }, 127 | "execution_count": 13, 128 | "metadata": {}, 129 | "output_type": "execute_result" 130 | } 131 | ], 132 | "source": [ 133 | "2 != 1" 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": 14, 139 | "metadata": { 140 | "collapsed": false 141 | }, 142 | "outputs": [ 143 | { 144 | "data": { 145 | "text/plain": [ 146 | "False" 147 | ] 148 | }, 149 | "execution_count": 14, 150 | "metadata": {}, 151 | "output_type": "execute_result" 152 | } 153 | ], 154 | "source": [ 155 | "2 != 2" 156 | ] 157 | }, 158 | { 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "#### Supérieur" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 9, 168 | "metadata": { 169 | "collapsed": false 170 | }, 171 | "outputs": [ 172 | { 173 | "data": { 174 | "text/plain": [ 175 | "True" 176 | ] 177 | }, 178 | "execution_count": 9, 179 | "metadata": {}, 180 | "output_type": "execute_result" 181 | } 182 | ], 183 | "source": [ 184 | "2 > 1" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": 10, 190 | "metadata": { 191 | "collapsed": false 192 | }, 193 | "outputs": [ 194 | { 195 | "data": { 196 | "text/plain": [ 197 | "False" 198 | ] 199 | }, 200 | "execution_count": 10, 201 | "metadata": {}, 202 | "output_type": "execute_result" 203 | } 204 | ], 205 | "source": [ 206 | "2 > 4" 207 | ] 208 | }, 209 | { 210 | "cell_type": "markdown", 211 | "metadata": {}, 212 | "source": [ 213 | "#### Inférieur" 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": 11, 219 | "metadata": { 220 | "collapsed": false 221 | }, 222 | "outputs": [ 223 | { 224 | "data": { 225 | "text/plain": [ 226 | "True" 227 | ] 228 | }, 229 | "execution_count": 11, 230 | "metadata": {}, 231 | "output_type": "execute_result" 232 | } 233 | ], 234 | "source": [ 235 | "2 < 4" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": 12, 241 | "metadata": { 242 | "collapsed": false 243 | }, 244 | "outputs": [ 245 | { 246 | "data": { 247 | "text/plain": [ 248 | "False" 249 | ] 250 | }, 251 | "execution_count": 12, 252 | "metadata": {}, 253 | "output_type": "execute_result" 254 | } 255 | ], 256 | "source": [ 257 | "2 < 1" 258 | ] 259 | }, 260 | { 261 | "cell_type": "markdown", 262 | "metadata": {}, 263 | "source": [ 264 | "#### Supérieur ou égal" 265 | ] 266 | }, 267 | { 268 | "cell_type": "code", 269 | "execution_count": 13, 270 | "metadata": { 271 | "collapsed": false 272 | }, 273 | "outputs": [ 274 | { 275 | "data": { 276 | "text/plain": [ 277 | "True" 278 | ] 279 | }, 280 | "execution_count": 13, 281 | "metadata": {}, 282 | "output_type": "execute_result" 283 | } 284 | ], 285 | "source": [ 286 | "2 >= 2" 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": 14, 292 | "metadata": { 293 | "collapsed": false 294 | }, 295 | "outputs": [ 296 | { 297 | "data": { 298 | "text/plain": [ 299 | "True" 300 | ] 301 | }, 302 | "execution_count": 14, 303 | "metadata": {}, 304 | "output_type": "execute_result" 305 | } 306 | ], 307 | "source": [ 308 | "2 >= 1" 309 | ] 310 | }, 311 | { 312 | "cell_type": "markdown", 313 | "metadata": {}, 314 | "source": [ 315 | "#### Inférieur ou égal" 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": 15, 321 | "metadata": { 322 | "collapsed": false 323 | }, 324 | "outputs": [ 325 | { 326 | "data": { 327 | "text/plain": [ 328 | "True" 329 | ] 330 | }, 331 | "execution_count": 15, 332 | "metadata": {}, 333 | "output_type": "execute_result" 334 | } 335 | ], 336 | "source": [ 337 | "2 <= 2" 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": 16, 343 | "metadata": { 344 | "collapsed": false 345 | }, 346 | "outputs": [ 347 | { 348 | "data": { 349 | "text/plain": [ 350 | "True" 351 | ] 352 | }, 353 | "execution_count": 16, 354 | "metadata": {}, 355 | "output_type": "execute_result" 356 | } 357 | ], 358 | "source": [ 359 | "2 <= 4" 360 | ] 361 | }, 362 | { 363 | "cell_type": "markdown", 364 | "metadata": {}, 365 | "source": [ 366 | "**Bravo !\n", 367 | "Examinez chaque opérateur de comparaison pour vous assurer de bien comprendre ce que chacun fait. Mais je pense que c'était facile**\n", 368 | "\n", 369 | "La prochaine fois, nous allons découvrir les opérateurs de comparaison enchainés" 370 | ] 371 | } 372 | ], 373 | "metadata": { 374 | "anaconda-cloud": {}, 375 | "kernelspec": { 376 | "display_name": "Python [default]", 377 | "language": "python", 378 | "name": "python3" 379 | }, 380 | "language_info": { 381 | "codemirror_mode": { 382 | "name": "ipython", 383 | "version": 3 384 | }, 385 | "file_extension": ".py", 386 | "mimetype": "text/x-python", 387 | "name": "python", 388 | "nbconvert_exporter": "python", 389 | "pygments_lexer": "ipython3", 390 | "version": "3.5.2" 391 | } 392 | }, 393 | "nbformat": 4, 394 | "nbformat_minor": 0 395 | } 396 | -------------------------------------------------------------------------------- /Partie2_Python_Déclarations/Range().ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# range()\n", 8 | "\n", 9 | "Dans cette courte leçon, nous allons découvrir la fonction range(). Nous n'avons pas encore développé une connaissance détaillée des fonctions, mais nous pouvons comprendre les bases de cette fonction simple (mais extrêmement utile!).\n", 10 | "\n", 11 | "range() nous permet de générer une liste de nombres entiers allant d'une valeur de départ *jusqu'à* une valeur de fin. Nous pouvons également spécifier la taille du pas.\n", 12 | "\n", 13 | "Voyons quelques exemples:" 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": 7, 19 | "metadata": { 20 | "collapsed": false 21 | }, 22 | "outputs": [ 23 | { 24 | "data": { 25 | "text/plain": [ 26 | "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" 27 | ] 28 | }, 29 | "execution_count": 7, 30 | "metadata": {}, 31 | "output_type": "execute_result" 32 | } 33 | ], 34 | "source": [ 35 | "list(range(0,10))" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 3, 41 | "metadata": { 42 | "collapsed": false 43 | }, 44 | "outputs": [ 45 | { 46 | "data": { 47 | "text/plain": [ 48 | "range" 49 | ] 50 | }, 51 | "execution_count": 3, 52 | "metadata": {}, 53 | "output_type": "execute_result" 54 | } 55 | ], 56 | "source": [ 57 | "x =range(0,10)\n", 58 | "type(x)" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 4, 64 | "metadata": { 65 | "collapsed": true 66 | }, 67 | "outputs": [], 68 | "source": [ 69 | "start = 0 #Défaut\n", 70 | "stop = 20 \n", 71 | "x = range(start,stop)" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": 5, 77 | "metadata": { 78 | "collapsed": false 79 | }, 80 | "outputs": [ 81 | { 82 | "data": { 83 | "text/plain": [ 84 | "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]" 85 | ] 86 | }, 87 | "execution_count": 5, 88 | "metadata": {}, 89 | "output_type": "execute_result" 90 | } 91 | ], 92 | "source": [ 93 | "# On affiche x\n", 94 | "list(x)" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": 9, 100 | "metadata": { 101 | "collapsed": false 102 | }, 103 | "outputs": [ 104 | { 105 | "data": { 106 | "text/plain": [ 107 | "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]" 108 | ] 109 | }, 110 | "execution_count": 9, 111 | "metadata": {}, 112 | "output_type": "execute_result" 113 | } 114 | ], 115 | "source": [ 116 | "# On affiche vraiment le contenu de range() avec la fonction list\n", 117 | "list(x)" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "Bravo !\n", 125 | "Remarquez qu'il y a bien 20 *valeurs*, mais 20 ne fait pas partie de la liste. Comme pour l'indexation. \n", 126 | "Nous pouvons aussi modifier le pas, 1 par défaut, comme troisième argument:" 127 | ] 128 | }, 129 | { 130 | "cell_type": "code", 131 | "execution_count": 11, 132 | "metadata": { 133 | "collapsed": false 134 | }, 135 | "outputs": [ 136 | { 137 | "data": { 138 | "text/plain": [ 139 | "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]" 140 | ] 141 | }, 142 | "execution_count": 11, 143 | "metadata": {}, 144 | "output_type": "execute_result" 145 | } 146 | ], 147 | "source": [ 148 | "x = range(start,stop,2)\n", 149 | "# Afficher\n", 150 | "list(x)" 151 | ] 152 | }, 153 | { 154 | "cell_type": "markdown", 155 | "metadata": {}, 156 | "source": [ 157 | "Magnifique, dernier exemple avec une boucle for :" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": 13, 163 | "metadata": { 164 | "collapsed": false 165 | }, 166 | "outputs": [ 167 | { 168 | "name": "stdout", 169 | "output_type": "stream", 170 | "text": [ 171 | "0\n", 172 | "1\n", 173 | "2\n", 174 | "3\n", 175 | "4\n", 176 | "5\n", 177 | "6\n", 178 | "7\n", 179 | "8\n", 180 | "9\n" 181 | ] 182 | } 183 | ], 184 | "source": [ 185 | "for num in range(10):\n", 186 | " print (num)" 187 | ] 188 | }, 189 | { 190 | "cell_type": "markdown", 191 | "metadata": { 192 | "collapsed": true 193 | }, 194 | "source": [ 195 | "Vous savez tout maintenant pour pouvoir utiliser range() en Python." 196 | ] 197 | } 198 | ], 199 | "metadata": { 200 | "anaconda-cloud": {}, 201 | "kernelspec": { 202 | "display_name": "Python [default]", 203 | "language": "python", 204 | "name": "python3" 205 | }, 206 | "language_info": { 207 | "codemirror_mode": { 208 | "name": "ipython", 209 | "version": 3 210 | }, 211 | "file_extension": ".py", 212 | "mimetype": "text/x-python", 213 | "name": "python", 214 | "nbconvert_exporter": "python", 215 | "pygments_lexer": "ipython3", 216 | "version": "3.5.2" 217 | } 218 | }, 219 | "nbformat": 4, 220 | "nbformat_minor": 0 221 | } 222 | -------------------------------------------------------------------------------- /Partie2_Python_Déclarations/Solutions du contrôle des connaissances.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Contrôle des connaissances\n", 10 | "\n", 11 | "Voyons un peu ce que vous avez appris !" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "_____\n", 19 | "**Utilisez les instructions for, split(), et if pour créer un code qui va n'afficher que les mots qui commencent par 'c' dans cette phrase :**" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 28, 25 | "metadata": { 26 | "collapsed": true 27 | }, 28 | "outputs": [], 29 | "source": [ 30 | "st = \"Cet exercice consiste à afficher uniquement les mots commencent par la lettre c\"" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 34, 36 | "metadata": { 37 | "collapsed": false 38 | }, 39 | "outputs": [ 40 | { 41 | "name": "stdout", 42 | "output_type": "stream", 43 | "text": [ 44 | "Cet\n", 45 | "consiste\n", 46 | "commencent\n", 47 | "c\n" 48 | ] 49 | } 50 | ], 51 | "source": [ 52 | "for mot in st.split():\n", 53 | " if mot[0].lower() == 'c' :\n", 54 | " print (mot)" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "______\n", 62 | "**Utilisez range() pour afficher les nombres pairs de 0 à 10.**" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 21, 68 | "metadata": { 69 | "collapsed": false 70 | }, 71 | "outputs": [ 72 | { 73 | "data": { 74 | "text/plain": [ 75 | "[0, 2, 4, 6, 8, 10]" 76 | ] 77 | }, 78 | "execution_count": 21, 79 | "metadata": {}, 80 | "output_type": "execute_result" 81 | } 82 | ], 83 | "source": [ 84 | "list(range(0,11,2))" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "___\n", 92 | "**Utilisez la compréhension de liste pour créer la liste des nombres divisibles par 3 compris entre 1 et 50.**" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": 35, 98 | "metadata": { 99 | "collapsed": false 100 | }, 101 | "outputs": [ 102 | { 103 | "data": { 104 | "text/plain": [ 105 | "[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48]" 106 | ] 107 | }, 108 | "execution_count": 35, 109 | "metadata": {}, 110 | "output_type": "execute_result" 111 | } 112 | ], 113 | "source": [ 114 | "[x for x in range(1,51) if x%3 == 0]" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "_____\n", 122 | "**Dans la chaine suivante, vérifiez le nombre de lettre de chaque mot et si celui-ci est pair, affichez le mot avec \"pair !\"**" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 23, 128 | "metadata": { 129 | "collapsed": true 130 | }, 131 | "outputs": [], 132 | "source": [ 133 | "st = 'Affichez chaque mot de cette phrase dont le nombre de lettres est pair'" 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": 24, 139 | "metadata": { 140 | "collapsed": false 141 | }, 142 | "outputs": [ 143 | { 144 | "name": "stdout", 145 | "output_type": "stream", 146 | "text": [ 147 | "Affichez <-- longueur paire !\n", 148 | "chaque <-- longueur paire !\n", 149 | "de <-- longueur paire !\n", 150 | "phrase <-- longueur paire !\n", 151 | "dont <-- longueur paire !\n", 152 | "le <-- longueur paire !\n", 153 | "nombre <-- longueur paire !\n", 154 | "de <-- longueur paire !\n", 155 | "pair <-- longueur paire !\n" 156 | ] 157 | } 158 | ], 159 | "source": [ 160 | "for mot in st.split():\n", 161 | " if len(mot)%2 == 0:\n", 162 | " print (mot + \" <-- longueur paire !\")" 163 | ] 164 | }, 165 | { 166 | "cell_type": "markdown", 167 | "metadata": {}, 168 | "source": [ 169 | "**Écrire un programme qui affiche les nombres entiers de 1 à 100. Pour les afficher de trois afficher \"Fizz\" à la place du nombre et pour les multiples de cinq imprimer \"Buzz\". Pour les nombres qui sont à la fois des multiples de trois et de cinq afficher \"FizzBuzz\". **" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": 25, 175 | "metadata": { 176 | "collapsed": false 177 | }, 178 | "outputs": [ 179 | { 180 | "name": "stdout", 181 | "output_type": "stream", 182 | "text": [ 183 | "1\n", 184 | "2\n", 185 | "Fizz\n", 186 | "4\n", 187 | "Buzz\n", 188 | "Fizz\n", 189 | "7\n", 190 | "8\n", 191 | "Fizz\n", 192 | "Buzz\n", 193 | "11\n", 194 | "Fizz\n", 195 | "13\n", 196 | "14\n", 197 | "FizzBuzz\n", 198 | "16\n", 199 | "17\n", 200 | "Fizz\n", 201 | "19\n", 202 | "Buzz\n", 203 | "Fizz\n", 204 | "22\n", 205 | "23\n", 206 | "Fizz\n", 207 | "Buzz\n", 208 | "26\n", 209 | "Fizz\n", 210 | "28\n", 211 | "29\n", 212 | "FizzBuzz\n", 213 | "31\n", 214 | "32\n", 215 | "Fizz\n", 216 | "34\n", 217 | "Buzz\n", 218 | "Fizz\n", 219 | "37\n", 220 | "38\n", 221 | "Fizz\n", 222 | "Buzz\n", 223 | "41\n", 224 | "Fizz\n", 225 | "43\n", 226 | "44\n", 227 | "FizzBuzz\n", 228 | "46\n", 229 | "47\n", 230 | "Fizz\n", 231 | "49\n", 232 | "Buzz\n", 233 | "Fizz\n", 234 | "52\n", 235 | "53\n", 236 | "Fizz\n", 237 | "Buzz\n", 238 | "56\n", 239 | "Fizz\n", 240 | "58\n", 241 | "59\n", 242 | "FizzBuzz\n", 243 | "61\n", 244 | "62\n", 245 | "Fizz\n", 246 | "64\n", 247 | "Buzz\n", 248 | "Fizz\n", 249 | "67\n", 250 | "68\n", 251 | "Fizz\n", 252 | "Buzz\n", 253 | "71\n", 254 | "Fizz\n", 255 | "73\n", 256 | "74\n", 257 | "FizzBuzz\n", 258 | "76\n", 259 | "77\n", 260 | "Fizz\n", 261 | "79\n", 262 | "Buzz\n", 263 | "Fizz\n", 264 | "82\n", 265 | "83\n", 266 | "Fizz\n", 267 | "Buzz\n", 268 | "86\n", 269 | "Fizz\n", 270 | "88\n", 271 | "89\n", 272 | "FizzBuzz\n", 273 | "91\n", 274 | "92\n", 275 | "Fizz\n", 276 | "94\n", 277 | "Buzz\n", 278 | "Fizz\n", 279 | "97\n", 280 | "98\n", 281 | "Fizz\n", 282 | "Buzz\n" 283 | ] 284 | } 285 | ], 286 | "source": [ 287 | "for num in range(1,101):\n", 288 | " if num % 5 == 0 and num % 3 == 0:\n", 289 | " print (\"FizzBuzz\")\n", 290 | " elif num % 3 == 0:\n", 291 | " print (\"Fizz\")\n", 292 | " elif num % 5 == 0:\n", 293 | " print (\"Buzz\")\n", 294 | " else:\n", 295 | " print (num)" 296 | ] 297 | }, 298 | { 299 | "cell_type": "markdown", 300 | "metadata": {}, 301 | "source": [ 302 | "____\n", 303 | "**Utilisez la compréhension de liste pour créer la liste des cinq premières lettres de chaque mot dans la chaine ci dessous :**" 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": 26, 309 | "metadata": { 310 | "collapsed": true 311 | }, 312 | "outputs": [], 313 | "source": [ 314 | "st = \"Création d'une liste des cinq premières lettres de chaque mot de cette chaine de caractères\"" 315 | ] 316 | }, 317 | { 318 | "cell_type": "code", 319 | "execution_count": 27, 320 | "metadata": { 321 | "collapsed": false 322 | }, 323 | "outputs": [ 324 | { 325 | "data": { 326 | "text/plain": [ 327 | "['Créat',\n", 328 | " \"d'une\",\n", 329 | " 'liste',\n", 330 | " 'des',\n", 331 | " 'cinq',\n", 332 | " 'premi',\n", 333 | " 'lettr',\n", 334 | " 'de',\n", 335 | " 'chaqu',\n", 336 | " 'mot',\n", 337 | " 'de',\n", 338 | " 'cette',\n", 339 | " 'chain',\n", 340 | " 'de',\n", 341 | " 'carac']" 342 | ] 343 | }, 344 | "execution_count": 27, 345 | "metadata": {}, 346 | "output_type": "execute_result" 347 | } 348 | ], 349 | "source": [ 350 | "[mot[0:5] for mot in st.split()]" 351 | ] 352 | }, 353 | { 354 | "cell_type": "markdown", 355 | "metadata": {}, 356 | "source": [ 357 | "### Bravo !" 358 | ] 359 | } 360 | ], 361 | "metadata": { 362 | "anaconda-cloud": {}, 363 | "kernelspec": { 364 | "display_name": "Python [default]", 365 | "language": "python", 366 | "name": "python3" 367 | }, 368 | "language_info": { 369 | "codemirror_mode": { 370 | "name": "ipython", 371 | "version": 3 372 | }, 373 | "file_extension": ".py", 374 | "mimetype": "text/x-python", 375 | "name": "python", 376 | "nbconvert_exporter": "python", 377 | "pygments_lexer": "ipython3", 378 | "version": "3.5.2" 379 | } 380 | }, 381 | "nbformat": 4, 382 | "nbformat_minor": 0 383 | } 384 | -------------------------------------------------------------------------------- /Partie3_Méthodes_et_Fonctions/Controle de connaissances sur les fonctions et les méthodes.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Controle de connaissances sur les fonctions et les méthodes\n", 8 | "\n", 9 | "Répondez aux questions suivantes :\n", 10 | "____\n", 11 | "**Ecrire une fonction qui renvoie le volume d'une sphère en fonction de son rayon**" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 1, 17 | "metadata": { 18 | "collapsed": true 19 | }, 20 | "outputs": [], 21 | "source": [ 22 | "def vol(rayon):\n", 23 | " pass" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "**Ecrire une fonction qui vérifie qu'un nombre est situé dans un intervalle donné (bornes incluses)**" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 7, 36 | "metadata": { 37 | "collapsed": true 38 | }, 39 | "outputs": [], 40 | "source": [ 41 | "def verif_intervalle(num,bas,haut):\n", 42 | " pass" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "Réponse sous forme d'un booléen :" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 8, 55 | "metadata": { 56 | "collapsed": true 57 | }, 58 | "outputs": [], 59 | "source": [ 60 | "def bool_intervalle(num,bas,haut):\n", 61 | " pass" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": 9, 67 | "metadata": { 68 | "collapsed": false 69 | }, 70 | "outputs": [ 71 | { 72 | "data": { 73 | "text/plain": [ 74 | "True" 75 | ] 76 | }, 77 | "execution_count": 9, 78 | "metadata": {}, 79 | "output_type": "execute_result" 80 | } 81 | ], 82 | "source": [ 83 | "bool_intervalle(3,1,10)" 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": {}, 89 | "source": [ 90 | "____\n", 91 | "** Écrivez une fonction Python qui calcule le nombre de lettres majuscules et minuscules dans une chaine. **\n", 92 | "\n", 93 | " Exemple de chaine : \"Bonjour Mr Martin, comment allez vous en cette belle journée de mardi ?\"\n", 94 | " Réponse souhaitée :\n", 95 | " Nombre de majuscules : 3\n", 96 | " Nombre de minuscules : 54\n", 97 | " \n", 98 | "Si vous vous sentez en forme, vous pouvez allez voir ce qu'il y a dans le module Collections pour résoudre ce problème !" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 11, 104 | "metadata": { 105 | "collapsed": true 106 | }, 107 | "outputs": [], 108 | "source": [ 109 | "def maj_min(s):\n", 110 | " pass" 111 | ] 112 | }, 113 | { 114 | "cell_type": "markdown", 115 | "metadata": {}, 116 | "source": [ 117 | "____\n", 118 | "**Ecrire une fonction Python qui prend une liste en entrée et retourne une nouvelle liste avec les éléments uniques de la première liste.**\n", 119 | "\n", 120 | " Exemple de liste : [1,1,1,1,2,2,3,3,3,3,4,5]\n", 121 | " Liste unique : [1, 2, 3, 4, 5]" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": 2, 127 | "metadata": { 128 | "collapsed": true 129 | }, 130 | "outputs": [], 131 | "source": [ 132 | "def liste_unique(l):\n", 133 | " pass" 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": 4, 139 | "metadata": { 140 | "collapsed": false 141 | }, 142 | "outputs": [], 143 | "source": [ 144 | "liste_unique([1,1,1,1,2,2,3,3,3,3,4,5])" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "____\n", 152 | "**Ecrire une fonction Python qui multiplie tous les nombres de la liste.**\n", 153 | "\n", 154 | " Exemple de liste : [1, 2, 3, -4]\n", 155 | " Sortie attendue : -24" 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": 17, 161 | "metadata": { 162 | "collapsed": true 163 | }, 164 | "outputs": [], 165 | "source": [ 166 | "def multiplie(nombre): \n", 167 | " pass" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 18, 173 | "metadata": { 174 | "collapsed": false 175 | }, 176 | "outputs": [ 177 | { 178 | "data": { 179 | "text/plain": [ 180 | "-24" 181 | ] 182 | }, 183 | "execution_count": 18, 184 | "metadata": {}, 185 | "output_type": "execute_result" 186 | } 187 | ], 188 | "source": [ 189 | "multiplie([1,2,3,-4])" 190 | ] 191 | }, 192 | { 193 | "cell_type": "markdown", 194 | "metadata": {}, 195 | "source": [ 196 | "____\n", 197 | "**Ecrire une fonction Python qui vérifie si une chaîne passée est un palindrome.**\n", 198 | "\n", 199 | "Note: Un palindrome est un mot, une phrase ou une séquence qui se lit vers l'arrière et vers l'avant, par exemple, kayak ou rêver." 200 | ] 201 | }, 202 | { 203 | "cell_type": "code", 204 | "execution_count": 5, 205 | "metadata": { 206 | "collapsed": true 207 | }, 208 | "outputs": [], 209 | "source": [ 210 | "def palindrome(s):\n", 211 | " pass" 212 | ] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": 6, 217 | "metadata": { 218 | "collapsed": false 219 | }, 220 | "outputs": [], 221 | "source": [ 222 | "palindrome('kayak')" 223 | ] 224 | }, 225 | { 226 | "cell_type": "markdown", 227 | "metadata": {}, 228 | "source": [ 229 | "____\n", 230 | "**Difficile**:\n", 231 | "\n", 232 | "Ecrire une fonction Python pour vérifier si une chaîne est un pangramme.\n", 233 | "\n", 234 | " Note : Un pangramme est une phrase contenant chaque lettre de l'alphabet au moins une fois.\n", 235 | " Par exemple : \"Buvez de ce whisky que le patron juge fameux\"\n", 236 | "\n", 237 | "Indice : Regardez le module String" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": 7, 243 | "metadata": { 244 | "collapsed": true 245 | }, 246 | "outputs": [], 247 | "source": [ 248 | "import string\n", 249 | "\n", 250 | "def est_un_pangramme(str1, alphabet=string.ascii_lowercase): \n", 251 | " pass" 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": 8, 257 | "metadata": { 258 | "collapsed": false 259 | }, 260 | "outputs": [], 261 | "source": [ 262 | "est_un_pangramme(\"Buvez de ce whisky que le patron juge fameux\")" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": 9, 268 | "metadata": { 269 | "collapsed": false 270 | }, 271 | "outputs": [ 272 | { 273 | "data": { 274 | "text/plain": [ 275 | "'abcdefghijklmnopqrstuvwxyz'" 276 | ] 277 | }, 278 | "execution_count": 9, 279 | "metadata": {}, 280 | "output_type": "execute_result" 281 | } 282 | ], 283 | "source": [ 284 | "string.ascii_lowercase" 285 | ] 286 | }, 287 | { 288 | "cell_type": "markdown", 289 | "metadata": { 290 | "collapsed": true 291 | }, 292 | "source": [ 293 | "#### **Bravo !**" 294 | ] 295 | }, 296 | { 297 | "cell_type": "code", 298 | "execution_count": null, 299 | "metadata": { 300 | "collapsed": true 301 | }, 302 | "outputs": [], 303 | "source": [] 304 | } 305 | ], 306 | "metadata": { 307 | "anaconda-cloud": {}, 308 | "kernelspec": { 309 | "display_name": "Python [default]", 310 | "language": "python", 311 | "name": "python3" 312 | }, 313 | "language_info": { 314 | "codemirror_mode": { 315 | "name": "ipython", 316 | "version": 3 317 | }, 318 | "file_extension": ".py", 319 | "mimetype": "text/x-python", 320 | "name": "python", 321 | "nbconvert_exporter": "python", 322 | "pygments_lexer": "ipython3", 323 | "version": "3.5.2" 324 | } 325 | }, 326 | "nbformat": 4, 327 | "nbformat_minor": 0 328 | } 329 | -------------------------------------------------------------------------------- /Partie3_Méthodes_et_Fonctions/Les méthodes.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Les méthodes\n", 8 | "\n", 9 | "Nous avons déjà vu quelques exemples de méthodes avec la leçon sur les objets et les structures de données Python. De façon très simplifiée, les méthodes sont des fonctions construites à l'intérieur des objets. Un peu plus tard dans le cours, nous apprendrons à créer nos propres objets et méthodes en utilisation la Programmation Orientée Objet (POO) et les classes.\n", 10 | "\n", 11 | "Les méthodes exécutent des actions spécifiques sur l'objet lui-même et peuvent également prendre des paramètres, tout comme une fonction. Cette leçon est une brève introduction aux méthodes et vous permettra de commencer réfléchir à la conception ce sur quoi nous reviendrons quand nous arriverons à la partie POO du cours.\n", 12 | "\n", 13 | "Les méthodes sont de la forme :\n", 14 | "\n", 15 | " objet.méthode(parm1,parm2,etc...)\n", 16 | "\n", 17 | "Nous verrons plus tard que certaines méthodes peuvent avoir un paramètre 'self' pour faire référence à l'objet lui-même. Nous verrons cela avec la partie POO.\n", 18 | "\n", 19 | "Faisons un rapide tour d'horizon des méthodes que l'on peut retrouver avec un objet liste :" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 2, 25 | "metadata": { 26 | "collapsed": true 27 | }, 28 | "outputs": [], 29 | "source": [ 30 | "# Création d'une liste simple\n", 31 | "l = [1,2,3,4,5]" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "Heureusement, avec iPython et les Notebooks Jupyter nous pouvons retrouver rapidement toutes les méthodes applicables à un objet au moyen de la touche tabulation. Il suffit pour cela de taper le nom de l'objet dans une cellule, suivit d'un point et ensuite la touche tabulation.\n", 39 | "\n", 40 | "Les méthodes pour une liste sont les suivantes :\n", 41 | "\n", 42 | "* append\n", 43 | "* count\n", 44 | "* extend\n", 45 | "* insert\n", 46 | "* pop\n", 47 | "* remove\n", 48 | "* reverse\n", 49 | "* sort\n", 50 | "\n", 51 | "Essayons en quelques unes :" 52 | ] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": {}, 57 | "source": [ 58 | "append() nous permet d'jouter des éléments à la fin d'une liste :" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 3, 64 | "metadata": { 65 | "collapsed": true 66 | }, 67 | "outputs": [], 68 | "source": [ 69 | "l.append(6)" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": 4, 75 | "metadata": { 76 | "collapsed": false 77 | }, 78 | "outputs": [ 79 | { 80 | "data": { 81 | "text/plain": [ 82 | "[1, 2, 3, 4, 5, 6]" 83 | ] 84 | }, 85 | "execution_count": 4, 86 | "metadata": {}, 87 | "output_type": "execute_result" 88 | } 89 | ], 90 | "source": [ 91 | "l" 92 | ] 93 | }, 94 | { 95 | "cell_type": "markdown", 96 | "metadata": {}, 97 | "source": [ 98 | "Bravo ! Et count() alors ? La méthode count() va dénombrer le nombre d'occurences d'un élément dans une liste." 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 5, 104 | "metadata": { 105 | "collapsed": false 106 | }, 107 | "outputs": [ 108 | { 109 | "data": { 110 | "text/plain": [ 111 | "1" 112 | ] 113 | }, 114 | "execution_count": 5, 115 | "metadata": {}, 116 | "output_type": "execute_result" 117 | } 118 | ], 119 | "source": [ 120 | "# Vérifie combien de fois 2 apparait dans la liste\n", 121 | "l.count(2)" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "Il est également possible d'utiliser majuscule et tabulation dans un Notebook Jupyter pour obtenir de l'aide à propos d'une méthode. Avec Python plus généralement, il faudra utiliser la fonction help() :" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 7, 134 | "metadata": { 135 | "collapsed": false 136 | }, 137 | "outputs": [ 138 | { 139 | "name": "stdout", 140 | "output_type": "stream", 141 | "text": [ 142 | "Help on built-in function count:\n", 143 | "\n", 144 | "count(...) method of builtins.list instance\n", 145 | " L.count(value) -> integer -- return number of occurrences of value\n", 146 | "\n" 147 | ] 148 | } 149 | ], 150 | "source": [ 151 | "help(l.count)" 152 | ] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "metadata": {}, 157 | "source": [ 158 | "N'hésitez pas à test les autres méthodes d'un objet liste. Plus tard dans cette section le controle de connaissances vous demandera d'utiliser help et Google pour retrouver les méthodes de différents objets !" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "Bravo !\n", 166 | "Avec cette leçon vous devriez maintenant être à l'aise pour appeler les méthodes d'objets Python !" 167 | ] 168 | } 169 | ], 170 | "metadata": { 171 | "anaconda-cloud": {}, 172 | "kernelspec": { 173 | "display_name": "Python [default]", 174 | "language": "python", 175 | "name": "python3" 176 | }, 177 | "language_info": { 178 | "codemirror_mode": { 179 | "name": "ipython", 180 | "version": 3 181 | }, 182 | "file_extension": ".py", 183 | "mimetype": "text/x-python", 184 | "name": "python", 185 | "nbconvert_exporter": "python", 186 | "pygments_lexer": "ipython3", 187 | "version": "3.5.2" 188 | } 189 | }, 190 | "nbformat": 4, 191 | "nbformat_minor": 0 192 | } 193 | -------------------------------------------------------------------------------- /Partie4_Premier_Projet/1 - Présentation du premier project.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Lancement du premier projet !\n", 8 | "## Présentation du projet\n", 9 | "\n", 10 | "Vous avez déjà beaucoup appris et vous êtes prêt pour travailler sur un vrai projet.\n", 11 | "\n", 12 | "Votre tâche : Créer un jeu de Morpion. Vous pouvez utiliser l'environnement de développement (IDE) que vous voulez. \n", 13 | "\n", 14 | "Voici les exigences :\n", 15 | "\n", 16 | "* c'est un jeu pour 2 personnes qui utilisent le même ordinateur.\n", 17 | "* le tableau de jeu est affiché chaque fois qu'un joueur place une marque\n", 18 | "* Vous devez demander au joueur la position de son mouvement et ensuite placer la marque sur le tableau\n", 19 | "\n", 20 | "Vous pouvez utiliser Google pour vous aider (mais ne cherchez pas \"Morpion en Python\", sinon vous n'apprendrez pas grand chose !). Gardez présent à l'esprit que ce projet peut dure de quelques heures à plusieurs jours.\n", 21 | "\n", 22 | "Il y a 3 bloc-notes Jupyter qui se rapportent à ce travail :\n", 23 | "\n", 24 | "* Ce bloc-note avec la présentation du travail à faire\n", 25 | "* Un bloc-note \"Feuille de route\" qui propose les étapes à suivre pour coder le jeu\n", 26 | "* Un bloc-note \"Solution\" avec les explications et le code du jeu\n", 27 | "\n", 28 | "Je vous encourage à démarrer le projet seul et sans retourner dans les bloc-notes Jupyter. Si vous êtes bloqué, consultez d'abord la prochaine leçon qui est un document comportant de nombreux conseils et les étapes utiles. Si vous êtes toujours coincé après cela, consultez la feuille de route, qui divise le projet en étapes simples à résoudre. Toujours bloqué ? Ensuite, vous pourrez consulter la vidéo de la feuille de route pour plus d'aide sur la manière de venir à bout de ce projet !" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "Il y a des parties pour lesquelles vous pouvez avoir à batailler... et c'est bien !\n", 36 | "J'ai confiance dans le fait que vous avez tous les outils et les connaissances pour réaliser ce projet si vous avez bien suivi toutes les leçons jusqu'ici . Rappelez-vous, vous pouvez consulter toute la documentation dont vous avez besoin, prenez votre temps, faites un peu de recherches, et n'oubliez surtout pas :\n", 37 | "\n", 38 | "## AMUSEZ VOUS BIEN !" 39 | ] 40 | } 41 | ], 42 | "metadata": { 43 | "anaconda-cloud": {}, 44 | "kernelspec": { 45 | "display_name": "Python [default]", 46 | "language": "python", 47 | "name": "python3" 48 | }, 49 | "language_info": { 50 | "codemirror_mode": { 51 | "name": "ipython", 52 | "version": 3 53 | }, 54 | "file_extension": ".py", 55 | "mimetype": "text/x-python", 56 | "name": "python", 57 | "nbconvert_exporter": "python", 58 | "pygments_lexer": "ipython3", 59 | "version": "3.5.2" 60 | } 61 | }, 62 | "nbformat": 4, 63 | "nbformat_minor": 0 64 | } 65 | -------------------------------------------------------------------------------- /Partie4_Premier_Projet/2 - Premier Projet d'étape - Feuille de route détaillée.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Premier Projet d'étape : Feuille de route\n", 8 | "\n", 9 | "Vous trouverez ci dessous les étapes à suivre pour créer le jeu de Morpion de votre projet d'étape." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "**1ère étape : Ecrire une fonction pour afficher le tableau de jeu. Configurer votre tableau comme une liste, où chaque index 1-9 correspond à un nombre sur un clavier, de sorte que vous obtenez un terrain de 3 par 3.**" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 2, 22 | "metadata": { 23 | "collapsed": true 24 | }, 25 | "outputs": [], 26 | "source": [ 27 | "from IPython.display import clear_output\n", 28 | "def affiche_tableau(tableau):\n", 29 | " pass" 30 | ] 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "metadata": {}, 35 | "source": [ 36 | "**2ème étape : Ecrire une fonction qui demande au joueur quelle marque «X» ou «O» il veut utiliser et lui assigner. Pensez à utiliser une boucle *while* pour demander une réponse au joueur jusqu'à obtenir une réponse correcte.**" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 3, 42 | "metadata": { 43 | "collapsed": true 44 | }, 45 | "outputs": [], 46 | "source": [ 47 | "def action_joueur():\n", 48 | " pass" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "**3ème étape : Ecrire une fonction qui manipule, dans l'objet tableau (list), une marque ('X' ou 'O') et la position désirée (numéro 1-9) et l'affecte au tableau.**" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": 4, 61 | "metadata": { 62 | "collapsed": true 63 | }, 64 | "outputs": [], 65 | "source": [ 66 | "def placer_marque(tableau, marque, position):\n", 67 | " pass" 68 | ] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "**4ème étape : Ecrire une fonction qui prend un tableau et une marque (X ou O), puis vérifie si cette marque a gagné. **" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 1, 80 | "metadata": { 81 | "collapsed": true 82 | }, 83 | "outputs": [], 84 | "source": [ 85 | "def vérifie_gagnant(tableau, marque):\n", 86 | " pass" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "**5ème étape : Ecrire une fonction qui utilise le module random pour décider au hasard quel joueur va jouer en premier. Vous devriez chercher du côté de random.randint(). La fonction retourne une chaîne qui indique le joueur qui joue le premier.**" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 91, 99 | "metadata": { 100 | "collapsed": true 101 | }, 102 | "outputs": [], 103 | "source": [ 104 | "import random\n", 105 | "def choix_premier():\n", 106 | " pass" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "**6ème étape :Ecrire une fonction qui renvoie un booléen indiquant si un espace sur la carte est disponible.**" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": 92, 119 | "metadata": { 120 | "collapsed": true 121 | }, 122 | "outputs": [], 123 | "source": [ 124 | "def vérifie_position(tableau, position):\n", 125 | " pass" 126 | ] 127 | }, 128 | { 129 | "cell_type": "markdown", 130 | "metadata": {}, 131 | "source": [ 132 | "**7ème étape : Ecrire une fonction qui vérifie si le tableau est plein et renvoie une valeur booléenne. Vrai si plein, Faux autrement.**" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": 5, 138 | "metadata": { 139 | "collapsed": true 140 | }, 141 | "outputs": [], 142 | "source": [ 143 | "def vérifie_tableau_complet(tableau):\n", 144 | " pass" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "**8ème étape : Ecrire une fonction qui demande au joueur la position où il veut placer sa marque (comme un nombre 1-9), puis utilise la fonction de l'étape 6 pour vérifier si sa position libre. Si c'est le cas, retourne la position pour pouvoir l'utiliser. **" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": 94, 157 | "metadata": { 158 | "collapsed": true 159 | }, 160 | "outputs": [], 161 | "source": [ 162 | "def choix_du_joueur(tableau):\n", 163 | " pass" 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "metadata": {}, 169 | "source": [ 170 | "**9ème étape : Ecrire une fonction qui demande au joueur s'il veut jouer de nouveau et retourne un booléen Vrai si oui.**" 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": 1, 176 | "metadata": { 177 | "collapsed": true 178 | }, 179 | "outputs": [], 180 | "source": [ 181 | "def rejouer():\n", 182 | " pass" 183 | ] 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "metadata": { 188 | "collapsed": true 189 | }, 190 | "source": [ 191 | "**10ème étape : Voici la partie difficile ! Utilisez boucles while et les fonctions que vous venez d'écrire pour donner vie au jeu!**" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 2, 197 | "metadata": { 198 | "collapsed": false 199 | }, 200 | "outputs": [ 201 | { 202 | "name": "stdout", 203 | "output_type": "stream", 204 | "text": [ 205 | "Bienvenue dans le jeu de Morpion !\n" 206 | ] 207 | } 208 | ], 209 | "source": [ 210 | "print('Bienvenue dans le jeu de Morpion !')\n", 211 | "\n", 212 | "#while True:\n", 213 | " # Préparer le tableau\n", 214 | " #pass\n", 215 | "\n", 216 | " #while jeu_en_cours:\n", 217 | " # Tour du joueur 1\n", 218 | " \n", 219 | " \n", 220 | " # Tour du joueur 2\n", 221 | " \n", 222 | " #pass\n", 223 | "\n", 224 | " #if not rejouer():\n", 225 | " #break" 226 | ] 227 | }, 228 | { 229 | "cell_type": "markdown", 230 | "metadata": { 231 | "collapsed": true 232 | }, 233 | "source": [ 234 | "## Bravo !" 235 | ] 236 | } 237 | ], 238 | "metadata": { 239 | "anaconda-cloud": {}, 240 | "kernelspec": { 241 | "display_name": "Python [default]", 242 | "language": "python", 243 | "name": "python3" 244 | }, 245 | "language_info": { 246 | "codemirror_mode": { 247 | "name": "ipython", 248 | "version": 3 249 | }, 250 | "file_extension": ".py", 251 | "mimetype": "text/x-python", 252 | "name": "python", 253 | "nbconvert_exporter": "python", 254 | "pygments_lexer": "ipython3", 255 | "version": "3.5.2" 256 | } 257 | }, 258 | "nbformat": 4, 259 | "nbformat_minor": 0 260 | } 261 | -------------------------------------------------------------------------------- /Partie5_Programmation_Orientée_Objet/Programmation Orientée Objet - Contrôle de connaissances - Solution.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Programmation Orientée Objet\n", 8 | "## Solution du contrôle de connaissances\n", 9 | "\n", 10 | "#### 1er problème\n", 11 | "\n", 12 | "Complétez les méthodes de la classe Ligne pour accepter en paramètre les coordonnées comme une paire de tuples et renvoyer la pente et la distance à la ligne." 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 1, 18 | "metadata": { 19 | "collapsed": true 20 | }, 21 | "outputs": [], 22 | "source": [ 23 | "class Ligne(object):\n", 24 | " \n", 25 | " def __init__(self,coor1,coor2):\n", 26 | " self.coor1 = coor1\n", 27 | " self.coor2 = coor2\n", 28 | " \n", 29 | " def distance(self):\n", 30 | " x1,y1 = self.coor1\n", 31 | " x2,y2 = self.coor2\n", 32 | " return ( (x2-x1)**2 + (y2-y1)**2 )**0.5\n", 33 | " \n", 34 | " def pente(self):\n", 35 | " x1,y1 = self.coor1\n", 36 | " x2,y2 = self.coor2\n", 37 | " return float((y2-y1))/(x2-x1)" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 9, 43 | "metadata": { 44 | "collapsed": true 45 | }, 46 | "outputs": [], 47 | "source": [ 48 | "coordonnées1 = (3,2)\n", 49 | "coordonnées2 = (8,10)\n", 50 | "\n", 51 | "li = Ligne(coordonnées1,coordonnées2)" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": 10, 57 | "metadata": { 58 | "collapsed": false 59 | }, 60 | "outputs": [ 61 | { 62 | "data": { 63 | "text/plain": [ 64 | "9.433981132056603" 65 | ] 66 | }, 67 | "execution_count": 10, 68 | "metadata": {}, 69 | "output_type": "execute_result" 70 | } 71 | ], 72 | "source": [ 73 | "li.distance()" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": 11, 79 | "metadata": { 80 | "collapsed": false 81 | }, 82 | "outputs": [ 83 | { 84 | "data": { 85 | "text/plain": [ 86 | "1.6" 87 | ] 88 | }, 89 | "execution_count": 11, 90 | "metadata": {}, 91 | "output_type": "execute_result" 92 | } 93 | ], 94 | "source": [ 95 | "li.pente()" 96 | ] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "metadata": {}, 101 | "source": [ 102 | "________\n", 103 | "#### 2ème problème" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": {}, 109 | "source": [ 110 | "Complétez la classe" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 12, 116 | "metadata": { 117 | "collapsed": false 118 | }, 119 | "outputs": [], 120 | "source": [ 121 | "class Cylindre(object):\n", 122 | " \n", 123 | " def __init__(self,hauteur=1,rayon=1):\n", 124 | " self.hauteur = hauteur\n", 125 | " self.rayon = rayon\n", 126 | " \n", 127 | " def volume(self):\n", 128 | " return self.hauteur * (3.14)* (self.rayon)**2\n", 129 | " \n", 130 | " def surface(self):\n", 131 | " dessus = (3.14)* (self.rayon)**2\n", 132 | " return 2*dessus + 2*3.14*self.rayon*self.hauteur" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": 13, 138 | "metadata": { 139 | "collapsed": true 140 | }, 141 | "outputs": [], 142 | "source": [ 143 | "c = Cylindre(2,3)" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": 14, 149 | "metadata": { 150 | "collapsed": false 151 | }, 152 | "outputs": [ 153 | { 154 | "data": { 155 | "text/plain": [ 156 | "56.52" 157 | ] 158 | }, 159 | "execution_count": 14, 160 | "metadata": {}, 161 | "output_type": "execute_result" 162 | } 163 | ], 164 | "source": [ 165 | "c.volume()" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": 15, 171 | "metadata": { 172 | "collapsed": false 173 | }, 174 | "outputs": [ 175 | { 176 | "data": { 177 | "text/plain": [ 178 | "94.2" 179 | ] 180 | }, 181 | "execution_count": 15, 182 | "metadata": {}, 183 | "output_type": "execute_result" 184 | } 185 | ], 186 | "source": [ 187 | "c.surface()" 188 | ] 189 | }, 190 | { 191 | "cell_type": "code", 192 | "execution_count": null, 193 | "metadata": { 194 | "collapsed": true 195 | }, 196 | "outputs": [], 197 | "source": [] 198 | } 199 | ], 200 | "metadata": { 201 | "anaconda-cloud": {}, 202 | "kernelspec": { 203 | "display_name": "Python [default]", 204 | "language": "python", 205 | "name": "python3" 206 | }, 207 | "language_info": { 208 | "codemirror_mode": { 209 | "name": "ipython", 210 | "version": 3 211 | }, 212 | "file_extension": ".py", 213 | "mimetype": "text/x-python", 214 | "name": "python", 215 | "nbconvert_exporter": "python", 216 | "pygments_lexer": "ipython3", 217 | "version": "3.5.2" 218 | } 219 | }, 220 | "nbformat": 4, 221 | "nbformat_minor": 0 222 | } 223 | -------------------------------------------------------------------------------- /Partie5_Programmation_Orientée_Objet/Programmation Orientée Objet - Contrôle de connaissances.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Programmation Orientée Objet\n", 8 | "## Votre mission et contrôle de connaissances\n", 9 | "\n", 10 | "#### 1er problème\n", 11 | "\n", 12 | "Complétez les méthodes de la classe Ligne pour accepter en paramètre les coordonnées comme une paire de tuples et renvoyer la pente et la distance à la ligne." 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 2, 18 | "metadata": { 19 | "collapsed": true 20 | }, 21 | "outputs": [], 22 | "source": [ 23 | "class Ligne(object):\n", 24 | " \n", 25 | " def __init__(self,coor1,coor2):\n", 26 | " pass\n", 27 | " \n", 28 | " def distance(self):\n", 29 | " pass\n", 30 | " \n", 31 | " def pente(self):\n", 32 | " pass" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 3, 38 | "metadata": { 39 | "collapsed": false 40 | }, 41 | "outputs": [], 42 | "source": [ 43 | "# EXEMPLE DE SORTIE\n", 44 | "\n", 45 | "coordonnées1 = (3,2)\n", 46 | "coordonnées2 = (8,10)\n", 47 | "\n", 48 | "li = Ligne(coordonnées1,coordonnées2)" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 4, 54 | "metadata": { 55 | "collapsed": false 56 | }, 57 | "outputs": [], 58 | "source": [ 59 | "li.distance()" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": 5, 65 | "metadata": { 66 | "collapsed": false 67 | }, 68 | "outputs": [], 69 | "source": [ 70 | "li.pente()" 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "metadata": {}, 76 | "source": [ 77 | "________\n", 78 | "#### 2ème problème" 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": {}, 84 | "source": [ 85 | "Complétez la classe" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 6, 91 | "metadata": { 92 | "collapsed": false 93 | }, 94 | "outputs": [], 95 | "source": [ 96 | "class Cylindre(object):\n", 97 | " \n", 98 | " def __init__(self,hauteur=1,rayon=1):\n", 99 | " pass\n", 100 | " \n", 101 | " def volume(self):\n", 102 | " pass\n", 103 | " \n", 104 | " def surface(self):\n", 105 | " pass" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 7, 111 | "metadata": { 112 | "collapsed": true 113 | }, 114 | "outputs": [], 115 | "source": [ 116 | "# EXEMPLE DE SORTIE\n", 117 | "c = Cylindre(2,3)" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": 8, 123 | "metadata": { 124 | "collapsed": false 125 | }, 126 | "outputs": [], 127 | "source": [ 128 | "c.volume()" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 9, 134 | "metadata": { 135 | "collapsed": false 136 | }, 137 | "outputs": [], 138 | "source": [ 139 | "c.surface()" 140 | ] 141 | } 142 | ], 143 | "metadata": { 144 | "anaconda-cloud": {}, 145 | "kernelspec": { 146 | "display_name": "Python [default]", 147 | "language": "python", 148 | "name": "python3" 149 | }, 150 | "language_info": { 151 | "codemirror_mode": { 152 | "name": "ipython", 153 | "version": 3 154 | }, 155 | "file_extension": ".py", 156 | "mimetype": "text/x-python", 157 | "name": "python", 158 | "nbconvert_exporter": "python", 159 | "pygments_lexer": "ipython3", 160 | "version": "3.5.2" 161 | } 162 | }, 163 | "nbformat": 4, 164 | "nbformat_minor": 0 165 | } 166 | -------------------------------------------------------------------------------- /Partie6_Erreurs_et_Exceptions/Gestion des erreurs et des exceptions - Controle de connaissances.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Gestion des erreurs et des exceptions\n", 8 | "## Controle de connaissances" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "metadata": {}, 14 | "source": [ 15 | "### 1er problème\n", 16 | "\n", 17 | "Traitez l'exception produite par le code ci-dessous en utilisant des blocs try et except." 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 1, 23 | "metadata": { 24 | "collapsed": false 25 | }, 26 | "outputs": [ 27 | { 28 | "ename": "TypeError", 29 | "evalue": "unsupported operand type(s) for ** or pow(): 'str' and 'int'", 30 | "output_type": "error", 31 | "traceback": [ 32 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 33 | "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", 34 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'a'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'b'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'c'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 35 | "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'str' and 'int'" 36 | ] 37 | } 38 | ], 39 | "source": [ 40 | "for i in ['a','b','c']:\n", 41 | " print (i**2)" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "### 2ème problème\n", 49 | "Gérer l'exception produite par le code ci-dessous en utilisant des blocs **try** et **except**. Ensuite, utilisez un bloc **finally** pour afficher 'Tout est terminé.'." 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 2, 55 | "metadata": { 56 | "collapsed": false 57 | }, 58 | "outputs": [ 59 | { 60 | "ename": "ZeroDivisionError", 61 | "evalue": "integer division or modulo by zero", 62 | "output_type": "error", 63 | "traceback": [ 64 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 65 | "\u001b[0;31mZeroDivisionError\u001b[0m Traceback (most recent call last)", 66 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 67 | "\u001b[0;31mZeroDivisionError\u001b[0m: integer division or modulo by zero" 68 | ] 69 | } 70 | ], 71 | "source": [ 72 | "x = 5\n", 73 | "y = 0\n", 74 | "\n", 75 | "z = x/y" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "### 3ème problème\n", 83 | "\n", 84 | "Ecrire une fonction qui demande un entier et affiche le carré de celui-ci. Utilisez une boucle while avec des blocs try, except et else pour gérer les entrées incorrectes." 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": 2, 90 | "metadata": { 91 | "collapsed": false 92 | }, 93 | "outputs": [], 94 | "source": [ 95 | "def demande():\n", 96 | " pass" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": 3, 102 | "metadata": { 103 | "collapsed": false 104 | }, 105 | "outputs": [ 106 | { 107 | "name": "stdout", 108 | "output_type": "stream", 109 | "text": [ 110 | "Tapez un entier : \n", 111 | "Une erreur s'est produite ! Merci d'essayer à nouveau !\n", 112 | "Tapez un entier : 4\n", 113 | "Merci, votre nombre au carré est : 16\n" 114 | ] 115 | } 116 | ], 117 | "source": [ 118 | "demande()" 119 | ] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "metadata": {}, 124 | "source": [ 125 | "# Bravo !" 126 | ] 127 | } 128 | ], 129 | "metadata": { 130 | "anaconda-cloud": {}, 131 | "kernelspec": { 132 | "display_name": "Python [default]", 133 | "language": "python", 134 | "name": "python3" 135 | }, 136 | "language_info": { 137 | "codemirror_mode": { 138 | "name": "ipython", 139 | "version": 3 140 | }, 141 | "file_extension": ".py", 142 | "mimetype": "text/x-python", 143 | "name": "python", 144 | "nbconvert_exporter": "python", 145 | "pygments_lexer": "ipython3", 146 | "version": "3.5.2" 147 | } 148 | }, 149 | "nbformat": 4, 150 | "nbformat_minor": 0 151 | } 152 | -------------------------------------------------------------------------------- /Partie6_Erreurs_et_Exceptions/Gestion des erreurs et des exceptions - Solution du controle de connaissances.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Gestion des erreurs et des exceptions\n", 8 | "## Solution du controle de connaissances" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "metadata": {}, 14 | "source": [ 15 | "### 1er problème\n", 16 | "\n", 17 | "Traitez l'exception produite par le code ci-dessous en utilisant des blocs try et except." 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 1, 23 | "metadata": { 24 | "collapsed": false 25 | }, 26 | "outputs": [ 27 | { 28 | "name": "stdout", 29 | "output_type": "stream", 30 | "text": [ 31 | "Une erreur s'est produite !\n" 32 | ] 33 | } 34 | ], 35 | "source": [ 36 | "try:\n", 37 | " for i in ['a','b','c']:\n", 38 | " print (i**2)\n", 39 | "except:\n", 40 | " print (\"Une erreur s'est produite !\")" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "### 2ème problème\n", 48 | "Gérer l'exception produite par le code ci-dessous en utilisant des blocs **try** et **except**. Ensuite, utilisez un bloc **finally** pour afficher 'Tout est terminé.'." 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 3, 54 | "metadata": { 55 | "collapsed": false 56 | }, 57 | "outputs": [ 58 | { 59 | "name": "stdout", 60 | "output_type": "stream", 61 | "text": [ 62 | "On ne peut pas diviser par 0 !\n", 63 | "Tout est terminé !\n" 64 | ] 65 | } 66 | ], 67 | "source": [ 68 | "x = 5\n", 69 | "y = 0\n", 70 | "try:\n", 71 | " z = x/y\n", 72 | "except ZeroDivisionError:\n", 73 | " print (\"On ne peut pas diviser par 0 !\")\n", 74 | "finally:\n", 75 | " print ('Tout est terminé !')" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "### 3ème problème\n", 83 | "\n", 84 | "Ecrire une fonction qui demande un entier et affiche le carré de celui-ci. Utilisez une boucle while avec des blocs try, except et else pour gérer les entrées incorrectes." 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": 8, 90 | "metadata": { 91 | "collapsed": false 92 | }, 93 | "outputs": [], 94 | "source": [ 95 | "def demande():\n", 96 | " \n", 97 | " while True:\n", 98 | " try:\n", 99 | " n = int(input('Tapez un entier : '))\n", 100 | " except:\n", 101 | " print (\"Une erreur s'est produite ! Merci d'essayer à nouveau !\")\n", 102 | " continue\n", 103 | " else:\n", 104 | " break\n", 105 | " print ('Merci, votre nombre au carré est : ',n**2)" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 9, 111 | "metadata": { 112 | "collapsed": false 113 | }, 114 | "outputs": [ 115 | { 116 | "name": "stdout", 117 | "output_type": "stream", 118 | "text": [ 119 | "Tapez un entier : e\n", 120 | "Une erreur s'est produite ! Merci d'essayer à nouveau !\n", 121 | "Tapez un entier : A\n", 122 | "Une erreur s'est produite ! Merci d'essayer à nouveau !\n", 123 | "Tapez un entier : 12121\n", 124 | "Merci, votre nombre au carré est : 146918641\n" 125 | ] 126 | } 127 | ], 128 | "source": [ 129 | "demande()" 130 | ] 131 | }, 132 | { 133 | "cell_type": "markdown", 134 | "metadata": {}, 135 | "source": [ 136 | "# Bravo !" 137 | ] 138 | } 139 | ], 140 | "metadata": { 141 | "anaconda-cloud": {}, 142 | "kernelspec": { 143 | "display_name": "Python [default]", 144 | "language": "python", 145 | "name": "python3" 146 | }, 147 | "language_info": { 148 | "codemirror_mode": { 149 | "name": "ipython", 150 | "version": 3 151 | }, 152 | "file_extension": ".py", 153 | "mimetype": "text/x-python", 154 | "name": "python", 155 | "nbconvert_exporter": "python", 156 | "pygments_lexer": "ipython3", 157 | "version": "3.5.2" 158 | } 159 | }, 160 | "nbformat": 4, 161 | "nbformat_minor": 0 162 | } 163 | -------------------------------------------------------------------------------- /Partie7_Deuxième_Projet/.ipynb_checkpoints/Milestone Project 2 - Développer un jeu de Blackjack-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Deuxième projet d'étape - jeu de Blackjack\n", 8 | "Dans ce projet, vous allez créer un jeu de cartes BlackJack complet en Python.\n", 9 | "\n", 10 | "Voici le détail de votre mission :\n", 11 | "\n", 12 | "* Vous allez créer un jeu de [BlackJack](https://fr.wikipedia.org/wiki/Blackjack_%28jeu%29) en mode texte.\n", 13 | "* Le jeu devra avoir un joueur contre une banque automatique.\n", 14 | "* Le joueur peut passer ou prendre une carte.\n", 15 | "* Le joueur doit pouvoir choisir le montant du pari.\n", 16 | "* Vous devez garder en mémoire le montant de l'argent du joueur.\n", 17 | "* Vous devez informer le joueur des gains, des pertes, etc.\n", 18 | "\n", 19 | "Et très important :\n", 20 | "\n", 21 | "* **Vous devez utiliser la programmation objet et les classes dans une partie de votre jeu. Vous ne devez pas vous limiter à utiliser des fonctions. Utilisez des classes pour vous aider à définir le sabot et la main du joueur. Il existe de nombreuses façons de le faire, alors bonne exploration !**\n", 22 | "\n", 23 | "N'hésitez pas à développer ce jeu: essayez d'autoriser plusieurs joueurs. Essayez d'ajouter la possibilité de Doubler et les splits ! N'oubliez pas que vous êtes libre d'utiliser les ressources que vous voulez et comme toujours :\n", 24 | "\n", 25 | "# Amusez vous bien !" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": { 32 | "collapsed": true 33 | }, 34 | "outputs": [], 35 | "source": [] 36 | } 37 | ], 38 | "metadata": { 39 | "anaconda-cloud": {}, 40 | "kernelspec": { 41 | "display_name": "Python [default]", 42 | "language": "python", 43 | "name": "python3" 44 | }, 45 | "language_info": { 46 | "codemirror_mode": { 47 | "name": "ipython", 48 | "version": 3 49 | }, 50 | "file_extension": ".py", 51 | "mimetype": "text/x-python", 52 | "name": "python", 53 | "nbconvert_exporter": "python", 54 | "pygments_lexer": "ipython3", 55 | "version": "3.5.2" 56 | } 57 | }, 58 | "nbformat": 4, 59 | "nbformat_minor": 0 60 | } 61 | -------------------------------------------------------------------------------- /Partie7_Deuxième_Projet/Milestone Project 2 - Développer un jeu de Blackjack.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Deuxième projet d'étape - jeu de Blackjack\n", 8 | "Dans ce projet, vous allez créer un jeu de cartes BlackJack complet en Python.\n", 9 | "\n", 10 | "Voici le détail de votre mission :\n", 11 | "\n", 12 | "* Vous allez créer un jeu de [BlackJack](https://fr.wikipedia.org/wiki/Blackjack_%28jeu%29) en mode texte.\n", 13 | "* Le jeu devra avoir un joueur contre une banque automatique.\n", 14 | "* Le joueur peut passer ou prendre une carte.\n", 15 | "* Le joueur doit pouvoir choisir le montant du pari.\n", 16 | "* Vous devez garder en mémoire le montant de l'argent du joueur.\n", 17 | "* Vous devez informer le joueur des gains, des pertes, etc.\n", 18 | "\n", 19 | "Et très important :\n", 20 | "\n", 21 | "* **Vous devez utiliser la programmation objet et les classes dans une partie de votre jeu. Vous ne devez pas vous limiter à utiliser des fonctions. Utilisez des classes pour vous aider à définir le sabot et la main du joueur. Il existe de nombreuses façons de le faire, alors bonne exploration !**\n", 22 | "\n", 23 | "N'hésitez pas à développer ce jeu: essayez d'autoriser plusieurs joueurs. Essayez d'ajouter la possibilité de Doubler et les splits ! N'oubliez pas que vous êtes libre d'utiliser les ressources que vous voulez et comme toujours :\n", 24 | "\n", 25 | "# Amusez vous bien !" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": { 32 | "collapsed": true 33 | }, 34 | "outputs": [], 35 | "source": [] 36 | } 37 | ], 38 | "metadata": { 39 | "anaconda-cloud": {}, 40 | "kernelspec": { 41 | "display_name": "Python [default]", 42 | "language": "python", 43 | "name": "python3" 44 | }, 45 | "language_info": { 46 | "codemirror_mode": { 47 | "name": "ipython", 48 | "version": 3 49 | }, 50 | "file_extension": ".py", 51 | "mimetype": "text/x-python", 52 | "name": "python", 53 | "nbconvert_exporter": "python", 54 | "pygments_lexer": "ipython3", 55 | "version": "3.5.2" 56 | } 57 | }, 58 | "nbformat": 4, 59 | "nbformat_minor": 0 60 | } 61 | -------------------------------------------------------------------------------- /Partie8_Modules_et_Paquets/.ipynb_checkpoints/Modules et Paquets-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Modules et Paquets (Packages)\n", 8 | "\n", 9 | "Vous ne trouverez pas de code dans cette leçon parce que cela n'a pas vraiment de sens. Consultez les vidéos de cours pour plus d'informations et les ressources en ligne.\n", 10 | "\n", 11 | "La meilleure ressource est la documentation officielle (en anglais):\n", 12 | "https://docs.python.org/3.7/tutorial/modules.html#packages\n", 13 | "\n", 14 | "Voici quelques informations supplémentaires pour vous aider :" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "Les modules en Python sont tout simplement des fichiers Python avec l'extension .py, qui implémentent un ensemble de fonctions déterminées. Pour importer un module, il suffit d'utiliser la commande import dans votre code.\n", 22 | "\n", 23 | "La première fois qu'un module est chargé dans un script Python en cours d'exécution, il est initialisé en exécutant le code dans le module une première fois. Si un autre module dans votre code importe à nouveau le même module, il ne sera pas chargé deux fois, mais une seule fois - de sorte que les variables locales à l'intérieur du module agissent comme un «singleton» - elles ne sont initialisées qu'une seule fois.\n", 24 | "\n", 25 | "Si nous voulons importer le module math, nous utilisons la commande suivante :" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "metadata": { 32 | "collapsed": true 33 | }, 34 | "outputs": [], 35 | "source": [ 36 | "# importer la bibliothèque\n", 37 | "import math" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 3, 43 | "metadata": { 44 | "collapsed": false 45 | }, 46 | "outputs": [ 47 | { 48 | "data": { 49 | "text/plain": [ 50 | "3" 51 | ] 52 | }, 53 | "execution_count": 3, 54 | "metadata": {}, 55 | "output_type": "execute_result" 56 | } 57 | ], 58 | "source": [ 59 | "# utiliser la bibliothèque (arrondi à l'entier directement supérieur à la valeur donnée)\n", 60 | "math.ceil(2.4)" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "## Explorons les modules intégrés\n", 68 | "Deux fonctions très importantes sont très utiles pour explorer les modules en Python: les fonctions dir et help.\n", 69 | "\n", 70 | "Nous pouvons rechercher quelles fonctions sont implémentées dans chaque module en utilisant la fonction dir:" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": 4, 76 | "metadata": { 77 | "collapsed": false 78 | }, 79 | "outputs": [ 80 | { 81 | "name": "stdout", 82 | "output_type": "stream", 83 | "text": [ 84 | "['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']\n" 85 | ] 86 | } 87 | ], 88 | "source": [ 89 | "print(dir(math))" 90 | ] 91 | }, 92 | { 93 | "cell_type": "markdown", 94 | "metadata": {}, 95 | "source": [ 96 | "Lorsque nous trouvons une fonction que nous voulons utiliser dans un module, nous pouvons en apprendre plus à son sujet avec la fonction aide de l'interpréteur Python:" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": 5, 102 | "metadata": { 103 | "collapsed": false 104 | }, 105 | "outputs": [ 106 | { 107 | "name": "stdout", 108 | "output_type": "stream", 109 | "text": [ 110 | "Help on built-in function ceil in module math:\n", 111 | "\n", 112 | "ceil(...)\n", 113 | " ceil(x)\n", 114 | " \n", 115 | " Return the ceiling of x as an Integral.\n", 116 | " This is the smallest integer >= x.\n", 117 | "\n" 118 | ] 119 | } 120 | ], 121 | "source": [ 122 | "help(math.ceil)" 123 | ] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "## Développer ses propres modules\n", 130 | "Ecrire des modules Python est très simple. Pour créer un module, créez simplement un nouveau fichier .py avec le nom du module, puis importez-le à l'aide du nom de fichier Python (sans l'extension .py) à l'aide de la commande import.\n", 131 | "\n", 132 | "## Rédaction de paquets (packages)\n", 133 | "Les packages sont des espaces de noms qui contiennent eux-mêmes plusieurs packages et modules. Ce ne sont en fait que des répertoires, mais avec un petit quelque chose en plus.\n", 134 | "\n", 135 | "Chaque paquet en Python est un répertoire qui DOIT contenir un fichier spécial appelé **\\__init\\__.Py**. Ce fichier peut être vide mais il indique que ce répertoire est en fait un paquet Python, il peut donc être importé de la même façon qu'un module peut l'être.\n", 136 | "\n", 137 | "Si nous créons un répertoire nommé toto, qui sera donc le nom du paquet, nous pouvons créer un module dans ce paquet appelé bar. Nous ne devons pas oublier d'ajouter le fichier **\\__init\\__.Py** dans le répertoire toto.\n", 138 | "\n", 139 | "Pour utiliser le module bar, nous pouvons l'importer de deux façons:" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": null, 145 | "metadata": { 146 | "collapsed": true 147 | }, 148 | "outputs": [], 149 | "source": [ 150 | "# Juste un exemple, cela ne fonctionne pas\n", 151 | "import toto.bar" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "metadata": { 158 | "collapsed": false 159 | }, 160 | "outputs": [], 161 | "source": [ 162 | "# OU on peut faire ainsi\n", 163 | "from toto import bar" 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "metadata": {}, 169 | "source": [ 170 | "Dans la première méthode, nous devons utiliser le préfixe foo chaque fois que nous accédons au module bar. Dans la deuxième méthode, nous ne le faisons pas, parce que nous importons ce module dans l'espace de nom de notre module.\n", 171 | "\n", 172 | "Le fichier **\\__init\\__.Py** peut également déterminer quels sont les modules qui seront exportés comme API par le package, tout en conservant les autres modules internes. Il suffit pour cela de placer une variable **\\__all\\__**, comme ceci:" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": null, 178 | "metadata": { 179 | "collapsed": true 180 | }, 181 | "outputs": [], 182 | "source": [ 183 | "__init__.py:\n", 184 | "\n", 185 | "__all__ = [\"bar\"]" 186 | ] 187 | } 188 | ], 189 | "metadata": { 190 | "anaconda-cloud": {}, 191 | "kernelspec": { 192 | "display_name": "Python [default]", 193 | "language": "python", 194 | "name": "python3" 195 | }, 196 | "language_info": { 197 | "codemirror_mode": { 198 | "name": "ipython", 199 | "version": 3 200 | }, 201 | "file_extension": ".py", 202 | "mimetype": "text/x-python", 203 | "name": "python", 204 | "nbconvert_exporter": "python", 205 | "pygments_lexer": "ipython3", 206 | "version": "3.5.2" 207 | } 208 | }, 209 | "nbformat": 4, 210 | "nbformat_minor": 0 211 | } 212 | -------------------------------------------------------------------------------- /Partie8_Modules_et_Paquets/Modules et Paquets.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Modules et Paquets (Packages)\n", 8 | "\n", 9 | "Vous ne trouverez pas de code dans cette leçon parce que cela n'a pas vraiment de sens. Consultez les vidéos de cours pour plus d'informations et les ressources en ligne.\n", 10 | "\n", 11 | "La meilleure ressource est la documentation officielle (en anglais):\n", 12 | "https://docs.python.org/3.7/tutorial/modules.html#packages\n", 13 | "\n", 14 | "Voici quelques informations supplémentaires pour vous aider :" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "Les modules en Python sont tout simplement des fichiers Python avec l'extension .py, qui implémentent un ensemble de fonctions déterminées. Pour importer un module, il suffit d'utiliser la commande import dans votre code.\n", 22 | "\n", 23 | "La première fois qu'un module est chargé dans un script Python en cours d'exécution, il est initialisé en exécutant le code dans le module une première fois. Si un autre module dans votre code importe à nouveau le même module, il ne sera pas chargé deux fois, mais une seule fois - de sorte que les variables locales à l'intérieur du module agissent comme un «singleton» - elles ne sont initialisées qu'une seule fois.\n", 24 | "\n", 25 | "Si nous voulons importer le module math, nous utilisons la commande suivante :" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "metadata": { 32 | "collapsed": true 33 | }, 34 | "outputs": [], 35 | "source": [ 36 | "# importer la bibliothèque\n", 37 | "import math" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 3, 43 | "metadata": { 44 | "collapsed": false 45 | }, 46 | "outputs": [ 47 | { 48 | "data": { 49 | "text/plain": [ 50 | "3" 51 | ] 52 | }, 53 | "execution_count": 3, 54 | "metadata": {}, 55 | "output_type": "execute_result" 56 | } 57 | ], 58 | "source": [ 59 | "# utiliser la bibliothèque (arrondi à l'entier directement supérieur à la valeur donnée)\n", 60 | "math.ceil(2.4)" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 4, 66 | "metadata": { 67 | "collapsed": false 68 | }, 69 | "outputs": [ 70 | { 71 | "data": { 72 | "text/plain": [ 73 | "1.4142135623730951" 74 | ] 75 | }, 76 | "execution_count": 4, 77 | "metadata": {}, 78 | "output_type": "execute_result" 79 | } 80 | ], 81 | "source": [ 82 | "math.sqrt(2)" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": 5, 88 | "metadata": { 89 | "collapsed": false 90 | }, 91 | "outputs": [ 92 | { 93 | "data": { 94 | "text/plain": [ 95 | "1.7320508075688772" 96 | ] 97 | }, 98 | "execution_count": 5, 99 | "metadata": {}, 100 | "output_type": "execute_result" 101 | } 102 | ], 103 | "source": [ 104 | "from math import sqrt\n", 105 | "sqrt(3)" 106 | ] 107 | }, 108 | { 109 | "cell_type": "markdown", 110 | "metadata": {}, 111 | "source": [ 112 | "## Explorons les modules intégrés\n", 113 | "Deux fonctions très importantes sont très utiles pour explorer les modules en Python: les fonctions dir et help.\n", 114 | "\n", 115 | "Nous pouvons rechercher quelles fonctions sont implémentées dans chaque module en utilisant la fonction dir:" 116 | ] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": 4, 121 | "metadata": { 122 | "collapsed": false 123 | }, 124 | "outputs": [ 125 | { 126 | "name": "stdout", 127 | "output_type": "stream", 128 | "text": [ 129 | "['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']\n" 130 | ] 131 | } 132 | ], 133 | "source": [ 134 | "print(dir(math))" 135 | ] 136 | }, 137 | { 138 | "cell_type": "markdown", 139 | "metadata": {}, 140 | "source": [ 141 | "Lorsque nous trouvons une fonction que nous voulons utiliser dans un module, nous pouvons en apprendre plus à son sujet avec la fonction aide de l'interpréteur Python:" 142 | ] 143 | }, 144 | { 145 | "cell_type": "code", 146 | "execution_count": 5, 147 | "metadata": { 148 | "collapsed": false 149 | }, 150 | "outputs": [ 151 | { 152 | "name": "stdout", 153 | "output_type": "stream", 154 | "text": [ 155 | "Help on built-in function ceil in module math:\n", 156 | "\n", 157 | "ceil(...)\n", 158 | " ceil(x)\n", 159 | " \n", 160 | " Return the ceiling of x as an Integral.\n", 161 | " This is the smallest integer >= x.\n", 162 | "\n" 163 | ] 164 | } 165 | ], 166 | "source": [ 167 | "help(math.ceil)" 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "## Développer ses propres modules\n", 175 | "Ecrire des modules Python est très simple. Pour créer un module, créez simplement un nouveau fichier .py avec le nom du module, puis importez-le à l'aide du nom de fichier Python (sans l'extension .py) à l'aide de la commande import.\n", 176 | "\n", 177 | "## Rédaction de paquets (packages)\n", 178 | "Les packages sont des espaces de noms qui contiennent eux-mêmes plusieurs packages et modules. Ce ne sont en fait que des répertoires, mais avec un petit quelque chose en plus.\n", 179 | "\n", 180 | "Chaque paquet en Python est un répertoire qui DOIT contenir un fichier spécial appelé **\\__init\\__.Py**. Ce fichier peut être vide mais il indique que ce répertoire est en fait un paquet Python, il peut donc être importé de la même façon qu'un module peut l'être.\n", 181 | "\n", 182 | "Si nous créons un répertoire nommé toto, qui sera donc le nom du paquet, nous pouvons créer un module dans ce paquet appelé bar. Nous ne devons pas oublier d'ajouter le fichier **\\__init\\__.Py** dans le répertoire toto.\n", 183 | "\n", 184 | "Pour utiliser le module bar, nous pouvons l'importer de deux façons:" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": null, 190 | "metadata": { 191 | "collapsed": true 192 | }, 193 | "outputs": [], 194 | "source": [ 195 | "# Juste un exemple, cela ne fonctionne pas\n", 196 | "import toto.bar" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": { 203 | "collapsed": false 204 | }, 205 | "outputs": [], 206 | "source": [ 207 | "# OU on peut faire ainsi\n", 208 | "from toto import bar" 209 | ] 210 | }, 211 | { 212 | "cell_type": "markdown", 213 | "metadata": {}, 214 | "source": [ 215 | "Dans la première méthode, nous devons utiliser le préfixe foo chaque fois que nous accédons au module bar. Dans la deuxième méthode, nous ne le faisons pas, parce que nous importons ce module dans l'espace de nom de notre module.\n", 216 | "\n", 217 | "Le fichier **\\__init\\__.Py** peut également déterminer quels sont les modules qui seront exportés comme API par le package, tout en conservant les autres modules internes. Il suffit pour cela de placer une variable **\\__all\\__**, comme ceci:" 218 | ] 219 | }, 220 | { 221 | "cell_type": "code", 222 | "execution_count": null, 223 | "metadata": { 224 | "collapsed": true 225 | }, 226 | "outputs": [], 227 | "source": [ 228 | "__init__.py:\n", 229 | "\n", 230 | "__all__ = [\"bar\"]" 231 | ] 232 | } 233 | ], 234 | "metadata": { 235 | "anaconda-cloud": {}, 236 | "kernelspec": { 237 | "display_name": "Python [default]", 238 | "language": "python", 239 | "name": "python3" 240 | }, 241 | "language_info": { 242 | "codemirror_mode": { 243 | "name": "ipython", 244 | "version": 3 245 | }, 246 | "file_extension": ".py", 247 | "mimetype": "text/x-python", 248 | "name": "python", 249 | "nbconvert_exporter": "python", 250 | "pygments_lexer": "ipython3", 251 | "version": "3.5.2" 252 | } 253 | }, 254 | "nbformat": 4, 255 | "nbformat_minor": 0 256 | } 257 | -------------------------------------------------------------------------------- /Partie9_Fonctions_Intégrées/.ipynb_checkpoints/All() et any()-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# all() et any()" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "all() et any() sont des fonctions intégrées de Python qui permettent de vérifier facilement l'état de booléen dans un objet itérable. All() renverra True si tous les éléments de l'objet iterable sont True. Elle est équivalente au code de cette fonction:\n", 15 | "\n", 16 | " def all(iterable):\n", 17 | " for element in iterable:\n", 18 | " if not element:\n", 19 | " return False\n", 20 | " return True\n", 21 | " \n", 22 | "any() renvoie True si au moins un des élements de l'objet iterable est True. Elle est équivalente au code de cette fonction:\n", 23 | "\n", 24 | " def any(iterable):\n", 25 | " for element in iterable:\n", 26 | " if element:\n", 27 | " return True\n", 28 | " return False\n", 29 | " " 30 | ] 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "metadata": {}, 35 | "source": [ 36 | "Voyons quelques exemples de ces fonctions. Ils son assez simples:" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 4, 42 | "metadata": { 43 | "collapsed": true 44 | }, 45 | "outputs": [], 46 | "source": [ 47 | "lst = [True,True,False,True]" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 5, 53 | "metadata": { 54 | "collapsed": false 55 | }, 56 | "outputs": [ 57 | { 58 | "data": { 59 | "text/plain": [ 60 | "False" 61 | ] 62 | }, 63 | "execution_count": 5, 64 | "metadata": {}, 65 | "output_type": "execute_result" 66 | } 67 | ], 68 | "source": [ 69 | "all(lst)" 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "Renvoie False parce qu'un élément n'est pas True." 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": 6, 82 | "metadata": { 83 | "collapsed": false 84 | }, 85 | "outputs": [ 86 | { 87 | "data": { 88 | "text/plain": [ 89 | "True" 90 | ] 91 | }, 92 | "execution_count": 6, 93 | "metadata": {}, 94 | "output_type": "execute_result" 95 | } 96 | ], 97 | "source": [ 98 | "any(lst)" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "Renvoie True parce qu'au moins un des éléments est True" 106 | ] 107 | }, 108 | { 109 | "cell_type": "markdown", 110 | "metadata": {}, 111 | "source": [ 112 | "C'est fait, vous devez maintenant être capable d'utiliser any() et all() dans votre code." 113 | ] 114 | } 115 | ], 116 | "metadata": { 117 | "anaconda-cloud": {}, 118 | "kernelspec": { 119 | "display_name": "Python [default]", 120 | "language": "python", 121 | "name": "python3" 122 | }, 123 | "language_info": { 124 | "codemirror_mode": { 125 | "name": "ipython", 126 | "version": 3 127 | }, 128 | "file_extension": ".py", 129 | "mimetype": "text/x-python", 130 | "name": "python", 131 | "nbconvert_exporter": "python", 132 | "pygments_lexer": "ipython3", 133 | "version": "3.5.2" 134 | } 135 | }, 136 | "nbformat": 4, 137 | "nbformat_minor": 0 138 | } 139 | -------------------------------------------------------------------------------- /Partie9_Fonctions_Intégrées/.ipynb_checkpoints/Controle de connaissances sur les fonctions intégrées-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Contrôle de connaissances sur les fonctions intégrées\n", 8 | "\n", 9 | "### Pour ce test, vous devrez utiliser les fonctions intégrées de Python pour écrire les fonctions demandées en une seule ligne." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "### 1er problème\n", 17 | "\n", 18 | "Utilisez map() pour créer une fonction qui donne la longueur de chaque mot dans une phrase\n", 19 | "(mots séparés par des espaces) et renvoie les valeurs dans une liste.\n", 20 | "\n", 21 | "La fonction aura une chaîne en entrée, et la liste d'entiers en sortie." 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 1, 27 | "metadata": { 28 | "collapsed": true 29 | }, 30 | "outputs": [], 31 | "source": [ 32 | "def longueur_mots(phrase):\n", 33 | " pass" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 6, 39 | "metadata": { 40 | "collapsed": false 41 | }, 42 | "outputs": [ 43 | { 44 | "data": { 45 | "text/plain": [ 46 | "[6, 3, 2, 8, 2, 3, 4, 4, 5, 6]" 47 | ] 48 | }, 49 | "execution_count": 6, 50 | "metadata": {}, 51 | "output_type": "execute_result" 52 | } 53 | ], 54 | "source": [ 55 | "longueur_mots(\"Quelle est la longueur de ces mots dans cette phrase\")" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "### 2e problème\n", 63 | "\n", 64 | "Utilisez filter() pour renvoyer les mots d'une liste qui commencent par une lettre particulière donnée également en paramètre." 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 2, 70 | "metadata": { 71 | "collapsed": true 72 | }, 73 | "outputs": [], 74 | "source": [ 75 | "def filtre_mots(liste_mots, lettre):\n", 76 | " pass" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": 12, 82 | "metadata": { 83 | "collapsed": false 84 | }, 85 | "outputs": [ 86 | { 87 | "data": { 88 | "text/plain": [ 89 | "['chat', 'chien', 'cheval', 'canard']" 90 | ] 91 | }, 92 | "execution_count": 12, 93 | "metadata": {}, 94 | "output_type": "execute_result" 95 | } 96 | ], 97 | "source": [ 98 | "l = ['poisson','chat','chien','hamster','cheval','vache','canard','hérisson','poule']\n", 99 | "list(filtre_mots(l,'c'))" 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "### 3e problème\n", 107 | "\n", 108 | "Utilisez zip() et la compréhension de liste pour renvoyer une liste de même longueur pour laquelle chaque valeur est le résultat de la concaténation des valeurs des listes données en paramètre, séparées par un connecteur.\n", 109 | "\n", 110 | "Regardez l'exemple ci-dessous :" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 3, 116 | "metadata": { 117 | "collapsed": true 118 | }, 119 | "outputs": [], 120 | "source": [ 121 | "def assemble(L1, L2, connecteur):\n", 122 | " pass" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 16, 128 | "metadata": { 129 | "collapsed": false 130 | }, 131 | "outputs": [ 132 | { 133 | "data": { 134 | "text/plain": [ 135 | "['A-a', 'B-b']" 136 | ] 137 | }, 138 | "execution_count": 16, 139 | "metadata": {}, 140 | "output_type": "execute_result" 141 | } 142 | ], 143 | "source": [ 144 | "assemble(['A','B'],['a','b'],'-')" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "### 4e problème\n", 152 | "\n", 153 | "Utilisez enumerate() et d'autres compétences pour renvoyer un dictionnaire qui a les valeurs de la liste comme clefs et l'index de ces entrées comme valeurs. Vous pouvez assumer qu'une valeur n'apparait qu'une seule fois dans une liste donnée." 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": 17, 159 | "metadata": { 160 | "collapsed": true 161 | }, 162 | "outputs": [], 163 | "source": [ 164 | "def d_list(L):\n", 165 | " pass" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": 18, 171 | "metadata": { 172 | "collapsed": false 173 | }, 174 | "outputs": [ 175 | { 176 | "data": { 177 | "text/plain": [ 178 | "{'a': 0, 'b': 1, 'c': 2}" 179 | ] 180 | }, 181 | "execution_count": 18, 182 | "metadata": {}, 183 | "output_type": "execute_result" 184 | } 185 | ], 186 | "source": [ 187 | "d_list(['a','b','c'])" 188 | ] 189 | }, 190 | { 191 | "cell_type": "markdown", 192 | "metadata": {}, 193 | "source": [ 194 | "### 5e problème\n", 195 | "\n", 196 | "Use enumerate() et d'autres compétences pour renvoyer la valeur du nombre d'items dans une liste pour lesquels la valeur est égale à l'index." 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": 21, 202 | "metadata": { 203 | "collapsed": true 204 | }, 205 | "outputs": [], 206 | "source": [ 207 | "def compte_index(L):\n", 208 | " pass" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 20, 214 | "metadata": { 215 | "collapsed": false 216 | }, 217 | "outputs": [ 218 | { 219 | "data": { 220 | "text/plain": [ 221 | "4" 222 | ] 223 | }, 224 | "execution_count": 20, 225 | "metadata": {}, 226 | "output_type": "execute_result" 227 | } 228 | ], 229 | "source": [ 230 | "compte_index([0,2,2,1,5,5,6,10])" 231 | ] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "metadata": {}, 236 | "source": [ 237 | "# Bravo, joli travail !" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": null, 243 | "metadata": { 244 | "collapsed": true 245 | }, 246 | "outputs": [], 247 | "source": [] 248 | } 249 | ], 250 | "metadata": { 251 | "anaconda-cloud": {}, 252 | "kernelspec": { 253 | "display_name": "Python [default]", 254 | "language": "python", 255 | "name": "python3" 256 | }, 257 | "language_info": { 258 | "codemirror_mode": { 259 | "name": "ipython", 260 | "version": 3 261 | }, 262 | "file_extension": ".py", 263 | "mimetype": "text/x-python", 264 | "name": "python", 265 | "nbconvert_exporter": "python", 266 | "pygments_lexer": "ipython3", 267 | "version": "3.5.2" 268 | } 269 | }, 270 | "nbformat": 4, 271 | "nbformat_minor": 0 272 | } 273 | -------------------------------------------------------------------------------- /Partie9_Fonctions_Intégrées/.ipynb_checkpoints/Solutions du controle de connaissances sur les fonctions intégrées-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Solutions du contrôle de connaissances sur les fonctions intégrées\n", 8 | "\n", 9 | "### Pour ce test, vous devrez utiliser les fonctions intégrées de Python pour écrire les fonctions demandées en une seule ligne." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "### 1er problème\n", 17 | "\n", 18 | "Utilisez map() pour créer une fonction qui donne la longueur de chaque mot dans une phrase\n", 19 | "(mots séparés par des espaces) et renvoie les valeurs dans une liste.\n", 20 | "\n", 21 | "La fonction aura une chaîne en entrée, et la liste d'entiers en sortie." 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 5, 27 | "metadata": { 28 | "collapsed": true 29 | }, 30 | "outputs": [], 31 | "source": [ 32 | "def longueur_mots(phrase):\n", 33 | " \n", 34 | " return list(map(len, phrase.split()))" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 6, 40 | "metadata": { 41 | "collapsed": false 42 | }, 43 | "outputs": [ 44 | { 45 | "data": { 46 | "text/plain": [ 47 | "[6, 3, 2, 8, 2, 3, 4, 4, 5, 6]" 48 | ] 49 | }, 50 | "execution_count": 6, 51 | "metadata": {}, 52 | "output_type": "execute_result" 53 | } 54 | ], 55 | "source": [ 56 | "longueur_mots(\"Quelle est la longueur de ces mots dans cette phrase\")" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "### 2e problème\n", 64 | "\n", 65 | "Utilisez filter() pour renvoyer les mots d'une liste qui commencent par une lettre particulière donnée également en paramètre." 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 11, 71 | "metadata": { 72 | "collapsed": true 73 | }, 74 | "outputs": [], 75 | "source": [ 76 | "def filtre_mots(liste_mots, lettre):\n", 77 | " \n", 78 | " return filter(lambda mot: mot[0]==lettre,liste_mots)" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 12, 84 | "metadata": { 85 | "collapsed": false 86 | }, 87 | "outputs": [ 88 | { 89 | "data": { 90 | "text/plain": [ 91 | "['chat', 'chien', 'cheval', 'canard']" 92 | ] 93 | }, 94 | "execution_count": 12, 95 | "metadata": {}, 96 | "output_type": "execute_result" 97 | } 98 | ], 99 | "source": [ 100 | "l = ['poisson','chat','chien','hamster','cheval','vache','canard','hérisson','poule']\n", 101 | "list(filtre_mots(l,'c'))" 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "### 3e problème\n", 109 | "\n", 110 | "Utilisez zip() et la compréhension de liste pour renvoyer une liste de même longueur pour laquelle chaque valeur est le résultat de la concaténation des valeurs des listes données en paramètre, séparées par un connecteur.\n", 111 | "\n", 112 | "Regardez l'exemple ci-dessous :" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 15, 118 | "metadata": { 119 | "collapsed": true 120 | }, 121 | "outputs": [], 122 | "source": [ 123 | "def assemble(L1, L2, connecteur):\n", 124 | " \n", 125 | " return [mot1+connecteur+mot2 for (mot1,mot2) in zip(L1,L2)]" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 16, 131 | "metadata": { 132 | "collapsed": false 133 | }, 134 | "outputs": [ 135 | { 136 | "data": { 137 | "text/plain": [ 138 | "['A-a', 'B-b']" 139 | ] 140 | }, 141 | "execution_count": 16, 142 | "metadata": {}, 143 | "output_type": "execute_result" 144 | } 145 | ], 146 | "source": [ 147 | "assemble(['A','B'],['a','b'],'-')" 148 | ] 149 | }, 150 | { 151 | "cell_type": "markdown", 152 | "metadata": {}, 153 | "source": [ 154 | "### 4e problème\n", 155 | "\n", 156 | "Utilisez enumerate() et d'autres compétences pour renvoyer un dictionnaire qui a les valeurs de la liste comme clefs et l'index de ces entrées comme valeurs. Vous pouvez assumer qu'une valeur n'apparait qu'une seule fois dans une liste donnée." 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 17, 162 | "metadata": { 163 | "collapsed": true 164 | }, 165 | "outputs": [], 166 | "source": [ 167 | "def d_list(L):\n", 168 | " \n", 169 | " return {clef:valeur for valeur,clef in enumerate(L)}" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": 18, 175 | "metadata": { 176 | "collapsed": false 177 | }, 178 | "outputs": [ 179 | { 180 | "data": { 181 | "text/plain": [ 182 | "{'a': 0, 'b': 1, 'c': 2}" 183 | ] 184 | }, 185 | "execution_count": 18, 186 | "metadata": {}, 187 | "output_type": "execute_result" 188 | } 189 | ], 190 | "source": [ 191 | "d_list(['a','b','c'])" 192 | ] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "metadata": {}, 197 | "source": [ 198 | "### 5e problème\n", 199 | "\n", 200 | "Use enumerate() et d'autres compétences pour renvoyer la valeur du nombre d'items dans une liste pour lesquels la valeur est égale à l'index." 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": 21, 206 | "metadata": { 207 | "collapsed": true 208 | }, 209 | "outputs": [], 210 | "source": [ 211 | "def compte_index(L):\n", 212 | " \n", 213 | " return len([num for compte,num in enumerate(L) if num == compte])" 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": 20, 219 | "metadata": { 220 | "collapsed": false 221 | }, 222 | "outputs": [ 223 | { 224 | "data": { 225 | "text/plain": [ 226 | "4" 227 | ] 228 | }, 229 | "execution_count": 20, 230 | "metadata": {}, 231 | "output_type": "execute_result" 232 | } 233 | ], 234 | "source": [ 235 | "compte_index([0,2,2,1,5,5,6,10])" 236 | ] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "# Bravo, joli travail !" 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": null, 248 | "metadata": { 249 | "collapsed": true 250 | }, 251 | "outputs": [], 252 | "source": [] 253 | } 254 | ], 255 | "metadata": { 256 | "anaconda-cloud": {}, 257 | "kernelspec": { 258 | "display_name": "Python [default]", 259 | "language": "python", 260 | "name": "python3" 261 | }, 262 | "language_info": { 263 | "codemirror_mode": { 264 | "name": "ipython", 265 | "version": 3 266 | }, 267 | "file_extension": ".py", 268 | "mimetype": "text/x-python", 269 | "name": "python", 270 | "nbconvert_exporter": "python", 271 | "pygments_lexer": "ipython3", 272 | "version": "3.5.2" 273 | } 274 | }, 275 | "nbformat": 4, 276 | "nbformat_minor": 0 277 | } 278 | -------------------------------------------------------------------------------- /Partie9_Fonctions_Intégrées/All() et any().ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# all() et any()" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "all() et any() sont des fonctions intégrées de Python qui permettent de vérifier facilement l'état de booléen dans un objet itérable. All() renverra True si tous les éléments de l'objet iterable sont True. Elle est équivalente au code de cette fonction:\n", 15 | "\n", 16 | " def all(iterable):\n", 17 | " for element in iterable:\n", 18 | " if not element:\n", 19 | " return False\n", 20 | " return True\n", 21 | " \n", 22 | "any() renvoie True si au moins un des élements de l'objet iterable est True. Elle est équivalente au code de cette fonction:\n", 23 | "\n", 24 | " def any(iterable):\n", 25 | " for element in iterable:\n", 26 | " if element:\n", 27 | " return True\n", 28 | " return False\n", 29 | " " 30 | ] 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "metadata": {}, 35 | "source": [ 36 | "Voyons quelques exemples de ces fonctions. Ils son assez simples:" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 4, 42 | "metadata": { 43 | "collapsed": true 44 | }, 45 | "outputs": [], 46 | "source": [ 47 | "lst = [True,True,False,True]" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 5, 53 | "metadata": { 54 | "collapsed": false 55 | }, 56 | "outputs": [ 57 | { 58 | "data": { 59 | "text/plain": [ 60 | "False" 61 | ] 62 | }, 63 | "execution_count": 5, 64 | "metadata": {}, 65 | "output_type": "execute_result" 66 | } 67 | ], 68 | "source": [ 69 | "all(lst)" 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "Renvoie False parce qu'un élément n'est pas True." 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": 6, 82 | "metadata": { 83 | "collapsed": false 84 | }, 85 | "outputs": [ 86 | { 87 | "data": { 88 | "text/plain": [ 89 | "True" 90 | ] 91 | }, 92 | "execution_count": 6, 93 | "metadata": {}, 94 | "output_type": "execute_result" 95 | } 96 | ], 97 | "source": [ 98 | "any(lst)" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "Renvoie True parce qu'au moins un des éléments est True" 106 | ] 107 | }, 108 | { 109 | "cell_type": "markdown", 110 | "metadata": {}, 111 | "source": [ 112 | "C'est fait, vous devez maintenant être capable d'utiliser any() et all() dans votre code." 113 | ] 114 | } 115 | ], 116 | "metadata": { 117 | "anaconda-cloud": {}, 118 | "kernelspec": { 119 | "display_name": "Python [default]", 120 | "language": "python", 121 | "name": "python3" 122 | }, 123 | "language_info": { 124 | "codemirror_mode": { 125 | "name": "ipython", 126 | "version": 3 127 | }, 128 | "file_extension": ".py", 129 | "mimetype": "text/x-python", 130 | "name": "python", 131 | "nbconvert_exporter": "python", 132 | "pygments_lexer": "ipython3", 133 | "version": "3.5.2" 134 | } 135 | }, 136 | "nbformat": 4, 137 | "nbformat_minor": 0 138 | } 139 | -------------------------------------------------------------------------------- /Partie9_Fonctions_Intégrées/Complex.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# complex()\n", 8 | "\n", 9 | "Complex() renvoie un nombre complexe avec la valeur *réel + imaginaire * 1j* ou convertit une chaîne ou un nombre en nombre complexe.\n", 10 | "\n", 11 | "Si le premier paramètre est une chaîne, il sera interprété comme un nombre complexe et la fonction doit être appelée sans second paramètre. Le second paramètre ne peut jamais être une chaîne. Chaque argument peut être n'importe quel type numérique (y compris complexe). Si la partie imaginaire est omise, elle est par défaut nulle et le constructeur sert de conversion numérique comme int ou float. Si les deux arguments sont omis, la fonction renvoie 0j.\n", 12 | "\n", 13 | "Si vous faites des mathématiques ou de l'ingénierie qui nécessite des nombres complexes (comme la dynamique, les systèmes de contrôle, ou l'impédance de circuit), c'est un outil utile à avoir en Python.\n", 14 | "\n", 15 | "Voyons quelques exemples:" 16 | ] 17 | }, 18 | { 19 | "cell_type": "code", 20 | "execution_count": 1, 21 | "metadata": { 22 | "collapsed": false 23 | }, 24 | "outputs": [ 25 | { 26 | "data": { 27 | "text/plain": [ 28 | "(2+3j)" 29 | ] 30 | }, 31 | "execution_count": 1, 32 | "metadata": {}, 33 | "output_type": "execute_result" 34 | } 35 | ], 36 | "source": [ 37 | "# Création de 2+3j\n", 38 | "complex(2,3)" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 2, 44 | "metadata": { 45 | "collapsed": false 46 | }, 47 | "outputs": [ 48 | { 49 | "data": { 50 | "text/plain": [ 51 | "(10+1j)" 52 | ] 53 | }, 54 | "execution_count": 2, 55 | "metadata": {}, 56 | "output_type": "execute_result" 57 | } 58 | ], 59 | "source": [ 60 | "complex(10,1)" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "On peut aussi passer une chaine :" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": 1, 73 | "metadata": { 74 | "collapsed": false 75 | }, 76 | "outputs": [ 77 | { 78 | "data": { 79 | "text/plain": [ 80 | "(12+2j)" 81 | ] 82 | }, 83 | "execution_count": 1, 84 | "metadata": {}, 85 | "output_type": "execute_result" 86 | } 87 | ], 88 | "source": [ 89 | "complex('12+2j')" 90 | ] 91 | }, 92 | { 93 | "cell_type": "markdown", 94 | "metadata": {}, 95 | "source": [ 96 | "C'est vraiment tout ce que l'on peut dire pour cette fonction très utile. Gardez cela à l'esprit si vous avez jamais affaire à des nombres complexes en Python !" 97 | ] 98 | } 99 | ], 100 | "metadata": { 101 | "anaconda-cloud": {}, 102 | "kernelspec": { 103 | "display_name": "Python [default]", 104 | "language": "python", 105 | "name": "python3" 106 | }, 107 | "language_info": { 108 | "codemirror_mode": { 109 | "name": "ipython", 110 | "version": 3 111 | }, 112 | "file_extension": ".py", 113 | "mimetype": "text/x-python", 114 | "name": "python", 115 | "nbconvert_exporter": "python", 116 | "pygments_lexer": "ipython3", 117 | "version": "3.5.2" 118 | } 119 | }, 120 | "nbformat": 4, 121 | "nbformat_minor": 0 122 | } 123 | -------------------------------------------------------------------------------- /Partie9_Fonctions_Intégrées/Controle de connaissances sur les fonctions intégrées.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Contrôle de connaissances sur les fonctions intégrées\n", 8 | "\n", 9 | "### Pour ce test, vous devrez utiliser les fonctions intégrées de Python pour écrire les fonctions demandées en une seule ligne." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "### 1er problème\n", 17 | "\n", 18 | "Utilisez map() pour créer une fonction qui donne la longueur de chaque mot dans une phrase\n", 19 | "(mots séparés par des espaces) et renvoie les valeurs dans une liste.\n", 20 | "\n", 21 | "La fonction aura une chaîne en entrée, et la liste d'entiers en sortie." 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 1, 27 | "metadata": { 28 | "collapsed": true 29 | }, 30 | "outputs": [], 31 | "source": [ 32 | "def longueur_mots(phrase):\n", 33 | " pass" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 6, 39 | "metadata": { 40 | "collapsed": false 41 | }, 42 | "outputs": [ 43 | { 44 | "data": { 45 | "text/plain": [ 46 | "[6, 3, 2, 8, 2, 3, 4, 4, 5, 6]" 47 | ] 48 | }, 49 | "execution_count": 6, 50 | "metadata": {}, 51 | "output_type": "execute_result" 52 | } 53 | ], 54 | "source": [ 55 | "longueur_mots(\"Quelle est la longueur de ces mots dans cette phrase\")" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "### 2e problème\n", 63 | "\n", 64 | "Utilisez filter() pour renvoyer les mots d'une liste qui commencent par une lettre particulière donnée également en paramètre." 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 2, 70 | "metadata": { 71 | "collapsed": true 72 | }, 73 | "outputs": [], 74 | "source": [ 75 | "def filtre_mots(liste_mots, lettre):\n", 76 | " pass" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": 12, 82 | "metadata": { 83 | "collapsed": false 84 | }, 85 | "outputs": [ 86 | { 87 | "data": { 88 | "text/plain": [ 89 | "['chat', 'chien', 'cheval', 'canard']" 90 | ] 91 | }, 92 | "execution_count": 12, 93 | "metadata": {}, 94 | "output_type": "execute_result" 95 | } 96 | ], 97 | "source": [ 98 | "l = ['poisson','chat','chien','hamster','cheval','vache','canard','hérisson','poule']\n", 99 | "list(filtre_mots(l,'c'))" 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "### 3e problème\n", 107 | "\n", 108 | "Utilisez zip() et la compréhension de liste pour renvoyer une liste de même longueur pour laquelle chaque valeur est le résultat de la concaténation des valeurs des listes données en paramètre, séparées par un connecteur.\n", 109 | "\n", 110 | "Regardez l'exemple ci-dessous :" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 3, 116 | "metadata": { 117 | "collapsed": true 118 | }, 119 | "outputs": [], 120 | "source": [ 121 | "def assemble(L1, L2, connecteur):\n", 122 | " pass" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 16, 128 | "metadata": { 129 | "collapsed": false 130 | }, 131 | "outputs": [ 132 | { 133 | "data": { 134 | "text/plain": [ 135 | "['A-a', 'B-b']" 136 | ] 137 | }, 138 | "execution_count": 16, 139 | "metadata": {}, 140 | "output_type": "execute_result" 141 | } 142 | ], 143 | "source": [ 144 | "assemble(['A','B'],['a','b'],'-')" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "### 4e problème\n", 152 | "\n", 153 | "Utilisez enumerate() et d'autres compétences pour renvoyer un dictionnaire qui a les valeurs de la liste comme clefs et l'index de ces entrées comme valeurs. Vous pouvez assumer qu'une valeur n'apparait qu'une seule fois dans une liste donnée." 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": 17, 159 | "metadata": { 160 | "collapsed": true 161 | }, 162 | "outputs": [], 163 | "source": [ 164 | "def d_list(L):\n", 165 | " pass" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": 18, 171 | "metadata": { 172 | "collapsed": false 173 | }, 174 | "outputs": [ 175 | { 176 | "data": { 177 | "text/plain": [ 178 | "{'a': 0, 'b': 1, 'c': 2}" 179 | ] 180 | }, 181 | "execution_count": 18, 182 | "metadata": {}, 183 | "output_type": "execute_result" 184 | } 185 | ], 186 | "source": [ 187 | "d_list(['a','b','c'])" 188 | ] 189 | }, 190 | { 191 | "cell_type": "markdown", 192 | "metadata": {}, 193 | "source": [ 194 | "### 5e problème\n", 195 | "\n", 196 | "Use enumerate() et d'autres compétences pour renvoyer la valeur du nombre d'items dans une liste pour lesquels la valeur est égale à l'index." 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": 21, 202 | "metadata": { 203 | "collapsed": true 204 | }, 205 | "outputs": [], 206 | "source": [ 207 | "def compte_index(L):\n", 208 | " pass" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 20, 214 | "metadata": { 215 | "collapsed": false 216 | }, 217 | "outputs": [ 218 | { 219 | "data": { 220 | "text/plain": [ 221 | "4" 222 | ] 223 | }, 224 | "execution_count": 20, 225 | "metadata": {}, 226 | "output_type": "execute_result" 227 | } 228 | ], 229 | "source": [ 230 | "compte_index([0,2,2,1,5,5,6,10])" 231 | ] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "metadata": {}, 236 | "source": [ 237 | "# Bravo, joli travail !" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": null, 243 | "metadata": { 244 | "collapsed": true 245 | }, 246 | "outputs": [], 247 | "source": [] 248 | } 249 | ], 250 | "metadata": { 251 | "anaconda-cloud": {}, 252 | "kernelspec": { 253 | "display_name": "Python [default]", 254 | "language": "python", 255 | "name": "python3" 256 | }, 257 | "language_info": { 258 | "codemirror_mode": { 259 | "name": "ipython", 260 | "version": 3 261 | }, 262 | "file_extension": ".py", 263 | "mimetype": "text/x-python", 264 | "name": "python", 265 | "nbconvert_exporter": "python", 266 | "pygments_lexer": "ipython3", 267 | "version": "3.5.2" 268 | } 269 | }, 270 | "nbformat": 4, 271 | "nbformat_minor": 0 272 | } 273 | -------------------------------------------------------------------------------- /Partie9_Fonctions_Intégrées/Enumerate.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# enumerate()\n", 8 | "\n", 9 | "Dans cette leçon, nous allons voir une fonction intégrée extrêmement utile : enumerate(). Elle permet de garder un décompte en itérant à travers un objet. Pour ce faire, elle renvoie un tuple sous la forme (compteur, élement). La fonction elle-même est équivalente à :\n", 10 | "\n", 11 | " def enumerate(sequence, start=0):\n", 12 | " n = start\n", 13 | " for element in sequence:\n", 14 | " yield n, element\n", 15 | " n += 1\n", 16 | "\n", 17 | "## Exemple" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 1, 23 | "metadata": { 24 | "collapsed": false 25 | }, 26 | "outputs": [ 27 | { 28 | "name": "stdout", 29 | "output_type": "stream", 30 | "text": [ 31 | "0 a\n", 32 | "1 b\n", 33 | "2 c\n" 34 | ] 35 | } 36 | ], 37 | "source": [ 38 | "lst = ['a','b','c']\n", 39 | "\n", 40 | "for nombre,item in enumerate(lst):\n", 41 | " print (nombre, item)" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "Enumerate() est particulièrement utile lorsque vous devez garder en mémoire une sorte de suivi. Par exemple:" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 4, 54 | "metadata": { 55 | "collapsed": false 56 | }, 57 | "outputs": [ 58 | { 59 | "name": "stdout", 60 | "output_type": "stream", 61 | "text": [ 62 | "a\n", 63 | "b\n" 64 | ] 65 | } 66 | ], 67 | "source": [ 68 | "for compte,item in enumerate(lst):\n", 69 | " if compte >= 2:\n", 70 | " break\n", 71 | " else:\n", 72 | " print (item)" 73 | ] 74 | }, 75 | { 76 | "cell_type": "markdown", 77 | "metadata": {}, 78 | "source": [ 79 | "Bravo ! Vous devez maintenant avoir une bonne compréhenson de enumerate et des pssibilités qu'elle offre." 80 | ] 81 | } 82 | ], 83 | "metadata": { 84 | "anaconda-cloud": {}, 85 | "kernelspec": { 86 | "display_name": "Python [default]", 87 | "language": "python", 88 | "name": "python3" 89 | }, 90 | "language_info": { 91 | "codemirror_mode": { 92 | "name": "ipython", 93 | "version": 3 94 | }, 95 | "file_extension": ".py", 96 | "mimetype": "text/x-python", 97 | "name": "python", 98 | "nbconvert_exporter": "python", 99 | "pygments_lexer": "ipython3", 100 | "version": "3.5.2" 101 | } 102 | }, 103 | "nbformat": 4, 104 | "nbformat_minor": 0 105 | } 106 | -------------------------------------------------------------------------------- /Partie9_Fonctions_Intégrées/Filter.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Filter\n", 8 | "\n", 9 | "La fonction filter(fonction, liste) procure un moyen simple de filtrer tous les éléments d'un objet iterable, pour lequel la fonction testée renvoie True.\n", 10 | "\n", 11 | "La fonction filter(fonction(), l) prend comme premier argument une fonction. Elle renvoie une valeur booléenne (True ou False). Cette fonction sera appliquée à chaque élément de l'objet itérable. L'élément de l'objet iterable ne sera inclus dans le résultat que si la fonction renvoie True.\n", 12 | "\n", 13 | "Voyons quelques exemples:" 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": 2, 19 | "metadata": { 20 | "collapsed": true 21 | }, 22 | "outputs": [], 23 | "source": [ 24 | "# Créons d'abord une fonction\n", 25 | "def verifie_pair(num):\n", 26 | " if num%2 ==0:\n", 27 | " return True" 28 | ] 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "metadata": {}, 33 | "source": [ 34 | "Maintenant, nous allons filtrer une liste de numéros. Note: mettre la fonction dans le filtre sans aucune parenthèse peut sembler étrange, mais gardez à l'esprit que les fonctions sont aussi des objets." 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 4, 40 | "metadata": { 41 | "collapsed": false 42 | }, 43 | "outputs": [ 44 | { 45 | "data": { 46 | "text/plain": [ 47 | "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]" 48 | ] 49 | }, 50 | "execution_count": 4, 51 | "metadata": {}, 52 | "output_type": "execute_result" 53 | } 54 | ], 55 | "source": [ 56 | "lst =range(20)\n", 57 | "\n", 58 | "list(filter(verifie_pair,lst))" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "Filter() est souvent utilisé avec les fonctions lambda, parce que nous utilisons généralement filter pour un petit travail rapide pour lequel nous ne voulons pas écrire une fonction complètement. Reprenons l'exemple ci-dessus en utilisant une expression lambda:" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 6, 71 | "metadata": { 72 | "collapsed": false 73 | }, 74 | "outputs": [ 75 | { 76 | "data": { 77 | "text/plain": [ 78 | "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]" 79 | ] 80 | }, 81 | "execution_count": 6, 82 | "metadata": {}, 83 | "output_type": "execute_result" 84 | } 85 | ], 86 | "source": [ 87 | "list(filter(lambda x: x%2==0,lst))" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "Bravo ! Vous devez maintenant avoir une bonne compréhension de filter() et comment l'utiliser dans votre code!" 95 | ] 96 | } 97 | ], 98 | "metadata": { 99 | "anaconda-cloud": {}, 100 | "kernelspec": { 101 | "display_name": "Python [default]", 102 | "language": "python", 103 | "name": "python3" 104 | }, 105 | "language_info": { 106 | "codemirror_mode": { 107 | "name": "ipython", 108 | "version": 3 109 | }, 110 | "file_extension": ".py", 111 | "mimetype": "text/x-python", 112 | "name": "python", 113 | "nbconvert_exporter": "python", 114 | "pygments_lexer": "ipython3", 115 | "version": "3.5.2" 116 | } 117 | }, 118 | "nbformat": 4, 119 | "nbformat_minor": 0 120 | } 121 | -------------------------------------------------------------------------------- /Partie9_Fonctions_Intégrées/Map.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# map()\n", 8 | "\n", 9 | "map() est une fonction qui prend deux arguments: une fonction et une séquence itérables. Sous la forme:\n", 10 | " map(fonction, séquence)\n", 11 | " \n", 12 | "Le premier argument est le nom d'une fonction et le second une séquence (par exemple une liste). La fonction map() applique la fonction passée en entrée à tous les éléments de la séquence. Elle renvoie une nouvelle liste contenant les éléments modifiés par la fonction.\n", 13 | "\n", 14 | "Quand nous avons vu la compréhension de la liste, nous avons créé une petite expression pour convertir Fahrenheit en Celsius. Nous pouvons refaire la même chose avec map().\n", 15 | "\n", 16 | "Nous allons commencer par deux fonctions:" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 30, 22 | "metadata": { 23 | "collapsed": true 24 | }, 25 | "outputs": [], 26 | "source": [ 27 | "def fahrenheit(T):\n", 28 | " return ((float(9)/5)*T + 32)\n", 29 | "def celsius(T):\n", 30 | " return (float(5)/9)*(T-32)" 31 | ] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "metadata": {}, 36 | "source": [ 37 | "Voyons map() en action:" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 36, 43 | "metadata": { 44 | "collapsed": false 45 | }, 46 | "outputs": [ 47 | { 48 | "data": { 49 | "text/plain": [ 50 | "[32.0, 72.5, 104.0, 212.0]" 51 | ] 52 | }, 53 | "execution_count": 36, 54 | "metadata": {}, 55 | "output_type": "execute_result" 56 | } 57 | ], 58 | "source": [ 59 | "température = [0, 22.5, 40,100]\n", 60 | "\n", 61 | "F_temps = list(map(fahrenheit, température))\n", 62 | "\n", 63 | "# Affichage\n", 64 | "F_temps" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 38, 70 | "metadata": { 71 | "collapsed": false 72 | }, 73 | "outputs": [ 74 | { 75 | "data": { 76 | "text/plain": [ 77 | "[0.0, 22.5, 40.0, 100.0]" 78 | ] 79 | }, 80 | "execution_count": 38, 81 | "metadata": {}, 82 | "output_type": "execute_result" 83 | } 84 | ], 85 | "source": [ 86 | "# Conversion inverse\n", 87 | "\n", 88 | "list(map(celsius, F_temps))" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": {}, 94 | "source": [ 95 | "Dans l'exemple ci-dessus, nous n'avons pas utilisé d'expression lambda. En utilisant une expression lambda, nous n'aurions pas eu à définir les fonctions fahrenheit() et celsius()." 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 40, 101 | "metadata": { 102 | "collapsed": false 103 | }, 104 | "outputs": [ 105 | { 106 | "data": { 107 | "text/plain": [ 108 | "[0.0, 22.5, 40.0, 100.0]" 109 | ] 110 | }, 111 | "execution_count": 40, 112 | "metadata": {}, 113 | "output_type": "execute_result" 114 | } 115 | ], 116 | "source": [ 117 | "list(map(lambda x: (5.0/9)*(x - 32), F_temps))" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "Bravo ! Nous avons obtenu le même résultat ! \n", 125 | "map() est très couramment utilisée avec des expressions lambda car le but final de map() est d'économiser les efforts pour écrire du code et cela permet d'éviter de créer des boucles." 126 | ] 127 | }, 128 | { 129 | "cell_type": "markdown", 130 | "metadata": {}, 131 | "source": [ 132 | "map() peut être appliqué à plusieurs objets iterable mais qui doivent avoir la même longueur.\n", 133 | "\n", 134 | "\n", 135 | "Par exemple, si nous travaillons avec deux listes, map() appliquera la fonction lambda aux éléments de la liste d'arguments, c'est-à-dire qu'elle s'appliquera d'abord aux éléments avec l'indice 0, puis aux éléments avec le 1er indice et ainsi de suite jusqu'à ce que n-ième indice soit atteint.\n", 136 | "\n", 137 | "Par exemple, voyons comment utiliser map() avec une expression lambda à deux listes:" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": 42, 143 | "metadata": { 144 | "collapsed": false 145 | }, 146 | "outputs": [ 147 | { 148 | "data": { 149 | "text/plain": [ 150 | "[6, 8, 10, 12]" 151 | ] 152 | }, 153 | "execution_count": 42, 154 | "metadata": {}, 155 | "output_type": "execute_result" 156 | } 157 | ], 158 | "source": [ 159 | "a = [1,2,3,4]\n", 160 | "b = [5,6,7,8]\n", 161 | "c = [9,10,11,12]\n", 162 | "\n", 163 | "list(map(lambda x,y:x+y,a,b))" 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": 13, 169 | "metadata": { 170 | "collapsed": false 171 | }, 172 | "outputs": [ 173 | { 174 | "data": { 175 | "text/plain": [ 176 | "[15, 18, 21, 24]" 177 | ] 178 | }, 179 | "execution_count": 13, 180 | "metadata": {}, 181 | "output_type": "execute_result" 182 | } 183 | ], 184 | "source": [ 185 | "# Maintenant avec trois listes\n", 186 | "list(map(lambda x,y,z:x+y+z, a,b,c)" 187 | ] 188 | }, 189 | { 190 | "cell_type": "markdown", 191 | "metadata": {}, 192 | "source": [ 193 | "Nous pouvons voir dans l'exemple ci-dessus que le paramètre x obtient ses valeurs de la liste a, alors que y obtient ses valeurs de b et z de la liste c. Vous pouvez maintenant développer votre propre exemple pour vous assurer de bien comprendre comment utiliser map() avec plus d'un b-objet itérable.\n", 194 | "\n", 195 | "Bravo ! Vous devez maintenant avoir une connaissance de base de la fonction map()." 196 | ] 197 | } 198 | ], 199 | "metadata": { 200 | "anaconda-cloud": {}, 201 | "kernelspec": { 202 | "display_name": "Python [default]", 203 | "language": "python", 204 | "name": "python3" 205 | }, 206 | "language_info": { 207 | "codemirror_mode": { 208 | "name": "ipython", 209 | "version": 3 210 | }, 211 | "file_extension": ".py", 212 | "mimetype": "text/x-python", 213 | "name": "python", 214 | "nbconvert_exporter": "python", 215 | "pygments_lexer": "ipython3", 216 | "version": "3.5.2" 217 | } 218 | }, 219 | "nbformat": 4, 220 | "nbformat_minor": 0 221 | } 222 | -------------------------------------------------------------------------------- /Partie9_Fonctions_Intégrées/Solutions du controle de connaissances sur les fonctions intégrées.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Solutions du contrôle de connaissances sur les fonctions intégrées\n", 8 | "\n", 9 | "### Pour ce test, vous devrez utiliser les fonctions intégrées de Python pour écrire les fonctions demandées en une seule ligne." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "### 1er problème\n", 17 | "\n", 18 | "Utilisez map() pour créer une fonction qui donne la longueur de chaque mot dans une phrase\n", 19 | "(mots séparés par des espaces) et renvoie les valeurs dans une liste.\n", 20 | "\n", 21 | "La fonction aura une chaîne en entrée, et la liste d'entiers en sortie." 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 5, 27 | "metadata": { 28 | "collapsed": true 29 | }, 30 | "outputs": [], 31 | "source": [ 32 | "def longueur_mots(phrase):\n", 33 | " \n", 34 | " return list(map(len, phrase.split()))" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 6, 40 | "metadata": { 41 | "collapsed": false 42 | }, 43 | "outputs": [ 44 | { 45 | "data": { 46 | "text/plain": [ 47 | "[6, 3, 2, 8, 2, 3, 4, 4, 5, 6]" 48 | ] 49 | }, 50 | "execution_count": 6, 51 | "metadata": {}, 52 | "output_type": "execute_result" 53 | } 54 | ], 55 | "source": [ 56 | "longueur_mots(\"Quelle est la longueur de ces mots dans cette phrase\")" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "### 2e problème\n", 64 | "\n", 65 | "Utilisez filter() pour renvoyer les mots d'une liste qui commencent par une lettre particulière donnée également en paramètre." 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 11, 71 | "metadata": { 72 | "collapsed": true 73 | }, 74 | "outputs": [], 75 | "source": [ 76 | "def filtre_mots(liste_mots, lettre):\n", 77 | " \n", 78 | " return filter(lambda mot: mot[0]==lettre,liste_mots)" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 12, 84 | "metadata": { 85 | "collapsed": false 86 | }, 87 | "outputs": [ 88 | { 89 | "data": { 90 | "text/plain": [ 91 | "['chat', 'chien', 'cheval', 'canard']" 92 | ] 93 | }, 94 | "execution_count": 12, 95 | "metadata": {}, 96 | "output_type": "execute_result" 97 | } 98 | ], 99 | "source": [ 100 | "l = ['poisson','chat','chien','hamster','cheval','vache','canard','hérisson','poule']\n", 101 | "list(filtre_mots(l,'c'))" 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "### 3e problème\n", 109 | "\n", 110 | "Utilisez zip() et la compréhension de liste pour renvoyer une liste de même longueur pour laquelle chaque valeur est le résultat de la concaténation des valeurs des listes données en paramètre, séparées par un connecteur.\n", 111 | "\n", 112 | "Regardez l'exemple ci-dessous :" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 15, 118 | "metadata": { 119 | "collapsed": true 120 | }, 121 | "outputs": [], 122 | "source": [ 123 | "def assemble(L1, L2, connecteur):\n", 124 | " \n", 125 | " return [mot1+connecteur+mot2 for (mot1,mot2) in zip(L1,L2)]" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 16, 131 | "metadata": { 132 | "collapsed": false 133 | }, 134 | "outputs": [ 135 | { 136 | "data": { 137 | "text/plain": [ 138 | "['A-a', 'B-b']" 139 | ] 140 | }, 141 | "execution_count": 16, 142 | "metadata": {}, 143 | "output_type": "execute_result" 144 | } 145 | ], 146 | "source": [ 147 | "assemble(['A','B'],['a','b'],'-')" 148 | ] 149 | }, 150 | { 151 | "cell_type": "markdown", 152 | "metadata": {}, 153 | "source": [ 154 | "### 4e problème\n", 155 | "\n", 156 | "Utilisez enumerate() et d'autres compétences pour renvoyer un dictionnaire qui a les valeurs de la liste comme clefs et l'index de ces entrées comme valeurs. Vous pouvez assumer qu'une valeur n'apparait qu'une seule fois dans une liste donnée." 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 17, 162 | "metadata": { 163 | "collapsed": true 164 | }, 165 | "outputs": [], 166 | "source": [ 167 | "def d_list(L):\n", 168 | " \n", 169 | " return {clef:valeur for valeur,clef in enumerate(L)}" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": 18, 175 | "metadata": { 176 | "collapsed": false 177 | }, 178 | "outputs": [ 179 | { 180 | "data": { 181 | "text/plain": [ 182 | "{'a': 0, 'b': 1, 'c': 2}" 183 | ] 184 | }, 185 | "execution_count": 18, 186 | "metadata": {}, 187 | "output_type": "execute_result" 188 | } 189 | ], 190 | "source": [ 191 | "d_list(['a','b','c'])" 192 | ] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "metadata": {}, 197 | "source": [ 198 | "### 5e problème\n", 199 | "\n", 200 | "Use enumerate() et d'autres compétences pour renvoyer la valeur du nombre d'items dans une liste pour lesquels la valeur est égale à l'index." 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": 21, 206 | "metadata": { 207 | "collapsed": true 208 | }, 209 | "outputs": [], 210 | "source": [ 211 | "def compte_index(L):\n", 212 | " \n", 213 | " return len([num for compte,num in enumerate(L) if num == compte])" 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": 20, 219 | "metadata": { 220 | "collapsed": false 221 | }, 222 | "outputs": [ 223 | { 224 | "data": { 225 | "text/plain": [ 226 | "4" 227 | ] 228 | }, 229 | "execution_count": 20, 230 | "metadata": {}, 231 | "output_type": "execute_result" 232 | } 233 | ], 234 | "source": [ 235 | "compte_index([0,2,2,1,5,5,6,10])" 236 | ] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "# Bravo, joli travail !" 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": null, 248 | "metadata": { 249 | "collapsed": true 250 | }, 251 | "outputs": [], 252 | "source": [] 253 | } 254 | ], 255 | "metadata": { 256 | "anaconda-cloud": {}, 257 | "kernelspec": { 258 | "display_name": "Python [default]", 259 | "language": "python", 260 | "name": "python3" 261 | }, 262 | "language_info": { 263 | "codemirror_mode": { 264 | "name": "ipython", 265 | "version": 3 266 | }, 267 | "file_extension": ".py", 268 | "mimetype": "text/x-python", 269 | "name": "python", 270 | "nbconvert_exporter": "python", 271 | "pygments_lexer": "ipython3", 272 | "version": "3.5.2" 273 | } 274 | }, 275 | "nbformat": 4, 276 | "nbformat_minor": 0 277 | } 278 | -------------------------------------------------------------------------------- /Partie9_Fonctions_Intégrées/Zip.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "nbpresent": { 7 | "id": "627f100d-de61-4400-adfd-c91f971571af" 8 | } 9 | }, 10 | "source": [ 11 | "# zip\n", 12 | "\n", 13 | "Zip() construit un itérateur qui agrège des éléments de chacun des iterables.\n", 14 | "\n", 15 | "Renvoie une séquence de tuples, où le tuple n contient l'élément n de chacun des arguments, séquence ou objet iterable. La séquence s'arrête lorsque la plus petite séquence itérative est épuisée. Avec un seul argument séquentiel, elle renvoie un itérateur de tuples à 1 élément. Sans arguments, elle retourne une séquence vide.\n", 16 | "\n", 17 | "Zip () est équivalent à:\n", 18 | "\n", 19 | " def zip(*iterables):\n", 20 | " # zip('ABCD', 'xy') --> Ax By\n", 21 | " sentinelle = object()\n", 22 | " items = [iter(it) for it in iterables]\n", 23 | " while items:\n", 24 | " resultat = []\n", 25 | " for it in items:\n", 26 | " elem = next(it, sentinelle)\n", 27 | " if elem is sentinelle:\n", 28 | " return\n", 29 | " result.append(elem)\n", 30 | " yield tuple(resultat)\n", 31 | " \n", 32 | "Zip() ne doit être utilisé avec des entrées de longueur inégale que lorsque vous ne vous souciez pas des valeurs de fin de tableau qui n'ont pas de correspondance, et qui donc disparaitront.\n", 33 | "\n", 34 | "Voyons cela en action dans quelques exemples:\n", 35 | "\n", 36 | "## Exemples" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 5, 42 | "metadata": { 43 | "collapsed": false, 44 | "nbpresent": { 45 | "id": "4118fcae-7f57-4148-8b36-8c39bbb90f31" 46 | } 47 | }, 48 | "outputs": [ 49 | { 50 | "data": { 51 | "text/plain": [ 52 | "[(1, 4), (2, 5), (3, 6)]" 53 | ] 54 | }, 55 | "execution_count": 5, 56 | "metadata": {}, 57 | "output_type": "execute_result" 58 | } 59 | ], 60 | "source": [ 61 | "x = [1,2,3]\n", 62 | "y = [4,5,6]\n", 63 | "\n", 64 | "list(zip(x,y))" 65 | ] 66 | }, 67 | { 68 | "cell_type": "markdown", 69 | "metadata": { 70 | "nbpresent": { 71 | "id": "52807d2f-df45-4fef-ae3d-f5e7783e8e3d" 72 | } 73 | }, 74 | "source": [ 75 | "Remarquez comment les tuples sont renvoyés. Que se passe-t-il quand une séquence est plus longue que l'autre?" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 6, 81 | "metadata": { 82 | "collapsed": false, 83 | "nbpresent": { 84 | "id": "81d588f9-8dcf-4b07-8c7a-99a0fe4dc22f" 85 | } 86 | }, 87 | "outputs": [ 88 | { 89 | "data": { 90 | "text/plain": [ 91 | "[(1, 4), (2, 5), (3, 6)]" 92 | ] 93 | }, 94 | "execution_count": 6, 95 | "metadata": {}, 96 | "output_type": "execute_result" 97 | } 98 | ], 99 | "source": [ 100 | "x = [1,2,3]\n", 101 | "y = [4,5,6,7,8]\n", 102 | "\n", 103 | "list(zip(x,y))" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": { 109 | "nbpresent": { 110 | "id": "d29384c8-06aa-48a5-9aaa-967a516c3c2f" 111 | } 112 | }, 113 | "source": [ 114 | "Remarquez comment le zip est défini par la longueur de la plus courte des séquences en entrée. Il est généralement conseillé de ne pas utiliser zip avec des séquences de longueur inégale à moins d'être absolument certain que vous n'avez pas besoin de tous les appariements.\n", 115 | "\n", 116 | "On peut avoir plus de deux itérables en entrée, par exemple :" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 4, 122 | "metadata": { 123 | "collapsed": false 124 | }, 125 | "outputs": [ 126 | { 127 | "data": { 128 | "text/plain": [ 129 | "[(1, 4, 7), (2, 5, 8), (3, 6, 9)]" 130 | ] 131 | }, 132 | "execution_count": 4, 133 | "metadata": {}, 134 | "output_type": "execute_result" 135 | } 136 | ], 137 | "source": [ 138 | "x = [1,2,3]\n", 139 | "y = [4,5,6]\n", 140 | "z = [7,8,9]\n", 141 | "\n", 142 | "list(zip(x,y,z))" 143 | ] 144 | }, 145 | { 146 | "cell_type": "markdown", 147 | "metadata": {}, 148 | "source": [ 149 | "C'est un moyen très efficace pour construire un dictionnaire à partir de deux listes :" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": null, 155 | "metadata": { 156 | "collapsed": true 157 | }, 158 | "outputs": [], 159 | "source": [ 160 | "clef = ['chat', 'chien']\n", 161 | "valeur = ['miaou', 'ouaf']\n", 162 | "\n", 163 | "d = dict(zip(clef, valeur))\n", 164 | "d" 165 | ] 166 | }, 167 | { 168 | "cell_type": "markdown", 169 | "metadata": {}, 170 | "source": [ 171 | "Que se passe-t-il si nous utilisons des dictionnaires en entrée ?" 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": 3, 177 | "metadata": { 178 | "collapsed": false, 179 | "nbpresent": { 180 | "id": "9e91f977-1d00-4e79-84f9-cdcca23acce4" 181 | } 182 | }, 183 | "outputs": [ 184 | { 185 | "data": { 186 | "text/plain": [ 187 | "[('c', 'f'), ('b', 'e'), ('a', 'd')]" 188 | ] 189 | }, 190 | "execution_count": 3, 191 | "metadata": {}, 192 | "output_type": "execute_result" 193 | } 194 | ], 195 | "source": [ 196 | "d1 = {'a':1, 'b':2, 'c':3}\n", 197 | "d2 = {'d':4, 'e':5, 'f':6}\n", 198 | "\n", 199 | "list(zip(d1,d2))" 200 | ] 201 | }, 202 | { 203 | "cell_type": "markdown", 204 | "metadata": { 205 | "nbpresent": { 206 | "id": "ed07b68b-1d30-424c-85f1-78f193a354ff" 207 | } 208 | }, 209 | "source": [ 210 | "C'est logique parce que réaliser les itérations dans un dictionnaire ne s'applique que sur les clefs. Il faudrait appeler des méthodes pour mélanger les clés et les valeurs:" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": 14, 216 | "metadata": { 217 | "collapsed": false, 218 | "nbpresent": { 219 | "id": "9a11d66c-fb20-4932-bad4-470dae9cf29a" 220 | }, 221 | "scrolled": true 222 | }, 223 | "outputs": [ 224 | { 225 | "data": { 226 | "text/plain": [ 227 | "[('d', 1), ('c', 2)]" 228 | ] 229 | }, 230 | "execution_count": 14, 231 | "metadata": {}, 232 | "output_type": "execute_result" 233 | } 234 | ], 235 | "source": [ 236 | "list(zip(d2,d1.values()))" 237 | ] 238 | }, 239 | { 240 | "cell_type": "markdown", 241 | "metadata": { 242 | "nbpresent": { 243 | "id": "1bdb7739-7ae3-4ca9-8eaa-daa8d00c3ed7" 244 | } 245 | }, 246 | "source": [ 247 | "Bravo ! Pour terminer, utilisons zip pour échanger les clés et les valeurs des deux dictionnaires:" 248 | ] 249 | }, 250 | { 251 | "cell_type": "code", 252 | "execution_count": 22, 253 | "metadata": { 254 | "collapsed": true, 255 | "nbpresent": { 256 | "id": "90cbfa34-b990-40a5-aa2b-c8648bcfb874" 257 | } 258 | }, 259 | "outputs": [], 260 | "source": [ 261 | "def echangiste(d1,d2):\n", 262 | " dsortie = {}\n", 263 | " \n", 264 | " for d1clef,d2valeur in zip(d1,d2.values()):\n", 265 | " dsortie[d1clef] = d2valeur\n", 266 | " \n", 267 | " return dsortie" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": 23, 273 | "metadata": { 274 | "collapsed": false, 275 | "nbpresent": { 276 | "id": "e965da74-68a4-4a00-8e30-d30db4483456" 277 | } 278 | }, 279 | "outputs": [ 280 | { 281 | "data": { 282 | "text/plain": [ 283 | "{'a': 5, 'b': 4}" 284 | ] 285 | }, 286 | "execution_count": 23, 287 | "metadata": {}, 288 | "output_type": "execute_result" 289 | } 290 | ], 291 | "source": [ 292 | "echangiste(d1,d2)" 293 | ] 294 | }, 295 | { 296 | "cell_type": "markdown", 297 | "metadata": { 298 | "nbpresent": { 299 | "id": "ec32fb2a-977f-4604-9735-2b2f179f6b0b" 300 | } 301 | }, 302 | "source": [ 303 | "Bravo ! Vous pouvez utiliser zip pour économiser beaucoup de lignes de code dans de nombreuses situations ! Vous devriez maintenant avoir une bonne connaissance de zip() et de quelques cas d'utilisation possibles." 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": null, 309 | "metadata": { 310 | "collapsed": true, 311 | "nbpresent": { 312 | "id": "eaec4037-c294-4284-8c88-61ab23a60cf8" 313 | } 314 | }, 315 | "outputs": [], 316 | "source": [] 317 | } 318 | ], 319 | "metadata": { 320 | "anaconda-cloud": {}, 321 | "kernelspec": { 322 | "display_name": "Python [default]", 323 | "language": "python", 324 | "name": "python3" 325 | }, 326 | "language_info": { 327 | "codemirror_mode": { 328 | "name": "ipython", 329 | "version": 3 330 | }, 331 | "file_extension": ".py", 332 | "mimetype": "text/x-python", 333 | "name": "python", 334 | "nbconvert_exporter": "python", 335 | "pygments_lexer": "ipython3", 336 | "version": "3.5.2" 337 | } 338 | }, 339 | "nbformat": 4, 340 | "nbformat_minor": 0 341 | } 342 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Python 2 | ## Formation intensive à la programmation 3 | 4 | Cet espace regroupe les doocuments qui accompagnent le cours de programmation avec Python disponible en ligne sur le site [UDEMY](https://www.udemy.com/course/1067008) --------------------------------------------------------------------------------