Notebook 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# <center>Initiation à la programmation (Python)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Découverte du notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Première expérience"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Bienvenu dans le notebook de la première séance du cours. Cette page web permet de dialoguer avec Python. La zone de texte ci-dessous s'appelle une cellule. Vous pouvez taper du Python à l'intérieur, et l'excuter. Essayez ! Tapez:\n",
    "```python\n",
    "2+2\n",
    "``` \n",
    "puis pressez `<shift>` + `<entrée>`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une fois une cellule exécutée, vous pouver y revenir et la modifier. Replacez le curseur dans la cellule ci-dessus, et tapez-y:\n",
    "```python\n",
    "2+3\n",
    "``` \n",
    "et exécutez à nouveau la cellule."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une cellule à une **entrée**, la zone dans laquelle on peut taper du code, et une **sortie**, la zone ou s'affiche le résultat. Le résultat de la dernière **instruction** est toujours affiché dans la sortie. Tapez les deux lignes suivantes dans la cellule ci-dessous :\n",
    "```python\n",
    "2+2\n",
    "2+3\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Un petit exercice\n",
    "Tapez dans la cellule ci-dessous une expression calcule combien il y a de secondes dans une année"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les chaînes de caractères"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Définition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python permet de manipuler du texte, plus particulièrement ce qu'on appelle des **chaînes de caractères**. Tapez `'Bonjour'` dans la cellule ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essayez également de taper :\n",
    "```python\n",
    "\"Bonjour\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essayer de taper une chaîne de caractères qui contient la phrase ci-dessous : \n",
    "\n",
    "`Aujourd'hui, c'est mardi.`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et à présent celle-ci : \n",
    "\n",
    "`Le prof a dit : \"Aujourd'hui, c'est mardi\".`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quelques manipulations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tapez à présent :\n",
    "```python\n",
    "'Bonjour ' + 'Python'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'Bonjour' + 'Python'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les deux chaînes ont été rassemblées en une seule, elles ont été **concaténées**. On peut remarquer que l'effet du signe + dépend de ce à quoi il est appliqué : \n",
    "* à des nombres, il effectue leur addition (ouf !)\n",
    "* à des chaines de caractères, il effectue leur concaténation.\n",
    "\n",
    "Selon vous, que va-t-il se passez si l'on essaie les instructions suivantes ?\n",
    "```python\n",
    "'bonjour' + 2\n",
    "'bonjour' + '2'\n",
    "'bonjour' * 2\n",
    "'bonjour' * '2'\n",
    "'bonjour' * 2.0\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les erreurs que l'on observe sont des erreurs de **type** (TypeError). Tout ce que l'on manipule en Python a un *type*, et c'est ce type qui définit le comportement des opérations : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type('bonjour')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(2.0) #Ceci est un commentaire : tout ce qui suit un caractère # est ignoré par python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": true
   },
   "source": [
    "Les **variables** sont un concept central commun à tous les langages de programmation. Elles permettent de mémoriser des valeurs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideOutput": true
   },
   "outputs": [],
   "source": [
    "x=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=x+1\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une variable associe une **valeur** à un **nom** (une variable a donc un également un type).\n",
    "\n",
    "Essayez de faire la même chose en changeant le nom de la variable. Essayez les noms suivants: `a`, `a1`, `1a`, `A`. Quelles conclusions tirez-vous ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecrire un petit programme qui utilise une variable `nom` et qui affiche la chaîne de caractères 'Bonjour *nom*', où *nom* est la valeur de la variable `nom`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# La commande *print*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il arrive que l'on souhaite afficher autre chose que la valeur de la dernière expression d'une cellule. La commande `print` permet ça :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=10 # on affecte 10 à la variable a\n",
    "print(a)\n",
    "A=a+5\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les branchements conditionnels\n",
    "Il faut parfois faire des choix. On peut avoir besoin d'exécuter certaines instuctions dans certains cas, d'autres instuctions dans d'autres cas. C'est possible en Python (et dans quasiment tous les langages de programation) avec la structure `si ... alors ... sinon ...`\n",
    "```python\n",
    "if a<b :\n",
    "    print('la variable a est plus petite que la variable b')\n",
    "else:\n",
    "    print('la variable a est plus grande que (ou égale à) la variable b')\n",
    "```\n",
    "L'**identation** est primordiale ! Elle permet de délimiter les **blocs**, c'est-à-dire ce qui est exécuté dans un cas ou dans l'autre. Les deux programmes suivants sont différents. D'une part :\n",
    "```python\n",
    "nom='Camille'\n",
    "genre='f'\n",
    "if genre=='f':\n",
    "    resultat = \"bonjour Madame \"\n",
    "else:\n",
    "    resultat = \"bonjour Monsieur \"\n",
    "resultat = resultat + nom\n",
    "print(resultat)\n",
    "```\n",
    "\n",
    "D'autre part:\n",
    "```python\n",
    "nom='Camille'\n",
    "genre='f'\n",
    "if genre=='f':\n",
    "    resultat = \"bonjour Madame \"\n",
    "else:\n",
    "    resultat = \"bonjour Monsieur \"\n",
    "    resultat = resultat + nom\n",
    "print(resultat)\n",
    "```\n",
    "\n",
    "Avez-vous une idée de la différence ? Essayez de deviner. Si vous ne voyez pas, vous pouvez toujours essayer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Petit exercice\n",
    "Ecrivez un programme avec une variable `bissextile` qui affiche le nombre de secondes dans une année, selon qu'elle est bissextile ou non."
   ]
  },
  {
   "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.8.3"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}