python-bases.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction rapide aux base du langage Python - Exercice pratique\n",
    "\n",
    "**Cours \"Informatique pour l'ingénieur**\" - _EPFL-ENAC-SSIE-BA3 - <Jean-Daniel.Bonjour@epfl.ch> (v. 2013-12-06) © [CC BY-SA](http://creativecommons.org/licenses/by-sa/3.0/deed.fr)_\n",
    "\n",
    "Cet exercice a pour objectif de vous faire acquérir de façon rapide et progressive les premières bases de la programmation Python en vous référant au moyen de liens à notre [support de cours](http://enacit1.epfl.ch/introduction-python/) en ligne.\n",
    "\n",
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chaînes de caractères : définition et affichage\n",
    "\n",
    "▶ ▶ ▶ Support de cours : le [type chaîne](http://enacit1.epfl.ch/introduction-python/#chaines-intro), la fonction [print](http://enacit1.epfl.ch/introduction-python/#print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Saisissez dans la cellule ci-dessous la chaîne : `C'est une chaîne` . Exécutez ensuite le contenu de cette cellule.  \n",
    "Il y a un problème, pourquoi ? Alors saisissez plutôt : `'C\\'est une chaîne'`  ou  `\"C'est une chaîne\"`. Quelle est la différence ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Référencez maintenant cette chaîne par une variable nommée : `ch1` (en d'autres termes affectez cette chaîne à ladite variable). Pour vérifier que ça fonctionne, entrez sur une seconde ligne : `ch1` (sinon vous n'aurez pas de résultat `Out[]` )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Définissez une seconde variable `ch2` référençant la chaîne : `de caractères`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concaténez, sur une nouvelle chaîne `ch3`, les 2 chaînes `ch1` et `ch2` précédentes sans omette d'ajouter un espace entre celles-ci. Vous devriez obtenir : `C'est une chaîne de caractères`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Affichez cette chaîne `ch3` sur la console avec la fonction `print`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Affichez maintenant les 2 chaînes `ch1` et `ch2` en une seule opération avec la fonction `print` (qui acccepte donc plusieurs arguments contrairement au `disp` MATLAB/Octave). Faut-il insérer un espace entre les 2 chaînes, et pourquoi ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing\n",
    "\n",
    "▶ ▶ ▶ Support de cours : le [slicing](http://enacit1.epfl.ch/introduction-python/#slicing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comment récupérez-vous la longueur de la chaîne `ch3` ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extrayez le mot `chaîne` de la variable `ch3`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extrayez les 2 premiers mots de `ch3`, c'est-à-dire : `C'est une`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extrayez de `ch3` un caractère sur deux. Vous devriez obtenir : `Cetuecan ecrcèe`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Types entiers et flottants\n",
    "\n",
    "▶ ▶ ▶ Support de cours : les [types simples](http://enacit1.epfl.ch/introduction-python/#types-simples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Affectez à la variable `nbi` le nombre entier `10`. Vérifiez en entrant `nbi` sur une seconde ligne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Affectez à la variable `nbr` le nombre réel 7.5. Vérifiez en entrant `nbr` sur une seconde ligne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Par quelques lignes de code dans la cellule ci-dessous :\n",
    "\n",
    "- assignez à une variable `nb` le produit de `nbi` par `nbr`\n",
    "- affichez le résultat avec `print`\n",
    "- affichez le type de ces 3 variables (`nbi`, `nbr` et `nb`) avec la fonction `type` (emballez cette fonction dans un `print` pour voir le résultat)\n",
    "- affichez la liste de l'ensemble de vos variables globales courantes avec la _magic fonction_ IPython `%whos`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essayons de faire le produit d'un nombre entier par une chaîne, en l'occurence : `nbi * '-='`  \n",
    "Que se passe-t-il, pourquoi ? Cela marche-t-il avec un nombre réel ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instructions sur plusieurs lignes, commentaires\n",
    "\n",
    "▶ ▶ ▶ Support de cours : [instructions multilignes](http://enacit1.epfl.ch/introduction-python/#multiligne-commentaires) et [commentaires](http://enacit1.epfl.ch/introduction-python/#multiligne-commentaires)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Définissez une variable chaîne s'étalant sur plusieurs lignes de code, et de manière qu'elle ne contienne pas de caractères newline ( `\\n` )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Définissez dans la cellule ci-dessous un commentaire d'une ligne ainsi qu'un commentaire multi-lignes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manipulation de listes\n",
    "\n",
    "▶ ▶ ▶ Support de cours : le [type liste](http://enacit1.epfl.ch/introduction-python/#listes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Créez un objet de type **liste** nommé `pers` contenant les 3 données suivantes caractérisant une personne : `98765`, `Jules`, `Dupond` (le premier élément représentant un numéro d'identification unique). Vérifiez en entrant `pers` sur une seconde ligne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ajoutez à cette liste un 4ème élément, l'année de naissance de la personne : `1980`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ajoutez encore les prénoms des 2 enfants de cette personnesous forme d'une sous-liste (donc vue comme 1 seul élément dans la liste principale) : `Marie` et `David`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Affichez et en une seule commande `print`, et par extraction à partir de cette liste `lst`, le prénom du premier enfant suivi du nom de famille de son parent, ce qui devrait donner : `Marie Dupond`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manipulation de dictionnaires\n",
    "\n",
    "▶ ▶ ▶ Support de cours : le type [dictionnaire](http://enacit1.epfl.ch/introduction-python/#dictionnaires)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ci-dessus vous conviendrez que le type liste n'était pas vraiment adapté à l'enregistrement de plusieurs personnes dans le même objet (à moins de faire de chaque personne une sous-liste). Utilisons donc plutôt le type **dictionnaire**. Le numéro d'identification se prête bien comme clé de dictionnaire, car il est unique pour chaque personne !\n",
    "\n",
    "Insérez donc dans un dictionnaire nommé `dic` la personne ci-dessus en récupérant les éléments utiles de la variable `pers`. La structure de ce dictionnaire doit être :\n",
    "\n",
    "- clé : le Numéro d'identification\n",
    "- valeur : liste comprenant Nom, Prénom, Année, Enfants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insérez une seconde personne : numéro 12345, Charlotte Durand, de 1985, sans enfants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Charlotte Durand` ayant maintenant un enfant, ajoutez son prénom : `Sarah`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opérations sur les chaînes, formatage de base\n",
    "\n",
    "▶ ▶ ▶ Support de cours : [formatage](http://enacit1.epfl.ch/introduction-python/#formatage) de chaînes, [fonctions et méthodes](http://enacit1.epfl.ch/introduction-python/#chaines-methodes) sur les chaînes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Définissez une variable `personne` contenant la chaîne : `98765;Jules;Dupond;1960`  \n",
    "Cela correspond à une manière courante de récupérer, par exportation au format texte depuis un autre logiciel, des données tabulaires dont les champs sont ici délimités par des `';'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En une seule instruction :\n",
    "\n",
    "- convertissez cette chaîne `personne` en majuscules\n",
    "- et découpez-là (_split_) aux emplacements où se trouvent les `';'` afin de récupérer les 4 données\n",
    "\n",
    "Quel est le type de l'objet sur lequel vous récupérez ces champs ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Faites l'opération inverse consistant à reconstituer une seule chaîne (_join_) contenant tous les éléments d'une liste délimités par un `';'` ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Définissez les variables suivantes:\n",
    "\n",
    "    nombre = 5\n",
    "    article = 'stylos'\n",
    "    prix = 2.5\n",
    "    \n",
    "puis utilisez celles-ci pour former, au moyen de l'opérateur de conversion `%`, une chaîne formatée contenant:\n",
    "    \n",
    "    5 stylos à CHF 2.50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exécution conditionnelle if - elif - else\n",
    "\n",
    "▶ ▶ ▶ Support de cours : la structure [if-elif-else](http://enacit1.epfl.ch/introduction-python/#if)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A l'aide d'une structure de type if-elif-else :\n",
    "\n",
    "- testez une variable `abrev` pouvant contenir l'un des caractères : L | M | W | autre caractère...\n",
    "- et retournez sur une variable `systeme` respectivement la chaîne : Linux | MacOS | Windows | indéfini"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boucle while\n",
    "\n",
    "▶ ▶ ▶ Support de cours : la boucle [while](http://enacit1.epfl.ch/introduction-python/#while)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implémentez une boucle `while` qui affiche, sous forme d'une seule ligne et sans espaces, tous les caractères minuscules de l'alphabet de a à z. Pour cela :\n",
    "\n",
    "- parcourez les valeurs de _code_ ASCII décimal de ces caractères se situant entre `97` (pour `a`) et `122` (pour `z`)\n",
    "- convertissez le _code_ en caractère (chaîne) avec la fonction `chr(code)`\n",
    "- utilisez judicieusement les paramètres `sep` et `end` de la commande `print` ( ▶ [print](http://enacit1.epfl.ch/introduction-python/#print) )\n",
    "\n",
    "Si vous avez mal contrôlé votre boucle, IPython va tourner en rond sans jamais s'arrêter (consommant 100% de CPU d'1 core de votre machine), avec le message \"Kernel busy\" au haut de l'écran. Pour l'interrompre, cliquez sur le bouton <i class=\"icon-stop\"></i> [Interrupt] (ou menu `Kernel>Interrupt`). Si ça ne fonctionne vraiment pas, il faudra tuer le serveur web avec `<ctrl-C>`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reprenez le code de la cellule précédente, mais au lieu d'afficher l'alphabet sur la console fabriquez une variable de type chaîne nommée `alphabet`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boucle for\n",
    "\n",
    "▶ ▶ ▶ Support de cours : l'itérateur de nombre entiers [range](http://enacit1.epfl.ch/introduction-python/#range-enumerate), la [boucle for](http://enacit1.epfl.ch/introduction-python/#for)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avec l'aide des fonctions `range` et `list`, construisez une liste contenant les nombres entiers de `20` à `30`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reprogrammez, au moyen d'une boucle `for` et en utilisant l'itérateur `range`, la boucle `while` que nous avons faite précédemment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _Compréhension_ de liste\n",
    "\n",
    "▶ ▶ ▶ Support de cours : [comprehension](http://enacit1.epfl.ch/introduction-python/#range-enumerate) de listes, sets et dictionnaires"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Contruisez une liste comportant tous les caractères de l'alphabet (de a à z) avec le mécanisme des _comprehension de liste_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puis appliquez à cette liste la méthode `.join` ( ▶ [méthodes](http://enacit1.epfl.ch/introduction-python/#chaines-methodes) de chaînes) pour récupérer sur une seule chaîne tous les caractères de l'alphabet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saisie interactive au clavier... dans une boucle while\n",
    "\n",
    "▶ ▶ ▶ Support de cours : la fonction [input](http://enacit1.epfl.ch/introduction-python/#input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Au moyen de la fonction `input`, demandez à l'utilisateur de saisir son nom, puis affichez: `Ok, bonjour xxx !`\n",
    "\n",
    "Puis implémentez cela dans une boucle `while` qui pose la question tant que l'utilisateur ne répond rien (c'est-à-dire frappe seulement `<enter>`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lecture de fichiers\n",
    "\n",
    "▶ ▶ ▶ Support de cours : [ouverture et fermeture](http://enacit1.epfl.ch/introduction-python/#fichiers-open-close) de fichiers, [lecture](http://enacit1.epfl.ch/introduction-python/#fichiers-lecture) de fichiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Téléchargez le fichier [dico.txt](http://enacit1.epfl.ch/introduction-python/exos/dico.txt) et déposez-le dans le répertoire de ce notebook. Puis, en décomposant explicitement toutes les opérations :\n",
    "\n",
    "- ouvrez ce fichier en mode lecture\n",
    "- lisez-le ligne après ligne  \n",
    "et affichez au fur et à mesure chaque ligne sur la console\n",
    "- refermez ce fichier\n",
    "\n",
    "Pourquoi une ligne vide s'intercale-t-elle, à l'affichage, entre chaque ligne ? Comment éviter cela ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Écriture de fichiers\n",
    "\n",
    "▶ ▶ ▶ Support de cours : [écriture](http://enacit1.epfl.ch/introduction-python/#fichiers-ecriture) de fichiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecrivez les quelques lignes de code affichant le carré, le cube et la puissance 4 des nombres de 1 à 10 de façon formatée comme ci-dessous. Puis complétez votre code par les instructions nécessaires pour envoyer ces données sur un fichier nommé `puissances.txt`.\n",
    "\n",
    "       1       1       1       1\n",
    "       2       4       8      16\n",
    "      ..     ...    ....   .....\n",
    "       9      81     729    6561\n",
    "      10     100    1000   10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Écriture de fonctions\n",
    "\n",
    "▶ ▶ ▶ Support de cours : les [fonctions](http://enacit1.epfl.ch/introduction-python/#fonctions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Réimplémentez sous forme de fonction ce que l'on a fait plus haut sous forme de structure `if-elif-else`.  \n",
    "La fonction doit pouvoir être utilisée ainsi : `systeme = convAbrev(abrev)`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testez, par une boucle `for` et un `print`, le retour de cette fonction pour les 4 cas possibles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Complétez votre fonction par un texte d'aide (_docstring_) expliquant son rôle et usage.  \n",
    "Testez que cette aide s'affiche proprement en frappant `help(convAbrev)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Et bien bravo d'être parvenu jusqu'ici, vous en savez déjà un bon petit bout sur Python !\n",
    "\n",
    "#### En espérant que vous vous êtes bien amusé et que cela vous donne l'envie d'aller plus en avant avec Python !"
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}