{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 🐍 Introduction à la programmation Python\n",
    "### SNT – Seconde\n",
    "\n",
    "Dans ce notebook, tu vas découvrir les bases de Python à travers des situations concrètes :\n",
    "- Les **variables** et les **types de données**\n",
    "- Les **opérations** sur les variables\n",
    "- Les **listes** pour stocker des séries de valeurs\n",
    "- Les **dictionnaires** pour organiser des informations structurées\n",
    "\n",
    "> 💡 **Comment utiliser ce notebook ?**  \n",
    "> Chaque cellule de code peut être exécutée en cliquant dessus puis en appuyant sur **Shift + Entrée**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Partie 1 – Les variables\n",
    "\n",
    "Une **variable**, c'est comme une boîte étiquetée dans laquelle on range une information.  \n",
    "On lui donne un nom, et on y stocke une valeur.\n",
    "\n",
    "```\n",
    "nom_de_la_variable = valeur\n",
    "```\n",
    "\n",
    "### 🚗 Mise en situation : un trajet en voiture\n",
    "\n",
    "Tu pars de Nice pour aller à Paris. Le GPS t'indique :\n",
    "- Distance : 930 km\n",
    "- Vitesse moyenne estimée : 110 km/h\n",
    "- Prix de l'essence : 1.85 €/L\n",
    "- Consommation du véhicule : 6.5 L/100km"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On stocke les informations du trajet dans des variables\n",
    "distance_km = 930          # en kilomètres\n",
    "vitesse_moyenne = 110      # en km/h\n",
    "prix_essence = 1.85        # en €/L\n",
    "consommation = 6.5         # en L/100km\n",
    "\n",
    "# Affichons la distance\n",
    "print(\"Distance du trajet :\", distance_km, \"km\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Partie 2 – Les opérations sur les variables\n",
    "\n",
    "On peut faire des **calculs** avec les variables, comme avec une calculatrice.\n",
    "\n",
    "| Opération | Symbole | Exemple |\n",
    "|-----------|---------|----------|\n",
    "| Addition | `+` | `2 + 3` → `5` |\n",
    "| Soustraction | `-` | `10 - 4` → `6` |\n",
    "| Multiplication | `*` | `3 * 4` → `12` |\n",
    "| Division | `/` | `10 / 4` → `2.5` |\n",
    "| Puissance | `**` | `2 ** 3` → `8` |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcul de la durée du trajet\n",
    "duree_heures = distance_km / vitesse_moyenne\n",
    "print(\"Durée estimée du trajet :\", duree_heures, \"heures\")\n",
    "\n",
    "# Calcul du coût en carburant\n",
    "litres_consommes = distance_km * consommation / 100\n",
    "cout_carburant = litres_consommes * prix_essence\n",
    "\n",
    "print(\"Litres d'essence nécessaires :\", litres_consommes, \"L\")\n",
    "print(\"Coût en carburant :\", cout_carburant, \"€\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ✏️ Exercice 1\n",
    "\n",
    "Le retour se fait en train. Le TGV Nice–Paris parcourt 930 km en 5h36.  \n",
    "1. Crée une variable `duree_train` contenant la durée en heures (5h36 = 5.6h)\n",
    "2. Calcule la vitesse moyenne du TGV et stocke-la dans `vitesse_tgv`\n",
    "3. Affiche le résultat avec `print()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écris ton code ici\n",
    "duree_train = ...         # durée en heures\n",
    "vitesse_tgv = ...         # vitesse = distance / durée\n",
    "print(\"Vitesse moyenne du TGV :\", vitesse_tgv, \"km/h\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Partie 3 – Les types de variables\n",
    "\n",
    "En Python, chaque variable a un **type** selon ce qu'elle contient.\n",
    "\n",
    "| Type | Nom Python | Exemple |\n",
    "|------|------------|--------|\n",
    "| Nombre entier | `int` | `42`, `-3`, `0` |\n",
    "| Nombre décimal | `float` | `3.14`, `1.85` |\n",
    "| Texte (chaîne de caractères) | `str` | `\"Bonjour\"`, `\"Paris\"` |\n",
    "| Booléen (vrai/faux) | `bool` | `True`, `False` |\n",
    "\n",
    "La fonction `type()` permet de connaître le type d'une variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ville_depart = \"Nice\"\n",
    "ville_arrivee = \"Paris\"\n",
    "nb_passagers = 3\n",
    "trajet_termine = False\n",
    "\n",
    "print(type(ville_depart))    # str\n",
    "print(type(distance_km))     # int\n",
    "print(type(prix_essence))    # float\n",
    "print(type(trajet_termine))  # bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On peut assembler du texte et des variables avec f-strings\n",
    "# On écrit f\"...\" et on place les variables entre { }\n",
    "print(f\"Trajet de {ville_depart} à {ville_arrivee} : {distance_km} km\")\n",
    "print(f\"Avec {nb_passagers} passagers, le coût par personne est de {cout_carburant / nb_passagers:.2f} €\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ✏️ Exercice 2\n",
    "\n",
    "Tu organises un covoiturage. Le coût total du trajet est calculé ci-dessus.  \n",
    "1. Crée une variable `nb_passagers` avec la valeur de ton choix (entre 2 et 5)\n",
    "2. Calcule le coût par personne\n",
    "3. Affiche un message lisible avec une f-string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écris ton code ici\n",
    "nb_passagers = ...\n",
    "cout_par_personne = ...\n",
    "print(f\"...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Partie 4 – Les listes\n",
    "\n",
    "Imagine qu'on fait une expérience de physique : on lâche une bille depuis différentes hauteurs et on mesure le temps qu'elle met pour toucher le sol.  \n",
    "\n",
    "On a **10 mesures** à stocker. Créer 10 variables séparées serait très fastidieux !  \n",
    "→ C'est là qu'intervient la **liste** : une variable qui contient **plusieurs valeurs**.\n",
    "\n",
    "```python\n",
    "ma_liste = [valeur1, valeur2, valeur3, ...]\n",
    "```\n",
    "\n",
    "### 🔬 Mise en situation : chute libre\n",
    "\n",
    "On lâche une bille depuis 10 hauteurs différentes (en mètres) et on mesure le temps de chute (en secondes)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hauteurs de lâcher (en mètres)\n",
    "hauteurs = [0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]\n",
    "\n",
    "# Temps de chute mesurés (en secondes) — légèrement bruités comme en vrai\n",
    "temps = [0.32, 0.45, 0.55, 0.64, 0.71, 0.78, 0.84, 0.90, 0.96, 1.01]\n",
    "\n",
    "print(\"Hauteurs :\", hauteurs)\n",
    "print(\"Temps de chute :\", temps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accéder à un élément de la liste\n",
    "\n",
    "Chaque élément d'une liste a un **indice** (une position), qui **commence à 0**.\n",
    "\n",
    "```\n",
    "hauteurs = [0.5, 1.0, 1.5, 2.0, ...]\n",
    "indices  =   0    1    2    3   ...\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Premier élément (indice 0)\n",
    "print(\"Première hauteur :\", hauteurs[0], \"m\")\n",
    "print(\"Premier temps mesuré :\", temps[0], \"s\")\n",
    "\n",
    "# Troisième mesure (indice 2)\n",
    "print(f\"\\nMesure n°3 : bille lâchée à {hauteurs[2]} m, temps = {temps[2]} s\")\n",
    "\n",
    "# Dernier élément (indice -1)\n",
    "print(f\"Dernière mesure : bille lâchée à {hauteurs[-1]} m, temps = {temps[-1]} s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fonctions utiles sur les listes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Nombre de mesures\n",
    "print(\"Nombre de mesures :\", len(hauteurs))\n",
    "\n",
    "# Temps minimum et maximum\n",
    "print(\"Temps minimum :\", min(temps), \"s\")\n",
    "print(\"Temps maximum :\", max(temps), \"s\")\n",
    "\n",
    "# Moyenne des temps\n",
    "moyenne_temps = sum(temps) / len(temps)\n",
    "print(f\"Temps moyen de chute : {moyenne_temps:.3f} s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ajouter un élément à une liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On a fait une nouvelle mesure à 5.5 m : temps = 1.06 s\n",
    "hauteurs.append(5.5)\n",
    "temps.append(1.06)\n",
    "\n",
    "print(\"Nouvelles listes après ajout :\")\n",
    "print(\"Hauteurs :\", hauteurs)\n",
    "print(\"Temps :\", temps)\n",
    "print(\"Nombre total de mesures :\", len(hauteurs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ✏️ Exercice 3\n",
    "\n",
    "On souhaite calculer la **vitesse** de la bille juste avant d'atterrir, pour chaque mesure.  \n",
    "La formule est : `v = 2 * h / t` (en m/s)\n",
    "\n",
    "1. Calcule la vitesse pour la **4ème mesure** (indice 3)\n",
    "2. Calcule la vitesse pour la **dernière mesure**\n",
    "3. Affiche les deux résultats de façon lisible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écris ton code ici\n",
    "vitesse_4 = ...   # 2 * hauteurs[?] / temps[?]\n",
    "vitesse_derniere = ...\n",
    "\n",
    "print(f\"Vitesse à {hauteurs[3]} m : {vitesse_4:.2f} m/s\")\n",
    "print(f\"Vitesse à {hauteurs[-1]} m : {vitesse_derniere:.2f} m/s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Partie 5 – Les dictionnaires\n",
    "\n",
    "Une liste est pratique pour stocker des valeurs du **même type**.  \n",
    "Mais comment stocker des informations **hétérogènes et nommées** sur un même objet ?\n",
    "\n",
    "→ Le **dictionnaire** associe des **clés** à des **valeurs** :\n",
    "\n",
    "```python\n",
    "mon_dict = {\"clé1\": valeur1, \"clé2\": valeur2, ...}\n",
    "```\n",
    "\n",
    "### ⚗️ Mise en situation : composition d'une molécule\n",
    "\n",
    "En chimie, une molécule est définie par le nombre d'atomes de chaque élément qu'elle contient.  \n",
    "Un dictionnaire est parfait pour représenter cela !\n",
    "\n",
    "La **masse molaire** d'une molécule se calcule en additionnant les masses de tous ses atomes.  \n",
    "Les masses molaires atomiques sont (en g/mol) : **C = 12**, **H = 1**, **O = 16**, **N = 14**.\n",
    "\n",
    "**Exemple : le glucose C₆H₁₂O₆**  \n",
    "Masse molaire = 6×12 + 12×1 + 6×16 = 72 + 12 + 96 = **180 g/mol**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Masses molaires atomiques (en g/mol)\n",
    "M_C = 12\n",
    "M_H = 1\n",
    "M_O = 16\n",
    "M_N = 14\n",
    "\n",
    "# Le glucose : C6 H12 O6\n",
    "glucose = {\n",
    "    \"nom\": \"Glucose\",\n",
    "    \"formule\": \"C6H12O6\",\n",
    "    \"C\": 6,   # 6 atomes de Carbone\n",
    "    \"H\": 12,  # 12 atomes d'Hydrogène\n",
    "    \"O\": 6    # 6 atomes d'Oxygène\n",
    "}\n",
    "\n",
    "print(glucose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accéder aux valeurs d'un dictionnaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On accède à une valeur avec sa clé\n",
    "print(\"Nom de la molécule :\", glucose[\"nom\"])\n",
    "print(\"Formule brute :\", glucose[\"formule\"])\n",
    "print(\"Nombre d'atomes de carbone :\", glucose[\"C\"])\n",
    "\n",
    "# Calcul du nombre total d'atomes\n",
    "total_atomes = glucose[\"C\"] + glucose[\"H\"] + glucose[\"O\"]\n",
    "print(f\"\\nNombre total d'atomes dans {glucose['nom']} : {total_atomes}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ajouter une entrée : la masse molaire calculée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On calcule la masse molaire à partir des atomes du dictionnaire\n",
    "masse_glucose = glucose[\"C\"] * M_C + glucose[\"H\"] * M_H + glucose[\"O\"] * M_O\n",
    "\n",
    "# On ajoute cette information dans le dictionnaire\n",
    "glucose[\"masse_molaire\"] = masse_glucose\n",
    "\n",
    "print(f\"Masse molaire du {glucose['nom']} : {glucose['masse_molaire']} g/mol\")\n",
    "print(\"Dictionnaire complet :\", glucose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ✏️ Exercice 4 — Masses molaires de plusieurs molécules\n",
    "\n",
    "Trois autres molécules importantes en chimie :\n",
    "\n",
    "| Molécule | Formule | C | H | O | N |\n",
    "|----------|---------|---|---|---|---|\n",
    "| Eau | H₂O | 0 | 2 | 1 | 0 |\n",
    "| Dioxyde de carbone | CO₂ | 1 | 0 | 2 | 0 |\n",
    "| Éthanol | C₂H₆O | 2 | 6 | 1 | 0 |\n",
    "| Acide aminé (glycine) | C₂H₅NO₂ | 2 | 5 | 2 | 1 |\n",
    "\n",
    "Pour chaque molécule :\n",
    "1. Crée son dictionnaire avec `\"nom\"`, `\"formule\"`, et le nombre de chaque atome\n",
    "2. Calcule sa masse molaire en utilisant les variables `M_C`, `M_H`, `M_O`, `M_N`\n",
    "3. Ajoute la masse molaire au dictionnaire avec la clé `\"masse_molaire\"`\n",
    "4. Affiche un bilan lisible pour chaque molécule\n",
    "\n",
    "> 💡 Le modèle du glucose ci-dessus est exactement la démarche à reproduire !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# --- Eau : H2O ---\n",
    "eau = {\n",
    "    \"nom\": \"Eau\",\n",
    "    \"formule\": \"H2O\",\n",
    "    \"C\": 0, \"H\": 2, \"O\": 1, \"N\": 0\n",
    "}\n",
    "eau[\"masse_molaire\"] = ...  # à compléter\n",
    "print(f\"{eau['nom']} ({eau['formule']}) : {eau['masse_molaire']} g/mol\")\n",
    "\n",
    "# --- Dioxyde de carbone : CO2 ---\n",
    "dioxyde_carbone = {\n",
    "    \"nom\": \"Dioxyde de carbone\",\n",
    "    \"formule\": \"CO2\",\n",
    "    \"C\": ..., \"H\": ..., \"O\": ..., \"N\": ...\n",
    "}\n",
    "dioxyde_carbone[\"masse_molaire\"] = ...\n",
    "print(f\"{dioxyde_carbone['nom']} ({dioxyde_carbone['formule']}) : {dioxyde_carbone['masse_molaire']} g/mol\")\n",
    "\n",
    "# --- Éthanol : C2H6O ---\n",
    "ethanol = {\n",
    "    \"nom\": \"Éthanol\",\n",
    "    \"formule\": \"C2H6O\",\n",
    "    \"C\": ..., \"H\": ..., \"O\": ..., \"N\": ...\n",
    "}\n",
    "ethanol[\"masse_molaire\"] = ...\n",
    "print(f\"{ethanol['nom']} ({ethanol['formule']}) : {ethanol['masse_molaire']} g/mol\")\n",
    "\n",
    "# --- Glycine : C2H5NO2 ---\n",
    "glycine = {\n",
    "    \"nom\": \"Glycine\",\n",
    "    \"formule\": \"C2H5NO2\",\n",
    "    \"C\": ..., \"H\": ..., \"O\": ..., \"N\": ...\n",
    "}\n",
    "glycine[\"masse_molaire\"] = ...\n",
    "print(f\"{glycine['nom']} ({glycine['formule']}) : {glycine['masse_molaire']} g/mol\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## ✏️ Exercice Final — Mini-projet : analyse d'une expérience\n",
    "\n",
    "Un élève mesure la **température** d'un liquide qui refroidit, toutes les minutes, pendant 10 minutes.\n",
    "\n",
    "| Temps (min) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |\n",
    "|-------------|---|---|---|---|---|---|---|---|---|---|----|\n",
    "| Température (°C) | 80 | 72 | 65 | 59 | 54 | 50 | 47 | 44 | 42 | 40 | 39 |\n",
    "\n",
    "1. Crée une liste `temperatures` avec ces valeurs\n",
    "2. Affiche la température initiale et la température finale\n",
    "3. Calcule le refroidissement total (temp initiale − temp finale)\n",
    "4. Calcule la température moyenne sur toute l'expérience\n",
    "5. Crée un dictionnaire `experience` avec les clés : `\"liquide\"` (\"eau\"), `\"duree_min\"` (10), `\"temp_initiale\"`, `\"temp_finale\"`, `\"temp_moyenne\"` — en réutilisant les variables calculées précédemment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écris ton code ici\n",
    "temperatures = [...]\n",
    "\n",
    "temp_initiale = ...\n",
    "temp_finale = ...\n",
    "refroidissement = ...\n",
    "temp_moyenne = ...\n",
    "\n",
    "print(f\"Température initiale : {temp_initiale} °C\")\n",
    "print(f\"Température finale   : {temp_finale} °C\")\n",
    "print(f\"Refroidissement total : {refroidissement} °C\")\n",
    "print(f\"Température moyenne  : {temp_moyenne:.1f} °C\")\n",
    "\n",
    "experience = {\n",
    "    \"liquide\": \"eau\",\n",
    "    \"duree_min\": 10,\n",
    "    \"temp_initiale\": temp_initiale,\n",
    "    \"temp_finale\": ...,\n",
    "    \"temp_moyenne\": ...\n",
    "}\n",
    "\n",
    "print(\"\\nFiche de l'expérience :\")\n",
    "print(experience)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 🎯 Bilan\n",
    "\n",
    "Dans ce notebook, tu as appris à :\n",
    "\n",
    "| Notion | Ce que tu sais faire |\n",
    "|--------|---------------------|\n",
    "| **Variable** | Stocker une valeur dans une boîte nommée |\n",
    "| **Types** | Reconnaître `int`, `float`, `str`, `bool` |\n",
    "| **Opérations** | Faire des calculs avec `+`, `-`, `*`, `/` |\n",
    "| **f-string** | Afficher du texte avec des valeurs variables |\n",
    "| **Liste** | Stocker plusieurs valeurs, accéder par indice, utiliser `len()`, `min()`, `max()`, `append()` |\n",
    "| **Dictionnaire** | Associer des clés à des valeurs, accéder par clé, ajouter des entrées |\n",
    "\n",
    "**Bravo, tu maîtrises les bases de Python ! 🐍**"
   ]
  }
 ],
 "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}