07 - Built-in Functions.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled4.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMvLW57+7Hc/4mujStMvV7z",
      "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/MachineLearnia/Python-tutoriel/blob/master/07%20-%20Built-in%20Functions.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VVszUmwz-bFM",
        "colab_type": "text"
      },
      "source": [
        "# 7/30 Built-in Functions\n",
        "Python contient un grand nombre de fonctions intégrées tres utiles a connaitre. Cela vous permet de construire des codes plus rapidement, sans avoir a développer vos propres fonctions pour les taches les plus basique. Dans ce notebook, je vous montre les plus importantes :\n",
        "\n",
        "- Fonctions de bases : abs(), round(), max(), min(), len(), sum(), any(), all()\n",
        "- Conversions de types de variables: int() str(), float(), type()\n",
        "- Conversions de structures de données: list(), tuple()\n",
        "- Conversions binaires (moins utile en machine learning): bin(), oct(), hex() \n",
        "- Fonction **input()**\n",
        "- Fonction **format()** (f-string)\n",
        "- Fonction **open()**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i_Gg60cR_oFB",
        "colab_type": "text"
      },
      "source": [
        "## 1. Fonction de bases\n",
        "Utiles en toute circonstance !"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EAfp-li6-ZSD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "c6a56073-a7b7-40b9-cdeb-114e9a607ce1"
      },
      "source": [
        "x = -3.14\n",
        "print(abs(x)) # valeur absolue\n",
        "print(round(x)) # arrondi"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.14\n",
            "-3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YnTEUj20_3Wq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "349fb051-30e0-4366-8411-2e994071c9bb"
      },
      "source": [
        "liste = [-2, 3, 1, 0, -4]\n",
        "\n",
        "print(min(liste)) # minimum\n",
        "print(max(liste)) # maximum\n",
        "print(len(liste)) # longueur\n",
        "print(sum(liste)) # somme des éléments"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-4\n",
            "3\n",
            "5\n",
            "-2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c3I6FPVkANmN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "a155cc37-193e-458c-b8af-132bb972ed4b"
      },
      "source": [
        "liste = [False, False, True]\n",
        "\n",
        "print(any(liste)) # y-a-t'il au moins un élément True ?\n",
        "print(all(liste)) # est-ce-que tous les éléments sont True ?"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2CKqQf0YAuvN",
        "colab_type": "text"
      },
      "source": [
        "## 2. Fonction de conversion\n",
        "Il peut etre tres utile de convertir une variable d'un type a un autre (par exemple pour faire des calculs). Pour cela, on dispose des fonctions int(), str() et float().\n",
        "\n",
        "La fonction **type()** est tres utile pour inspecter les types de nos variables"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-_P3CGAvAatE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b7d86d2a-ac56-4165-80cd-4c98e19f6d04"
      },
      "source": [
        "age = '32'\n",
        "type(age)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9QkhdpCEBK0W",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f0a8a95c-d0cb-4551-9f08-a4021a68ed93"
      },
      "source": [
        "age = int(age)\n",
        "type(age)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5DDHy7qBBT9l",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "cef6fe90-15f3-40ad-9239-e742c56db63c"
      },
      "source": [
        "age + 10"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "42"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MYxly1nnBhxL",
        "colab_type": "text"
      },
      "source": [
        "On peut également convertir des listes en tuples, ou des tableaux Numpy (que l'on verra par la suite) en liste..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sl7n5xP8BWCW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b0e48c93-f717-427e-be8c-83864da48fdd"
      },
      "source": [
        "tuple_1 = (1, 2, 3, 4)\n",
        "\n",
        "liste_1 = list(tuple_1) # convertir un tuple en liste\n",
        "\n",
        "type(liste_1)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "orx_mdrPCCqx",
        "colab_type": "text"
      },
      "source": [
        "## 3. La fonction **input()**\n",
        "Cette fonction est tres utile pour demander a l'utilisateur du programme d'entrer une valeur dans votre programme"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VRzdH0oeB3w8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4535b183-4540-477d-c649-e0446c75d2a8"
      },
      "source": [
        "age = input('quel age avez-vous ?')"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "quel age avez-vous ?30 ans\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mR0irKo7CXFj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "2df066f9-12a1-4ba5-dc82-05cc376598f2"
      },
      "source": [
        "type(age) # age est de type string. il faut penser a le convertir si on désire faire un calcul avec"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ClGnpncTCpSh",
        "colab_type": "text"
      },
      "source": [
        "## 4. La fonction **format()**\n",
        "cette fonction permet d'insérer la valeur d'une variable au sein d'une chaine de cacacteres (string).\n",
        "\n",
        "Une méthode plus rapide pour utiliser cette fonction est de faire appel au **f-string**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YNo1gncmCZjb",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e4e51b60-5b8d-422b-a1c8-2d26fa34f4e0"
      },
      "source": [
        "x = 25\n",
        "ville = 'Paris'\n",
        "\n",
        "message = 'il fait {} degrés a {}'.format(x, ville)\n",
        "print(message)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "il faut 25 degrés a Paris\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h3xtfGoHDCmu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "45d10f11-4183-4daa-852c-3b86dac38002"
      },
      "source": [
        "message = f'il fait {x} degrées a {ville}'\n",
        "print(message)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "il fait 25 degrées a Paris\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PWFMzobFDkfP",
        "colab_type": "text"
      },
      "source": [
        "## 5. La fonction **open()**\n",
        "Cette fonction est l'une des plus utile de Python. Elle permet d'ouvrir n'importe quel fichier de votre ordinateur et de l'utiliser dans Python. Différents modes existent :\n",
        "- le mode 'r' : lire un fichier de votre ordinateur\n",
        "- le mode 'w' : écrire un fichier sur votre ordinateur\n",
        "- le mode 'a' : (append) ajouter du contenu dans un fichier existant"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ovu_J5rhDS0-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "f = open('text.txt', 'w') # ouverture d'un objet fichier f\n",
        "f.write('hello')\n",
        "f.close() # il faut fermer notre fichier une fois le travail terminé"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3GjqncN3NvO8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c94ca820-e42b-47d4-8840-425110ad62ef"
      },
      "source": [
        "f = open('text.txt', 'r')\n",
        "print(f.read())\n",
        "f.close() "
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tjuY60QsN3Ax",
        "colab_type": "text"
      },
      "source": [
        "Dans la pratique, on écrit plus souvent **with open() as f** pour ne pas avoir a fermer le fichier une fois le travail effectué :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8NeneA9zNy6N",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "74c9c575-68f2-4250-82b5-eca1c73669ee"
      },
      "source": [
        "with open('text.txt', 'r') as f:\n",
        "    print(f.read())"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4W96D02DOVmC",
        "colab_type": "text"
      },
      "source": [
        "## 6. Exercice et Solution\n",
        "Le code ci-dessous permet de créer un fichier qui contient les nombres carrée de 0 jusqu'a 19.\n",
        "L'exercice est d'implémenter un code qui permet de lire ce fichier et d'écrire chaque ligne dans une liste.\n",
        "\n",
        "Note_1 : la fonction **read().splitlines()** sera tres utile\n",
        "\n",
        "Note_2 : Pour un meilleur résultat, essayer d'utiliser une liste comprehension !"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5NOsB5k5OAlC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Ce bout de code permet d'écrire le fichier \n",
        "with open('fichier.txt', 'w') as f:\n",
        "    for i in range(0, 20):\n",
        "        f.write(f'{i}: {i**2} \\n')\n",
        "    f.close()\n",
        "\n",
        "# Écrivez ici le code pour lire le fichier et enregistrer chaque lignes dans une liste."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ua9uDeenOtdl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        },
        "outputId": "790d5c6f-5f81-480f-8218-6777cf4a4fa6"
      },
      "source": [
        "# SOLUTION (non optimale)\n",
        "with open('fichier.txt','r') as f:\n",
        "    liste = f.read().splitlines()\n",
        "\n",
        "liste"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['0: 0 ',\n",
              " '1: 1 ',\n",
              " '2: 4 ',\n",
              " '3: 9 ',\n",
              " '4: 16 ',\n",
              " '5: 25 ',\n",
              " '6: 36 ',\n",
              " '7: 49 ',\n",
              " '8: 64 ',\n",
              " '9: 81 ',\n",
              " '10: 100 ',\n",
              " '11: 121 ',\n",
              " '12: 144 ',\n",
              " '13: 169 ',\n",
              " '14: 196 ',\n",
              " '15: 225 ',\n",
              " '16: 256 ',\n",
              " '17: 289 ',\n",
              " '18: 324 ',\n",
              " '19: 361 ']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HC9zEPSlPFKE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        },
        "outputId": "51f9cd11-fd8a-4001-e5a4-8a56569a8b3d"
      },
      "source": [
        "# SOLUTION (Améliorée)\n",
        "# Une meilleure facon de procéder est d'utiliser une liste comprehension !\n",
        "\n",
        "liste = [row.strip() for row in open('fichier.txt','r')]\n",
        "liste"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['0: 0',\n",
              " '1: 1',\n",
              " '2: 4',\n",
              " '3: 9',\n",
              " '4: 16',\n",
              " '5: 25',\n",
              " '6: 36',\n",
              " '7: 49',\n",
              " '8: 64',\n",
              " '9: 81',\n",
              " '10: 100',\n",
              " '11: 121',\n",
              " '12: 144',\n",
              " '13: 169',\n",
              " '14: 196',\n",
              " '15: 225',\n",
              " '16: 256',\n",
              " '17: 289',\n",
              " '18: 324',\n",
              " '19: 361']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hpbjZcGaQQN1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}