1_premiers_pas.ipynb

{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# Initiation à la programmation Python 3 - Prise en main"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "- Langage Haut niveau - Langage proche du langage humain."
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "***\n",
    "## Syntaxe d'écriture\n",
    "\n",
    "- L'**indentation** est essentielle !\n",
    "\n",
    "*Exemple de l'écriture d'une fonction en langage C d'une part et langage Python d'autre part.*\n",
    "- En C les `{` et `}` sont essentielles pour délimiter les structures (fonction, boucles itératives, boucles conditionnelles).\n",
    "- En Python ces caractères n'apparaissent pas. C'est l'indentation qui joue le rôle de délimiteurs de structures.\n",
    "\n",
    "Le crible d'Eratosthène en Python de [Rosetta code, Sieve of Eratosthenes, Plain sieve, without any optimizations](https://rosettacode.org/wiki/Sieve_of_Eratosthenes#C):\n",
    "\n",
    "```python\n",
    "def eratosthenes2(n):\n",
    "    multiples = set()\n",
    "    for i in range(2, n+1):\n",
    "        if i not in multiples:\n",
    "            yield i\n",
    "            multiples.update(range(i*i, n+1, i))\n",
    "\n",
    "print(list(eratosthenes2(100)))\n",
    "```\n",
    "\n",
    "En comparaison, le crible d'Eratosthène en langage C de [Rosetta code, Sieve of Eratosthenes, Using set lookup](https://rosettacode.org/wiki/Category:Python):\n",
    "\n",
    "```c\n",
    "#include <stdlib.h>\n",
    "#include <math.h>\n",
    "\n",
    "char*\n",
    "eratosthenes(int n, int *c)\n",
    "{\n",
    "\tchar* sieve;\n",
    "\tint i, j, m;\n",
    "\n",
    "\tif(n < 2)\n",
    "\t\treturn NULL;\n",
    "\n",
    "\t*c = n-1;     /* primes count */\n",
    "\tm = (int) sqrt((double) n);\n",
    "\n",
    "\t/* calloc initializes to zero */\n",
    "\tsieve = calloc(n+1,sizeof(char));\n",
    "\tsieve[0] = 1;\n",
    "\tsieve[1] = 1;\n",
    "\tfor(i = 2; i <= m; i++)\n",
    "\t\tif(!sieve[i])\n",
    "\t\t\tfor (j = i*i; j <= n; j += i)\n",
    "\t\t\t\tif(!sieve[j]){\n",
    "\t\t\t\t\tsieve[j] = 1; \n",
    "\t\t\t\t\t--(*c);\n",
    "\t\t\t\t}\n",
    "  \treturn sieve;\n",
    "}\n",
    "```"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Espace de travail"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "- Il est essentiel pour vous de créer un espace de travail propre et bien organisé. \n",
    "*Vous pouvez par exemple commencer par créer un dossier nommé \"Python\" dans votre espace de travail principal*\n",
    "- Il est **primordial** de donner des noms significatifs à vos dossiers et fichiers qui composent votre espace de travail. Éviter les noms par défaut type *Sans titre.py* ou les noms non significatifs type *Exercice1.py*\n"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 1. Commentaires"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Les commentaires, essentiels à tous programmes informatiques *(à la fois pour vous en tant que développeur ou pour vos clients, collaborateurs, ...)*. \n",
    "Les commentaires sur une seule ligne sont introduits par le caractère `#`. Il suffit de placer le caractère `#` u début du commentaire. \n"
   ]
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:21.723100Z",
     "start_time": "2024-10-15T13:00:21.717975Z"
    }
   },
   "cell_type": "code",
   "source": "# Ceci est un commentaire sur une seule ligne !",
   "outputs": [],
   "execution_count": 14
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Si votre commentaire s'écrit sur plusieurs lignes (multilignes) il faut alors utiliser les caractères `'` ou `\"` en début et fin de commentaire. Chaque caractère doit être écrit trois fois en début et en fin de commentaire. \n",
    "On retrouve la plupart du temps, les commentaires multilignes dans les *docstrings*. Ces dernières sont une documentation de fonctions, classes, méthodes, ...  "
   ]
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:22.139901Z",
     "start_time": "2024-10-15T13:00:22.127904Z"
    }
   },
   "cell_type": "code",
   "source": [
    "'''\n",
    "Ceci est un commentaire sur plusieurs lignes dit \"multiligne\", \n",
    "le caractère \" peut être utilisé dans ce commentaire \n",
    "(ex: lors d'une citation, un dialogue en discours direct).\n",
    "'''"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nCeci est un commentaire sur plusieurs lignes dit \"multiligne\", \\nle caractère \" peut être utilisé dans ce commentaire \\n(ex: lors d\\'une citation, un dialogue en discours direct).\\n'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:22.180789Z",
     "start_time": "2024-10-15T13:00:22.173156Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\"\"\"\n",
    "Ceci est un commentaire sur plusieurs lignes dit 'multiligne',\n",
    "le caractère ' peut être utilisé dans ce commentaire \n",
    "(ex: mot avec apostrophe comme aujourd'hui, c'est, ...)\n",
    "\"\"\""
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nCeci est un commentaire sur plusieurs lignes dit 'multiligne',\\nle caractère ' peut être utilisé dans ce commentaire \\n(ex: mot avec apostrophe comme aujourd'hui, c'est, ...)\\n\""
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Dans la PEP257, il est mentionné que c'est l'usage des `\"\"\"` en début et fin de dosctring qui doit être préconisé.\n",
    "\n",
    "Ce sont des commentaires, mais aussi des chaînes de caractères multilignes.\n",
    "On peut la stocker dans une variable :"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:22.312503Z",
     "start_time": "2024-10-15T13:00:22.305638Z"
    }
   },
   "cell_type": "code",
   "source": [
    "multiligne = \"\"\"\n",
    "Ceci est un commentaire sur plusieurs lignes dit 'multiligne',\n",
    "le caractère ' peut être utilisé dans ce commentaire \n",
    "(ex: mot avec apostrophe comme aujourd’hui, c'est, ...)\n",
    "\"\"\"\n",
    "multiligne"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nCeci est un commentaire sur plusieurs lignes dit 'multiligne',\\nle caractère ' peut être utilisé dans ce commentaire \\n(ex: mot avec apostrophe comme aujourd’hui, c'est, ...)\\n\""
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Voir: https://peps.python.org/pep-0257/#multi-line-docstrings"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 2. Notions de variables"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Définition"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "- Une variable est une information, une donnée\n- Ces données sont rangées dans des cases de la RAM *Random Access Memory*"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Pour déclarer une fonction en Python il est nécessaire de lui attribuer un nom/identifiant (cette étape est appelée la **Déclaration** de variable) et une valeur initiale  (cette étape est appelée l'**Initialisation**)."
  },
  {
   "metadata": {
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:22.361556Z",
     "start_time": "2024-10-15T13:00:22.355177Z"
    }
   },
   "cell_type": "code",
   "source": "# Declaration et Initialisation de variables\ni = 10\nma_variable = \"Python\"",
   "outputs": [],
   "execution_count": 18
  },
  {
   "metadata": {
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:22.494150Z",
     "start_time": "2024-10-15T13:00:22.486634Z"
    }
   },
   "cell_type": "code",
   "source": "i",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:22.539277Z",
     "start_time": "2024-10-15T13:00:22.533082Z"
    }
   },
   "cell_type": "code",
   "source": "ma_variable",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 20
  },
  {
   "metadata": {
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:22.624003Z",
     "start_time": "2024-10-15T13:00:22.617728Z"
    }
   },
   "cell_type": "code",
   "source": "i, ma_variable",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 'Python')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 21
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Types de variables"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Il existe différents types de variables en fonction de la valeur qu'elles contiennent. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Ci-dessous une liste non exhaustive des principaux types de variables: \n",
    "\n",
    "| Type en Python | Signification        | Exemple                                             |\n",
    "|----------------|----------------------|-----------------------------------------------------|\n",
    "| bool           | Booléen              | True                                                |\n",
    "| int            | Nombre Entier        | 20                                                  |\n",
    "| float          | Nombre à virgule     | 20.2                                                |\n",
    "| str            | Chaîne de caractères | 'String'                                            |\n",
    "| tuple          | N-uplet              | (20, 20.2, 'string')                                |\n",
    "| list           | Liste                | [20, 20.2, 'string']                                |\n",
    "| dict           | Dictionnaire         | {'Entier': 20, 'Virgule': 20.2, 'Chaîne': 'string'} |\n",
    "\n",
    "En python, il **n'est pas nécessaire** de préciser le type de la variable au moment de sa déclaration !"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Python est un langage dont le typage est **dynamique**. "
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:22.663749Z",
     "start_time": "2024-10-15T13:00:22.656662Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#Déclaration en Python\n",
    "un_entier = 20\n",
    "#Déclaration en C\n",
    "int un_entier = 20; # Will crash"
   ],
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (126079615.py, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001B[0;36m  Cell \u001B[0;32mIn[22], line 4\u001B[0;36m\u001B[0m\n\u001B[0;31m    int un_entier = 20; # Will crash\u001B[0m\n\u001B[0m        ^\u001B[0m\n\u001B[0;31mSyntaxError\u001B[0m\u001B[0;31m:\u001B[0m invalid syntax\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Il est possible de connaître le type d'une variable ou d'une donnée. C'est la fonction **type()** qui permet de réaliser cette action"
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:22.769841Z",
     "start_time": "2024-10-15T13:00:22.762970Z"
    }
   },
   "cell_type": "code",
   "source": "un_entier = 20\nun_flottant = 20.2\nune_chaine = 'string'\nprint(type(un_entier))\nprint(type(un_flottant))\nprint(type(une_chaine))",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "execution_count": 23
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Conversion de types"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Il existe plusieurs fonctions permettant de forcer le type d'une variable en un autre type. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "| Fonction Python | Description                                                 |\n",
    "|-----------------|-------------------------------------------------------------|\n",
    "| int()           | Permet de modifier une variable en entier                   |\n",
    "| float()         | Permet de modifier une variable en flottant                 |\n",
    "| str()           | Permet de modifier une variable en chaîne de caractères     |\n",
    "| *eval()*        | *Évalue le contenu de son argument et lui attribue un type* |\n"
   ]
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:22.799829Z",
     "start_time": "2024-10-15T13:00:22.791758Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(int(20.2))\n",
    "print(float(20))\n",
    "print(str(65), \"est de type: \", type(65))\n",
    "print(type(eval('65')))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "20.0\n",
      "65 est de type:  <class 'int'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "execution_count": 24
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Opérateurs arithmétiques"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathematics comme des additions, soustractions, ... entre différentes variables ou donnée représentant des valeurs numériques.   "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "| Opérateur | Nom                             | Exemple       |\n",
    "|-----------|---------------------------------|---------------|\n",
    "| +         | Addition                        | 2 + 4 = 6     |\n",
    "| -         | Soustraction                    | 2 - 4 = -2    |\n",
    "| \\*        | Multiplication                  | 2 \\* 4 = 8    |\n",
    "| /         | Division                        | 2 / 4 = 0.5   |\n",
    "| %         | Modulo (reste division entière) | 2 % 4 = 2     |\n",
    "| \\*\\*      | Puissance, exposant             | 2 \\*\\* 4 = 16 |\n",
    "| //        | Division entière                | 2 / 4 = 0     |\n"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "**Attention aux types de données ou variables utilisées dans l'opération souhaitée !**"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Pour vous rendre compte de l'utilité de certains de ces opérateurs sur des variables ne contenant des valeurs numériques, vous pouvez essayer avec des variables de type *str* ou *list*. Certains opérateurs ne sont utilisables qu'avec des valeurs numériques !"
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:23.103486Z",
     "start_time": "2024-10-15T13:00:23.066839Z"
    }
   },
   "cell_type": "code",
   "source": [
    "var1 = 10\n",
    "var2 = 5\n",
    "var3 = \"Cours\"\n",
    "var4 = \"Python\"\n",
    "print(var1 + var2, \"il s'agit d'une somme ou addition\")\n",
    "print(var3 + var4, \"Il s'agit d'une concaténation\")\n",
    "print(var3 * 2)\n",
    "print([var3] + [var4])\n",
    "print([var3, var4] * 2)\n",
    "print(var1 + var3)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 il s'agit d'une somme ou addition\n",
      "CoursPython Il s'agit d'une concaténation\n",
      "CoursCours\n",
      "['Cours', 'Python']\n",
      "['Cours', 'Python', 'Cours', 'Python']\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mTypeError\u001B[0m                                 Traceback (most recent call last)",
      "Cell \u001B[0;32mIn[25], line 10\u001B[0m\n\u001B[1;32m      8\u001B[0m \u001B[38;5;28mprint\u001B[39m([var3] \u001B[38;5;241m+\u001B[39m [var4])\n\u001B[1;32m      9\u001B[0m \u001B[38;5;28mprint\u001B[39m([var3, var4] \u001B[38;5;241m*\u001B[39m \u001B[38;5;241m2\u001B[39m)\n\u001B[0;32m---> 10\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[43mvar1\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m+\u001B[39;49m\u001B[43m \u001B[49m\u001B[43mvar3\u001B[49m)\n",
      "\u001B[0;31mTypeError\u001B[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "execution_count": 25
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Comment réaliser des calculs plus difficiles faisant intervenir des opérateurs plus complexes comme la fonction exponentielle, logarithme, racine carrée, ..."
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Il existe une multitude de modules. Un module est un fichier contenant des définitions et des instructions. Il existe des modules pré-programmés et pré-installés que vous pouvez utiliser librement dans votre script Python, c'est la standard library. Pour connaître les modules pré-installés, vous pouvez utiliser la fonction `help()` puis saisir le nom de module. Vous avez également la possibilité de créer vos propres modules pour les intégrer dans vos projets. "
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:37.811216Z",
     "start_time": "2024-10-15T13:00:23.117804Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#Exécuter la commande help() puis saisir le mot \"modules\" vous obtiendrez alors la liste des modules pré-installés. \n",
    "help()"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Python 3.12's help utility! If this is your first time using\n",
      "Python, you should definitely check out the tutorial at\n",
      "https://docs.python.org/3.12/tutorial/.\n",
      "\n",
      "Enter the name of any module, keyword, or topic to get help on writing\n",
      "Python programs and using Python modules.  To get a list of available\n",
      "modules, keywords, symbols, or topics, enter \"modules\", \"keywords\",\n",
      "\"symbols\", or \"topics\".\n",
      "\n",
      "Each module also comes with a one-line summary of what it does; to list\n",
      "the modules whose name or summary contain a given string such as \"spam\",\n",
      "enter \"modules spam\".\n",
      "\n",
      "To quit this help utility and return to the interpreter,\n",
      "enter \"q\" or \"quit\".\n",
      "\n",
      "Help on built-in module math:\n",
      "\n",
      "NAME\n",
      "    math\n",
      "\n",
      "DESCRIPTION\n",
      "    This module provides access to the mathematical functions\n",
      "    defined by the C standard.\n",
      "\n",
      "FUNCTIONS\n",
      "    acos(x, /)\n",
      "        Return the arc cosine (measured in radians) of x.\n",
      "\n",
      "        The result is between 0 and pi.\n",
      "\n",
      "    acosh(x, /)\n",
      "        Return the inverse hyperbolic cosine of x.\n",
      "\n",
      "    asin(x, /)\n",
      "        Return the arc sine (measured in radians) of x.\n",
      "\n",
      "        The result is between -pi/2 and pi/2.\n",
      "\n",
      "    asinh(x, /)\n",
      "        Return the inverse hyperbolic sine of x.\n",
      "\n",
      "    atan(x, /)\n",
      "        Return the arc tangent (measured in radians) of x.\n",
      "\n",
      "        The result is between -pi/2 and pi/2.\n",
      "\n",
      "    atan2(y, x, /)\n",
      "        Return the arc tangent (measured in radians) of y/x.\n",
      "\n",
      "        Unlike atan(y/x), the signs of both x and y are considered.\n",
      "\n",
      "    atanh(x, /)\n",
      "        Return the inverse hyperbolic tangent of x.\n",
      "\n",
      "    cbrt(x, /)\n",
      "        Return the cube root of x.\n",
      "\n",
      "    ceil(x, /)\n",
      "        Return the ceiling of x as an Integral.\n",
      "\n",
      "        This is the smallest integer >= x.\n",
      "\n",
      "    comb(n, k, /)\n",
      "        Number of ways to choose k items from n items without repetition and without order.\n",
      "\n",
      "        Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates\n",
      "        to zero when k > n.\n",
      "\n",
      "        Also called the binomial coefficient because it is equivalent\n",
      "        to the coefficient of k-th term in polynomial expansion of the\n",
      "        expression (1 + x)**n.\n",
      "\n",
      "        Raises TypeError if either of the arguments are not integers.\n",
      "        Raises ValueError if either of the arguments are negative.\n",
      "\n",
      "    copysign(x, y, /)\n",
      "        Return a float with the magnitude (absolute value) of x but the sign of y.\n",
      "\n",
      "        On platforms that support signed zeros, copysign(1.0, -0.0)\n",
      "        returns -1.0.\n",
      "\n",
      "    cos(x, /)\n",
      "        Return the cosine of x (measured in radians).\n",
      "\n",
      "    cosh(x, /)\n",
      "        Return the hyperbolic cosine of x.\n",
      "\n",
      "    degrees(x, /)\n",
      "        Convert angle x from radians to degrees.\n",
      "\n",
      "    dist(p, q, /)\n",
      "        Return the Euclidean distance between two points p and q.\n",
      "\n",
      "        The points should be specified as sequences (or iterables) of\n",
      "        coordinates.  Both inputs must have the same dimension.\n",
      "\n",
      "        Roughly equivalent to:\n",
      "            sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))\n",
      "\n",
      "    erf(x, /)\n",
      "        Error function at x.\n",
      "\n",
      "    erfc(x, /)\n",
      "        Complementary error function at x.\n",
      "\n",
      "    exp(x, /)\n",
      "        Return e raised to the power of x.\n",
      "\n",
      "    exp2(x, /)\n",
      "        Return 2 raised to the power of x.\n",
      "\n",
      "    expm1(x, /)\n",
      "        Return exp(x)-1.\n",
      "\n",
      "        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.\n",
      "\n",
      "    fabs(x, /)\n",
      "        Return the absolute value of the float x.\n",
      "\n",
      "    factorial(n, /)\n",
      "        Find n!.\n",
      "\n",
      "        Raise a ValueError if x is negative or non-integral.\n",
      "\n",
      "    floor(x, /)\n",
      "        Return the floor of x as an Integral.\n",
      "\n",
      "        This is the largest integer <= x.\n",
      "\n",
      "    fmod(x, y, /)\n",
      "        Return fmod(x, y), according to platform C.\n",
      "\n",
      "        x % y may differ.\n",
      "\n",
      "    frexp(x, /)\n",
      "        Return the mantissa and exponent of x, as pair (m, e).\n",
      "\n",
      "        m is a float and e is an int, such that x = m * 2.**e.\n",
      "        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.\n",
      "\n",
      "    fsum(seq, /)\n",
      "        Return an accurate floating point sum of values in the iterable seq.\n",
      "\n",
      "        Assumes IEEE-754 floating point arithmetic.\n",
      "\n",
      "    gamma(x, /)\n",
      "        Gamma function at x.\n",
      "\n",
      "    gcd(*integers)\n",
      "        Greatest Common Divisor.\n",
      "\n",
      "    hypot(...)\n",
      "        hypot(*coordinates) -> value\n",
      "\n",
      "        Multidimensional Euclidean distance from the origin to a point.\n",
      "\n",
      "        Roughly equivalent to:\n",
      "            sqrt(sum(x**2 for x in coordinates))\n",
      "\n",
      "        For a two dimensional point (x, y), gives the hypotenuse\n",
      "        using the Pythagorean theorem:  sqrt(x*x + y*y).\n",
      "\n",
      "        For example, the hypotenuse of a 3/4/5 right triangle is:\n",
      "\n",
      "            >>> hypot(3.0, 4.0)\n",
      "            5.0\n",
      "\n",
      "    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)\n",
      "        Determine whether two floating point numbers are close in value.\n",
      "\n",
      "          rel_tol\n",
      "            maximum difference for being considered \"close\", relative to the\n",
      "            magnitude of the input values\n",
      "          abs_tol\n",
      "            maximum difference for being considered \"close\", regardless of the\n",
      "            magnitude of the input values\n",
      "\n",
      "        Return True if a is close in value to b, and False otherwise.\n",
      "\n",
      "        For the values to be considered close, the difference between them\n",
      "        must be smaller than at least one of the tolerances.\n",
      "\n",
      "        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\n",
      "        is, NaN is not close to anything, even itself.  inf and -inf are\n",
      "        only close to themselves.\n",
      "\n",
      "    isfinite(x, /)\n",
      "        Return True if x is neither an infinity nor a NaN, and False otherwise.\n",
      "\n",
      "    isinf(x, /)\n",
      "        Return True if x is a positive or negative infinity, and False otherwise.\n",
      "\n",
      "    isnan(x, /)\n",
      "        Return True if x is a NaN (not a number), and False otherwise.\n",
      "\n",
      "    isqrt(n, /)\n",
      "        Return the integer part of the square root of the input.\n",
      "\n",
      "    lcm(*integers)\n",
      "        Least Common Multiple.\n",
      "\n",
      "    ldexp(x, i, /)\n",
      "        Return x * (2**i).\n",
      "\n",
      "        This is essentially the inverse of frexp().\n",
      "\n",
      "    lgamma(x, /)\n",
      "        Natural logarithm of absolute value of Gamma function at x.\n",
      "\n",
      "    log(...)\n",
      "        log(x, [base=math.e])\n",
      "        Return the logarithm of x to the given base.\n",
      "\n",
      "        If the base is not specified, returns the natural logarithm (base e) of x.\n",
      "\n",
      "    log10(x, /)\n",
      "        Return the base 10 logarithm of x.\n",
      "\n",
      "    log1p(x, /)\n",
      "        Return the natural logarithm of 1+x (base e).\n",
      "\n",
      "        The result is computed in a way which is accurate for x near zero.\n",
      "\n",
      "    log2(x, /)\n",
      "        Return the base 2 logarithm of x.\n",
      "\n",
      "    modf(x, /)\n",
      "        Return the fractional and integer parts of x.\n",
      "\n",
      "        Both results carry the sign of x and are floats.\n",
      "\n",
      "    nextafter(x, y, /, *, steps=None)\n",
      "        Return the floating-point value the given number of steps after x towards y.\n",
      "\n",
      "        If steps is not specified or is None, it defaults to 1.\n",
      "\n",
      "        Raises a TypeError, if x or y is not a double, or if steps is not an integer.\n",
      "        Raises ValueError if steps is negative.\n",
      "\n",
      "    perm(n, k=None, /)\n",
      "        Number of ways to choose k items from n items without repetition and with order.\n",
      "\n",
      "        Evaluates to n! / (n - k)! when k <= n and evaluates\n",
      "        to zero when k > n.\n",
      "\n",
      "        If k is not specified or is None, then k defaults to n\n",
      "        and the function returns n!.\n",
      "\n",
      "        Raises TypeError if either of the arguments are not integers.\n",
      "        Raises ValueError if either of the arguments are negative.\n",
      "\n",
      "    pow(x, y, /)\n",
      "        Return x**y (x to the power of y).\n",
      "\n",
      "    prod(iterable, /, *, start=1)\n",
      "        Calculate the product of all the elements in the input iterable.\n",
      "\n",
      "        The default start value for the product is 1.\n",
      "\n",
      "        When the iterable is empty, return the start value.  This function is\n",
      "        intended specifically for use with numeric values and may reject\n",
      "        non-numeric types.\n",
      "\n",
      "    radians(x, /)\n",
      "        Convert angle x from degrees to radians.\n",
      "\n",
      "    remainder(x, y, /)\n",
      "        Difference between x and the closest integer multiple of y.\n",
      "\n",
      "        Return x - n*y where n*y is the closest integer multiple of y.\n",
      "        In the case where x is exactly halfway between two multiples of\n",
      "        y, the nearest even value of n is used. The result is always exact.\n",
      "\n",
      "    sin(x, /)\n",
      "        Return the sine of x (measured in radians).\n",
      "\n",
      "    sinh(x, /)\n",
      "        Return the hyperbolic sine of x.\n",
      "\n",
      "    sqrt(x, /)\n",
      "        Return the square root of x.\n",
      "\n",
      "    sumprod(p, q, /)\n",
      "        Return the sum of products of values from two iterables p and q.\n",
      "\n",
      "        Roughly equivalent to:\n",
      "\n",
      "            sum(itertools.starmap(operator.mul, zip(p, q, strict=True)))\n",
      "\n",
      "        For float and mixed int/float inputs, the intermediate products\n",
      "        and sums are computed with extended precision.\n",
      "\n",
      "    tan(x, /)\n",
      "        Return the tangent of x (measured in radians).\n",
      "\n",
      "    tanh(x, /)\n",
      "        Return the hyperbolic tangent of x.\n",
      "\n",
      "    trunc(x, /)\n",
      "        Truncates the Real x to the nearest Integral toward 0.\n",
      "\n",
      "        Uses the __trunc__ magic method.\n",
      "\n",
      "    ulp(x, /)\n",
      "        Return the value of the least significant bit of the float x.\n",
      "\n",
      "DATA\n",
      "    e = 2.718281828459045\n",
      "    inf = inf\n",
      "    nan = nan\n",
      "    pi = 3.141592653589793\n",
      "    tau = 6.283185307179586\n",
      "\n",
      "FILE\n",
      "    (built-in)\n",
      "\n",
      "\n",
      "\n",
      "You are now leaving help and returning to the Python interpreter.\n",
      "If you want to ask for help on a particular object directly from the\n",
      "interpreter, you can type \"help(object)\".  Executing \"help('string')\"\n",
      "has the same effect as typing a particular string at the help> prompt.\n"
     ]
    }
   ],
   "execution_count": 26
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Pour avoir des informations sur les méthodes et fonctions contenues dans un module en particulier, vous pouvez de nouveau utiliser la fonction `help()` puis saisir le nom du module, comme par exemple `math`."
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:38.526594Z",
     "start_time": "2024-10-15T13:00:37.814430Z"
    }
   },
   "cell_type": "code",
   "source": "#Exemple avec le module math - Instruction help() puis saisir \"math\" \n#Vous obtiendrez toutes les méthodes (fonctions) qu'il contient\nhelp()",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Python 3.12's help utility! If this is your first time using\n",
      "Python, you should definitely check out the tutorial at\n",
      "https://docs.python.org/3.12/tutorial/.\n",
      "\n",
      "Enter the name of any module, keyword, or topic to get help on writing\n",
      "Python programs and using Python modules.  To get a list of available\n",
      "modules, keywords, symbols, or topics, enter \"modules\", \"keywords\",\n",
      "\"symbols\", or \"topics\".\n",
      "\n",
      "Each module also comes with a one-line summary of what it does; to list\n",
      "the modules whose name or summary contain a given string such as \"spam\",\n",
      "enter \"modules spam\".\n",
      "\n",
      "To quit this help utility and return to the interpreter,\n",
      "enter \"q\" or \"quit\".\n",
      "\n",
      "\n",
      "You are now leaving help and returning to the Python interpreter.\n",
      "If you want to ask for help on a particular object directly from the\n",
      "interpreter, you can type \"help(object)\".  Executing \"help('string')\"\n",
      "has the same effect as typing a particular string at the help> prompt.\n"
     ]
    }
   ],
   "execution_count": 27
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Si vous souhaitez obtenir des informations de manière plus immédiate sur une méthode ou fonction contenue dans un module en particulier, vous devez importer cette méthode en précisant le module concerné puis saisir le nom de la fonction comme paramètre de la fonction `help(<nom de module>)`"
  },
  {
   "metadata": {
    "scrolled": true,
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:38.535739Z",
     "start_time": "2024-10-15T13:00:38.529239Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#Exemple avec la méthode sqrt() du module math\n",
    "from math import sqrt\n",
    "\n",
    "help(sqrt)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sqrt in module math:\n",
      "\n",
      "sqrt(x, /)\n",
      "    Return the square root of x.\n",
      "\n"
     ]
    }
   ],
   "execution_count": 28
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "#### *Exercice 1*"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Donnez le rôle de chacune des 3 méthodes suivantes contenues dans le module `random`.\n",
    "- randint()\n",
    "- random()\n",
    "- uniform()"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Affichage dans le Terminal - Sortie"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "La fonction `print()` permet d'afficher dans le Terminal ou à l'écran les données renseignées en paramètres. **Un retour à la ligne est également réalisé à chaque fin d'instruction de la fonction** `print()`. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "`print()` permet d'afficher un texte précis désiré comme par exemple la fameuse phrase \"Hello World\" mais il est également possible d'afficher le contenu d'une variable quel que soit son type. "
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:38.572553Z",
     "start_time": "2024-10-15T13:00:38.539721Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#utilisation des \"...\" = affichage du contenu des double guillemets\n",
    "print(\"Hello World\")\n",
    "#Pas de double guillemet, juste le nom d'une variable\n",
    "print(var1)\n",
    "#Attention si la variable n'a pas été déclarée en amont\n",
    "print(var10000)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "10\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'var10000' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mNameError\u001B[0m                                 Traceback (most recent call last)",
      "Cell \u001B[0;32mIn[29], line 6\u001B[0m\n\u001B[1;32m      4\u001B[0m \u001B[38;5;28mprint\u001B[39m(var1)\n\u001B[1;32m      5\u001B[0m \u001B[38;5;66;03m#Attention si la variable n'a pas été déclarée en amont\u001B[39;00m\n\u001B[0;32m----> 6\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[43mvar10000\u001B[49m)\n",
      "\u001B[0;31mNameError\u001B[0m: name 'var10000' is not defined"
     ]
    }
   ],
   "execution_count": 29
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Il est également possible d'afficher à la suite les unes des autres des chaînes de caractères et/ou contenus de variables. S'il ne s'agit que de chaînes de caractères il s'agit donc d'une concaténation, réalisée avec l'opérateur `+`. Si l'affichage concerne d'autres types de variables il est alors nécessaire de séparer les éléments par des `,`. "
  },
  {
   "metadata": {
    "trusted": false
   },
   "cell_type": "code",
   "source": [
    "print(\"Votre premier \" + var3 + \" de \" + var4)\n",
    "print(\"var1 contient la valeur: \", var1, \". var3 contient la valeur: \" + var3)"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Voir le site https://pyformat.info/ dédié au formatage des chaînes de caractères en Python!\n",
    "\n",
    "*Saurez-vous déterminer le contenu des différents affichages résultant de l'exécution du script Python ci-dessous :*"
   ]
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:00:38.661837Z",
     "start_time": "2024-10-15T13:00:38.655214Z"
    }
   },
   "cell_type": "code",
   "source": "a = \"Je suis une chaîne.\"\nprint(type(a))\na = 12\nprint(type(a))\nprint(\"a\")\nprint(a)\nprint(\"La valeur de a est \", a)",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'int'>\n",
      "a\n",
      "12\n",
      "La valeur de a est  12\n"
     ]
    }
   ],
   "execution_count": 30
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Saisie de données - Entrée"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "La fonction `input()` permet à l'utilisateur de saisir une ou des données. Cette fonction provoque une interruption dans le programme courant. L'utilisateur est alors invité à saisir des caractères au clavier. Cette saisie se terminant au moment de l'appui sur la touche *Enter*. Lorsque cette touche est enfoncée, l'exécution du programme se poursuit, et la fonction `input()` fournit en retour une valeur correspondant à ce que l'utilisateur à saisi au clavier. Cette valeur peut alors être assignée à une variable de votre choix. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Pour utiliser la fonction `input()` et afficher un message d'information à l'utilisateur lui signifiant ce qu'il doit faire, vous pouvez:\n",
    "- soit utiliser la fonction `print()` en amont avec le message renseigné en paramètre, puis la fonction `input()` sans paramètres. \n",
    "- soit directement saisir le message d'information dans les paramètres de la fonction `input()`. "
   ]
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:01:22.557737Z",
     "start_time": "2024-10-15T13:01:15.001196Z"
    }
   },
   "cell_type": "code",
   "source": "#Exemple 1 avec l'utilisation de la fonction print() en amont\nprint(\"Veuillez saisir un nombre: \")\nnb_user1 = input()\nprint(nb_user1, \" est de type \", type(nb_user1))",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Veuillez saisir un nombre: \n",
      "5  est de type  <class 'str'>\n"
     ]
    }
   ],
   "execution_count": 34
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:01:40.785892Z",
     "start_time": "2024-10-15T13:01:36.285421Z"
    }
   },
   "cell_type": "code",
   "source": "#Exemple 2 directement avec la fonction input()\nnb_user2 = input(\"Veuillez saisir un nombre: \")\nprint(nb_user2, \" est de type \", type(nb_user2))",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2  est de type  <class 'str'>\n"
     ]
    }
   ],
   "execution_count": 35
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "**Attention, comme vous pouvez le constater sur les deux exemples ci-dessus, par défaut la fonction `input()` renvoie toujours une donnée de type `str` c'est-à-dire une chaîne de caractères. Si la donnée saisie doit être exploitée autrement qu'en tant que chaînes de caractères il faut alors procéder à une conversion de type avec la fonction adaptée.**"
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:01:47.234103Z",
     "start_time": "2024-10-15T13:01:45.947963Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#Exemple si la valeur saisie doit être utilisée dans un calcul\n",
    "nb_user3 = input(\"Veuillez saisir un nombre: \")\n",
    "nb_user3 = int(nb_user3)\n",
    "print(\"Le carre de \", nb_user3, \" est égale à \", nb_user3 ** 2)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le carre de  2  est égale à  4\n"
     ]
    }
   ],
   "execution_count": 36
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-15T13:01:51.162678Z",
     "start_time": "2024-10-15T13:01:49.283828Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#Il est possible de combiner la saisie et la conversion de type\n",
    "nb_user4 = int(input(\"Veuillez saisir un nombre: \"))\n",
    "print(\"Le carre de \", nb_user4, \" est égale à \", nb_user4 ** 2)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le carre de  3  est égale à  9\n"
     ]
    }
   ],
   "execution_count": 37
  },
  {
   "metadata": {
    "trusted": true
   },
   "cell_type": "markdown",
   "source": "#### *Exercice 2*"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "**Python Bank** : Écrire un script Python appelé `credit.py` qui permet à un utilisateur de calculer les intérêts perçus sur une somme initiale saisie et un taux donné. Ces deux informations sont donc des données d'entrée que l'utilisateur devra saisir. Le script devra calculer les intérêts acquis au bout d'une année et donc la somme totale disponible.  "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Attention au nommage des variables ainsi qu'aux commentaires ! Faire valider votre script et son exécution !"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}