{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Les Fonctions\n", "\n", "## Introduction aux fonctions\n", "\n", "Pendant cette leçon nous allons découvrir ce qu'est une fonction avec Python et comment en créer. Les fonctions seront l'un de nos principaux blocs de construction lorsque nous allons développer de plus en plus de code pour résoudre des problèmes.\n", "\n", "**Qu'est-ce qu'une fonction ?**\n", "\n", "De façon très formelle, une fonction est un moyen très utile de regrouper un ensemble d'instructions afin qu'elles puissent être exécutées plus d'une fois. Elles permettent également de spécifier des paramètres qui peuvent servir comme variables d'entrées aux fonctions.\n", "\n", "Sur un plan plus pratique, les fonctions permettent de ne pas avoir à écrire à plusieurs reprises le même code encore et encore. Si vous vous souvenez des leçons sur les chaines et les listes, vous devriez vous rappeler que nous avons utilisé une fonction len() pour obtenir la longueur d'une chaîne. Comme la vérification de la longueur d'une séquence est une tâche courante, il est utile d'écrire une fonction qui peut le faire à plusieurs reprises à la demande.\n", "\n", "Les fonctions sont une des façons les plus simples de réutilisation de code en Python, et elles vont nous permettre de commencer à penser à la conception de programmes (nous allons plonger plus profondément dans la conception lorsque nous découvrirons la Programmation Orientée Objet)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## L' instruction def\n", "\n", "Voyons comment se construit une fonction avec Python.\n", "Elle a la forme suivante :" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def nom_de_fonction(parm1,parm2):\n", " '''\n", " C'est l'endroit où placer la description de la fonction (doc-string)\n", " '''\n", " # Ici, on fait des chose\n", " # Et on retourne le résultat\n", " \n", "# Ce n'est plus la fonction" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On commence par le terme def suivi du nom de la fonction séparé par un espace. Essayez de trouver un nom pertinent, par exemple len() est bien pour une fonction qui donne une longueur (length en anglais). Soyez également prudent quand vous choisissez un nom, vous ne devez pas appeler une fonction avec le même nom qu'une [fonction intégrée dans Python](https://docs.python.org/3.7/library/functions.html) (comme len).\n", "\n", "Après le nom de la fonction nous trouvons une paire de parenthèses qui enferment un certain nombre d'arguments séparés par une virgule. Ces arguments sont les paramètres d'entrée de votre fonction. Vous pourrez utiliser ces paramètres dans votre fonction et les référencer comme variables. Un deux-points termine systématiquement la ligne de déclaration.\n", "\n", "Nous arrivons à une étape très importante, vous devez indenter le code à l'intérieur de votre fonction car Python utilise les espaces pour organiser le code. La pluspart des autres langages de programmation ne le font pas, donc gardez bien cela à l'esprit.\n", "\n", "Ensuite, vous verrez la \"doc-string\", c'est là que vous devez écrire une description simple de la fonction. Ce commentaire n'est pas obligatoire et pour les fonctions simples on peut sans doute s'en passer, mais c'est une bonne pratique de les écrire afin que vous ou d'autres personnes peuvent facilement comprendre le code que vous avez écrit.\n", "\n", "C'est à partir de là que vous commencez à écrire le code que vous souhaitez exécuter.\n", "\n", "Les exemples sont la meilleure façon d'apprendre à utiliser les fonctions. Nous allons donc en voir quelques uns qui utilisent différents objets et structures de données que nous avons vus auparavant." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exemple 1 : Une fonction simple d'affichage de bonjour" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": true }, "outputs": [], "source": [ "def dire_bonjour():\n", " print ('bonjour')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Appeler la fonction" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "bonjour\n" ] } ], "source": [ "dire_bonjour()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exemple 2 : Une fonction simple de bienvenue\n", "\n", "Écrivons une fonciton simple qui souhaite la bienvenue en appelant les gens par leur nom" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def bienvenue(nom):\n", " print ('Bonjour %s' %nom)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Bonjour Marc\n" ] } ], "source": [ "bienvenue('Marc')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Utilisation de return\n", "Voyons quelques cas d'ultilisation de la directive return. Celle-ci permet à la fonction de *retourner* un résultat qui pourra être stocké comme variable, ou utiliser de quelque manière que le programmeur le souhaite.\n", "### Exemple 3 : Fonction Addition" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": true }, "outputs": [], "source": [ "def ajoute_nombre(nombre1,nombre2):\n", " return nombre1+nombre2" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "9" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ajoute_nombre(4,5)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# On peut aussi sauvegarder la valeur renvoyée dans une variable\n", "résultat = ajoute_nombre(4,5)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "9\n" ] } ], "source": [ "print (résultat)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Que se passe-t-il avec des chaines de caractères ?" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "onetwo\n" ] } ], "source": [ "print (ajoute_nombre('one','two'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Remarquez que grace au typage faible des variables en Python, nous pouvons utiliser cette fonction pour additionner des nombres ou pour concatener des séquences ensemble !\n", "Nous verrons ensuite comment ajouter des contrôles à l'entrée pour s'assurer que l'utilisateur a bien spécifier les paramèrtres attendus par la fonction.\n", "\n", "Nous allons maintenant utiliser également les directives *break*, *continue* et *pass* dans notre code. Nous les avons découvertes dans la leçon sur les boucles while." ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "Pour terminer, voyons un exemple complet d'une fonction qui teste si un nombre est premier (un exercice relativement commun en entretien d'embauche...).\n", "\n", "On sait qu'un nombre est premier si ce nombre est divisible uniquement par 1 et par lui même. Écrivons une première version de cette fonction en vérifiant tous les nombres de 1 à N avec modulo." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": true }, "outputs": [], "source": [ "def est_premier(numéro):\n", " '''\n", " Méthode simple de vérification de nombre premiers\n", " '''\n", " for n in range(2,numéro):\n", " if numéro % n == 0:\n", " print ('non premier')\n", " break\n", " else: # si on a parcouru la boucle sans jamais avoir de reste à 0, le nombre est premier\n", " print ('premier')" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "premier\n" ] } ], "source": [ "est_premier(16)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Remarquez comment nous casssons la boucle en cas de nombre non premier après l'affichage du message !\n", "Il est possible d'améliorer ce code en vérifiant uniquement jusqu'à la racine carrée du nombre cible, nous pouvons également ignorer tous les nombres pairs après avoir vérifié 2. Enfin, nous allons aussi retourner une valeur booléenne pour obtenir un exemple d'utilisation de l'instruction return:\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [], "source": [ "import math\n", "\n", "def est_premier(numéro):\n", " '''\n", " Méthode plus évoluée de vérifier les nombres premiers\n", " '''\n", " if numéro % 2 == 0 and numéro > 2: \n", " return False\n", " for i in range(3, int(math.sqrt(numéro)) + 1, 2):\n", " if numéro % i == 0:\n", " return False\n", " return True" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "est_premier(14)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bravo !\n", "Vous devez maintenant avoir acquis les bases de la création d'une fonction en Python pour éviter d'avoir à ré-écrire le même code !" ] } ], "metadata": { "anaconda-cloud": {}, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.0" } }, "nbformat": 4, "nbformat_minor": 0 }