PythonPourLImpatient.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=\"6\"><b> Python pour l'impatient </b></font>\n",
    "\n",
    "*Formation rapide pour enseignants de Physique-Chimie, premier volet*\n",
    "\n",
    "# Introduction\n",
    "Cette formation a été initialement créée dans l'objectif de faire découvrir le langage Python aux **enseignants de Physique-Chimie**, et donner un ensemble de concepts et d'outils permettant de commencer **rapidement** à utiliser ce langage. La formation se veut efficace, aussi rapide que possible, plutôt orientée sur l'utilisation de cet outil dans le cadre de l'enseignement de la Physique-Chimie. **Même si avoir déjà écrit un programme un jour dans un langage de programmation vous aidera, aucune connaissance en programmation n'est requise pour cette formation**.\n",
    "\n",
    "<div style=\"text-align:right;\">Pierre-Emmanuel LEROY</div>\n",
    "\n",
    "> **Pour ceux qui connaissent déjà un peu ce langage**\n",
    "> \n",
    "> Dans le cadre de cette découverte du langage Python, le choix de présenter des méthodes de codage extrèmement simples est délibéré, si vous avez plus d'expérience avec ce langage vous pourrez trouver que d'autres sont bien plus pertinentes ou élégantes. Il a été par exemple décidé de n'aborder dans un premier temps que la notion de liste, repoussant (éventuellement) à plus tard la découverte de la notion de tableau. De plus l'usage des fonctions a été réduit à son strict nécessaire pour ce premier contact.\n",
    "\n",
    "## Installation d'un environnement de développement Python\n",
    "Il existe de nombreuse façon d'installer un << environnement de développement >> Python. Je vous recommande grandement de chercher la simplicité en installant une << distribution >> scientifique, qui contient alors toutes les << bibiothèques >> nécessaires à une utilisation en sciences.\n",
    "\n",
    "> **En installant une distribution Python, vous installez plusieurs composantes en même temps :**\n",
    "> - l'environnment de développement (<< IDE >> en anglais, pour integrated development environment), qui correspond à l'interface graphique dans laquelle vous allez taper le code et l'exécuter. Ici, le choix s'est porté sur l'IDE **Pyzo** pour sa simplicité et sa légèreté ;\n",
    "> - l'environnement Python en tant que tel ;\n",
    "> - des bibliothèques supplémentaires, notamment ici des bibliothèques scientifiques.\n",
    "\n",
    "Ainsi :\n",
    "- Sous Windows je vous recommande la distribution [Winpython](https://sourceforge.net/projects/winpython/files/WinPython_3.7/3.7.1.0/WinPython32-3.7.1.0.exe/download). Une fois installée, il suffit de cliquer sur le fichier *Pyzo.exe* situé dans le dossier d'installation pour lancer l'IDE Pyzo.\n",
    "- Sous Mac OS, vous pouvez d'abord [installer l'IDE Pyzo](https://github.com/pyzo/pyzo/releases/download/v4.6.1/pyzo-4.6.1-osx64.dmg) puis [la distribution Anaconda](https://repo.continuum.io/archive/Anaconda3-2018.12-MacOSX-x86_64.pkg).\n",
    "- Sous un système GNU/Linux comme Ubuntu, vous pouvez installer l'IDE Pyzo et les bibliothèques scientifiques nécessaires en tapant dans un terminal `sudo apt-get install python3 python3-matplotlib pyzo`. Enfin, lancez l'IDE Pyzo, choisissez l'option *shell config* et indiquez *python3* dans la ligne nommée *exe*.\n",
    "\n",
    "Une fois votre distribution installée, lancez l'IDE Pyzo pour tester son bon fonctionnement. C'est dans la partie gauche que vous pourrez taper du code Python puis l'exécuter. C'est dans la partie droite (appelée << shell >>) que vous pourrez voir le résultat. Tapez pour tester par exemple le code `print(42)` dans la partie gauche puis exécutez-le en presant la touche `F5`. Le résultat doit apparaître sur la partie droite comme sur l'image ci-dessous.\n",
    "\n",
    "![Pyzo](pyzo.png)\n",
    "\n",
    "## Quelques petites choses concernant la philosophie du langage avant de commencer\n",
    "Vous n'êtes pas obligés de retenir ce qui suit, c'est juste pour vous faire sentir la philosophie de l'utilisation du langage Python, et vous donner quelques règles de bon sens sur lesquelles vous pourrez revenir plus tard.\n",
    "\n",
    "> ### Quelques règles de base\n",
    ">\n",
    ">> Ces règles sont extraites de la << [PEP 20](https://www.python.org/dev/peps/pep-0020/) >>.\n",
    ">\n",
    "> - le beau est préférable au laid ;\n",
    "> - le simple est préférable au complexe ;\n",
    "> - le complexe est préférable au compliqué.\n",
    ">\n",
    "> ### Mais aussi...\n",
    "> - jamais d'espaces ni d'accents dans les noms donnés aux << objets >> (tous les trucs auquels on pourra donner un nom) ;\n",
    "> - ajouter des commentaires pour clarifier les choses ;\n",
    "> - il y a 1001 façon de faire une même chose en Python, dans un premier temps rechercher celle qui fonctionne...\n",
    ">   - ... puis celle qui est la plus simple...\n",
    ">   - ... puis si on a du temps celle qui est la plus élégante...\n",
    ">   - ... puis si on a vraiment du temps celle qui est la plus efficace !\n",
    "\n",
    "## Comment utiliser ce document ?\n",
    "Les lignes de code peuvent être exécutées directement dans ce document en cliquant dans la cellule où se situe le code puis en utilisant la combinaison de touches `Ctrl+Entrée`, ou en cliquant sur l'icône `Run`. Le résultat apparaît alors juste en dessous. Essayez de faire apparaître le résultat de la ligne de code ci-dessous (le nombre 42 doit apparaître juste en dessous) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Modifiez le code, relancez l'exécution, etc. N'hésitez pas, c'est aussi en trifouillant du code que l'on apprend à programmer.\n",
    ">> **Si vous vous retrouvez perdus à un moment, pour réinitialiser l'ensemble de la page utilisez le menu *Kernel* puis *Restart & Clear Output*.**\n",
    "\n",
    "Mais vous voudrez rapidement faire la même chose dans votre IDE Pyzo. Comme indiqué plus haut, lancez l'IDE Pyzo, notez le code dans la partie gauche puis exécutez-le en pressant la touche `F5`, ou mieux en réalisant la combinaison de touches `Crtl+Shift+E` (pour tout réinitialiser avant l'éxécution). Le résultat apparaît sur la partie droite.\n",
    "\n",
    "> Dans ce premier volet on va très rapidement aborder les bases, une sorte de **kit de survie**, pour éviter de se retrouver coincé devant un message d'erreur que l'on n'arrive pas à déchiffrer, et sans comprendre ce qui coince (bon en fait cela arrivera quand même, mais on va essayer de limiter les moments où l'on se retrouve dans cette situation).\n",
    "\n",
    "> Mais dans le volet suivant, on abordera des **outils utiles en Physique-Chimie**, comme tracer des graphes, des courbes d'ajustement, représenter des trajectoires (même en 3D), des vecteurs, créer des animations, etc.\n",
    "\n",
    "C'est parti !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affichage/saisie\n",
    "L'affichage d'un texte se fait simplement à l'aide de la fonction `print()`, par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello World !')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut encadrer le texte à afficher avec les symboles `'` ou `\"` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello World !')\n",
    "print(\"Hello World !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et voilà, vous avez réalisé votre premier programme en langage Python ! Essayez de le faire fonctionner dans l'IDE Pyzo, comme expliqué un peu plus haut.\n",
    "\n",
    "> Les parenthèses de `print()` montrent que l'objet `print` est en fait une << fonction >>. Entre les parenthèses on << passe >> des << paramètres >> (ici la chaîne de caractères `'Hello World !'`). On reviendra sur tout cela au fur et à mesure...\n",
    "\n",
    "On peut ajouter un commentaire à l'aide du signe `#`. En fait dès que l'on utilise ce signe, tout ce qui est écrit derrière sur la même ligne est considéré comme un commentaire et ne sera pas exécuté."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello World !') # Mon premier programme !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et maintenant, si je veux qu'il me demande de rentrer du texte puis l'afficher ? Et bien cela se fait à l'aide de la fonction `input()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rep=input('Quel âge avez-vous ? ')\n",
    "print('Vous avez',rep,'ans')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici, on stocke la réponse dans la << variable >> `rep`, puis on affiche le résultat avec la fonction `print()`. Notez que l'on sépare par le signe `,` les parties à afficher : du texte, le contenu d'une variable, puis à nouveau du texte.\n",
    "\n",
    "Et si l'on veut faire une petite rectification sur l'âge, disons 5 ans de moins ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Vous avez',rep-5,'ans')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Houlà ! C'est quoi tout ces messages ! En fait cela ne fonctionne pas et l'interpréteur Python << retourne une erreur >>. Le message d'erreur indique que l'opération `-` n'est pas utilisable avec une chaîne de caractères (*str* pour string) et un entier (*int* pour integer). Cela ne fonctionne pas car `rep` est une chaîne de caractères et `5` un entier !\n",
    "\n",
    "> Python est ce que l'on appelle un langage << typé >>. Chaque objet possède un << type >> et l'on ne peut faire des opérations que sur des objets de même type. On parle en réalité de << classe >>, mais ce n'est pas le propos ici de développer ce qu'est exactement une classe, ce sera pour plus tard (beaucoup plus tard)...\n",
    "\n",
    "Essayons en utilisant le contenu de la variable `rep` comme un entier pour effectuer le calcul :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Vous avez',int(rep)-5,'ans')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Donc nous avons transformé la variable `rep` en un entier ? Non, pas ici, la variable `rep` n'a pas été modifiée, nous avons simplement fait un calcul avec *sa valeur convertie en entier*. Pour vérifier le type d'un objet, on peut utiliser la fonction `type()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(rep))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La variable `rep` est toujours de type chaîne de caractère. La fonction `int()` a seulement permis d'utiliser sa valeur sous la forme d'un entier.\n",
    "\n",
    "Amusons-nous, essayez de comprendre le résultat retourné par les lignes de code suivantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(rep-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(int(rep)-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rep=int(rep)\n",
    "print(rep-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(rep))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les types de données\n",
    "On vient de voir que chaque objet était d'un certain type, voyons les principaux.\n",
    "\n",
    "## Les entiers\n",
    "Affectons à une variable appelée `a` la valeur 3 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le signe `=` signifie une affectation dans une variable, pour information l'égalité mathématique sera notée `==`.\n",
    "\n",
    "Affichons la valeur de la variable `a` et son type :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La variable `a` est un entier ! Car on lui a affecté... un entier !\n",
    "\n",
    "> Le language Python possède ce que l'on appelle un typage dynamique. Lorsque l'on affecte par exemple une valeur à une variable, celle-ci hérite immédiatement de son type. Si on lui affecte une valeur d'un autre type, celui-ci s'adapte immédiatement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les nombres décimaux\n",
    "Le séparateur décimal est le point `.`. L'écriture `1.` correspond à `1.0` (cela sert à signifier que 1 est ici un nombre décimal)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=3.26\n",
    "print(b)\n",
    "b=1.\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'écriture d'un nombre avec une puissance de 10 se fait avec la notation classique `e` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=1.26e-3 # L'écriture d'un nombre avec une puissance de 10...\n",
    "print(b)\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le type *float* correspond à un nombre décimal.\n",
    "\n",
    "## Les chaîne de caractères\n",
    "Nous avons déjà rencontré une chaîne de caractère (type *str*), voici quelques manipulations pour rappels :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c='Boujour !'\n",
    "print(c)\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les listes\n",
    "C'est une structure de données très importante. Pour faire simple, une liste est un objet qui contient des objets. Pour la définir, on utilise des crochets `[]`, et pour séparer les objets qu'elle contient des virgules `,`. Voyons quelques exemples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d=[1,2,3,7,'Bonjour !']\n",
    "print(d)\n",
    "print(type(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La liste `d` contient les entiers 1, 2, 3 et 7, et la chaîne de caractères \"Bonjour !\".\n",
    "\n",
    "On peut afficher la taille de la liste à l'aide de la fonction `len()` :\n",
    "\n",
    "> En fait `len()` est une fonction très générale pour afficher la taille d'un objet... qui en a une bien sûr :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(d)) # Affiche la taille de 'd'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Ici j'ai ajouté un petit commentaire, juste pour vous rappeler que c'est bien de le faire. Au moment où l'on écrit un programme, on maîtrise naturellement son contexte d'écriture. 15 jours plus tard, c'est beaucoup moins vrai... et parfois (souvent) on ne comprend même plus vraiment ce que l'on fait exactement !\n",
    "\n",
    "Maintenant, si je veux accéder au troisième élément, pour l'affichier, ou faire des calculs avec, etc., comment faire ? Une règle très importante : **Le langage Python compte à partir de 0 !** Ainsi le troisième élément est le numéro... 2 !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(d[2]) # Affiche l'élément numéro 2 qui se trouve être le troisième élément"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ainsi le premier élément est le numéro 0, et donc le dernier élément est le numéro... -1 ! Voilà pourquoi ce système de comptage est en réalité très pratique :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(d[0]) # Affiche le premier élément (le numéro 0)\n",
    "print(d[-1]) # Affiche le dernier élément... le numéro -1 !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un dernier point, pour afficher une partie des éléments, on utilise le symbole `:` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(d[1:4]) # Affichage les éléments numéros 1 à... 3 !!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais attendez, les numéros de 1 à 3 ?! Pourquoi pas de 1 à 4 comme demandé ?! Et bien il enlève 1 à l'index de fin indiqué, car... c'est pratique dans d'autres circonstances !\n",
    "\n",
    "> C'est quoi ces circonstantes ? Prenons l'exemple d'une concaténation, je souhaite afficher le résultat d'un conacaténation de deux listes. Bon nous, on va prendre la même pour l'exemple. Et bien c'est plus reposant intellectuellement à écrire avec ce mode de fonctionnement :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(d[0:3]+d[3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Il ne manque pas la valeur finale dans `[3:]` ? En fait si je mets -1 ce ne sera pas interprété comme la dernière valeur (il enlève 1 à l'index de fin) et le langage Python comprend que je parle de la dernière valeur si je ne mets rien après les `:`. On peut même faire pareil avec la valeur initiale :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(d[:3]+d[3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les tuples\n",
    "Les tuples, à notre niveau, ce sont juste des listes qui ne sont plus modifiables une fois créées.\n",
    "\n",
    "> On dit que ce ce sont des objets << non mutables >>. Quel est l'intérêt ? Nous le verrons sur des exemples.\n",
    "\n",
    "Pour définir un tuple, on utilise des parenthèses `()` (ou même rien, ça marche aussi) et on sépare les objets qu'il contient par des virgules `,` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e=(1,2,3) # e=1,2,3 est compris exactement de la même manière par le langage Python\n",
    "print(e)\n",
    "print(type(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Opérations sur les types\n",
    "Nous allons ici traiter des opérations possibles avec les différents types d'objets vus plus haut.\n",
    "\n",
    "## Opérations sur les variables\n",
    "Les opération possibles sur les variables sont assez intuitives, essayez de comprendre les lignes de code et les résultats suivants :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=3\n",
    "b=3.26\n",
    "print(a+b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut utiliser la valeur de `a` pour faire un calcul dont le résultat sera alors stocké dans `a` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=a+b\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quelques autres exemples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a**2) # Il faut le savoir la puissance s'écrit '**'\n",
    "\n",
    "a=a+1 # Souvent utilisé pour incrémenter une valeur\n",
    "print(a)\n",
    "\n",
    "a+=1 # Notation totalement équivalente, avec moins de signes...\n",
    "print(a)\n",
    "\n",
    "print(a,b) # Pour afficher les valeurs de 2 variables à suivre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Mais écrit comme ça... c'est un tuple (et oui) ! Et on en a pas fini avec les tuples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b=b,a # Une façon élégante d'échanger les valeurs de 2 variables\n",
    "print(a,b)\n",
    "\n",
    "a,b,c=2,3,4 # Une façon élégante de faire des affectations multiples\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> En fait les tuples sont présents à pas mal de niveau sans que l'on ne rende compte. On n'a donc pas dans un premier temps à s'en occuper, c'est plutôt naturel, mais cela permet de comprendre quelques petites choses..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opérations sur les chaînes de caractères\n",
    "Cette partie est peu utile pour nous, mais permet d'apprendre à mettre en forme des retours textuels dans les programmes.\n",
    "\n",
    "Je vous laisse découvrir et comprendre les exemples suivants :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c='Boujour !'\n",
    "print(c+c) # On peut concaténer deux chaînes de caractères avec un simple '+'\n",
    "print(2*c) # On peut répéter une chaîne de caractères avec un simple '*'\n",
    "print(c+' Ça va ?') # On met un petit espace...\n",
    "print(c+'\\nÇa va ?') # On va à la ligne avec '\\n'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lorsque l'on doit mettre une apostrophe dans une chaîne de caractères, Python va l'interpréter comme la fin de cette chaîne de caractères (oui, forcément...) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('J'aime le Python !')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deux solutions, soit utiliser le caractère d'échappement `\\` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('J\\'aime le Python !')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou changer de signe pour marquer une chaîne de caractères :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"J'aime le Python !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opérations sur les listes\n",
    "En Physique-Chimie nous ferons souvent des opérations sur des listes, notamment il arrive très souvent que l'on parte d'une liste vide, puis que l'on ajoute des éléments au fur et à mesure de l'exécution d'un calcul.\n",
    "\n",
    "### Ajouter un élément\n",
    "Pour ajouter un élément, la méthode la plus efficace est d'utiliser la méthode `append()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d=[1,2,3,7,'Bonjour !']\n",
    "d.append(5)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> J'ai bien dit méthode, et pas fonction ?! C'est une façon de programmer caractéristique de la programmation objet : `objet.methode()`. Pour travailler sur un objet, on peut utiliser une fonction (`fonction(objet)`) ou une méthode (`objet.methode()`).\n",
    "\n",
    "Une autre façon, peut-être plus intuitive mais moins efficace pour un grand nombre d'ajouts (et peu lisible) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d=[1,2,3,7,'Bonjour !']\n",
    "d=d+[5]\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Supprimer un élément\n",
    "On ne l'utilisera (pour ainsi dire) jamais. On peut utiliser la fonction `del`, attention la syntaxe peut être surprenante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d=[1,2,3,7,'Bonjour !']\n",
    "del d[3] # Pour supprimer l'élément numéro 3, soit ici le 7\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copier une liste\n",
    "On ne le fera jamais non plus, mais voici comment procéder.\n",
    "\n",
    "Tout d'abord la **fausse bonne idée** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=d # La fausse bonne idée !\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tout semble bien se passer, mais regardez, si j'ajoute un objet dans la liste `d` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.append(5)\n",
    "print(d)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le 5 a été ajouté aussi à la liste `l`. En fait `l` n'est pas une copie de `l` mais une image permanente, en réalité lorsque l'on cherche à accéder à `l` on accède à `d`.\n",
    "\n",
    "> On dit que `l` << pointe >> vers `d`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On fait comment alors ? Voici la **bonne méthode** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=list(d) # La solution !\n",
    "l.append(8)\n",
    "print(l)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opérations sur les tuples\n",
    "Comme on l'a dit plus haut, ce n'est pas possible :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "e=(1,2,3)\n",
    "e.append(4) # Action impossible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les boucles\n",
    "Je pense que la notion de boucle est intuitive pour tous les professeurs, même ceux qui n'ont jamais programmé : on souhaite réitérer un calcul un certain nombre de fois en changeant à chaque fois la valeur d'un paramètre.\n",
    "\n",
    "## Utilisation de `range`\n",
    "\n",
    "Par exemple, si je souhaite afficher tous les chiffres de 0 à 9, la solution naïve est bien sûr :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(0)\n",
    "print(1)\n",
    "print(2)\n",
    "print(3)\n",
    "print(4)\n",
    "print(5)\n",
    "print(6)\n",
    "print(7)\n",
    "print(8)\n",
    "print(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une boucle `for` permet de le faire en deux lignes de code :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ainsi, on indique avec cette syntaxe que **pour i allant de 0 à 9** il faut **afficher i**.\n",
    "\n",
    "> De 0 à 9 ? Mais c'est 10 qui est en paramètres du `range()` ?! Oui, c'est encore un décalage de -1 sur l'index de fin qui est présent avec cette syntaxe. Mais vous allez vite voir que c'est pratique, encore une fois car... Python compte à partir de 0 !\n",
    "\n",
    "Plusieurs aspects importants ici :\n",
    "- notez les `:` à la fin de la ligne démarrant le boucle `for` ;\n",
    "- notez le décalage du `print(i)`, on parle d'<< indentation >>.\n",
    "\n",
    "L'indentation est très importante dans le langage Python. Lorsque l'on réalise une indendation, tout ce qui est indenté de la même façon appartient à la structure définie plus haut. Dans l'exemple suivant :\n",
    "\n",
    "```\n",
    "for i in range(0,10):\n",
    "    print(i)\n",
    "    print('-')\n",
    "\n",
    "print('Fini !')\n",
    "```\n",
    "\n",
    "`print(i)` et `print('-')` appartiennent à la boucle `for` et seront exécutés à chaque tour de boucle. Par contre `print('Fini !')` ne sera exécuté qu'une seule fois, après l'exécution de la boucle.\n",
    "\n",
    "> Comment **créer une indentation correcte** (oui, si elle n'est pas bien effectuée, des messages d'erreur apparaîtront) ? La méthode selon moi la plus simple, celle que j'utilise personnellement, c'est tout simplement de placer le curseur à la ligne précédente juste derrière le symbole `:` et de taper sur la touche `Entrée` : l'indentation se fait automatiquement avec le bon nombre d'espaces. Si l'on veut créer soi-même une indentation (cela peut arriver), je vous conseille fortement d'utiliser une largeur de 4 espaces.\n",
    ">> On peut aussi utiliser une largeur de tabulation. En tous cas, ce qui est important à savoir, notamment si vous reprenez un programme écrit par quelqu'un d'autre, c'est qu'il faut éviter de mélanger les types d'indentation. L'IDE peut retourner une erreur vous indiquant que le type d'indentation n'est pas le même dans tout le document. Il vous faudra alors remettre toutes les indentations de la même façon.\n",
    "\n",
    "Pour le vérifier :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,10):\n",
    "    print(i)\n",
    "    print('-')\n",
    "\n",
    "print('Fini !')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une petite astuce, on peut aussi omettre l'index de départ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Démarrer à 0 est sous-entendu. Et cela donne bien 10 tours de boucle ! D'où l'intérêt de ce décalage de -1 de l'index de fin.\n",
    "\n",
    "Ainsi, on peut préciser la valeur de départ de `i` si on le souhaite, sinon ce sera 0.\n",
    "\n",
    "> Le fonctionnement de `range()` est un peut particulier, cela sort du cadre de cette présentation. Pourquoi le dire alors ? Pour les plus curieux, allez voir du côté des objets << itérables >>, vous serez surpris de tout ce qui se cache derrière :)\n",
    "\n",
    "> Pour ceux qui ont déjà programmé, vous avez peut-être en tête différents types de boucles : *for*, *while*, *do while*, etc. En langage Python, même si la boucle `while` existe, on essaye de tout écrire avec des boucles `for`.\n",
    "\n",
    "Une structure de boucle très classique, intéressante à connaître, par exemple si je souhaite afficher les éléments d'une liste, on peut le faire ainsi :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[1,2,3,7,'Bonjour !']\n",
    "for i in range(len(l)): # 'len()' retourne la taille d'un objet\n",
    "    print(l[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voyez comme c'est pratique ! Mais il y a encore mieux...\n",
    "\n",
    "## Utilisation d'une liste\n",
    "Plutôt que d'utiliser l'objet `range` on peut utiliser une liste ! Voici l'exemple précédent écrit autrement :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[1,2,3,7,'Bonjour !']\n",
    "for truc in l:\n",
    "    print(truc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'est encore plus simple et intuitif !\n",
    "\n",
    "> J'ai utilisé le nom de variable `truc` pour vous montrer que vous pouvez choisir ce que vous voulez comme nom !\n",
    "\n",
    "## Remplir une liste\n",
    "Enfin, voici une dernière structure très intéressante à connaître, celle permettant de remplir une liste avec des valeurs calculées au fur et à mesure :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[] # On commence par créer une liste vide\n",
    "for i in range(10): # On effectue 10 tours de boucle (par exemple)\n",
    "    l.append(i**2) # On calcule i^2 (par exemple)\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les conditions\n",
    "Les conditions se comprennent plutôt bien : **si** telle condition alors faire telle action, **sinon** faire telle autre action. Ainsi par exemple, vous allez facilement comprendre les lignes suivantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(l)):\n",
    "    if l[i]<=5:\n",
    "        print(l[i])\n",
    "    else:\n",
    "        print('Stop !')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Pas grand chose à voir de plus pour le moment, pour les curieux ou ceux qui se posent la question, il existe bien une structure en **sinon si** avec `elif`.\n",
    "\n",
    "# Les fonctions\n",
    "Nous avons déjà vu et utilisé des fonctions : `len(objet)` << retourne >> la taille de l'objet, `print(a)` affiche la valeur de la variable `a`, etc. Mais on peut aussi (et c'est tellement plus pratique) créer nos propres fonctions !\n",
    "\n",
    "La structure sera basée sur celle-ci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ma_fonction(parametre1,parametre2,parametre3):\n",
    "    resultat=parametre1*parametre2+parametre3 # Un exemple de calcul\n",
    "    return resultat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Il ne se passe rien à l'exécution ?! Oui, on n'a fait que définir cette nouvelle fonction `ma_fonction`. Au passage on peut mettre le nom que l'on veut à cette fonction !\n",
    "\n",
    "`def` permet de définir une fonction, et `return` d'en retourner le résultat.\n",
    "\n",
    "> On peut écrire `return(resultat)` si cela paraît plus naturel, cela ne change rien.\n",
    "\n",
    "Pour utiliser cette fonction (on dit qu'on l'<< appelle >>) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r=ma_fonction(1,2,3) # Le résultat de l'appel de 'ma_fonction' est affecté à la variable 'r'\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais et la variable `resultat`, je peux l'utiliser ? Non... C'est ce que l'on appelle une variable << locale >>, elle est définie **localement** dans la fonction. Les variables du corps du programme (en dehors des fonctions) sont appelées des variables << globales >> :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(resultat) # Ne fonctionne pas car 'resultat' est une variable définie localement !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> En résumé je ne peux pas utiliser (on dit << appeler >>) une variable locale dans le corps du programme.\n",
    ">> Mais par contre je peux appeler une variable globale dans une fonction, Python nous facilite les choses en allant chercher cette variable (oui, c'est imagé...) d'abord dans la fonction, puis s'il ne la trouve pas dans le corps du programme.\n",
    "\n",
    "Par exemple, essayez de comprendre les lignes suivantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vitesse(distance,temps):\n",
    "    return distance/temps # On peut retourner directement le résultat du calcul\n",
    "\n",
    "print(vitesse(10,3)) # On peut afficher directement le résultat de l'appel de la fonction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=5 # Une variable globale !\n",
    "def calcul(b,c):\n",
    "    return a*b/c # On peut l'appeler pour effectuer un calcul !\n",
    "\n",
    "print(calcul(2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les graphes\n",
    "Enfin ! En Physique-Chimie cela va beaucoup nous servir. Exécutez la ligne suivante `%matplotlib notebook`, mais ne la notez pas dans un IDE Python, elle ne sert qu'à afficher les graphes dans cette page."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Un graphe tout simple sans fioritures\n",
    "Pour tracer un graphe, il faut utiliser des fonctions de tracé qui ne sont pas chargées par défaut. Il faut donc les appeler en << important >> des << bibliothèques >> qui contiennent ces fonctions.\n",
    "\n",
    "C'est le rôle de la ligne `from matplotlib.pyplot import *`. On importe **toutes** les fonctions du << module >> `pyplot` de la bibliothèque `matplotlib`. N'ayez aucune crainte, c'est toujours la même syntaxe qu'il faut recopier !\n",
    "\n",
    "> Les plus aguerris utiliseraient une autre syntaxe, que vous pouvez rencontrer : `import matplotlib.pyplot as plt`. On créé en fait l'alias `plt` pour désigner le module `pyplot`, alias qu'il faut rappeler à chaque appel de fonction sous la forme `plt.lafonction()`. Bien que je préfère cette syntaxe, pour une première approche je pense qu'il vaut mieux faire simple et utiliser la syntaxe précédente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from matplotlib.pyplot import * # Bibliothèque graphique à appeler pour les tracés\n",
    "\n",
    "liste_x=[1,2,3,4]\n",
    "liste_y=[0.1,0.2,0.3,0.4]\n",
    "\n",
    "figure(1) # Pour numéroter la figure\n",
    "plot(liste_x,liste_y) # Pour créer le graphe\n",
    "show() # Pour afficher le graphe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assez simple non ? Notez qu'en déplaçant la souris sur le graphe vous pouvez voir ses coordonnées.\n",
    "\n",
    "Allez, avec quelques fioritures quand même :\n",
    "\n",
    "## Avec quelques fioritures..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_x=[1,2,3,4]\n",
    "liste_y=[0.1,0.2,0.3,0.4]\n",
    "\n",
    "liste_x2=[1,2,3,4] # Pour superposer une autre courbe...\n",
    "liste_y2=[1,2,3,4]\n",
    "\n",
    "figure(2) # C'est la deuxième figure !\n",
    "plot(liste_x,liste_y,'r+') # Pour avoir des croix ('+') rouges ('r' comme 'red')\n",
    "plot(liste_x2,liste_y2,'b+') # L'autre avec des croix bleus...\n",
    "\n",
    "title('Représentation de y(x) et y2(x)') # Un titre\n",
    "xlabel('x') # L'axe des abscisses\n",
    "ylabel('y') # L'axe des ordonnées\n",
    "legend(['y','y2']) # S'il y a plusieurs courbes on met la liste des légendes dans l'ordre\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour relier les points, faire des ajustements, etc., nous verrons cela dans le second (et dernier) volet de cette formation !\n",
    "\n",
    "C'est donc terminé pour ce premier volet, merci et bravo !"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}