{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Premier pas en Python\n",
    "\n",
    "## La console\n",
    "\n",
    "La __console__ est un endroit où l'on peut écrire du code en Python.\n",
    "\n",
    "Le code sera exécuté immédiatement dès validation de la ligne, c'est-à-dire dès que vous appuyer sur la touche ENTRÉE.\n",
    "\n",
    "### 1. À Faire\n",
    "\n",
    "1. Éxécuter le code suivant (_sans les ???_) :\n",
    "```python\n",
    "5 + 2\n",
    "???\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Quel est le résultat obtenu ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bilan 1\n",
    "\n",
    "- A travers ce premier exemple, on constate que Python sait faire des calculs !!\n",
    "- Lorsque l'on appuie sur ENTRÉE, python lit le code 5 + 2, calcule l'opération associée et restitue le résultat."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. À Faire\n",
    "\n",
    "1. Écrire et exécuter successivement les instructions suivantes (_sans les ???_) `\n",
    "\n",
    "```python\n",
    "5 - 2\n",
    "???\n",
    "5 * 2\n",
    "???\n",
    "5 / 2\n",
    "???\n",
    "5 // 2\n",
    "???\n",
    "5 % 2\n",
    "???\n",
    "5 ** 2\n",
    "???\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Quels sont les résultats obtenus ? Compléter le tableau suivant en décrivant ce que fait l'opérateur de l'instruction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Opérateur | Description |\n",
    "| :--: | :-- |\n",
    "| - | | \n",
    "| * | |\n",
    "| / | |\n",
    "| // | |\n",
    "| % | |\n",
    "| * | |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bilan 2\n",
    "\n",
    "- Python permet l'utilisation des opérateurs arithmétiques usuelles $+, -, *, /$ sur les entiers,\n",
    "- Python permet l'utilisation d'opérateurs arithmétiques avec une syntaxe spécifique comme $//, \\%, **$ \n",
    "\n",
    "### 3. À Faire\n",
    "\n",
    "1. En prenant votre âge à votre prochaine date d'anniversaire (en nombre d'années), écrire une instruction qui calcule le nombre de jours équivalents (on considère qu'une année correspond à 365 jours)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Sachant qu'à mon prochain anniversaire j'aurai 9490 jours, écrire une instruction qui calcule mon âge, en nombre d'années :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Sachant que ma maison se situe au 256 de la rue (dont je tairais le nom pour ne pas être localisé ;-)) et que toutes les maisons font 12 mètres et demi de longueur, à quelle distance se situe ma maison par rapport au début de la rue ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bilan 3\n",
    "\n",
    "- Outre des entiers, Python permet d'utiliser des nombres décimaux,\n",
    "- La partie suivante explicitera plus l'utilisation et le comportement des nombre décimaux."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. À Faire\n",
    "\n",
    "Exécuter le code suivant. Que constatez-vous ?\n",
    "\n",
    "```python\n",
    "# 3 + 2\n",
    "???\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les variables\n",
    "\n",
    "En informatique, il est indispensable de conserver des informations de natures diverses. Par exemple, votre smartphone enregistre dans sa mémoire votre numéro de téléphone, les numéros de téléphones de vos contacts, vos messages (SMS), vos photos, vos applications, etc. Chacune de ces informations est stockée à un endroit précis dans la mémoire dans ce qu’on appelle une variable.\n",
    "\n",
    "### Définition\n",
    "\n",
    "> Une __variable__ est un __espace de stockage__ de la mémoire (une case mémoire). Chaque variable est caractérisée par son __nom__, son __type__ et sa __valeur__.\n",
    "\n",
    "### Valeur des variables\n",
    "\n",
    "#### Affecter une valeur à une variable\n",
    "\n",
    "##### 5. À Faire\n",
    "\n",
    "Copier et exécuter les instructions suivantes\n",
    "\n",
    "```python\n",
    "a = 5\n",
    "b = 2\n",
    "a + b\n",
    "???\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Bilan 5\n",
    "\n",
    "1. La syntaxe pour déclarer et affecter une valeur a une variable est `nom de la variable = valeur`\n",
    "2. Pour les instructions 1 et 2, Le signe `=` indique que la valeur 5 est affectée à la variable `a` et 2 à la variable `b`.\n",
    "3. Lorsque Python interprète l'instruction 3, il lit les valeurs associées aux variables et effectue l'opération.\n",
    "\n",
    "#### Afficher la valeur d’une variable\n",
    "\n",
    "Pour afficher la valeur d’une variable on utilise la fonction `print()`. Par exemple, pour afficher la valeur de la variable `note` on écrit simplement : `print(note)`. A l’exécution du code, la valeur s’affiche dans la console.\n",
    "\n",
    "```python\n",
    "note = 12\n",
    "print(note)\n",
    "???\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type des variables\n",
    "\n",
    "Dans les travaux à faire précédent, nous avons manipulé essentiellement des entiers, Python permet de manipuler d'autres types de variables :\n",
    "\n",
    "- le type __entier__ : il désigne les entiers relatifs (positifs ou négatifs). En Python on parle du type `int` (pour integer qui signifie « entier » en anglais) ;\n",
    "- le type __flottant__ : il désigne les nombres décimaux (à virgule). En Python on parle du type `float` (pour floating qui signifie « flottant » en anglais)\n",
    "- le type __chaîne de caractères__ : il désigne toute suite ordonnée de caractères. En Python on parle du type `str` (pour string qui signifie « chaîne » en anglais).\n",
    "\n",
    "#### 6. À Faire\n",
    "\n",
    "Indiquez le type des variables permettant de stocker (sur votre smartphone) les informations suivantes :\n",
    "\n",
    "| Variable | Type identifié |\n",
    "| :--: | :-- |\n",
    "| le nom d’un contact | |\n",
    "| le numéro de téléphone d’un contact | |\n",
    "| un SMS | |\n",
    "| l’heure du réveil | |\n",
    "| le code de votre partage de connexion Wi-Fi | |\n",
    "| le pourcentage affiché de batterie restante | |\n",
    "| les notes aux deux derniers devoirs de Mathématiques de l'année dernière | |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7. À Faire\n",
    "\n",
    "Copier et exécuter les instructions suivantes\n",
    "\n",
    "```python\n",
    "a = \"Je suis\"\n",
    "b = \" Yoda \"\n",
    "a + b \n",
    "???\n",
    "b + a\n",
    "???\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bilan 7\n",
    "\n",
    "Comme vous le voyez, on peut ajouter deux chaînes : c'est une ___concaténation___.\n",
    "\n",
    "Cependant, on ne peut pas ajouter n'importe quoi :\n",
    "\n",
    "```python\n",
    "a = 'Je mesure '\n",
    "b = 1.12\n",
    "c = 'm'\n",
    "a + b + c\n",
    "???\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cela ne marche pas car les variables ne sont pas du même *type*. Il faut les convertir en utilisant :\n",
    "\n",
    "- soit la fonction `str(nombre)` qui convertit le nombre en chaîne.\n",
    "- soit la fonction `int(chaîne)` qui convertit, si possible, la chaîne en entier.\n",
    "- soit la fonction `float(chaîne)` qui convertit, si possible ,la chaîne en flottant.\n",
    "\n",
    "```python\n",
    "str(b)\n",
    "???\n",
    "a + str(b) + c\n",
    "???\n",
    "str(b) + c + a\n",
    "???\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nom des variables\n",
    "\n",
    "Chaque variable possède un nom qui permet d’identifier l’emplacement mémoire correspondant.\n",
    "\n",
    "Dans le langage Python, il y a des règles à respecter pour nommmer les variables. Voici celles qui vous concernent :\n",
    "\n",
    "- __Règle 1__ : un nom ne peut contenir que des lettres (a-z, A-Z), des chiffres (0 - 9) et le caractère _ (underscore).\n",
    "- __Règle 2__ : un nom ne peut pas commencer par un chiffre.\n",
    "- __Règle 3__ : les noms sont sensibles à la casse, cela signifie qu’il y a une distinction entre les minuscules et les majuscules : la variable nommée `snt` est différente de la variable `Snt`.\n",
    "- __Règle 4__ : il est préférable de toujours choisir un nom de variable représentatif : par exemple, si vous voulez stocker le nom d’une personne dans une variable, il est préférable de l’appeler nom plutôt que x.\n",
    "- __Règle 5__ : il est préférable de ne pas utiliser de caractères accentués dans le nom d’une variable (nous n’entrerons pas dans le pourquoi du comment).\n",
    "\n",
    "#### À Faire\n",
    "\n",
    "1. Quels sont les noms de variables incorrects parmi ceux proposés ? Vous indiquerez pourquoi."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Noms de variable | Correct ou Incorrect | Pourquoi (si Incorrect) |\n",
    "| :--:| :--: | :-- | \n",
    "| `prix achat` | | |\n",
    "| `prix_achat` | | |\n",
    "| `note` | | | \n",
    "| `2ndeG` | | |\n",
    "| `SecondeG` | | | \n",
    "| `Seconde:G`| | |\n",
    "| `dix-huit` | | |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Proposez un nom de variable permettant de stocker :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Variable | Nom de variable |\n",
    "| :-- | :--: |\n",
    "| le nombre de personnes aux yeux bleus de Seconde G | |\n",
    "| le tarif d’un repas au self | |\n",
    "| l’aire d’un triangle (il n’y a qu’une seule figure) | |\n",
    "| la note à un devoir d’anglais | |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices\n",
    "\n",
    "### Exercice 1\n",
    "\n",
    "On considère le programme Python suivant.\n",
    "\n",
    "```python\n",
    "a = 8\n",
    "b = 3\n",
    "a = a - 4\n",
    "b = 2 * b\n",
    "a = a + b\n",
    "print(a)\n",
    "```\n",
    "\n",
    "1. Combien de variables sont utilisées ? Combien de valeurs différentes ont-elles prises au cours de l’exécution du programme ?\n",
    "2. Quelle est la valeur finale de la variable `a` ?\n",
    "3. Il est possible d’afficher plusieurs valeurs avec la fonction `print`. Par exemple, si on veut afficher les valeurs des variables `a` et `b` on écrit simplement `print(a, b)`. Modifiez la dernière ligne du programme et exécutez-le."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 2\n",
    "\n",
    "On considère le programme de calcul suivant.\n",
    "\n",
    "- A prend la valeur 5\n",
    "- Multiplier A par 3\n",
    "- Soustraire 4 au résultat\n",
    "- Elever le résultat au carré\n",
    "- Afficher le résultat\n",
    "\n",
    "Écrire un programme Python permettant de coder ce programme de calcul. Vérifiez ensuite en l'exécutant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 3\n",
    "\n",
    "Sur un site de vente en ligne, on peut acheter différents articles. Un paquet de farine d'un kg coûte 1,15 € et une boîte de six oeufs coûte 1,50 €.\n",
    "\n",
    "Écrire un programme Python qui utilise deux variables pour stocker le nombre de paquets de farine et de boîtes d'oeufs souhaités puis, qui calcule et affiche le prix total à payer pour la commande."
   ]
  },
  {
   "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
