2015-11-26 - TD14 - Rappels de cours sur les entrées, les sorties, et les entrées-sorties.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notions étendues d'entrées-sorties**\n",
    "\n",
    "*(Merci à Pierre-Antoine Champin pour la rédaction de ce rappel de cours)*\n",
    "\n",
    "On peut considérer que tout algorithme a nécessairement des entrées et des sorties, mais que la manière dont ces entrées-sorties sont communiquées avec l'extérieur (leur \"mode de transmission\") varie d'un algorithme à l'autre.\n",
    "\n",
    "Par exemple, les trois algorithmes suivants effectuent le même calcul, mais échangent leurs entrées-sorties de trois manières différentes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "'''\n",
    ":entrée n: int, SAISIE au clavier\n",
    ":pré-cond: n ≥ 0\n",
    ":sortie f: int, AFFICHÉE à l'écran\n",
    ":post-cond: f = n! = 1×2×3×...×n\n",
    "'''\n",
    "n = int(input(\"Valeur de n (entier positif ou nul) ? \"))\n",
    "f = 1\n",
    "i = 2\n",
    "while i < n:\n",
    "    f = f*i\n",
    "    i = i+1\n",
    "print(f)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'''\n",
    ":entrée n: int, AFFECTÉE précédemment\n",
    ":pré-cond: n ≥ 0\n",
    ":sortie f: int, AFFECTÉE pour la suite\n",
    ":post-cond: f = n! = 1×2×3×...×n\n",
    "'''\n",
    "f = 1\n",
    "i = 2\n",
    "while i < n:\n",
    "    f = f*i\n",
    "    i = i+1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fact(n):\n",
    "    '''\n",
    "    :entrée n: int, PASSÉE en paramètre\n",
    "    :pré-cond: n ≥ 0\n",
    "    :sortie f: int, RETOURNÉE\n",
    "    :post-cond: f = n! = 1×2×3×...×n\n",
    "    '''\n",
    "    f = 1\n",
    "    i = 2\n",
    "    while i < n:\n",
    "        f = f*i\n",
    "        i = i+1\n",
    "    return f\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On admettra que, dans une fonction, lorsque qu'on ne spécifie pas le mode de transmission des entrées-sorties, il est forcément \"PASSÉE en paramètre\" pour les entrées, et \"RETOURÉE\" pour les sorties.\n",
    "\n",
    "Mais certaines fonctions utilisent d'autres modes de transmission, par exemple :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# la fonction input fournie par Python (version sans paramètre)\n",
    "def input():\n",
    "    \"\"\"\n",
    "    :entrée txt1: str, SAISIE au clavier\n",
    "    :sortie txt2: str\n",
    "    :post-cond: txt2 = txt1\n",
    "    \"\"\"\n",
    "    \n",
    "# la fonction print fournie par Python\n",
    "def print(val1):\n",
    "    \"\"\"\n",
    "    :entrée val1: une valeur quelconque\n",
    "    :sortie val2: une valeur quelconque, AFFICHÉE à l'écran\n",
    "    :post-cond: val2 = val1\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notons cependant que les entrées-sorties d'une fonction ne peuvent pas avoir pour mode de transmission \"AFFECTÉE précédemment\" ou \"AFFECTÉE pour la suite\", puisque les variables d'une fonction n'existent qu'à l'intérieur de cette fonction.\n",
    "\n",
    "**Fonction et procédure**\n",
    "\n",
    "On a appelé \"fonction\" tout algorithme défini par le mot-clé def. C'est effectivement le terme général employé dans la plupart des langages de programmation.\n",
    "\n",
    "Cela dit, il est parfois nécessaire de distinguer plusieurs types de fonction (au sens large).\n",
    "\n",
    "- Dans son sens strict, le terme fonction désigne un algorithme dont toutes les entrées sont PASSÉES en paramètre, et toutes les sorties sont RETOURNÉES (par exemple, la fonction fact ci-dessus).\n",
    "\n",
    "- On appelle procédure un algorithme dont aucune sortie n'est RETOURNÉE (par exemple, la fonction print de Python).\n",
    "\n",
    "La dénomination des algorithmes ne rentrant dans aucune de ces deux catégorie varie d'une personne à l'autre ; par exemple, la fonction input de Python sera appelée \"fonction\" par certains (parce qu'elle retourne une valeur), et \"procédure\" par d'autres (parce que ce n'est pas une fonction au sens strict, son entrée n'est pas passée en paramètre).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Exercice 1 ** Écrire un algorithme qui recherche si un entier est contenu dans un tableau. Vous écrirez également le contrat et ferez bien attention à expliquer si vous manipulez des entrées, des sorties ou les deux. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def rechercheTab(tab, nb):\n",
    "    '''\n",
    "    :entree tab: un tableau d'entiers \n",
    "    :entree nb: le nombre recherché\n",
    "    :sortie present: un booleen qui indique si le nombre est présent dans le tableau ou non \n",
    "    :pré-condition: le tableau peut être vide\n",
    "    '''\n",
    "    present = False\n",
    "    i = 0\n",
    "    while (i < len(tab)) and (present == False):\n",
    "        if tab[i] == nb:\n",
    "            present = True\n",
    "        i = i + 1\n",
    "    return present\n",
    "\n",
    "print(rechercheTab([3, 6, 4, 5, 9], 6))\n",
    "print(rechercheTab([3, 6, 4, 5, 9], 1))\n",
    "print(rechercheTab([], 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Même solution (et même contrat), mais avec un for à la place du while\n",
    "# Attention, on va parcourir tout le tableau même si on n'en a pas besoin\n",
    "def rechercheTabBis(tab, nb):\n",
    "    present = False\n",
    "    for i in range(len(tab)):\n",
    "        if tab[i] == nb:\n",
    "            present = True\n",
    "            \n",
    "    return present\n",
    "    \n",
    "print(rechercheTabBis([3, 6, 4, 5, 9], 6))\n",
    "print(rechercheTabBis([3, 6, 4, 5, 9], 1))\n",
    "print(rechercheTabBis([], 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 2** Écrire un algorithme qui remplace tous les élements du tableau par leur double. Vous écrirez également le contrat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[4, 8, 14, 18]\n"
     ]
    }
   ],
   "source": [
    "def doublerTableau(tab):\n",
    "    '''\n",
    "    :entree-sortie: tab un tableau d'entiers ou de flottants\n",
    "    :pre-condition: aucune\n",
    "    :post-condition: le tableau est modifié. Chaque case contient le double de la valeur qu'elle contenait précédemment\n",
    "    '''\n",
    "    for i in range(len(tab)):\n",
    "        tab[i] = 2*tab[i]\n",
    "    \n",
    "    return tab\n",
    "\n",
    "print(doublerTableau([]))\n",
    "print(doublerTableau([2,4,7,9]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}