{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quelques bases de python pour la SPC"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    ":download:`Télécharger le pdf <./bases.pdf>` |\n",
    ":download:`Télécharger le notebook <./bases.ipynb>` |\n",
    ":download:`Lancer le notebook sur binder (lent) <https://mybinder.org/v2/gl/pyspc%2Fpyspc-formation/master?filepath=notions%2Fbases.ipynb>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## L'environnement\n",
    "\n",
    "Utilisation des notebook Jupyter\n",
    "\n",
    "- ENT\n",
    "- anaconda\n",
    "\n",
    "Notebook = \"mélange\" de code et de texte\n",
    "\n",
    "\n",
    "## Le markdown\n",
    "\n",
    "Le markdown est le langage utilisé pour mettre en forme le texte dans les cellules \"markdown\" des notebooks. C'est un langage très utilisé dans le monde du développement, parce qu'il permet de mettre en forme du texte tout en conservant une bonne lisibilité.\n",
    "\n",
    "\n",
    "```\n",
    "\n",
    "# Titre\n",
    "## Sous titre\n",
    "### Sous-sous titre\n",
    "#### ....\n",
    "\n",
    "On peut formater du texte **en gras**, en *italique*. On peut mettre `des extraits de code`\n",
    "\n",
    "- une liste non numérotée\n",
    "- élément 2\n",
    "- élément 3\n",
    "\n",
    "Une liste numérotée :\n",
    "\n",
    "1. liste numérotée\n",
    "2. liste numérotée \n",
    "3. liste numérotée \n",
    "\n",
    "Pour changer de paragraphe\n",
    "il faut \n",
    "sauter\n",
    "une ligne\n",
    "\n",
    "Prochain paragraphe\n",
    "\n",
    "Ecrire des maths : $x^2$ ou une formule séparée : $$\\frac{x^2}{\\sqrt{3}}$$\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les éléments de base\n",
    "\n",
    "En Python, tout est objet : les nombres, les chaînes de caractères, les listes, les fonctions... Pour déterminer le type d'un objet : fonction `type()`\n",
    "\n",
    "A l'intérieur du code, un commentaire débute par #\n",
    "\n",
    "### Les nombres\n",
    "\n",
    "- nombres entiers (**int**) : exemple : 3\n",
    "- nombres à virgule (**float**) exemple : 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les opérations : classiquement, addition (+), soustraction (-), multiplication (\\*), division (/) et puissance (\\*\\*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "1.5\n",
      "15625\n"
     ]
    }
   ],
   "source": [
    "# Opérations\n",
    "print(2*3)\n",
    "print(6/4)\n",
    "print(5**6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3.0\n"
     ]
    }
   ],
   "source": [
    "# Conversions de type\n",
    "# 3.124 --> int = 3\n",
    "print(int(3.124))\n",
    "# int -> float\n",
    "print(float(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.3814e+02 4.45e+05\n",
      "338.1416 444848.32\n"
     ]
    }
   ],
   "source": [
    "# Mise en forme - notation scientifique \n",
    "print(\"{0:.4e} {1:.2e}\".format(338.14159, 444848.3234234))\n",
    "# Mise en forme - un nombre donné de décimales\n",
    "print(\"{0:.4f} {1:.2f}\".format(338.14159, 444848.3234234))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les caractères"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bonjour\n",
      "bonjour\n"
     ]
    }
   ],
   "source": [
    "# Chaîne de caractères\n",
    "print('bonjour')\n",
    "print(\"bonjour\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les variables\n",
    "\n",
    "- on assigne une valeur à une variable avec le signe `=`. Exemple : `a=12` met la valeur 12 dans la variable `a`\n",
    "- précision sur les noms de variables : \n",
    "    - **uniquement des lettres sans accents**, ou des underscores `_`\n",
    "    - on peut utiliser des **chiffres** mais  **pas au début**\n",
    "    - **pas de majuscules, juste des minuscules**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "Yo Yo Yo Albert\n"
     ]
    }
   ],
   "source": [
    "x=3\n",
    "msg = 'Yo'\n",
    "nom = \"Albert\"\n",
    "\n",
    "print(x)\n",
    "print (x*(msg+\" \")+nom)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Albert Raymond\n"
     ]
    }
   ],
   "source": [
    "nom = nom + \" Raymond\"\n",
    "print(nom)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les listes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.2\n"
     ]
    }
   ],
   "source": [
    "l = [1, 'toto',3.2 , \"5\", 12]\n",
    "# recupérer un element de  la liste\n",
    "e = l[2]\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Fin cours étapes 1 et 2 : faire applications correspondantes (dissolution et structures des atomes)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les fonctions\n",
    "### Les librairies\n",
    "\n",
    "Par défaut, le python a très peu de fonctionnalités. Mais il existe une énorme **bibliothèque** de fonctions qu'on peut utiliser pour enrichir les fonctionnalités d'un programme. L'index de la bibilothèque se trouve à l'adresse https://docs.python.org/3/library/index.html\n",
    "\n",
    "En plus de cette bibliothèque de fonctions \"par défaut\" (bibliothèque standard), il existe des dizaines de milliers de bibliothèques que l'on peut consulter sur https://pypi.org/\n",
    "\n",
    "Pour utiliser une fonction mathématique, ou d'autres types de fonctions qui ne sont pas connues \"de base\", il faut les **importer**.\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.cos(3.14)\n",
    "math.sin(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.9999987317275395"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pour importer une seule fonction : \n",
    "\n",
    "from math import cos\n",
    "cos(3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.9999987317275395"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pour tout importer (à éviter)\n",
    "\n",
    "from math import *\n",
    "cos(3.14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Créer ses propres fonctions\n",
    "\n",
    "Une fonction en maths : $f(x)=3x+2$ s'écrit en python :\n",
    "\n",
    "```python\n",
    "def f(x):\n",
    "    return 3*x+2\n",
    "```\n",
    "\n",
    "- contraintes sur le nom de la fonction : pareil que pour les variables\n",
    "- début de la définition : **def**\n",
    "- un ou plusieurs arguments donnés entre parenthèses\n",
    "- le corps de la fonction doit être indenté (4 espaces)\n",
    "- la valeur retournée par la fonction est renvoyée par `return`\n",
    "- **la définition de la fonction se termine par :**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "47\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    return 3*x+2\n",
    "print(f(3))\n",
    "print(f(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Une fonction peut avoir des arguments par défaut\n",
    "def affine(x, a, b=0):\n",
    "    return a*x+b\n",
    "\n",
    "print(affine(2,5,3))\n",
    "print(affine(2,5,0))\n",
    "print(affine(2,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "# On peut donner les arguments par nom\n",
    "print(affine(a=5,x=2,b=3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coucou\n",
      "4\n",
      "15\n",
      "0\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "# Il y a des variables LOCALES dans la fonction\n",
    "\n",
    "toto = 12\n",
    "titi = 15\n",
    "\n",
    "def pouet(x):\n",
    "    print(\"Coucou\")\n",
    "    toto=x+2\n",
    "    tutu=x-2\n",
    "    print(toto)\n",
    "    print(titi) # <--- pas d'erreur, on utilise la valeur globale\n",
    "    print(tutu)\n",
    "    \n",
    "pouet(2)\n",
    "print(toto)\n",
    "# print(tutu) <--- ça plante parce que tutu est local dans pouet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "# Une fonction est une objet comme les autres, on peut donc\n",
    "# la mettre dans une variable\n",
    "\n",
    "def f(x):\n",
    "    return 3*x+2\n",
    "\n",
    "g=f\n",
    "print(g(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Les structures du langage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les booléens et les tests\n",
    "\n",
    "#### Les booléens et les opérations booléennes\n",
    "\n",
    "Un booléen : valeur vraie ou fausse (0/1)... en python `True` ou `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vrai et vrai =  True\n",
      "vrai ou faux =  True\n",
      "non vrai =  False\n"
     ]
    }
   ],
   "source": [
    "print(\"vrai et vrai = \", True and True)\n",
    "print(\"vrai ou faux = \", True or False)\n",
    "print(\"non vrai = \", not True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Les tests\n",
    "\n",
    "Les tests renvoient une valeur booléenne\n",
    "\n",
    "\"est-ce que machin est plus grand que truc ?\" : vrai / faux\n",
    "\n",
    "liste des tests disponibles : \n",
    "- `>` supérieur\n",
    "- `<` inférieur\n",
    "- `>=` supérieur ou égal\n",
    "- `<=` inférieur ou égal\n",
    "- `==` égal\n",
    "- `!=` différent\n",
    "- `in` présent dans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(3<4)\n",
    "print(2>=2)\n",
    "print(3!=2)\n",
    "print(3==3.)\n",
    "print(3 in [1, 3, 4])\n",
    "print(2 in [1, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les structures conditionnelles\n",
    "\n",
    "Plusieurs manière de faire des actions qui dépendent d'une condition :\n",
    "\n",
    "```\n",
    "SI une condition\n",
    "ALORS on fait des trucs\n",
    "```\n",
    "\n",
    "```\n",
    "SI une condition\n",
    "ALORS on fait des trucs\n",
    "SINON on fait autre chose\n",
    "```    \n",
    "\n",
    "```\n",
    "SI une condition\n",
    "ALORS on fait des trucs\n",
    "SINON SI une autre condition\n",
    "ALORS on fait des trucs\n",
    "SINON SI encore une autre condition\n",
    "ALORS onfait des trucs\n",
    "SINON on fait des trucs\n",
    "```\n",
    "\n",
    "Au niveau de la syntaxe, le python ne précise pas le \"ALORS\" :\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Regarde l'inspecteur Derrick\n"
     ]
    }
   ],
   "source": [
    "# Exemple complet pour la syntaxe\n",
    "\n",
    "age = 253\n",
    "\n",
    "if age < 6:\n",
    "    print(\"Regarde tchoupi\")\n",
    "elif age < 9:\n",
    "    print(\"Regarde power rangers\")\n",
    "elif age < 12:\n",
    "    print(\"Regarde ta console\")\n",
    "elif age < 16:\n",
    "    print(\"Arrête d'être sur ton téléphone et travaille\")\n",
    "elif age < 80:\n",
    "    print(\"Abonne toi à Netflix\")\n",
    "else:\n",
    "    print(\"Regarde l'inspecteur Derrick\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Fin de cours étape 3 : faire application correspondante (loi d'Ohm - étape 1)**"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Aucun(e)",
  "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
}