{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Affectation des variables et impression des résultats\n", "\n", "(code sous licence creative commun CC BY-NC-SA BY Alexis Dendiével)" ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext" }, "source": [ ":download:`Télécharger le pdf <./02-variables_input_print.pdf>`\n", "\n", ":download:`Télécharger le notebook <./02-variables_input_print.ipynb>`\n", "\n", ":download:`Lancer le notebook sur binder (lent) `" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Les differents types de variables\n", "Python est un langage objet, l'affectation du type de variable se fait par l'objet, il n'est donc pas nécessaire de déclarer le type d'une variable.\n", "\n", "Il existe plusieurs types d'objets:\n", "- entier\n", "- flottant\n", "- chaine de caractère\n", "- booléen\n", "...\n", "\n", "voyons par l'exemple l'affectation des variables:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n = 1\n", "type (n)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La commande type renvoi le type de variable.\n", "Ici l'objet 1 étant un entier, la variable n prend le type de l'objet." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "str" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n = \"1\"\n", "type(n)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "l'objet \"1\" étant une chaîne de caractère, la variable n prend le type chaine de caractère (str)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n = 1.13e-7\n", "type (n)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "de même ici, 1.13e-7 est un flottant, la variable n prend le type flottant." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tuple" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n = (1, 2, 3, 5, 7, 11, 13, 17, 19)\n", "type (n)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "En conclusion, en python, c'est l'objet qui détermine le type de la variable.\n", "\n", "\n", "## La fonction input\n", "\n", "### Présentation\n", "\n", "**Attention, l'utilisation de `input` est fortement déconseillée, il vaut mieux utiliser des fonctions, voir un peu après**. \n", "\n", "Quand on demande à l'utilisateur d'entrer une grandeur, on utilise la commande input. Il faut cependant faire attention au type de grandeur :" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "entrer un nombre entier : 42\n" ] }, { "data": { "text/plain": [ "str" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n = input (\"entrer un nombre entier : \")\n", "type(n)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Par défaut, la fonction input entre une chaîne de caractère, avec laquelle nous ne pouvons pas faire de calculs.\n", "Il faut alors préciser que nous souhaitons une valeur entière :\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "entrer un nombre entier : 42\n" ] }, { "data": { "text/plain": [ "int" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n = int(input(\"entrer un nombre entier : \"))\n", "type(n)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "entrer un nombre : 42.42\n", "42.42\n" ] } ], "source": [ "n = float(input(\"entrer un nombre : \"))\n", "print(n)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ici n est un nombre réel." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Comment ne pas utiliser `input`\n", "\n", "Imaginons un programme devant calculer le nombre de neutrons d'un atome; nous avons besoin de `A` et de `Z` pour faire le calcul.\n", "\n", "Une (mauvaise) solution serait d'écrire le programme de la manière suivante :\n", "\n", "```python\n", "A = int(input(\"A ?\"))\n", "Z = int(input(\"Z ?\"))\n", "print(\"Nombre de protons : \", A-Z)\n", "```\n", "\n", "Ce code nécessite une intéraction avec l'utilisateur pour être utilisé, on ne peut pas l'utiliser de manière automatique pour calculer le nombre de protons d'un ensemble d'atomes => pas bien :)\n", "\n", "La \"bonne\" solution est d'écrire l'action que l'on souhaite faire sous la forme d'une fonction (voir un peu plus loin pour les détails sur les fonctions), en détaillant et documentant les arguments à utiliser, et de faire utiliser cette fonction à l'utilisateur." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Nombre de neutrons : 6\n" ] } ], "source": [ "def calcul_nombre_protons(A, Z):\n", " \"\"\"\n", " Calcul et affichage du nombre de neutrons d'un atome\n", " \n", " :param A: nombre de masse\n", " :param Z: numéro atomique\n", " \"\"\"\n", " print(\"Nombre de neutrons : \", A-Z)\n", "\n", " \n", "calcul_nombre_protons(A=12, Z=6)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Print et l'écriture scientifique\n", "Quand on souhaite imprimer un résultat à l'écran, on peut utiliser la fonction print.\n", "\n", "Cependant, dans un notebook jupyter, il n'est pas toujours utile d'utiliser print : en effet, la valeur retournée par la dernière instruction est automatiquement affichée comme résultat de la cellule." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.4285714285714286" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Affichage sans \"print\" (notebook jupyter)\n", "n = 10\n", "m = n/7\n", "m" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.4285714285714286\n" ] } ], "source": [ "# Affichage avec print\n", "n = 10\n", "m = n/7\n", "print(m)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "L'instruction print a cependant quelques avantages : il est par exemple souvent utile en sciences de présenter les résultats avec un nombre correct de chiffres significatifs." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.43e+00\n" ] } ], "source": [ "print(\"{0:.2e}\".format(m))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ce formalisme dans le print permet de présenter les résultats avec le nombre de chiffres significatifs corrects. Nous avons ici l'écriture scientifique à trois chiffres significatifs.\n", "\n", "La commande print permet d'afficher des caractères afin de présenter le résultat:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "le résultats du calcul est: 1.43e+00\n" ] } ], "source": [ "print(\"le résultats du calcul est: \", \"{0:.2e}\".format(m))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On remarque que les chaînes de caractères sont entre \" \". Nous pouvons également utiliser ' '. Il faut cependant faire attention, car si la chaîne de caractère contient un ', elle doit être entourée de \" \" :\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ceci est une écriture correcte\n", "ceci est une écriture équivalente\n", "l'usage de l'apostrophe nécessite ce formalisme\n" ] } ], "source": [ "print(\"ceci est une écriture correcte\")\n", "print('ceci est une écriture équivalente')\n", "print(\"l'usage de l'apostrophe nécessite ce formalisme\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Alignement des résultats\n", "il peut être utlise d'aligner les résultats pour une lecture facilitée. \n", "\n", "L'instruction print(\"{:60}\".format()) calera ce qu'il y a dans la parenthèse du format sur 60 caractères, et permet donc cet alignement. \n", "\n", "Exemple :\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "le résultat avec un chiffre significatif est: 1e+00\n", "le résultat avec deux chiffres significatif est: 1.4e+00\n", "le résultat avec trois chiffres significatif est: 1.43e+00\n", "le résultat avec quatre chiffres significatif est: 1.429e+00\n" ] } ], "source": [ "n = 10\n", "m = n/7\n", "print('{:60}'.format(\"le résultat avec un chiffre significatif est: \"),\n", " \"{0:.0e}\".format(m))\n", "print('{:60}'.format(\"le résultat avec deux chiffres significatif est: \"),\n", " \"{0:.1e}\".format(m))\n", "print('{:60}'.format(\"le résultat avec trois chiffres significatif est: \"),\n", " \"{0:.2e}\".format(m))\n", "print('{:60}'.format(\"le résultat avec quatre chiffres significatif est: \"),\n", " \"{0:.3e}\".format(m))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il est possible également d'utiliser la tabulation, grâce à la commande `\\t`" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "le résultat avec deux chiffres significatifs est: 1.4e+00\n", "le résultat avec trois chiffres significatifs est: 1.43e+00\n", "le résultat avec trois chiffres significatifs est: 1.43e+00\n", "le résultat avec trois chiffres significatifs est: 1.43e+00\n" ] } ], "source": [ "n = 10\n", "m = n/7\n", "print(\"le résultat avec deux chiffres significatifs est: \\t\",\n", " \"{0:.1e}\".format(m))\n", "print(\"le résultat avec trois chiffres significatifs est: \\t\",\n", " \"{0:.2e}\".format(m))\n", "print(\"le résultat avec trois chiffres significatifs est: \\t\\t\",\n", " \"{0:.2e}\".format(m))\n", "print(\"le résultat avec trois chiffres significatifs est: \\t\\t\\t\",\n", " \"{0:.2e}\".format(m))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Le passage à la ligne\n", "Il peut être intéressant dans la présentation des résultats d'empécher le passage à la ligne. On utilise pour cela la commande end=' '" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "premier résultat second résultat\n" ] } ], "source": [ "print(\"premier résultat\", end =\" \")\n", "print(\"second résultat\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La commande end = ' ' permet également de pouvoir positionner des séparateurs." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - " ] } ], "source": [ "for i in range (10):\n", " print(i, end=\" - \")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il peut également être intéressant de passer volontairement à la ligne. On utilise pour cela la commande `\\n`" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ceci est le début d'une phrase \n", "ceci est la suite à la ligne\n" ] } ], "source": [ "print(\"ceci est le début d'une phrase \\nceci est la suite à la ligne\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Affichage de caractères spéciaux\n", "Il peut s'avérer nécessaire d'utiliser des caractères spéciaux. On utilise pour cela la commande \\" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "le mot \"Pierre\" est entre guillements\n" ] } ], "source": [ "print(\"le mot \\\"Pierre\\\" est entre guillements\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Séparateurs\n", "Enfin, il peut être utlise d'utiliser des séparateurs. On utilise pour cela la commande sep :" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "premier résultat -- deuxième résultat -- troisième résultat -- .\n" ] } ], "source": [ "print(\"premier résultat\",\n", " \"deuxième résultat\",\n", " \"troisième résultat\",\n", " \".\",\n", " sep = \" -- \")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## conclusion\n", "Nous avons vu l'essentiel des fonctions imput et print. Il existe d'autres méthodes que l'on trouvera facilement quand l'usage s'en fera sentir." ] } ], "metadata": { "celltoolbar": "Format de la Cellule Texte Brut", "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 }