CHAPITRE 1 Un peu d' arithmétique.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CHAPITRE I : Un peu d'arithmétique.\n",
    "# Principes de base de la programmation Python\n",
    "Contenu :\n",
    "- variables, types\n",
    "- opérandes et opérateurs\n",
    "- conditionnelles et booléens\n",
    "- fonctions (paramètres et arguments, spécification, variables locales et globales\n",
    "- boucles bornées et non bornées"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## I) Les variables\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. variables et affectations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "x=2\n",
    "y=3\n",
    "z=y\n",
    "print(x+z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "x = 2 est une instruction d'affectation. \n",
    "Dans l'expression x+z, \"+\" est l'*opérateur* et x et y sont les *opérandes*. On peut écrire :\n",
    "\n",
    " **+: int x int -> int**\n",
    "(int signifie *integer*, c'est à dire entier)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,z = 1,2,3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bonjour,nsi\n"
     ]
    }
   ],
   "source": [
    "x='bonjour,'\n",
    "y='nsi'\n",
    "print(x+y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ici x et y sont de type string*, c'est à dire chaîne de caractère. Le + est donc ici un opérateur de *concaténation* de deux chaînes de caractère. On peut écrire :\n",
    "\n",
    "  \\ **+ : string x string -> string**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Python, Un langage typé "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-bcd98feecc7c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m      \u001b[0;31m# affectation simultanée de 2 variables\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'La somme de ces 2 nombres vaut :'\u001b[0m\u001b[0;34m+\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "a, b = 6, 10      # affectation simultanée de 2 variables\n",
    "print('La somme de ces 2 nombres vaut :'+ a + b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le python est donc un langage typé. C'est normal que l'exemple précédent donne une erreur car il y a une ambiguïté sur le + : concaténation ou addition ?. Pour corriger, nous allons remplacer a + b qui est un entier (*int*), par str(a+b) qui est une chaîne. A vous !  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=input(\"saisissez un entier entre 1 et 10\")\n",
    "double = 2*a\n",
    "print('son double est '+str(double))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que s'est-il passé ? Pour le comprendre, vous pouvez inspecter le type de a en tapant print(type(a)).\n",
    "Pour que a soit considéré comme un entier, il faut remplacer input(... par int(input....).\n",
    "A vous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pourquoi ce .0 ? L'opérateur de division / est un opérateur /:float x float -> float. float signifie flottant, c'est à dire réel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4//2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "// est l'opérateur de division euclidienne //: int x int -> int. Il donne le quotient de la division euclidienne. Par contre il peut y avoir un reste. On peut l'obtenir avec l'opérateur \n",
    "\n",
    "**%:int x int -> int (on dit *modulo*)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Instruction conditionnelle et booléen\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a  = int(input(\"votre nombre (entier) ?\"))\n",
    "if a>b:\n",
    "    print(\"il est plus grand que 10\")\n",
    "else:\n",
    "    print(\"il est plus petit ou égal à 10\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit que le langage python est *indenté* : cela signifie que les blocs de code sont distingués par un décalage à la ligne. Ici les instructions print sont dans le bloc d'instruction de if et de else."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que dire de > ? . Ici c'est un opérateur  qu'on peut spécifier comme suit :\n",
    "\n",
    " **> : int x int -> bool**\n",
    "\n",
    "Bool signifie booléen. C'est une variable très importante en informatique, elle prend 2 valeurs : True et False (attention aux majuscules) pour vrai et faux. Ainsi, l'instruction if attend un booléen . Pourquoi ne pas écrire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if True:\n",
    "    print(\"vive l'informatique\")\n",
    "else:\n",
    "    print(\"à mort l'informatique\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le monde des booléens est muni d'un véritable algèbre, dont les opérateurs sont bien connus : not, and, or ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Synthèse sur les types déjà vus\n",
    "\n",
    "| Type            | signifie                          | opérateurs fréquents    |\n",
    "| --------------- |:----------------------------------| -----------------------:|\n",
    "| int             | entier                            |  + - *  ** // %         |\n",
    "| float           | réel (flottant)                   |  + - * ** /             |\n",
    "| str             | chaîne de caractère (string)      |  +  *                   |\n",
    "| bool            | booléen (True ou False            |  == > < >= <= and not or|       \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# II. Les fonctions\n",
    "appel de fonction, paramètres et arguments, paramètres par défaut, paramètres nommés)\n",
    "\n",
    "La fonction en Python s'apparente à la notion de fonction vue en mathématiques.\n",
    "\n",
    "## 1 paramètres et arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cube(x):\n",
    "    '''\n",
    "    int or float -> int or float\n",
    "    retourne le cube de x\n",
    "    '''\n",
    "    return x**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# vous pouvez modifier l'argument\n",
    "cube(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans cette fonction x est un **paramètre** de la fonction, lorsque j'appelle cube(-1), -1 est un **argument** passé à la fonction.\n",
    "\n",
    "Les commentaires entourés de 3 guillements sont des docstrings. Ils permettent de documenter avec rigueur les fonctions. Quand vous pointez sur u ne fonction, \\[shift\\] + \\[tab\\] vous permet d'afficher la documentation.\n",
    "\n",
    "Les fonctions booléennes, couplées à une conditionnelle, sont très utiles.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math # pour la racine carrée\n",
    "\n",
    "def positif(x):\n",
    "    '''\n",
    "    float -> bool\n",
    "    détermine si x est positif\n",
    "    '''\n",
    "    return (x>=0)\n",
    "\n",
    "a =int(input(\"votre nombre ?\"))\n",
    "if positif(a):\n",
    "    print(math.sqrt(a))\n",
    "else:\n",
    "    print(\"opération impossible !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une fonction peut avoir de nombreux paramètres :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def moyenne(a,b):\n",
    "    '''\n",
    "     float x float -> float\n",
    "     retourne la moyenne de a et de b\n",
    "    '''\n",
    "    return (a+b)/2\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# vous pouvez modifier l'argument\n",
    "moyenne(5,7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si on omet les arguments, on peut définir des valeurs par défaut:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bonjour(nom=\"anonyme\"):\n",
    "    '''\n",
    "     str -> str\n",
    "     retourne une phrase amicale\n",
    "    '''\n",
    "    return 'bonjour '+nom+'!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# essayez avec ou sans argument\n",
    "bonjour('toto')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si on a un doute sur l'ordre des arguments, on peut les nommer à l'appel :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def identite(etat_civil,prenom,nom):\n",
    "    ''' str x str x str -> str\n",
    "        décline l'identité\n",
    "    '''\n",
    "    return(etat_civil+' '+prenom+' '+nom)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "identite('M.',nom='Dupont',prenom='Jean')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 variable locale et variable globale\n",
    "\n",
    "Observez ce code et devinez l'affichage final:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a= 4\n",
    "def toto(x):\n",
    "    a = 5\n",
    "toto(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici la variable a dans la fonction a une portée locale. La variable a de départ est une autre variable, une variable globale. Pour modifier réellement la variable globale a, ajouter en début de fonction\n",
    "**global a**\n",
    "\n",
    "ATTENTION, CETTE DISTINCTION VARIABLE GLOBALE / VARIABLE LOCALE EST TRES IMPORTANTE !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# III)Boucles bornées et non bornées\n",
    "La boucle for et la boucle while\n",
    "\n",
    "## 1 Boucles bornées : la boucle for\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,10): # observez l'effet de la borne supérieure\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n",
      "o\n",
      "n\n",
      "j\n",
      "o\n",
      "u\n",
      "r\n"
     ]
    }
   ],
   "source": [
    "for c in 'bonjour':\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "50\n",
      "60\n",
      "70\n",
      "80\n",
      "90\n"
     ]
    }
   ],
   "source": [
    "for i in range (0,100,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Boucles non bornées : La boucle while"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i**2 < 100 :\n",
    "    print(i)\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La condition derrière le while est un booléen. Voir l'exemple: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def petit(x):\n",
    "    '''int ou float -> bool'''\n",
    "    return (x<5)\n",
    "a = 1\n",
    "while petit(a):\n",
    "    print(a)\n",
    "    a+=1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}