{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "df634229",
      "metadata": {},
      "source": [
        "# Cours 2 — Boucles et conditions pour le marketing digital\n",
        "\n",
        "Ce deuxième cours part du niveau **ultra débutant** vu en Cours 1.\n",
        "\n",
        "### Prérequis (vus au Cours 1)\n",
        "- Savoir exécuter un notebook (lancer une cellule de code).\n",
        "- Comprendre ce qu’est une **variable** et une **assignation** (les boîtes en mémoire avec une étiquette).\n",
        "- Manipuler quelques types simples : `int`, `float`, `str`, `bool`.\n",
        "- Utiliser `print()` pour afficher des phrases marketing simples.\n",
        "- Créer des **listes** et utiliser `len()` pour connaître leur longueur.\n",
        "\n",
        "### Objectifs du Cours 2\n",
        "- Comprendre et utiliser `range()` pour générer des suites de nombres.\n",
        "- Utiliser des **boucles `for`** simples pour répéter une action.\n",
        "- Combiner **listes + boucles** pour parcourir des clients / montants.\n",
        "- Découvrir les **conditions `if / elif / else`** pour prendre des décisions marketing simples.\n",
        "- Faire beaucoup de **petits exercices pratiques** après chaque nouvelle notion.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b7e0016c",
      "metadata": {},
      "source": [
        "## 0. Petit rappel du Cours 1\n",
        "\n",
        "Avant d’aller plus loin, réponds (même mentalement) à ces questions :\n",
        "\n",
        "1. Sais‑tu exécuter une cellule de code dans un notebook ?  \n",
        "2. Sais‑tu ce qu’est une **variable** (une case mémoire avec une étiquette) ?  \n",
        "3. Sais‑tu créer une petite **liste** et utiliser `len()` pour connaître sa taille ?\n",
        "\n",
        "Si tu n’es pas à l’aise avec ça, ce n’est pas grave :\n",
        "- n’hésite pas à rouvrir le **Cours 1** et à rejouer quelques cellules ;\n",
        "- pendant ce Cours 2, on va refaire quelques rappels.\n",
        "\n",
        "Dans la cellule suivante, on vérifie juste que tout fonctionne."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "4b03e165",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Cours 2 — tout fonctionne, on peut continuer.\n"
          ]
        }
      ],
      "source": [
        "# Vérification rapide : exécute cette cellule\n",
        "print(f\"Cours 2 — tout fonctionne, on peut continuer.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ed6a4853",
      "metadata": {},
      "source": [
        "## 1. `range()` — générer une séquence de nombres\n",
        "\n",
        "`range()` est un outil qui permet de **générer une suite de nombres**. Python s’en sert très souvent avec les boucles.\n",
        "\n",
        "On peut le voir comme une **liste virtuelle** de nombres :\n",
        "- `range(5)` correspond à : 0, 1, 2, 3, 4\n",
        "- `range(1, 5)` correspond à : 1, 2, 3, 4\n",
        "\n",
        "On rappelle que Python commence à compter à 0.\n",
        "On va d’abord regarder ce que Python affiche, puis on fera des petits exercices.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "6960ba1b",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "range(5) -> [0, 1, 2, 3, 4]\n",
            "range(1, 5) -> [1, 2, 3, 4]\n",
            "range(0, 10, 2) -> [0, 2, 4, 6, 8]\n"
          ]
        }
      ],
      "source": [
        "# Exemple : quelques ranges\n",
        "print(f\"range(5) -> {list(range(5))}\")          # 0,1,2,3,4\n",
        "print(f\"range(1, 5) -> {list(range(1, 5))}\")    # 1,2,3,4\n",
        "print(f\"range(0, 10, 2) -> {list(range(0, 10, 2))}\")  # 0,2,4,6,8"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c09c0cf6",
      "metadata": {},
      "source": [
        "### Exercice 1 — Comprendre `range`\n",
        "\n",
        "Dans la cellule suivante :\n",
        "1. Remplace `...` par les bons appels à `range` pour obtenir les séquences demandées.\n",
        "2. Exécute plusieurs fois en changeant les paramètres.\n",
        "\n",
        "Séquences à obtenir :\n",
        "- `0, 1, 2, 3, 4, 5`\n",
        "- `1, 2, 3, 4, 5`\n",
        "- `2, 4, 6, 8, 10`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4c3c511b",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO — Exercice 1 (voir l'énoncé ci-dessus)\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "b63ef3e0",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "De 0 à 5 inclus : [0, 1, 2, 3, 4, 5]\n",
            "De 1 à 5 inclus : [1, 2, 3, 4, 5]\n",
            "Pairs de 2 à 10 : [2, 4, 6, 8, 10]\n"
          ]
        }
      ],
      "source": [
        "# À toi : complète les ranges\n",
        "\n",
        "print(f\"De 0 à 5 inclus : {list(range(0, 6))}\")  # à adapter si besoin\n",
        "print(f\"De 1 à 5 inclus : {list(range(1, 6))}\")  # à adapter si besoin\n",
        "print(f\"Pairs de 2 à 10 : {list(range(2, 11, 2))}\")  # à adapter si besoin"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6f97d926",
      "metadata": {},
      "source": [
        "## 2. Boucles `for` avec `range` — répéter une action\n",
        "\n",
        "Une **boucle `for`** permet de répéter une action **plusieurs fois**.\n",
        "\n",
        "Exemple d’idée :\n",
        "- envoyer un message pour chaque jour d’une campagne,\n",
        "- afficher les numéros des emails envoyés,\n",
        "- tester quelque chose pour les 5 premiers clients.\n",
        "\n",
        "Structure générale :\n",
        "```python\n",
        "for nombre in range(5):\n",
        "    print(nombre)\n",
        "```\n",
        "\n",
        "Dans la cellule suivante, on fait quelques boucles très simples."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d3d12648",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Exemple : répéter une action plusieurs fois\n",
        "\n",
        "for i in range(5):\n",
        "    print(f\"Envoi de l'email numéro {i}\")\n",
        "\n",
        "print(f\"-\")\n",
        "\n",
        "for jour in range(1, 4):\n",
        "    print(f\"Jour de campagne : {jour}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cd556109",
      "metadata": {},
      "source": [
        "### Exercice 2 — Boucles très simples\n",
        "\n",
        "1. Écris une boucle `for` qui affiche :\n",
        "   - `Jour 1`, `Jour 2`, `Jour 3`, `Jour 4`, `Jour 5`.\n",
        "2. Écris une boucle `for` qui affiche :\n",
        "   - `Email 1 envoyé`, `Email 2 envoyé`, `Email 3 envoyé`.\n",
        "\n",
        "Tu peux t’inspirer de la cellule précédente et adapter le texte."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5c433807",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO — Exercice 2 (voir l'énoncé ci-dessus)\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "af5cd688",
      "metadata": {},
      "outputs": [],
      "source": [
        "# À toi : complète les boucles\n",
        "\n",
        "# 1) Afficher Jour 1, Jour 2, ..., Jour 5\n",
        "for jour in range(1, 6):\n",
        "    print(f\"Jour {jour}\")\n",
        "\n",
        "print(f\"-\")\n",
        "\n",
        "# 2) Afficher Email 1 envoyé, Email 2 envoyé, Email 3 envoyé\n",
        "for numero in range(1, 4):\n",
        "    print(f\"Email {numero} envoyé\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7f1b2294",
      "metadata": {},
      "source": [
        "## 3. Boucles `for` sur des listes (clients, montants)\n",
        "\n",
        "On va maintenant combiner :\n",
        "- une **liste** (clients, montants, canaux) ;\n",
        "- une **boucle `for`** qui parcourt la liste **élément par élément**.\n",
        "\n",
        "Structure générale :\n",
        "```python\n",
        "clients = [\"Alice\", \"Bob\"]\n",
        "for client in clients:\n",
        "    print(client)\n",
        "```\n",
        "\n",
        "C’est un schéma qu’on utilisera tout le temps en analyse de données."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "11494b84",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Exemple : parcourir une liste de clients\n",
        "clients = [\"Alice\", \"Bob\", \"Chloé\", \"David\"]\n",
        "\n",
        "for client in clients:\n",
        "    print(f\"Client : {client}\")\n",
        "\n",
        "print(f\"-\")\n",
        "\n",
        "# Exemple : parcourir une liste de montants\n",
        "montants_achats = [120, 45, 200, 80]\n",
        "\n",
        "for montant in montants_achats:\n",
        "    print(f\"Montant d'achat : {montant} euros\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "887bd2be",
      "metadata": {},
      "source": [
        "### Exercice 3 — Parcourir des listes marketing\n",
        "\n",
        "1. Crée une liste `clients` avec au moins 4 prénoms.\n",
        "2. Crée une liste `canaux` avec au moins 3 canaux (\"Instagram\", \"Google Ads\", \"Email\", ...).\n",
        "3. Écris une boucle qui affiche :\n",
        "   - `Client : ...` pour chaque client.\n",
        "4. Écris une autre boucle qui affiche :\n",
        "   - `Canal utilisé : ...` pour chaque canal.\n",
        "\n",
        "Tu peux copier / coller les exemples et les adapter."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a309f2f4",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO — Exercice 3 (voir l'énoncé ci-dessus)\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e68c2d01",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Correction — Exercice 3 : boucles sur des listes\n",
        "\n",
        "clients = [\"Alice\", \"Bob\", \"Chloé\", \"David\"]  # ajoute plusieurs noms\n",
        "canaux = [\"Instagram\", \"Google Ads\", \"Email\"]   # ajoute plusieurs canaux\n",
        "\n",
        "for client in clients:\n",
        "    print(f\"Client : {client}\")\n",
        "\n",
        "print(f\"-\")\n",
        "\n",
        "for canal in canaux:\n",
        "    print(f\"Canal utilisé : {canal}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "36fb5d69",
      "metadata": {},
      "source": [
        "## 4. Combiner deux listes : clients + montants\n",
        "\n",
        "Souvent, on a **deux listes liées** :\n",
        "- une liste de clients ;\n",
        "- une liste de montants d’achats ;\n",
        "- à la position 0 : client 0 et montant 0 vont ensemble, etc.\n",
        "\n",
        "On peut alors utiliser un **indice** `i` pour parcourir les deux listes en même temps.\n",
        "\n",
        "Schéma :\n",
        "```python\n",
        "clients = [\"Alice\", \"Bob\"]\n",
        "montants = [120, 45]\n",
        "\n",
        "for i in range(len(clients)):\n",
        "    nom = clients[i]\n",
        "    montant = montants[i]\n",
        "    print(nom, montant)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "310eac6d",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Exemple : clients + montants\n",
        "clients = [\"Alice\", \"Bob\", \"Chloé\", \"David\"]\n",
        "montants_achats = [120, 45, 200, 80]\n",
        "\n",
        "for i in range(len(clients)):\n",
        "    nom = clients[i]\n",
        "    montant = montants_achats[i]\n",
        "    print(f\"Client {nom} - montant d'achat : {montant} €\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "10813e57",
      "metadata": {},
      "source": [
        "### Exercice 4 — Mini reporting clients\n",
        "\n",
        "1. Crée une liste `clients` avec 4 noms.\n",
        "2. Crée une liste `montants` avec 4 montants (mêmes positions).\n",
        "3. Utilise une boucle `for i in range(len(clients))` pour afficher pour chaque client :\n",
        "\n",
        "   > \"Client X a dépensé Y euros.\"\n",
        "\n",
        "4. Variante : change un des montants et réexécute la boucle pour voir l’impact."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "51d1a64b",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO — Exercice 4 (voir l'énoncé ci-dessus)\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "88ac0190",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Correction — Exercice 4 : mini reporting clients\n",
        "\n",
        "clients = [\"Alice\", \"Bob\", \"Chloé\", \"David\"]\n",
        "montants = [120, 45, 200, 80]  # mêmes longueurs que `clients`\n",
        "\n",
        "for i in range(len(clients)):\n",
        "    nom = clients[i]\n",
        "    montant = montants[i]\n",
        "    print(f\"Client {nom} a dépensé {montant} euros.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "edffdba0",
      "metadata": {},
      "source": [
        "## 5. Conditions `if / elif / else` — prendre des décisions\n",
        "\n",
        "Les **conditions** permettent de prendre des décisions en fonction d’une règle.\n",
        "\n",
        "Exemples marketing :\n",
        "- si le montant d’achat est supérieur à 100 € → client **premium** ;\n",
        "- sinon → client **standard**.\n",
        "\n",
        "Structure générale :\n",
        "```python\n",
        "if condition:\n",
        "    # faire quelque chose\n",
        "else:\n",
        "    # faire autre chose\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5d6f76dd",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Exemple : client premium ou standard\n",
        "\n",
        "montant_achat = 120\n",
        "seuil_premium = 100\n",
        "\n",
        "if montant_achat > seuil_premium:\n",
        "    print(f\"Client premium\")\n",
        "else:\n",
        "    print(f\"Client standard\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "39f00c7d",
      "metadata": {},
      "source": [
        "### Exercice 5 — Classer un client\n",
        "\n",
        "1. Crée une variable `montant_achat_client`.\n",
        "2. Si le montant est **strictement supérieur** à 100 €, affiche `\"client premium\"`.\n",
        "3. Sinon, affiche `\"client standard\"`.\n",
        "\n",
        "Variante (si tu es à l’aise) :\n",
        "- ajoute une variable `nombre_visites` ;\n",
        "- si `nombre_visites` est supérieur à 3, affiche aussi `\"prospect engagé\"`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cbe37020",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO Exercice 5 — Classer un client\n",
        "# Complète `montant_achat_client` et compare avec `seuil_premium`.\n",
        "# La cellule suivante contient un exemple corrigé.\n",
        "\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "80b97c52",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Correction — Exercice 5 : classer un client\n",
        "\n",
        "montant_achat_client = 120\n",
        "seuil_premium = 100\n",
        "\n",
        "if montant_achat_client > seuil_premium:\n",
        "    print(f\"client premium\")\n",
        "else:\n",
        "    print(f\"client standard\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7cb1efa5",
      "metadata": {},
      "source": [
        "## 6. Mini défi — Qui relancer, qui garder ?\n",
        "\n",
        "On combine maintenant :\n",
        "- listes ;\n",
        "- boucles ;\n",
        "- conditions.\n",
        "\n",
        "### Scénario\n",
        "Tu as :\n",
        "- une liste de clients ;\n",
        "- une liste de montants d’achats correspondants ;\n",
        "- un seuil de relance (par ex. 60 €).\n",
        "\n",
        "Règle simple :\n",
        "- si un client a dépensé **moins** que le seuil → `\"à relancer\"` ;\n",
        "- sinon → `\"client intéressant\"`.\n",
        "\n",
        "### Objectif\n",
        "1. Créer les listes et le seuil.\n",
        "2. Parcourir les clients avec une boucle.\n",
        "3. Pour chaque client, afficher un message :\n",
        "\n",
        "   > \"Client X a dépensé Y € : à relancer.\"  \n",
        "   ou  \n",
        "   > \"Client X a dépensé Y € : client intéressant.\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "262a4b7a",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO Mini défi — Qui relancer, qui garder ?\n",
        "# Complète `clients`, `montants_achats` et `seuil_relance`,\n",
        "# puis exécute la cellule suivante (correction).\n",
        "\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "218be9b4",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Mini défi : relance ou non\n",
        "\n",
        "clients = [\"Alice\", \"Bob\", \"Chloé\", \"David\"]  # tu peux modifier\n",
        "montants_achats = [120, 45, 200, 80]               # tu peux modifier\n",
        "seuil_relance = 60\n",
        "\n",
        "for i in range(len(clients)):\n",
        "    nom = clients[i]\n",
        "    montant = montants_achats[i]\n",
        "\n",
        "    if montant < seuil_relance:\n",
        "        print(f\"Client {nom} a dépensé {montant} € : à relancer.\")\n",
        "    else:\n",
        "        print(f\"Client {nom} a dépensé {montant} € : client intéressant.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7b9484f3",
      "metadata": {},
      "source": [
        "### Variante libre\n",
        "\n",
        "- Change la valeur de `seuil_relance` et observe quels clients changent de catégorie.\n",
        "- Modifie les messages pour qu’ils soient plus proches d’une vraie campagne CRM (ex. \"à relancer avec un bon de réduction\", \"client fidèle à chouchouter\", etc.).\n",
        "\n",
        "---\n",
        "\n",
        "À la fin de ce Cours 2, tu dois être à l’aise avec :\n",
        "- `range()` ;\n",
        "- les boucles `for` sur des nombres et sur des listes ;\n",
        "- les conditions `if / else` simples ;\n",
        "- la combinaison liste + boucle + condition pour faire un mini reporting marketing.\n",
        "\n",
        "Dans les cours suivants, on ira vers **`pandas` et les fichiers CSV ShopNow**, qui recycleront exactement ces schémas (mais sur des tableaux beaucoup plus grands)."
      ]
    }
  ],
  "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.11.9"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}