{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercices de rappel — Cours 1 à 5 (Python pour le marketing digital)\n",
    "\n",
    "Ce notebook regroupe **uniquement des exercices** pour consolider les notions vues dans les 5 premiers cours :\n",
    "\n",
    "- **Cours 1** : variables, types simples (`int`, `float`, `str`, `bool`), `print` / f-strings, calculs marketing simples, listes, `len()`.\n",
    "- **Cours 2** : `range()`, boucles `for`, parcours de listes, conditions `if / elif / else`.\n",
    "- **Cours 3** : chaînes de caractères (`+`, `len`, `upper`, `lower`), accès et modification par index dans une liste.\n",
    "- **Cours 4** : dictionnaires (création, lecture, mise à jour, ajout), listes de dictionnaires.\n",
    "- **Cours 5** : `pandas` (`DataFrame`, `read_csv`, `head`, `tail`, `shape`, `columns`, sélection de colonnes).\n",
    "\n",
    "### Mode d'emploi\n",
    "- Chaque exercice est précédé d'une cellule **Markdown** avec l'énoncé.\n",
    "- La cellule **Code** juste en dessous (avec `TODO`) est là pour ta solution.\n",
    "- Aucune correction n'est fournie ici : c'est volontaire. Sois rigoureux, teste, modifie, observe.\n",
    "- Si tu bloques sur une notion, retourne consulter le notebook de cours correspondant.\n",
    "\n",
    "> Objectif : être à l'aise sur l'ensemble des bases avant d'attaquer le filtrage et le `groupby` en pandas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Partie 1 — Rappel du Cours 1 : variables, types, listes, `print`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 1.1 — Créer des variables et afficher leur type\n",
    "\n",
    "Tu es analyste sur la campagne *\"Black Friday 2026\"*. Crée les variables suivantes (choisis toi-même des valeurs réalistes) :\n",
    "\n",
    "1. `nom_campagne` (un texte)\n",
    "2. `nombre_clics` (un entier)\n",
    "3. `cout_total` (un nombre à virgule, en euros)\n",
    "4. `campagne_active` (un booléen `True` ou `False`)\n",
    "\n",
    "Puis :\n",
    "- affiche chaque variable avec `print()` ;\n",
    "- affiche son type avec `print(type(...))` ;\n",
    "- termine par une phrase récapitulative en **f-string** du style :\n",
    "  > \"La campagne X a généré N clics pour un coût total de C euros (active : True/False).\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 1.1\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 1.2 — Calculs marketing simples (CPC + taux de conversion)\n",
    "\n",
    "Tu disposes des chiffres suivants pour une campagne :\n",
    "\n",
    "- `budget` = 480 (euros)\n",
    "- `clics` = 320\n",
    "- `conversions` = 24\n",
    "\n",
    "1. Calcule le **CPC** (coût par clic) : `budget / clics`.\n",
    "2. Calcule le **taux de conversion** : `conversions / clics`.\n",
    "3. Affiche une phrase claire avec f-string, par exemple :\n",
    "   > \"CPC moyen : 1.50 euros — Taux de conversion : 0.075\".\n",
    "4. Change la valeur de `budget` à `960` et relance la cellule : observe l'effet sur le CPC."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 1.2\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 1.3 — Listes et `len()`\n",
    "\n",
    "1. Crée une liste `canaux` contenant au moins **5 canaux d'acquisition** (par exemple `\"Instagram\"`, `\"Google Ads\"`, `\"Email\"`, `\"SEO\"`, `\"TikTok\"`).\n",
    "2. Crée une liste `clients` contenant au moins **4 prénoms** de clients.\n",
    "3. Affiche :\n",
    "   - la liste complète des canaux ;\n",
    "   - le **premier** canal ;\n",
    "   - le **dernier** canal (utilise `len()` ou l'index `-1`) ;\n",
    "   - le **nombre total** de canaux ;\n",
    "   - le **nombre total** de clients.\n",
    "4. Termine par une phrase du style :\n",
    "   > \"Nous suivons 5 canaux différents pour 4 clients.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 1.3\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Partie 2 — Rappel du Cours 2 : `range`, boucles `for`, conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 2.1 — Boucles avec `range`\n",
    "\n",
    "1. Écris une boucle `for` qui affiche `Jour 1`, `Jour 2`, ..., `Jour 7` (utilise `range`).\n",
    "2. Écris une autre boucle qui affiche **uniquement les jours pairs** entre 2 et 10 inclus (`Jour 2`, `Jour 4`, ..., `Jour 10`).\n",
    "3. Écris une troisième boucle qui affiche `Email 1 envoyé`, `Email 2 envoyé`, ..., `Email 5 envoyé`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 2.1\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 2.2 — Parcourir deux listes en parallèle\n",
    "\n",
    "Tu disposes de :\n",
    "\n",
    "```python\n",
    "clients = [\"Alice\", \"Bob\", \"Chloé\", \"David\", \"Emma\"]\n",
    "montants = [120, 45, 200, 80, 350]\n",
    "```\n",
    "\n",
    "1. Écris une boucle qui parcourt les clients **par index** (`for i in range(len(clients))`).\n",
    "2. Pour chaque ligne, affiche une phrase de la forme :\n",
    "   > \"Client Alice a dépensé 120 euros.\"\n",
    "3. À la fin de la boucle, affiche le **nombre total de clients** (sans recalculer à la main, utilise `len`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 2.2\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 2.3 — Conditions `if / elif / else`\n",
    "\n",
    "Pour un client donné, on définit :\n",
    "\n",
    "- `montant_achat` (en euros) ;\n",
    "- `nombre_visites` (entier).\n",
    "\n",
    "Règles à appliquer :\n",
    "\n",
    "- Si `montant_achat >= 200` → afficher `\"client VIP\"`.\n",
    "- Sinon, si `montant_achat >= 100` → afficher `\"client premium\"`.\n",
    "- Sinon → afficher `\"client standard\"`.\n",
    "\n",
    "Puis ajoute une **deuxième condition indépendante** :\n",
    "\n",
    "- Si `nombre_visites > 5` → afficher en plus `\"prospect engagé\"`.\n",
    "- Sinon → afficher `\"prospect à réveiller\"`.\n",
    "\n",
    "Teste ton code avec **au moins 3 jeux de valeurs différents** (en modifiant `montant_achat` et `nombre_visites`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 2.3\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 2.4 — Mini reporting CRM (liste + boucle + condition)\n",
    "\n",
    "Tu disposes des données suivantes :\n",
    "\n",
    "```python\n",
    "clients = [\"Alice\", \"Bob\", \"Chloé\", \"David\", \"Emma\", \"Farid\"]\n",
    "montants = [250, 35, 90, 180, 12, 410]\n",
    "seuil_vip = 200\n",
    "seuil_relance = 50\n",
    "```\n",
    "\n",
    "Écris une boucle qui, pour chaque client :\n",
    "\n",
    "- affiche `\"Client X a dépensé Y € : client VIP\"` si `montant >= seuil_vip` ;\n",
    "- affiche `\"Client X a dépensé Y € : à relancer\"` si `montant < seuil_relance` ;\n",
    "- affiche `\"Client X a dépensé Y € : client standard\"` sinon.\n",
    "\n",
    "Bonus : à la fin, affiche **combien de clients sont VIP** (utilise un compteur initialisé à 0 et incrémenté dans la boucle)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 2.4\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Partie 3 — Rappel du Cours 3 : chaînes de caractères et listes par index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 3.1 — Manipulation de chaînes\n",
    "\n",
    "À partir des variables suivantes :\n",
    "\n",
    "```python\n",
    "nom_campagne = \"Summer Promo\"\n",
    "pays = \"France\"\n",
    "```\n",
    "\n",
    "1. Construis une phrase **par concaténation** (`+`) du style :\n",
    "   > \"La campagne Summer Promo cible le pays France.\"\n",
    "2. Affiche la **longueur** du nom de campagne (`len`).\n",
    "3. Affiche le nom de campagne **en majuscules** (`.upper()`) puis **en minuscules** (`.lower()`).\n",
    "4. Construis la **même phrase** qu'au point 1 mais cette fois avec une **f-string**.\n",
    "5. Quelle version trouves-tu la plus lisible ? (commentaire libre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 3.1\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 3.2 — Lire et modifier une liste par index\n",
    "\n",
    "On part des deux listes parallèles suivantes :\n",
    "\n",
    "```python\n",
    "campagnes = [\"Google Ads\", \"Facebook Ads\", \"Email\", \"LinkedIn\"]\n",
    "budgets = [500, 300, 150, 800]\n",
    "```\n",
    "\n",
    "1. Affiche `campagnes[1]` et `budgets[1]` (la deuxième campagne et son budget).\n",
    "2. Affiche la **dernière** campagne en utilisant `len(campagnes) - 1` comme index (et **pas** `-1`).\n",
    "3. **Modifie** le budget de la campagne `\"Email\"` (à l'index 2) pour le passer à `350`.\n",
    "4. Affiche la liste `budgets` **avant** et **après** la modification.\n",
    "5. Construis une phrase finale par concaténation :\n",
    "   > \"La campagne Email a un budget de 350 euros.\"\n",
    "\n",
    "Indice : pour concaténer un nombre à un texte, il faut le convertir avec `str(...)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 3.2\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Partie 4 — Rappel du Cours 4 : dictionnaires"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 4.1 — Premier dictionnaire de campagne\n",
    "\n",
    "Crée un dictionnaire `campagne` qui décrit une campagne marketing avec les clés suivantes :\n",
    "\n",
    "- `nom` (str)\n",
    "- `canal` (str)\n",
    "- `budget` (int ou float)\n",
    "- `clics` (int)\n",
    "- `conversions` (int)\n",
    "\n",
    "Puis affiche :\n",
    "\n",
    "1. Le dictionnaire complet.\n",
    "2. Le nom de la campagne (`campagne['nom']`).\n",
    "3. Le canal et le budget dans une phrase en f-string.\n",
    "4. Le CPC calculé : `campagne['budget'] / campagne['clics']` (avec un format à 2 décimales : `:.2f`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 4.1\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 4.2 — Mise à jour et enrichissement d'un dictionnaire\n",
    "\n",
    "Pars du dictionnaire suivant :\n",
    "\n",
    "```python\n",
    "campagne = {\n",
    "    \"nom\": \"Promo Hiver\",\n",
    "    \"canal\": \"Email\",\n",
    "    \"budget\": 500,\n",
    "    \"clics\": 150,\n",
    "    \"conversions\": 9,\n",
    "}\n",
    "```\n",
    "\n",
    "Effectue les opérations suivantes (dans l'ordre) :\n",
    "\n",
    "1. **Modifie** le budget : passe-le à `750`.\n",
    "2. **Ajoute** une clé `pays` avec la valeur `\"Belgique\"`.\n",
    "3. **Ajoute** une clé `actif` avec la valeur `True`.\n",
    "4. Récupère la clé `objectif` avec `.get(\"objectif\", \"Non défini\")` (qui n'existe pas) et affiche le résultat.\n",
    "5. Affiche le dictionnaire mis à jour.\n",
    "6. Affiche une phrase récapitulative du style :\n",
    "   > \"Campagne Promo Hiver (canal: Email, pays: Belgique) — budget: 750 €, active: True.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 4.2\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 4.3 — Mini reporting sur une liste de dictionnaires\n",
    "\n",
    "Crée une liste `campagnes` contenant **au moins 4 dictionnaires** (4 campagnes). Chaque dictionnaire doit avoir les clés :\n",
    "\n",
    "- `nom`\n",
    "- `canal`\n",
    "- `budget`\n",
    "- `clics`\n",
    "- `conversions`\n",
    "\n",
    "Puis, dans une **boucle `for`** sur cette liste :\n",
    "\n",
    "1. Calcule le **CPC** (`budget / clics`).\n",
    "2. Calcule le **taux de conversion** (`conversions / clics`).\n",
    "3. Classe la performance avec un `if / elif / else` :\n",
    "   - `\"À renforcer\"` si `taux_conversion >= 0.08`,\n",
    "   - `\"À optimiser\"` si `taux_conversion >= 0.05`,\n",
    "   - `\"À revoir\"` sinon.\n",
    "4. Affiche une ligne par campagne avec : nom, canal, CPC (`:.2f`), taux de conversion (`:.2%`) et segment.\n",
    "\n",
    "Bonus : à la fin, affiche le **budget total** de toutes les campagnes (utilise un cumul dans la boucle)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 4.3\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Partie 5 — Rappel du Cours 5 : premiers pas avec `pandas`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 5.1 — Créer un `DataFrame` à partir d'une liste de dictionnaires\n",
    "\n",
    "1. Importe `pandas` avec l'alias habituel : `import pandas as pd`.\n",
    "2. Crée une liste `sessions_demo` contenant **au moins 4 dictionnaires**. Chaque dictionnaire doit avoir les clés :\n",
    "   - `session_id` (str)\n",
    "   - `source` (par exemple `\"Google Ads\"`, `\"Instagram\"`, `\"Email\"`, ...)\n",
    "   - `device` (`\"mobile\"` ou `\"desktop\"`)\n",
    "   - `converted` (0 ou 1)\n",
    "3. Construis un `DataFrame` `df_sessions_demo` à partir de cette liste.\n",
    "4. Affiche le `DataFrame`.\n",
    "5. Affiche son `shape` et la liste de ses `columns`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 5.1\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 5.2 — Lire un CSV ShopNow et l'explorer\n",
    "\n",
    "On utilise les fichiers du fil rouge ShopNow (`sessions.csv`, `users.csv`, `orders.csv`, `campaigns.csv`).\n",
    "\n",
    "> ⚠️ Les fichiers CSV doivent se trouver **dans le même dossier** que ce notebook (ou il faut adapter le chemin).\n",
    "\n",
    "1. Lis le fichier `sessions.csv` dans un `DataFrame` `df_sessions` (`pd.read_csv(...)`).\n",
    "2. Affiche les **5 premières lignes** avec `head()`.\n",
    "3. Affiche les **3 dernières lignes** avec `tail(3)`.\n",
    "4. Affiche le `shape` (nombre de lignes, nombre de colonnes).\n",
    "5. Affiche la liste des `columns`.\n",
    "6. Affiche le résumé technique avec `df_sessions.info()`.\n",
    "\n",
    "Question (réponse en commentaire dans la cellule) : la colonne `converted` est-elle de type texte ou de type nombre ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 5.2\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 5.3 — Sélectionner des colonnes (parallèle SQL `SELECT`)\n",
    "\n",
    "À partir du `DataFrame` `df_sessions` chargé à l'exercice précédent :\n",
    "\n",
    "1. Affiche **uniquement** la colonne `source` (les 5 premières valeurs suffisent) avec `df_sessions[\"source\"].head()`.\n",
    "2. Crée un sous-`DataFrame` `df_kpi` qui contient **uniquement** les colonnes :\n",
    "   - `source`\n",
    "   - `device`\n",
    "   - `pages_viewed`\n",
    "   - `time_on_site`\n",
    "   - `converted`\n",
    "3. Affiche les 5 premières lignes de `df_kpi`.\n",
    "4. Compare le `shape` de `df_kpi` à celui de `df_sessions` : qu'est-ce qui change, qu'est-ce qui ne change pas ?\n",
    "5. En commentaire, écris la requête SQL équivalente (du style `SELECT ... FROM sessions;`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Exercice 5.3\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Mini défi final — Synthèse transversale (cours 1 à 5)\n",
    "\n",
    "Ce mini défi combine **tout ce que tu as vu**. L'idée : partir d'une liste de dictionnaires \"à la main\", la transformer en `DataFrame`, et produire un mini reporting.\n",
    "\n",
    "### Énoncé\n",
    "\n",
    "1. Crée une liste `campagnes` de **5 dictionnaires** avec les clés :\n",
    "   - `nom`, `canal`, `budget`, `clics`, `conversions`.\n",
    "\n",
    "2. **Avec une boucle `for`** (sans `pandas`), pour chaque campagne, affiche une ligne avec :\n",
    "   - `nom` en MAJUSCULES (`.upper()`),\n",
    "   - `canal`,\n",
    "   - `cpc` (`budget / clics`, format `:.2f`),\n",
    "   - `taux_conversion` (`conversions / clics`, format `:.2%`),\n",
    "   - un segment `\"VIP\"` / `\"Standard\"` / `\"À relancer\"` selon le taux de conversion.\n",
    "\n",
    "3. **Avec `pandas`** maintenant :\n",
    "   - Construis un `DataFrame` `df_campagnes` à partir de la liste `campagnes`.\n",
    "   - Affiche son `shape` et la liste de ses colonnes.\n",
    "   - Affiche les **3 premières lignes** avec `head(3)`.\n",
    "   - Crée un sous-`DataFrame` `df_resume` qui ne garde que `nom`, `canal` et `budget`.\n",
    "   - Affiche `df_resume`.\n",
    "\n",
    "4. Bonus (si tu es à l'aise) :\n",
    "   - Gère le cas où `clics` est égal à 0 (sinon, Python lèvera une `ZeroDivisionError`).\n",
    "   - Affiche le **budget total** et le **nombre total de conversions** sur l'ensemble des campagnes (cumul dans la boucle)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO — Mini défi final (synthèse cours 1 à 5)\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Pour aller plus loin\n",
    "\n",
    "Quand tous les exercices ci-dessus sont validés, tu es prêt pour la suite du programme :\n",
    "\n",
    "- **Filtrage de `DataFrame`** (équivalent du `WHERE` en SQL).\n",
    "- **Premier `groupby`** simple (compter / moyenner par `source`, par `device`, etc.).\n",
    "- Premières **jointures** entre fichiers ShopNow (`sessions` ↔ `users`, `sessions` ↔ `orders`).\n",
    "\n",
    "Bonne révision !"
   ]
  }
 ],
 "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}