Les_fonctions.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Les fonctions.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMQHUFxp2WZ/M+j4Kq1W4cO",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/GeoLabUniLaSalle/Python/blob/main/Les_fonctions.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3iEJHUTZPhTa"
      },
      "source": [
        "# **Les fonctions**\n",
        "\n",
        "Dans ce chapitre, nous allons voir comment créer et utiliser nos propres fonctions en Python.\n",
        "\n",
        "Débutons par la création d'une liste sur laquelle nous allons réaliser une opération simple : Elever chaque terme au carré."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CUq3yfGIPe1Y",
        "outputId": "e1bfb0e1-a989-49f7-ff3e-7f5a3be182f7"
      },
      "source": [
        "l = [4, 7, 3, 5, 8]\n",
        "for i in l:\n",
        "  print(i,\"x\",i,\"=\",i**2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4 x 4 = 16\n",
            "7 x 7 = 49\n",
            "3 x 3 = 9\n",
            "5 x 5 = 25\n",
            "8 x 8 = 64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WGZP1NGOQIA1"
      },
      "source": [
        "Ecrivons une fonction qui prenne en paramètre une liste et affiche le carré de chaque élément de cette liste."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "92KG8MZeQQir"
      },
      "source": [
        "def carre(x):\n",
        "  for i in x:\n",
        "    print(i,\"x\",i,\"=\",i**2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W61orKovQYng"
      },
      "source": [
        "Maintenant que notre fonction est définie, nous pouvons l'appeler en lui passant la liste de notre choix en paramètre."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oxRoiHhgP_RJ",
        "outputId": "15318314-d67b-4ce5-c538-3bfab9541910"
      },
      "source": [
        "carre(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4 x 4 = 16\n",
            "7 x 7 = 49\n",
            "3 x 3 = 9\n",
            "5 x 5 = 25\n",
            "8 x 8 = 64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "54YaO4znQjQ6",
        "outputId": "40d36a1c-20b7-4808-a791-a442a915947c"
      },
      "source": [
        "carre([3,12,8.1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3 x 3 = 9\n",
            "12 x 12 = 144\n",
            "8.1 x 8.1 = 65.61\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tWbkNdKWQrG4"
      },
      "source": [
        "Examinons maintenant le retour de cette fonction."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9F7A6KZ4QpHq",
        "outputId": "d4f8391e-ce75-4f3d-f6ba-061d2502d147"
      },
      "source": [
        "print(carre(l))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4 x 4 = 16\n",
            "7 x 7 = 49\n",
            "3 x 3 = 9\n",
            "5 x 5 = 25\n",
            "8 x 8 = 64\n",
            "None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vHHqW1K1Q0MC"
      },
      "source": [
        "Le retour est *None*, car la fonction carre est une fonction sans retour.\n",
        "\n",
        "Ajoutons maintenant un retour à notre fonction : la somme des carrés des éléments de la liste passée en paramètre.\n",
        "\n",
        "L'instruction return permet de retourner la valeur souhaitée, mais elle a aussi la propriété de nous faire sortir de la fonction et nous ramener là où la fonction a été appelée."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lpTNpIs8Qyde"
      },
      "source": [
        "def carre(x):\n",
        "  somme=0\n",
        "  for i in x:\n",
        "    somme+=i**2\n",
        "  return somme"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YIywqNyrRF3p"
      },
      "source": [
        "Et affichons ce retour (16 + 49 + 9 + 2 5 + 64 = 163)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y7Ja3w5tREEv",
        "outputId": "f9ff4c31-2257-4ba0-e963-00939374bf3f"
      },
      "source": [
        "print(carre(l))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "163\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hx9jlg3BRcQH"
      },
      "source": [
        "Il est possible de créer la documentation de nos fonctions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QhYdEcj2RR_x"
      },
      "source": [
        "def carre(x):\n",
        "  \"\"\"\n",
        "  Retourne la somme des carrés des éléments de la liste x\n",
        "  \"\"\"\n",
        "  somme=0\n",
        "  for i in x:\n",
        "    somme+=i**2\n",
        "  return somme"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rrWbWiQmRvCU"
      },
      "source": [
        "Nous pouvons alors consulter la documentation comme pour n'importe quelle fonction."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EB9IZ2AsRuSi",
        "outputId": "2fc88d21-a202-4a34-d090-68f321e41668"
      },
      "source": [
        "help(carre)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on function carre in module __main__:\n",
            "\n",
            "carre(x)\n",
            "    Retourne la somme des carrés des éléments de la liste x\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ghb5HhmlSKcA"
      },
      "source": [
        "Il est possible d'écrire une fonction qui retourne plusieurs valeurs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZJFCWiNGR6NQ"
      },
      "source": [
        "def puissances(x):\n",
        "  \"\"\"\n",
        "  Retourne les 3 premières puissances de x\n",
        "  \"\"\"\n",
        "  return x**2, x**3, x**4"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y4IFa1UpSdls",
        "outputId": "74962e2f-4a5d-432a-d205-7587522c53aa"
      },
      "source": [
        "help(puissances)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on function puissances in module __main__:\n",
            "\n",
            "puissances(x)\n",
            "    Retourne les 3 premières puissances de x\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jh6p77p-SZai",
        "outputId": "417d6f82-cd6b-4381-cc1d-971113ca8c8a"
      },
      "source": [
        "a=puissances(3)\n",
        "print(a)\n",
        "print(type(a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(9, 27, 81)\n",
            "<class 'tuple'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a2YoWtQYSvbr"
      },
      "source": [
        "Puissances retourne un tuple. Nous pouvons aussi stocker le retour de la fonction ainsi :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4GwNbjWASf90",
        "outputId": "5e9110e7-beba-42ca-b933-d250292cc9c2"
      },
      "source": [
        "a, b, c = puissances(3)\n",
        "print(a,b,c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "9 27 81\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J_EbkEK2TFDE"
      },
      "source": [
        "Réalisons une fonction puissance qui prenne 2 nombres en paramètre pour élever le premier à la puissance du second, et un paramètre booléen qui indique si le résultat du calcul doit être affiché ou retourné."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G-_dLyB0SlmG",
        "outputId": "2f7dc3a0-6d58-45ba-95e8-d62b72b4ab40"
      },
      "source": [
        "def puissance(x,y,r):\n",
        "  p=x**y\n",
        "  if r:\n",
        "    return p\n",
        "  else:\n",
        "    print(p)\n",
        "  \n",
        "print(puissance(5,3,True))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "125\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7MHuXrS0UZpI"
      },
      "source": [
        "Il est possible de fixer des valeurs par défaut aux paramètres de nos fonctions.\n",
        "\n",
        "Ici, nous souhaitons que la puissances soit 2, et que la fonction affiche le résultat par défaut."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bkcrj_XgUTsj",
        "outputId": "c836deb5-abd2-4e4d-e06e-1c1a8c239611"
      },
      "source": [
        "def puissance(x,y=2,r=False):\n",
        "  p=x**y\n",
        "  if r:\n",
        "    return p\n",
        "  else:\n",
        "    print(p)\n",
        "  \n",
        "puissance(5) # Affichage de la représentation interne du retour de la fonction puissance"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ouEobfAxUsta",
        "outputId": "672ecc35-ecd1-461b-ea6a-004a736cac56"
      },
      "source": [
        "puissance(5,3) # La valeur 125 est affichée par l'instruction print"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "125\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ewAWvdoPUyPo",
        "outputId": "9fd2d3b8-9b2f-4b83-9dc8-e0f134279a4f"
      },
      "source": [
        "x = puissance(5,3,True) # La valeur 125 est retournée et peut être affichée dans un print\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "125\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jpzAQloTVFVf"
      },
      "source": [
        "Il est possible d'expliciter les noms des paramètres pour que l'ordre n'importe plus"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WAt0bJ75U1OA",
        "outputId": "90852b77-b0af-40e3-d10f-389763f2899e"
      },
      "source": [
        "x = puissance(5,r=True)\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hf5ucFBLVDKe",
        "outputId": "54dadd88-23dd-4739-ed54-8d3bcc3b440f"
      },
      "source": [
        "x = puissance(r=True,x=5)\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p-iENYSLVUHs"
      },
      "source": [
        "Attention : Lors du passage en paramètre d'une liste dans une fonction, les valeurs ne sont pas copiées. Il s'agit de passage par référence."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pqKhKKERVeW4",
        "outputId": "ac3080c3-e6d0-4017-8e8c-4ccee43dd45e"
      },
      "source": [
        "def ajout(x):\n",
        "  x+=x\n",
        "  return x\n",
        "\n",
        "a=[8,5]\n",
        "print(ajout(a))\n",
        "print(a) # a est modifié"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[8, 5, 8, 5]\n",
            "[8, 5, 8, 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EiR0ftKZXDxI"
      },
      "source": [
        "Une solution simple à ce \"problème\" consiste à créer une copie explicite à l'intérieur de la fonction."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Vid__4NVM_T",
        "outputId": "f3aa5b99-d874-48c2-fe8f-09f7572b367b"
      },
      "source": [
        "def ajout(x):\n",
        "  l=list(x)\n",
        "  l+=l\n",
        "  return l\n",
        "\n",
        "a=[8,5]\n",
        "print(ajout(a))\n",
        "print(a) # a n'est pas modifié"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[8, 5, 8, 5]\n",
            "[8, 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gcziREfHi8ay"
      },
      "source": [
        "Attention : L'instruction return met fin à la fonction :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5MdhZjYmjBhi",
        "outputId": "fbfc2224-07e8-453b-8a6b-ea173812c845"
      },
      "source": [
        "def max(x,y):\n",
        "  if x>=y:\n",
        "    return x\n",
        "  else:\n",
        "    return y\n",
        "\n",
        "print(max(5,7))"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "71OPremdjZ-6"
      },
      "source": [
        "Peut donc aussi s'écrire :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EF3kFIhGjX-R",
        "outputId": "9e33e4e3-dcf1-41f8-a17c-510d9bf6be1c"
      },
      "source": [
        "def max(x,y):\n",
        "  if x>=y:\n",
        "    return x\n",
        "  return y\n",
        "\n",
        "print(max(5,7))"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}