{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les entrées/sorties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les entrées/sorties permettent au programmeur de saisir au clavier des données, d'afficher à l'écran ou de manipuler des fichiers de données. Les entrées sorties en python3 se font essentiellement à l'aide de 2 fonctions : print() pour l'affichage et input() pour la saisie."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## L'affichage sur la sortie standard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons tout d'abord étudier la façon dont un programme python peut effectuer des affichages sur la sortie standard, c'est-à-dire l'écran. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La fonction print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction print() permet d'afficher n'importe quel nombre de valeurs fournies en arguments (c'est-à-dire entre les parenthèses). Par défaut, ces valeurs sont séparées les unes des autres par un espace, et le tout se terminer par\n",
    "un saut à la ligne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Il fait beau\", \"super !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "il est possible de choisir le séparateur à l'aide de l'argument sep, de la façon suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Il fait beau\", \"super !\", sep=\"/\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De même, il est possible d'avoir un saut à la ligne ou non à la fin\n",
    "de l'affichage, en fonction de l'argument end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Il fait beau\", \"super !\", end=\"/\");\n",
    "print(\"N'est-ce pas ?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'exemple ci-dessus ne provoque ainsi pas de saut à la ligne mais termine avec le caractère '/'. D'ailleurs, le second affichage est réalisé sur la même ligne que le premier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est également possible d'afficher le contenu de variables et non seulement la valeur d'un texte directement renseigné entre guillemets. Si l'on suppose que l'on dispose d'une variable entière i, print(i) affiche la valeur de cette variable. De la même manière, si la variable j correspond à un tableau, alors print(j) affiche le contenu de ce tableau. Ce comportement se généralise à tous les types (dictionnaires, etc.)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=12\n",
    "print(i)\n",
    "j=[1, 2, 3, 4]\n",
    "print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est également possible d'afficher le résultat d'une opération arithmétique directement :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=5\n",
    "j=7\n",
    "print(i+j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Affichage formaté"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction print() peut également utiliser une notion de format des valeurs à afficher, de la même manière que le fait la fonction printf() en langage C. Il y a cependant plusieurs possibilités offertes au programmeur. Il peut faire références aux arguments à l'aide de numéros entiers (1er argument = 0, second = 1, etc ...) et y faire référence de la façon suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"{0} a plus de dents que {1}\".format(\"Albert\", \"Raymond\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "{0} fait ainsi référence au premier argument, dont la valeur est précisée après le mot clé format (ici \"Albert\"), {1} fait référence au second argument (ici \"Raymond\"). L'intérêt de cette écriture est qu'il possible d'utiliseur plusieurs les arguments à l'aide de la notation {n}, et de fournir une seule fois leur valeur, après le mot clé format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"{0} a plus de dents que {1}, mais {0} est plus agé que {1}\" .format(\"Albert\", \"Raymond\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est également possible d'utiliser le format d'affichage en utilisant le caractère % suivi d'une lettre, comme le propose la fonction printf() du langage C. Ceci peut alors donner :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age=12\n",
    "taille=1.77\n",
    "nom=\"raymond\"\n",
    "print(\"Nom : %s, Taille : %f m, Age : %d\" % (nom,taille,age))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est enfin possible d'utiliser des caractères spéciaux dans les chaînes d'affichage, par exemple le caractère \\n qui permet d'afficher un saut à la ligne ou le caractère \\t qui permet d'affiche une tabulation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La saisie de caractères au clavier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons dans un premier temps étudier comment un programme python peut effectuer une saisie interactive de caractéres sur l'entrée standard, c'est-à-dire le clavier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La fonction input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction principale permettant de faire de la saisie utilisateur est la fonction input(). Elle retourne par défaut une chaîne de caractères qu'il est ensuite possible de convertir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ch=input()\n",
    "print(ch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est possible de fournir en argument une chaîne de caractère que input affiche sur l'écran avant de faire la saisie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ch=input(\"merci de fournir votre nom : \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction input() renvoie toujours une chaîne de caractères correspondant simplement au flux de caractères saisis par l'utilisateur. Ainsi, si l'utilisateur saisie 12, c'est bien la chaîne de caractères composée des caractères '1' puis '2 qui est affectèe à la variable ch. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ch=input()\n",
    "type(ch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est en revanche possible d'utiliser la fonction eval() et de l'appliquer à la sortie de la fonction input() pour convertir immédiatement la chaîne de caractère retournée par input() en une variable de type int ou autre, en fonction des données saisies par l'utilisateur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=eval(input())\n",
    "type(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecrire un code python qui saisit au clavier le nom, prenom, annee de naissance de plusieurs individus, et qui ensuite affiche ces informations sous la forme :\n",
    "\n",
    "Nom : <nom>\n",
    "    \n",
    "Prenom : <prenom>\n",
    "    \n",
    "Age : <age>\n",
    "    \n",
    "On proposera plusieurs solutions : une qui saisit les informations en une seule fois (sur une seule ligne) et une qui saisit les informations en plusieurs fois. On affichera à chaque fois la valeur de variable utilisé pour stocker le nom ou le prénom ou l'age, ainsi que son type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La lecture et l'écriture dans des fichiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons à présent étudier comment un programme python peut réaliser des lectures/écritures dans des fichiers. La gestion des fichiers est légèrement différente de l'entrée et la sortie standard au sens où il est nécessaire d'ouvrir un fichier avant son utilisation. L'entrée standard et la sortie standard étant toujours ouvertes par défaut, il n'est pas nécessaire de les ouvrir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'ouverture d'un fichier texte se fait à l'aide de la commande open qui prend 2 paramètres. Le nom du fichier à ouvrir et la mode d'ouverture ('r' pour lecture, 'w' pour écriture, par exemple). La fonction open retourne une variable représentant une abstraction en mémoire du fichier. C'est ensuite grâce à cette variable qu'il est possible de lire ou d'écrire des données dans le fichier. Le code suivant en lecture le fichier \"fichier.txt\", il lit la première ligne de ce fichier, grâce à la fonction readline et affiche ensuite son contenu. Il ferme enfin le fichier grâce à la fonction close. il n'est bien sûr possible d'exécuter ce programme que si le fichier \"fichier.txt\" existe, qu'il est accessible en lecture et qu'il contient des données. Nous vous invitons donc à créer ce fichier avant d'exécuter l'exemple ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fd=open(\"fichier.txt\",'r')\n",
    "ch=fd.readline()\n",
    "print(ch)\n",
    "fd.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction readline renvoie la ligne courante du fichier que l'on est en train de lire mais il est également possible de lire et récupérer l'intégralité du contenu du fichier à l'aide de la commande read, sous la forme d'une unique chaîne de caractères, ou à l'aide de la commande readlines, sous la forme d'un tableau de lignes. Ainsi l'exemple suivant affiche l'intégralité du fichier à l'écran."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fd=open(\"fichier.txt\",'r')\n",
    "ch=fd.read()\n",
    "print(ch)\n",
    "fd.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si l'on souhaite pouvoir modifier un fichier, il est nécessaire de l'ouvrir dans le mode adéquate, donc en utilisant 'w' ou 'a' comme second argument. Le mode 'w' va provoquer l'écrasement des données dans le fichier alors que le mode 'a' va ajouter des données à la fin du fichier (concaténation).\n",
    "Notez donc la différence entre les 2 exemples suivants :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"je lis le fichier :\")\n",
    "fd=open(\"fichier.txt\",'r')\n",
    "ch=fd.read()\n",
    "print(ch)\n",
    "fd.close()\n",
    "print(\"j'écris dans le fichier : \")\n",
    "fd=open(\"fichier.txt\",'w')\n",
    "fd.write(\"nouvelles donnees\")\n",
    "fd.close()\n",
    "print(\"je relis le fichier : \")\n",
    "fd=open(\"fichier.txt\",'r')\n",
    "ch=fd.read()\n",
    "print(ch)\n",
    "fd.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"je lis le fichier :\")\n",
    "fd=open(\"fichier.txt\",'r')\n",
    "ch=fd.read()\n",
    "print(ch)\n",
    "fd.close()\n",
    "print(\"j'écris à la fin du fichier : \")\n",
    "fd=open(\"fichier.txt\",'a')\n",
    "fd.write(\"nouvelles donnees\\n\")\n",
    "fd.close()\n",
    "print(\"je relis le fichier : \")\n",
    "fd=open(\"fichier.txt\",'r')\n",
    "ch=fd.read()\n",
    "print(ch)\n",
    "fd.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Noter que la fonction write n'ajoute pas de caractère fin de ligne à la fin de l'écriture donc si vous exécutez 2 fois ce programme, la dernière ligne du fichier sera ainsi constituée : nouvelles donnéesnouvelles données. Il est possible d'insérer un retour à la ligne en écrivant : fd.write(\"nouvelles donnees\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On vous propose de réaliser un petit programme python qui prend en entrée un fichier comportant des données sur des personnes :\n",
    "\n",
    "Nom      Prénom     Age    Taille\n",
    "\n",
    "Dupont   Raymond    45      177\n",
    "\n",
    "Durand   Albert     13      180\n",
    "\n",
    "On suppose que le séparateur entre les différents champs est le caractère TAB. Le programme doit lire chaque ligne du fichier et initialiser une liste comprenant 4 élements (nom,prénom,age,taille).\n",
    "Cette liste est ensuite affichée à l'écran."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On vous demande de réaliser un programme python qui coupe un fichier en fragments. Chaque fragment contient\n",
    "simplement une partie du fichier principal, chaque partie étant composée de 10 lignes (voire moins pour le dernier fragment). Si l'on suppose que le fichier d'entrée s'appelle f, les fichiers résultant du découpage s'appellent f.1, f.2, etc. Le nom du fichier d'entrée est passé en paramère du programme python, ainsi :\n",
    "./split.py input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## L'ecriture et la lecture de types complexes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le début de ce notebook a montré que les fonctions python permettent d'afficher (à l'écran ou dans un fichier) ou de lire des types simples tels que les chaînes de caractères. Le langage python permet également de réaliser ces opérations avec des types plus complexes, tels que les tableaux. Par exemple, on peut définir un tableau nommé tab, contenant dans l'ordre, l'entier 123, la chaîne de caractères coucou et le tuple ('a', '12) et on peut facilement écrire une telle structure dans un fichier à l'aide du programme suivant : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab=[123, \"coucou\", ('a', 12)]\n",
    "f=open(\"tab.txt\",\"w\")\n",
    "print(tab, file=f)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour nous assurer qu'il est possible de récupérer ces informations sous la forme d'un tableau, il faut ouvrir à nouveau le fichier mais en lecture cette fois-ci. La ligne lue doit ensuite être évaluée avec fonction eval (que nous avons déjà présentée en début de ce notebook). Si l'on capture cette ligne dans la variable tab2 et que l'on affiche son contenu, on constate que l'on retrouve le contenu de tab. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=open(\"tab.txt\",\"r\")\n",
    "tab2=eval(f.readline())\n",
    "f.close()\n",
    "print(tab2)\n",
    "print(type(tab2))\n",
    "print(type(tab2[0]))\n",
    "print(type(tab2[1]))\n",
    "print(type(tab2[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On vous propose d'initialiser une matrice d'entiers de taille 2,3. Vous devez ensuite sauvegarder le contenu de la matrice dans un fichier, puis ouvrir de nouveau ce même fichier en lecture et initialiser une matrice à partir du contenu du fichier."
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}