fr/TP0/tp0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c5765865",
   "metadata": {},
   "source": [
    "# TP 0\n",
    "\n",
    "## 0bjectifs\n",
    "\n",
    "* Comprendre les bases de la programmation Python :\n",
    "* Variables, types de données, listes, ensembles et tuples.\n",
    "* Expressions conditionnelles et boucles\n",
    "* Trier\n",
    "* Dictionnaire\n",
    "* Fichiers et interaction avec les utilisateurs\n",
    "* Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a058a5a5",
   "metadata": {},
   "source": [
    "## Exercice 1\n",
    "\n",
    "1\\. Commentaires\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a998057d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ceci est un commentaire\n",
    "print(\"Bonjour\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf04e9d9",
   "metadata": {},
   "source": [
    "2\\. Variables\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddbc2175",
   "metadata": {},
   "outputs": [],
   "source": [
    "# une variable\n",
    "message = \"le monde!\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0194e00",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 20\n",
    "c = a + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfd20ed7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# nombres réels\n",
    "pi = 3.14\n",
    "print(pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00ada049",
   "metadata": {},
   "outputs": [],
   "source": [
    "# types de donnés\n",
    "message1 = \"Bonjour\"\n",
    "a = 12\n",
    "pi = 3.14\n",
    "print(type(message1))\n",
    "print(type(a))\n",
    "print(type(pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c93ac78e",
   "metadata": {},
   "source": [
    "3\\. Concaténation de deux chaînes de caractères\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b055e492",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Concaténation de deux chaînes de caractères\n",
    "message = \"le monde!\"\n",
    "print(\"Bonjour\" + message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3000646c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Concaténation de deux chaînes de caractères\n",
    "message1 = \"Bonjour \"\n",
    "message2 = \"le monde!\"\n",
    "print(message1 + message2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6df89244",
   "metadata": {},
   "outputs": [],
   "source": [
    "# concaténation de deux variables de types de données différents\n",
    "# opération + sur deux types de données différents\n",
    "\n",
    "# Supprimer le commentaire ci-dessous et lancer le code\n",
    "message1 = \"Bonjour en Python\"\n",
    "a = 3\n",
    "# print(message1 + a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f3cbd0a",
   "metadata": {},
   "source": [
    "Pourquoi cette erreur ? Dans le code suivant, nous corrigeons cette erreur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e0afbfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# solution de concaténation entre deux variables de types de données différents\n",
    "message1 = \"Bonjour en Python \"\n",
    "a = 3\n",
    "print(message1 + str(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24431b65",
   "metadata": {},
   "source": [
    "4\\. Listes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67e0609e",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [10, 20, 30, 40, 50]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef10a80d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [10, 20, 30, 40, 50]\n",
    "print(a[0])\n",
    "print(a[1])\n",
    "print(a[2])\n",
    "print(a[3])\n",
    "print(a[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6903529",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Supprimer le commentaire ci-dessous et lancer le code\n",
    "a = [10, 20, 30, 40, 50]\n",
    "# print(a[8])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03187ffd",
   "metadata": {},
   "source": [
    "Nous essayons d'accéder à un élément à un index qui n'existe pas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "306e01c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "message1 = \"Bonjour en Python \"\n",
    "print(message1[0])\n",
    "print(message1[1])\n",
    "print(message1[2])\n",
    "print(message1[3])\n",
    "print(message1[4])\n",
    "print(message1[5])\n",
    "print(message1[6])\n",
    "print(message1[7])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f06358fb",
   "metadata": {},
   "source": [
    "Le code ci-dessus affiche les différents caractères de la chaîne (ou liste de caractères).\n",
    "Nous allons maintenant obtenir la longueur de cette chaîne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1d899e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "message1 = \"Bonjour en Python \"\n",
    "print(len(message1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e955d408",
   "metadata": {},
   "source": [
    "Nous allons maintenant créer une liste d'entiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7bfa176",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [10, 20, 30, 40, 50]\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2692a2d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [10, 20, 30, 40, 50]\n",
    "\n",
    "# ajouter un nouveau numéro à la fin de la liste\n",
    "a.append(60)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57d20f66",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [10, 20, 30, 40, 50]\n",
    "\n",
    "# modifier un numéro à un index donné\n",
    "a[0] = 0\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f7bccd7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Supprimer le commentaire ci-dessous et lancer le code\n",
    "a = [10, 20, 30, 40, 50]\n",
    "\n",
    "# a[6] = 20\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd8312ec",
   "metadata": {},
   "source": [
    "Pourquoi cette erreur? Nous modifions un élément à un indice inexistant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab36ea42",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [10, 20, 30, 40, 50]\n",
    "\n",
    "# l'insertion d'un élément à un index particulier modifiera la liste\n",
    "a.insert(0, 0)\n",
    "print(a)\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3543e803",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [10, 20, 30, 40, 50]\n",
    "a.insert(6, 60)\n",
    "print(a)\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c37f267",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [10, 20, 30, 40, 50]\n",
    "\n",
    "# Nous allons maintenant essayer d'insérer un nombre à un index plus grand que la longueur\n",
    "# de la liste. Nous veillerons à ce qu'il n'y ait pas d'erreur et le nouveau numéro\n",
    "# est ajouté à la fin de la liste\n",
    "a.insert(10, 60)\n",
    "print(a)\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3931840c",
   "metadata": {},
   "source": [
    "5\\. Tuples (non-modifiable lists)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f05f5dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = (10, 20, 30, 40, 50)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e7fcfe4",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = (10, 20, 30, 40, 50)\n",
    "print(a[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65559b5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = (10, 20, 30, 40, 50)\n",
    "\n",
    "\n",
    "# Nous essayons maintenant de modifier un tuple\n",
    "# Décommentez le code ci-dessous et lancez le code\n",
    "# Un tupe est une liste non modifiable\n",
    "\n",
    "# a[0] = 0\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fd230e4",
   "metadata": {},
   "source": [
    "6\\. Sets\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad9947cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Un ensemble(Set) est une collection d'éléments distincts\n",
    "\n",
    "a = {10, 20, 30, 40, 50, 10, 20, 30, 40, 50}\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a2056c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {10, 20, 30, 40, 50, 10, 20, 30, 40, 50}\n",
    "a.add(10)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f7cbf0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {10, 20, 30, 40, 50, 10, 20, 30, 40, 50}\n",
    "a.add(60)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "feef2d95",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {10, 20, 30, 40, 50, 10, 20, 30, 40, 50}\n",
    "a.remove(40)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee46f2e3",
   "metadata": {},
   "source": [
    "Nous allons maintenant essayer différents types de données avec les chiffres et afficher le résultat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3c814e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set\n",
    "a = {10, 20, 30, 40, 50, 10, 20, 30, 40, 50}\n",
    "print(a)\n",
    "print(type(a))\n",
    "\n",
    "# tuple\n",
    "b = (10, 20, 30, 40, 50, 10, 20, 30, 40, 50)\n",
    "print(b)\n",
    "print(type(b))\n",
    "\n",
    "# list\n",
    "c = [10, 20, 30, 40, 50, 10, 20, 30, 40, 50]\n",
    "print(c)\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8baf5ec4",
   "metadata": {},
   "source": [
    "## Exercice 2\n",
    "\n",
    "1\\. Expressions conditionnelles\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "824b2139",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 12\n",
    "if a % 2 == 0:\n",
    "    print(a, \" is divisible by 2\")\n",
    "else:\n",
    "    print(a, \" is not divisible by 2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73f2ca72",
   "metadata": {},
   "outputs": [],
   "source": [
    "lang = \"Français\"\n",
    "if lang == \"Français\":\n",
    "    print(\"Bonjour le monde!\")\n",
    "else:\n",
    "    print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eec2cbe5",
   "metadata": {},
   "source": [
    "2\\. Boucles\n",
    "\n",
    "Les boucles peuvent également être utilisées pour accéder aux éléments de différents indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e464e62",
   "metadata": {},
   "outputs": [],
   "source": [
    "# liste\n",
    "for i in [10, 20, 30, 40, 50, 10, 20, 30, 40, 50]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "973f5260",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tuples\n",
    "for i in (10, 20, 30, 40, 50, 10, 20, 30, 40, 50):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b39e944d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set\n",
    "for i in {10, 20, 30, 40, 50, 10, 20, 30, 40, 50}:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "634c118c",
   "metadata": {},
   "source": [
    "2\\. Limites\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6fb4cb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0, 10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fa25123",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe0f2cf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# print() par défaut affiche le message suivi d'une nouvelle ligne\n",
    "# Mais vous pouvez changer son comportement\n",
    "\n",
    "for i in range(0, 10, 2):\n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e286ca1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10, 0, -2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f68273f",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10, 0):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "253c83db",
   "metadata": {},
   "source": [
    "split(): La fonction peut être utilisée pour séparer une chaîne de caractères en utilisant \n",
    "un délimiteur spécifié. Par défaut, le délimiteur est un espace blanc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4a01286",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in \"Bonjour,le,monde!\".split():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5776cdd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in \"Bonjour,le,monde!\".split(\",\"):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "859a4206",
   "metadata": {},
   "source": [
    "Write a program in Python to display the following output\n",
    "\n",
    "  \n",
    " 1\n",
    " \n",
    " 12\n",
    " \n",
    " 123\n",
    " \n",
    " 1234\n",
    " \n",
    " 12345\n",
    " \n",
    " 123456\n",
    " \n",
    " 1234567\n",
    " \n",
    " 12345678"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30bf8b4c",
   "metadata": {},
   "source": [
    "## Exercice 3\n",
    "\n",
    "1\\. Tri\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d59216f",
   "metadata": {},
   "outputs": [],
   "source": [
    "num = [10, 20, 30, 40, 50, 10, 20, 30, 40, 50]\n",
    "num.sort()\n",
    "print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d8d19b9",
   "metadata": {},
   "source": [
    "2\\. Tri (ordre décroissant)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "547bae2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "num = [10, 20, 30, 40, 50, 10, 20, 30, 40, 50]\n",
    "num.sort(reverse=True)\n",
    "print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0882ff64",
   "metadata": {},
   "source": [
    "3\\. minimum\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "419e92aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "num = [10, 20, 30, 40, 50, 10, 20, 30, 40, 50]\n",
    "print(min(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f3e0852",
   "metadata": {},
   "source": [
    "4\\. maximum\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07fefbd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "num = [10, 20, 30, 40, 50, 10, 20, 30, 40, 50]\n",
    "print(max(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a7c139b",
   "metadata": {},
   "source": [
    "5\\. sorted()\n",
    "\n",
    "Vous pouvez utiliser cette fonction si vous ne souhaitez pas modifier votre liste initiale par un tri."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f13b3018",
   "metadata": {},
   "outputs": [],
   "source": [
    "num = [70, 20, 30, 10, 50, 60, 20, 80, 70, 50]\n",
    "tri = sorted(num, reverse=True)\n",
    "print(num)\n",
    "print(tri)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa2eac4b",
   "metadata": {},
   "source": [
    "Modifiez le code donné ci-dessous pour afficher les cinq plus grands numéros uniques.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b77a97e",
   "metadata": {},
   "outputs": [],
   "source": [
    "num = [70, 20, 30, 10, 50, 60, 20, 80, 70, 50]\n",
    "\n",
    "# sélectionner les cinq premiers numéros\n",
    "tri = sorted(num, reverse=True)[:5]\n",
    "print(tri)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f44e7e9e-0139-4197-915c-98f99dc20315",
   "metadata": {},
   "source": [
    "Nous pouvons également utiliser la fonction pour les chaînes de caractères."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da510476",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sorted(\"Bonjour le monde!\".split(), key=str.lower, reverse=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22c02a09",
   "metadata": {},
   "source": [
    "## Exercice 4\n",
    "\n",
    "1\\. Dictionnaire\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c92b7ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {\"contente\": 12, \"content\": 12, \"triste\": 2}\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "359b3e16",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {\"contente\": 12, \"content\": 12, \"triste\": 2}\n",
    "for key in a:\n",
    "    print(\"le mot \", key, \" apparait \", a[key], \" fois\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a36b8302",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {\"contente\": 12, \"content\": 12, \"triste\": 2}\n",
    "for key, value in a.items():\n",
    "    print(\"le mot\", key, \" apparait \", value, \" fois\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "931ff59d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {\"contente\": 12, \"content\": 12, \"triste\": 2}\n",
    "a[\"joie\"] = 10\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52ccac14",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {\"contente\": 12, \"content\": 12, \"triste\": 2}\n",
    "del a[\"triste\"]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dd3444b",
   "metadata": {},
   "outputs": [],
   "source": [
    "mots = {\"contente\": 12, \"content\": 12, \"triste\": 2, \"joie\": 10}\n",
    "print(sorted(mots))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d24c68c",
   "metadata": {},
   "outputs": [],
   "source": [
    "mots = {\"contente\": 12, \"content\": 12, \"triste\": 2, \"joie\": 10}\n",
    "mots_tuple = [(key, value) for key, value in mots.items()]\n",
    "print(mots_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8577435e",
   "metadata": {},
   "source": [
    "2\\. itemgetter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3c57a6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import itemgetter\n",
    "\n",
    "mots = {\"contente\": 12, \"content\": 12, \"triste\": 2, \"joie\": 10}\n",
    "mots_tuple = [(key, value) for key, value in mots.items()]\n",
    "print(sorted(mots_tuple, key=itemgetter(1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a6c4e59",
   "metadata": {},
   "source": [
    "3\\. Interaction with user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a93acd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# nom = input(\"Quel est votre nom?\")\n",
    "# print(nom)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6112ce4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# age = input(\"Quel est votre âge? \")\n",
    "# print(age)\n",
    "# print(type(age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a69a743",
   "metadata": {},
   "outputs": [],
   "source": [
    "# age = input(\"Quel est votre âge? \")\n",
    "# age = int(age)\n",
    "# print(age)\n",
    "# print(type(age))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "421cda55",
   "metadata": {},
   "source": [
    "**Question:** Ecrire un programme en Python qui interagit avec l'utilisateur pour\n",
    "obtenir les informations suivantes de 5 étudiants :\n",
    "\n",
    "- Nom de l'étudiant\n",
    "- Âge\n",
    "- Notes en 5 modules\n",
    "\n",
    "Une fois les informations obtenues pour les cinq étudiants, calculez\n",
    "et afficher les valeurs suivantes pour chaque module :\n",
    "\n",
    "- note moyenne\n",
    "- note maximale\n",
    "- note minimale"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "127e46c6",
   "metadata": {},
   "source": [
    "## Exercice 5\n",
    "\n",
    "Lire et écrire dans un fichier"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63636dc5",
   "metadata": {},
   "source": [
    "1\\. Fichiers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58588f4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# écrire dans un fichier\n",
    "message = \"Bonjour le monde\"\n",
    "with open(\"bonjour.txt\", \"w\") as file:\n",
    "    file.write(message)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29dbb8a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# lire un fichier\n",
    "with open(\"bonjour.txt\", \"r\") as file:\n",
    "    text = file.read()\n",
    "    print(text)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f65caf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# écrire dans un fichier\n",
    "message1 = \"Bonjour le monde\"\n",
    "message2 = \"Programmation en Python\"\n",
    "with open(\"bonjour.txt\", \"w\") as file:\n",
    "    file.write(message1)\n",
    "    file.write(message2)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81c3d5df",
   "metadata": {},
   "outputs": [],
   "source": [
    "# lire un fichier\n",
    "with open(\"bonjour.txt\", \"r\") as file:\n",
    "    text = file.read()\n",
    "    print(text)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08b06855",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rédaction dans un fichier en utilisant le caractère de nouvelle ligne\n",
    "message1 = \"Bonjour le monde\\n\"\n",
    "message2 = \"Programmation en Python\"\n",
    "with open(\"bonjour.txt\", \"w\") as file:\n",
    "    file.write(message1)\n",
    "    file.write(message2)\n",
    "file.close()\n",
    "\n",
    "with open(\"bonjour.txt\", \"r\") as file:\n",
    "    text = file.read()\n",
    "    print(text)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58b4427b",
   "metadata": {},
   "source": [
    "2\\. readline()\n",
    "\n",
    "Cette fonction peut être utilisée pour lire un fichier ligne par ligne et non le contenu complet en un seul appel comme read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d398e00",
   "metadata": {},
   "outputs": [],
   "source": [
    "message1 = \"Bonjour le monde\\n\"\n",
    "message2 = \"Programmation en Python\"\n",
    "with open(\"bonjour.txt\", \"w\") as file:\n",
    "    file.write(message1)\n",
    "    file.write(message2)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93f72f63",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"bonjour.txt\", \"r\") as file:\n",
    "    text = file.readline()\n",
    "    print(text)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c176078",
   "metadata": {},
   "outputs": [],
   "source": [
    "message1 = \"Bonjour le monde\\n\"\n",
    "message2 = \"Programmation en Python\\n\"\n",
    "with open(\"bonjour.txt\", \"w\") as file:\n",
    "    file.write(message1)\n",
    "    file.write(message2)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20350b12",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"bonjour.txt\", \"r\") as file:\n",
    "    for line in file:\n",
    "        print(line)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41d28da3",
   "metadata": {},
   "source": [
    "**Question:** Copiez un fichier HTML dans votre répertoire. Ecrire un programme\n",
    "en Python pour obtenir les valeurs suivantes :\n",
    "\n",
    "- nombre de caractères dans le fichier HTML\n",
    "- nombre de lignes dans le fichier HTML\n",
    "- nombre de mots dans le fichier HTML\n",
    "- les vingt premiers mots du fichier HTML\n",
    "- des mots distincts dans le fichier HTML\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9c4b360",
   "metadata": {},
   "source": [
    "**Question:** Copier le CSV\n",
    "du fichier population.csv du dossier **data**. Le fichier contient les valeurs de population entre\n",
    "1901 et 2016. Écrivez un programme en Python pour obtenir la valeur maximale.\n",
    "\n",
    "- la valeur maximale de la population\n",
    "- la valeur minimale de la population\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25a982d4",
   "metadata": {},
   "source": [
    "## Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34544b31",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d770b54",
   "metadata": {},
   "source": [
    "### Les opérations sur les matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d493188",
   "metadata": {},
   "outputs": [],
   "source": [
    "a1 = [1, 2, 3, 4]\n",
    "b1 = [5, 6, 7, 8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e195685",
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = np.add(a1, b1)\n",
    "print(c1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d064b84d",
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = np.subtract(a1, b1)\n",
    "print(c1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b9d2302",
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = np.multiply(a1, b1)\n",
    "print(c1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c34fe6e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = np.multiply(4, b1)\n",
    "print(c1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b8e305a",
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = np.dot(a1, b1)\n",
    "print(c1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20c8d9d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = np.dot(5, b1)\n",
    "print(c1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2715cf3",
   "metadata": {},
   "outputs": [],
   "source": [
    "b1 = [5, 6, 7, 8]\n",
    "c1 = np.dot(a1, b1)\n",
    "print(c1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2bdb666",
   "metadata": {},
   "outputs": [],
   "source": [
    "a1 = [1, 2]\n",
    "moyen = np.average(a1)\n",
    "print(moyen)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "415f2009",
   "metadata": {},
   "source": [
    "### Tranposition matricielle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87b13595",
   "metadata": {},
   "outputs": [],
   "source": [
    "b1 = [[5, 6, 7, 8, 9], [1, 2, 3, 4, 5]]\n",
    "print(b1)\n",
    "b1 = np.array(b1)\n",
    "print(b1.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dd930b1",
   "metadata": {},
   "source": [
    "### Séparer une matrice en deux, horizontalement et verticalement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47a6dc9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [[0, 0, 0], [0, 1, 0], [1, 0, 0], [1, 1, 1]]\n",
    "a = np.array(a)\n",
    "\n",
    "a = np.hsplit(a, [2])\n",
    "\n",
    "a1 = a[0]\n",
    "a2 = a[1]\n",
    "print(a1)\n",
    "print(a2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32075a5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [[0, 0, 0], [0, 1, 0], [1, 0, 0], [1, 1, 1]]\n",
    "a = np.array(a)\n",
    "\n",
    "a = np.vsplit(a, [2])\n",
    "\n",
    "a1 = a[0]\n",
    "a2 = a[1]\n",
    "print(a1)\n",
    "print(a2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d94494c",
   "metadata": {},
   "source": [
    "### Les opérations sur les matrices bidimensionnelles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1b4a838",
   "metadata": {},
   "outputs": [],
   "source": [
    "a2 = [[1, 2, 3, 4], [1, 2, 3, 4]]\n",
    "b2 = [[5, 6, 7, 8], [5, 6, 7, 8]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3e80188",
   "metadata": {},
   "outputs": [],
   "source": [
    "c2 = np.add(a2, b2)\n",
    "print(c2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b376751",
   "metadata": {},
   "outputs": [],
   "source": [
    "c2 = np.subtract(a2, b2)\n",
    "print(c2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8507acfb",
   "metadata": {},
   "outputs": [],
   "source": [
    "c2 = np.multiply(a2, b2)\n",
    "print(c2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a198e0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "a2 = [[1, 2, 3, 4], [1, 2, 3, 4]]\n",
    "a2 = np.array(a2)\n",
    "b2 = [[5, 6, 7, 8], [5, 6, 7, 8]]\n",
    "b2 = np.array(b2)\n",
    "c2 = np.dot(a2, b2.T)\n",
    "print(c2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0268ffe9",
   "metadata": {},
   "source": [
    "### Redéfinir une matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d58bfc51",
   "metadata": {},
   "outputs": [],
   "source": [
    "b2.reshape(4, 2)\n",
    "print(b2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fc46a12",
   "metadata": {},
   "source": [
    "### Créer des matrices avec des nombres aléatoires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3a76b69",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.rand()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ab40e70",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.rand(1)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da565d7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.rand(2, 5)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64c7098f",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.rand(2, 3, 3)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94eed581",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.zeros(1)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b810583",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.zeros(1, dtype=int)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13fca4c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.zeros((2, 5), dtype=int)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01d6f047",
   "metadata": {},
   "source": [
    "### Quelques fonctions pour travailler avec des listes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58140e75",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [12, 13, 14, 15]\n",
    "a_reverse = reversed(a)\n",
    "\n",
    "for num in a_reverse:\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c59bf985",
   "metadata": {},
   "outputs": [],
   "source": [
    "jours = [\"dimanche\", \"lundi\", \"mardi\", \"mercredi\", \"jeudi\", \"vendredi\"]\n",
    "jours_num = list(enumerate(jours))\n",
    "print(jours_num)\n",
    "\n",
    "jours_num = list(enumerate(jours, start=1))\n",
    "print(jours_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ce2754e",
   "metadata": {},
   "outputs": [],
   "source": [
    "a1 = [1, 2, 3, 4]\n",
    "b1 = [5, 6, 7, 8]\n",
    "\n",
    "zipped = list(zip(a1, b1))\n",
    "print(zipped)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ef8e0ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "a1 = [1, 2, 3, 4]\n",
    "b1 = [5, 6, 7, 8]\n",
    "\n",
    "ezipped = list(enumerate(zip(a1, b1)))\n",
    "print(ezipped)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}