TP Python - 2e partie.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TP Python : 2e partie "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Consigne de travail** : avant chaque exécution d'instruction, vous devez deviner ce que python répondra. Pour ce faire, ajouter une cellule avant la console (outil \"+\" dans la barre d'outils, puis sélectionner \"Texte brut\" dans la liste déroulante de la barre d'outils).  \n",
    "Dans le cas où il n'y a pas concordance après exécution, proposer une explication dans une nouvelle cellule après la console."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Vos propres fonctions !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous vous souvenez des fonctions comme `print()`, `int()`, que vous pouvez exécuter en Python ? Et bien, bonne nouvelle : vous allez apprendre à écrire vos propres fonctions !\n",
    "\n",
    "Une fonction est un ensemble d'instructions que Python va exécuter. Chaque fonction en Python commence par le mot-clef `def`. On lui donne un nom, et elle peut avoir des paramètres. Essayons !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def salut():\n",
    "    print('Salut toi !')\n",
    "    print('Comment vas-tu ?')\n",
    "\n",
    "salut()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voilà, notre première fonction est prête !\n",
    "\n",
    "Vous vous demandez peut-être pourquoi nous avons écrit le nom de la fonction à la fin du programme. Quand nous écrivons `def salut():` et les lignes indentées qui suivent, nous écrivons les instructions disant ce que la fonction `salut` doit faire. Python va lire et mémoriser ces instructions, mais ne va pas exécuter la fonction tout de suite. Pour dire à Python que nous voulons exécuter la fonction, nous devons appeler la fonction avec `hi()`. Python lit le fichier et l’exécute de haut en bas, donc nous devons définir la fonction dans le fichier avant de l’appeler.\n",
    "\n",
    "Construisons maintenant notre première fonction avec des paramètres. Dans l'exemple précédent, nous avions une fonction que disait \"Salut toi !\" à la personne qui la lançait. Faisons une fonction identique, mais ajoutons un nom cette fois-ci : nous donnons à notre fonction un paramètre appelé `nom`.  \n",
    "*Rappelez-vous : la fonction print est indentée dans le bloc `if`, car elle est exécutée uniquement quand la condition est remplie.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def salut(nom):\n",
    "    if nom == 'Roger':\n",
    "        print('Salut Roger !')\n",
    "    elif nom == 'Julia':\n",
    "        print('Salut Julia !')\n",
    "    else:\n",
    "        print('Salut anonyme !')\n",
    "\n",
    "salut()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oups, une erreur. Heureusement, Python nous donne un message d'erreur assez utile. Il nous dit que la fonction `salut()` (celle que nous avons définie) a besoin d'un argument (que nous avons appelé `nom`). Nous avons oublié de passer cet argument lorsque nous avons appelé notre fonction. Corrigeons la dernière instruction :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "salut('Roger')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 1.1** Tester de nouveaux appels de la fonction `salut` pour qu'elle affiche toutes les possibilités programmées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Super, non ? Avec ça, vous n'avez pas besoin de répéter de lignes de code lorsque vous voulez changer le nom de la personne à saluer. C'est pour cette raison que nous avons besoin de fonctions : vous ne voulez pas avoir à répéter votre code !\n",
    "\n",
    "Faisons quelque chose de plus intelligent – il existe bien plus que deux noms, et écrire une condition pour chacun d'entre eux serait difficile, non ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def salut(nom):\n",
    "    print('Salut ' + nom + ' !')\n",
    "\n",
    "salut('Rachel')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 1.2** Écrire une fonction `double` prenant en paramètre un nombre, et affichant le double de celui-ci."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 1.3** Écrire une fonction `minimum` prenant en paramètres deux nombres, et affichant le plus petit des deux."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 1.4** Écrire une fonction `reciproquePythagore` prenant en paramètres trois nombres positifs correspondant aux longueurs des côtés d'un triangle, et affichant si celui-ci est rectangle ou non."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 1.5** Écrire une fonction `bissextile` prenant en paramètre un entier naturel correspondant à une année, et affichant si celle-ci est bissextile ou non.  \n",
    "(rappel : une année est bissextile si elle est un multiple de 4, mais pas de 100, sauf si elle multiple de 400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Appeler le professeur pour vérification*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### La commande `return`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifions l'unique instruction de la fonction `salut` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def salut(nom):\n",
    "    return 'Salut ' + nom + ' !'\n",
    "\n",
    "salut('Rachel')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'exécution de la fonction affiche le texte entre guillemets (simples). Normal ! Nous ne lui demandons plus d'afficher mais de retourner une réponse. Ainsi, l'instruction `salut('Rachel')` n'affiche plus `Salut Rachel !`, mais se contente de renvoyer la chaîne de caractères `'Salut Rachel !'`, que nous pouvons alors faire afficher avec la fonction `print` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reponse = salut('Rachel')\n",
    "print(reponse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'intérêt de retourner au lieu d'afficher réside dans la nouvelle possibilité d'utiliser le résultat d'une fonction dans un programme.  \n",
    "Par exemple, pour trouver le plus petit de trois nombres donnés, on peut réexploiter la fonction `minimum` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def minimum(a,b):\n",
    "    if a<b:\n",
    "        return a\n",
    "    else:\n",
    "        return b\n",
    "\n",
    "def minimum3(a,b,c):\n",
    "    d = minimum(a,b)\n",
    "    return minimum(d,c)\n",
    "\n",
    "print(minimum3(51,16,23))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Les listes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En plus des chaines de caractères et des entiers, Python possède tout un tas d'autres types d'objets. Nous allons maintenant vous présenter un type appelé `list` (liste). Les listes sont exactement ce que vous pensez : des objets qui sont des listes d’autres objets. :)\n",
    "\n",
    "Allons-y, créons une liste :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oui, cette liste est vide. Pas très utile, non ? Créons maintenant une liste de numéros de loterie. Nous ne voulons pas nous répéter tout le temps, donc mettons-la dans une variable :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loto = [3, 42, 12, 19, 30, 59]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voilà, nous avons une liste ! Qu'est ce que nous pourrions en faire ? Commençons par voir combien de numéros de loterie il y a dans cette liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(loto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`len` vous donne le nombre d'objects dans une liste. Pratique, non ?  \n",
    "En considérant une chaîne de caractères comme une liste de caractères, `len` permet aussi de compter les caractères d'un mot, d'une phrase :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(\"Combien cette phrase a-t-elle de caractères ?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Revenons aux listes : peut-être qu'on peut aussi les trier ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loto.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ça ne renvoie rien : cette fonction a juste changé l'ordre dans lequel les nombres apparaissent dans la liste. Affichons-la encore pour voir ce qu'il s'est passé :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(loto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comme vous pouvez le voir, les nombres de la liste sont maintenant triés du plus petit au plus grand. Bravo !\n",
    "\n",
    "Pouvons-nous inverser cet ordre ? Essayons !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loto.reverse()\n",
    "print(loto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si vous voulez ajouter quelque chose à la liste, vous pouvez le faire en tapant cette commande :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loto.append(199)\n",
    "print(loto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si vous ne souhaitez afficher que le premier élément, vous pouvez le faire en utilisant des indices. Un indice est un nombre qui indique où se trouve un élément dans la liste. Les programmeurs⋅euses préfèrent compter à partir de 0 : le premier objet dans notre liste a donc pour indice 0, le suivant 1 et ainsi de suite. Essayez ça :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(loto[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(loto[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comme vous pouvez le voir, nous pouvons accéder à différents objets dans la liste en utilisant le nom de la liste suivi de l'indice de l'objet entre crochets.\n",
    "\n",
    "Pour supprimer quelque chose de votre liste, vous devrez utiliser les indices comme nous l'avons appris ci-dessus et la méthode `pop()`. Essayons l'exemple suivant : supprimez le premier élément de votre liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(loto)\n",
    "loto.pop(0)\n",
    "print(loto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 2.1** Uniquement à l'aide des méthodes `append()`, `pop()` et `sort()`, modifier la liste `premiers` fournie pour qu'elle contienne les nombres premiers inférieurs à 20 (2, 3, 5, 7, 11, 13, 17 et 19) dans l'ordre croissant en un minimum d'instructions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "premiers = [1, 9, 11, 3, 7, 19, 2, 5]\n",
    "# Tapez vos instructions ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 2.2** Uniquement à l'aide des méthodes `append()`, `pop()` et `sort()`, modifier la chaîne de caractères `consonnes` fournie pour qu'elle contienne toutes les consonnes dans l'ordre alphabétique en un minimum d'instructions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabet = \"azertyuiopqsdfghjklmwxcvbn\"\n",
    "# Tapez vos instructions ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Appelez le professeur pour vérification*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Les boucles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les programmeurs⋅euses n'aiment pas devoir se répéter. L'essence de la programmation est d'automatiser les choses. Pour reprendre l'exemple précédent, nous aimerions pouvoir saluer automatiquement chaque personne. Pour cela, nous allons utiliser des boucles.\n",
    "\n",
    "Faisons une liste de personnes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "personnes = ['Roger', 'Julia', 'Brigitte', 'Rachel', 'Jean-René']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous voulons saluer chacun d'entre eux par son nom. Nous avons déjà la fonction `salut` pour faire ça, utilisons-la donc dans une boucle :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def salut(nom):\n",
    "    print(\"Salut \" + nom + \" !\")\n",
    "\n",
    "personnes = ['Roger', 'Julia', 'Brigitte', 'Rachel', 'Jean-René']\n",
    "for nom in personnes:\n",
    "    salut(nom)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'instruction `for` se comporte un peu comme `if`. Le code qui suit doit donc être indenté. Tout ce que vous mettez dans la déclaration `for` avec une indentation sera répété pour chaque élément de la liste.\n",
    "L'instruction `for ... in ...:` se traduit en langage naturel par « Pour chaque élément ... de la liste ... » : la variable `nom` va prendre tour à tour la valeur de chaque élément de la liste.\n",
    "\n",
    "Vous pouvez aussi utiliser `for` sur des nombres grâce à la fonction `range` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,6):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`range` est une fonction qui crée une liste de nombres qui se suivent (c'est vous qui définissez l’intervalle à l'aide de paramètres).\n",
    "\n",
    "Vous pouvez remarquer que le second de ces nombres n'est pas inclus dans la liste que Python nous donne (ce qui signifie que `range(1, 6)` compte de 1 à 5, mais n'inclue pas 6). Cela est du au fait que `range` est semi-ouvert, c'est-à-dire qu'il prend en compte la première valeur mais pas la dernière."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 3.1** Afficher les mots de la liste fournie ayant au moins 23 lettres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mots = ['anticonstitutionnelle', 'anticonstitutionnellement', 'anticonstitutionnelles', 'arrière-grands-oncles', 'arrière-grands-parents', 'arrière-petites-filles', 'arrière-petits-enfants', 'chirurgiens-dentistes', 'commissaires-priseurs', 'constitutionnellement', 'contre-interrogatoire', 'contre-interrogatoires', 'contre-manifestations', 'contre-révolutionnaire', 'contre-révolutionnaires', 'électroencéphalogramme', 'électroencéphalogrammes', 'hospitalo-universitaire', 'hospitalo-universitaires', 'institutionnalisaient', 'institutionnalisation', 'institutionnaliseraient', 'institutionnaliserait', 'institutionnalisèrent', 'institutionnaliseront', 'intergouvernementales', 'internationaliseraient', 'internationaliserions', 'interprofessionnelles', 'mécaniciens-dentistes', 'médico-professionnelle', 'médico-professionnelles', 'médico-professionnels', 'moissonneuse-batteuse', 'moissonneuses-batteuses', 'nationaux-socialistes', 'oto-rhino-laryngologiste', 'oto-rhino-laryngologistes', 'présidents-directeurs', 'radicales-socialistes', 'réapprovisionneraient', 'socioprofessionnelles']\n",
    "# Taper les instructions ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 3.2** Calculer la somme des nombres de la liste fournie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombres = [1, 68, 42, 102, 673]\n",
    "# Taper les instructions ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 3.3** Écrire une fonction `diviseurs` qui prend en paramètre un nombre entier positif et affiche ses diviseurs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 3.4** Écrire un fonction `miniliste` qui prend en paramètres une liste de nombres, et retroune le plus petit d'entre eux. (*Utiliser la fonction `minimum` de la partie précédente.*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 3.5** Écrire une fonction `plusjeune` prenant en paramètres deux listes de même taille : l'une contenant des prénoms de personnes, l'autre contenant leur âge (l'ordre est bien sûr respecté ; les âges sont tous différents). La fonction doit renvoyer le prénom du plus jeune.  \n",
    "*Aide : pour connaître la position de la première occurrence d'un élément dans une liste, on utilise la méthode `index()`. Par exemple, si `liste = ['A', 'D', 'F', 'K', 'L']`, alors `liste.index('K')` renverra `3`.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plusjeune(prenoms, ages):\n",
    "    # Taper les instructions ici\n",
    "\n",
    "    \n",
    "# Pour tester :\n",
    "print(plusjeune(['Abdul', 'Bernard', 'Caroline', 'Daphné', 'Élian'], [15, 17, 16, 14, 18]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Appeler le professeur pour vérification*"
   ]
  }
 ],
 "metadata": {
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}