{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "0f8b02b0",
      "metadata": {},
      "source": [
        "# Cours 1 — Introduction ultra débutant à Python pour le marketing digital\n",
        "\n",
        "Ce notebook est conçu pour des **débutants complets** en informatique.\n",
        "\n",
        "### Objectifs de la séance\n",
        "- Comprendre ce qu’est **Python** et ce qu’on va en faire en marketing digital.\n",
        "- Découvrir le fonctionnement d’un **notebook** (Jupyter / Google Colab).\n",
        "- Comprendre **ce qu’est une variable** et une **assignation**.\n",
        "- Manipuler quelques **types simples** : nombres et textes.\n",
        "- Faire **beaucoup de petits exercices pratiques**, juste après chaque explication.\n",
        "\n",
        "> Idée importante : Python n’est pas “magique”. C’est juste un outil qui suit des instructions, pas à pas. Si les instructions sont claires, l’ordinateur les exécute sans réfléchir."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "be17e86f",
      "metadata": {},
      "source": [
        "## 0. Comment utiliser ce notebook\n",
        "\n",
        "Un notebook est composé de **cellules** :\n",
        "- des cellules *texte* (comme celle-ci) pour les explications ;\n",
        "- des cellules *code* (avec fond différent) pour écrire / exécuter du Python.\n",
        "\n",
        "### Exécuter une cellule de code\n",
        "- Cliquez dans la cellule de code.\n",
        "- Appuyez sur `Ctrl + Entrée` (ou sur le bouton ▶︎ à gauche de la cellule).\n",
        "- Le résultat s’affiche juste en dessous.\n",
        "\n",
        "### Mini-exercice\n",
        "Dans la cellule suivante :\n",
        "1. Exécute la cellule **sans rien modifier**.\n",
        "2. Modifie légèrement le texte.\n",
        "3. Ré-exécute la cellule et observe la différence."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f92ffe32",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO — mini-exercice (voir consignes dans la cellule Markdown au-dessus)\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "f1b2da8f",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Bienvenue dans le cours Python pour le marketing digital !\n"
          ]
        }
      ],
      "source": [
        "# Cellule à exécuter puis à modifier\n",
        "print(f\"Bienvenue dans le cours Python pour le marketing digital !\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3c39b5c4",
      "metadata": {},
      "source": [
        "## 1. Qu’est‑ce qu’une variable ? (explication imagée)\n",
        "\n",
        "On va utiliser une **métaphore de “cases mémoire” dans l’ordinateur**.\n",
        "\n",
        "- Imagine que ton ordinateur contient des **étagères** avec des **boîtes**.\n",
        "- Quand tu écris `x = 5` en Python, on peut l’expliquer ainsi :\n",
        "  - Python **ouvre une boîte** dans la mémoire,\n",
        "  - il met la **valeur `5`** dans cette boîte,\n",
        "  - il colle une **étiquette `x`** sur la boîte.\n",
        "- Plus tard, quand tu écris `x + 3`, Python va chercher la boîte étiquetée `x`, lire la valeur (5), et faire le calcul.\n",
        "\n",
        "On appelle cette opération une **assignation** :\n",
        "- `x = 5` se lit : *« x reçoit la valeur 5 »*.\n",
        "\n",
        "Dans les cellules suivantes, on va **dessiner mentalement** ce qui se passe, puis écrire du code."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bc786ed5",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Exemple 1 : première assignation\n",
        "x = 5\n",
        "print(f\"Valeur de x : {x}\")\n",
        "\n",
        "# À VOIX HAUTE (en classe), on peut dire :\n",
        "# - Python ouvre une case mémoire\n",
        "# - Il met 5 dedans\n",
        "# - Il colle l'étiquette x sur cette case"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "953c1210",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Exemple 2 : réassignation de variable\n",
        "x = 5\n",
        "print(f\"Au début, x vaut : {x}\")\n",
        "\n",
        "x = x + 3  # on relit la case x (5), on ajoute 3, puis on remet 8 dans la case x\n",
        "print(f\"Après x = x + 3, x vaut : {x}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "685bfdbd",
      "metadata": {},
      "source": [
        "### Exercice 1 — Suivre les cases mémoire \"à la main\"\n",
        "\n",
        "Sans exécuter de code, essaie de deviner mentalement la valeur finale de chaque variable.\n",
        "\n",
        "1. Sur papier (ou dans ta tête), suis ces instructions :\n",
        "   - `a = 10`\n",
        "   - `a = a + 2`\n",
        "   - `a = a * 3`\n",
        "   - **Question :** à la fin, combien vaut `a` ?\n",
        "\n",
        "2. Même chose avec :\n",
        "   - `b = 100`\n",
        "   - `b = b - 40`\n",
        "   - `b = b / 2`\n",
        "   - **Question :** à la fin, combien vaut `b` ?\n",
        "\n",
        "Dans la cellule suivante, tu vas vérifier tes réponses avec Python."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2c37c6b1",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO — Exercice 1 (voir l'énoncé ci-dessus)\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b2ee6dde",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Vérification de l'exercice 1\n",
        "\n",
        "# 1) Suite pour a\n",
        "a = 10\n",
        "a = a + 2\n",
        "a = a * 3\n",
        "print(f\"Valeur finale de a : {a}\")\n",
        "\n",
        "# 2) Suite pour b\n",
        "b = 100\n",
        "b = b - 40\n",
        "b = b / 2\n",
        "print(f\"Valeur finale de b : {b}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0c57e5f9",
      "metadata": {},
      "source": [
        "## 2. Types simples : int, float, str, bool\n",
        "\n",
        "Nous allons manipuler **quatre types de base** très utilisés en marketing :\n",
        "\n",
        "- `int` : nombres entiers (ex : 10 visites, 350 clics)\n",
        "- `float` : nombres à virgule (ex : 2.5 €, 0.03 taux de conversion)\n",
        "- `str` : textes (chaînes de caractères) (ex : \"Instagram\", \"France\")\n",
        "- `bool` : booléens, valeurs logiques `True` ou `False` (ex : a converti ou pas)\n",
        "\n",
        "On va créer des variables marketing très simples de ces différents types."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8d823400",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Quelques exemples de types simples\n",
        "nombre_visites = 10          # int : nombre entier\n",
        "budget_campagne = 250.50     # float : nombre à virgule\n",
        "nom_campagne = \"Summer Sale\"  # str : texte\n",
        "conversion = True            # bool : vrai / faux\n",
        "\n",
        "print(f\"{nombre_visites} {type(nombre_visites)}\")\n",
        "print(f\"{budget_campagne} {type(budget_campagne)}\")\n",
        "print(f\"{nom_campagne} {type(nom_campagne)}\")\n",
        "print(f\"{conversion} {type(conversion)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "57a0e807",
      "metadata": {},
      "source": [
        "### Exercice 2 — Créer tes propres variables marketing\n",
        "\n",
        "Crée dans la cellule suivante :\n",
        "- une variable `nom_client` (par exemple \"Alice\") ;\n",
        "- une variable `visites_30_jours` (nombre entier) ;\n",
        "- une variable `dernier_montant_achat` (nombre à virgule) ;\n",
        "- une variable `a_converti_dernier_mois` (True ou False).\n",
        "\n",
        "Puis :\n",
        "- affiche chaque variable avec `print()` ;\n",
        "- affiche aussi son type avec `print(type(ma_variable))`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "981747bb",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO — Exercice 2 (voir l'énoncé ci-dessus)\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7c627cf4",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Correction — Exercice 2 : créer tes propres variables marketing\n",
        "\n",
        "nom_client = \"Alice\"\n",
        "visites_30_jours = 10\n",
        "dernier_montant_achat = 249.99\n",
        "a_converti_dernier_mois = True\n",
        "\n",
        "print(f\"{nom_client} {type(nom_client)}\")\n",
        "print(f\"{visites_30_jours} {type(visites_30_jours)}\")\n",
        "print(f\"{dernier_montant_achat} {type(dernier_montant_achat)}\")\n",
        "print(f\"{a_converti_dernier_mois} {type(a_converti_dernier_mois)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cde370ad",
      "metadata": {},
      "source": [
        "## 3. `print()` pour raconter une petite histoire marketing\n",
        "\n",
        "`print()` sert à **afficher** des informations à l’écran.\n",
        "\n",
        "Deux façons courantes de mélanger texte + variables :\n",
        "- `print(\"Le client\", nom_client, \"a dépensé\", montant, \"euros\")`\n",
        "- `print(f\"Le client {nom_client} a dépensé {montant} euros\")`\n",
        "\n",
        "Les deux font la même chose, mais la deuxième (avec `f\"...\"`) est souvent plus lisible."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e903e59f",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Exemple : phrase marketing avec virgules et f-string\n",
        "nom_client = \"Alice\"\n",
        "visites_30_jours = 5\n",
        "montant_achat = 120\n",
        "\n",
        "# Version avec virgules\n",
        "print(f\"Le client {nom_client} a effectué {visites_30_jours} visites et a dépensé {montant_achat} euros.\")\n",
        "\n",
        "# Version avec f-string\n",
        "print(f\"Le client {nom_client} a effectué {visites_30_jours} visites et a dépensé {montant_achat} euros.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "53cfafca",
      "metadata": {},
      "source": [
        "### Exercice 3 — Personnaliser un message client\n",
        "\n",
        "1. Reprends les variables que tu as créées (`nom_client`, `visites_30_jours`, etc.).\n",
        "2. Écris une phrase marketing **avec une f-string**, par exemple :\n",
        "\n",
        "   > \"Le client Alice a effectué 3 visites et a dépensé 59.9 euros le mois dernier.\"\n",
        "\n",
        "3. Écris la même phrase **avec des virgules** dans `print()`.\n",
        "4. Choisis la version que tu trouves la plus lisible."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "85f44368",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO — Exercice 3 (voir l'énoncé ci-dessus)\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a59e156c",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Correction — Exercice 3 : personnaliser un message client\n",
        "\n",
        "nom_client = \"Alice\"\n",
        "visites_30_jours = 3\n",
        "dernier_montant_achat = 59.9\n",
        "\n",
        "# Version 1 (inline f-string)\n",
        "print(f\"Le client {nom_client} a effectué {visites_30_jours} visites et a dépensé {dernier_montant_achat} euros.\")\n",
        "\n",
        "# Version 2 (f-string construite dans une variable)\n",
        "message = f\"Le client {nom_client} a effectué {visites_30_jours} visites et a dépensé {dernier_montant_achat} euros.\"\n",
        "print(message)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7b929f70",
      "metadata": {},
      "source": [
        "## 4. Calculs marketing très simples (CPC, taux de conversion)\n",
        "\n",
        "On va utiliser Python comme une **calculatrice lisible**.\n",
        "\n",
        "Exemples de KPI :\n",
        "- **CPC (Coût Par Clic)** : `budget / nombre_de_clics`\n",
        "- **Taux de conversion** : `nombre_de_conversions / nombre_de_clics`\n",
        "\n",
        "On reste volontairement sur **des cas très simples** pour bien voir le lien entre les formules et le code."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1b76daff",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Exemple : calcul d'un CPC et d'un taux de conversion\n",
        "budget = 500       # euros\n",
        "clics = 250        # nombre de clics\n",
        "conversions = 25   # nombre de conversions\n",
        "\n",
        "cpc = budget / clics\n",
        "taux_conversion = conversions / clics\n",
        "\n",
        "print(f\"Budget : {budget} euros\")\n",
        "print(f\"Clics : {clics}\")\n",
        "print(f\"Conversions : {conversions}\")\n",
        "print(f\"CPC : {cpc} euros\")\n",
        "print(f\"Taux de conversion : {taux_conversion}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "15ff62cb",
      "metadata": {},
      "source": [
        "### Exercice 4 — Tes propres KPI\n",
        "\n",
        "1. Crée :\n",
        "   - `budget_reseau_social` (par ex. 300) ;\n",
        "   - `clics_reseau_social` (par ex. 120) ;\n",
        "   - `conversions_reseau_social` (par ex. 10).\n",
        "2. Calcule :\n",
        "   - un CPC moyen ;\n",
        "   - un taux de conversion.\n",
        "3. Affiche les résultats avec des phrases claires.\n",
        "4. Modifie ensuite une des valeurs (par exemple doubler le budget) et observe ce qui change."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d26c0edf",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO — Exercice 4 (voir l'énoncé ci-dessus)\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0d92387b",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Correction — Exercice 4 : tes propres KPI\n",
        "\n",
        "budget_reseau_social = 300   # euros\n",
        "clics_reseau_social = 150    # nombre de clics\n",
        "conversions_reseau_social = 20\n",
        "\n",
        "cpc_reseau_social = budget_reseau_social / clics_reseau_social\n",
        "taux_conversion_reseau_social = conversions_reseau_social / clics_reseau_social\n",
        "\n",
        "print(f\"Budget réseau social : {budget_reseau_social} euros\")\n",
        "print(f\"Clics réseau social : {clics_reseau_social}\")\n",
        "print(f\"Conversions réseau social : {conversions_reseau_social}\")\n",
        "print(f\"CPC moyen : {cpc_reseau_social} euros\")\n",
        "print(f\"Taux de conversion : {taux_conversion_reseau_social}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "eeafc44f",
      "metadata": {},
      "source": [
        "## 5. Les listes (sans boucles pour l’instant)\n",
        "\n",
        "Une **liste** permet de stocker plusieurs valeurs dans **une seule variable**.\n",
        "\n",
        "Exemples de listes :\n",
        "- liste de noms de clients ;\n",
        "- liste de montants d’achats ;\n",
        "- liste de pays ou de canaux d’acquisition.\n",
        "\n",
        "Important :\n",
        "- En Python, le **premier élément** a l’indice **0** ;\n",
        "- Si une liste contient 4 éléments, le dernier a l’indice **3**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "59ac2630",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Exemple : liste de clients et montants\n",
        "clients = [\"Alice\", \"Bob\", \"Chloé\", \"David\"]\n",
        "montants_achats = [120, 45, 200, 80]\n",
        "\n",
        "print(f\"Liste des clients : {clients}\")\n",
        "print(f\"Montants d'achats : {montants_achats}\")\n",
        "\n",
        "# Accéder à certains éléments\n",
        "print(f\"Premier client : {clients[0]}\")\n",
        "print(f\"Dernier client : {clients[3]}\")  # 3 car la liste a 4 éléments (0,1,2,3)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ab36cff7",
      "metadata": {},
      "source": [
        "### Exercice 5 — Jouer avec les indices\n",
        "\n",
        "1. Crée une liste `clients` avec au moins 4 noms.\n",
        "2. Affiche :\n",
        "   - le premier client ;\n",
        "   - le deuxième client ;\n",
        "   - le dernier client.\n",
        "3. Question à discuter : si ta liste a 5 éléments, quel est **l’indice** du dernier ?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bd2562e9",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO — Exercice 5 (voir l'énoncé ci-dessus)\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "58751bb5",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Correction — Exercice 5 : jouer avec les indices\n",
        "\n",
        "clients = [\"Alice\", \"Bob\", \"Chloé\", \"David\"]  # au moins 4 noms\n",
        "\n",
        "print(f\"Liste complète : {clients}\")\n",
        "print(f\"Premier client : {clients[0]}\")\n",
        "print(f\"Deuxième client : {clients[1]}\")\n",
        "print(f\"Dernier client : {clients[-1]}\")\n",
        "print(f\"Indice du dernier client : {len(clients) - 1}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "af04a91f",
      "metadata": {},
      "source": [
        "## 6. Longueur d’une liste avec `len()`\n",
        "\n",
        "`len()` permet de connaître le **nombre d’éléments** dans une liste.\n",
        "\n",
        "En marketing, cela peut signifier :\n",
        "- nombre total de clients dans une campagne ;\n",
        "- nombre de canaux d’acquisition ;\n",
        "- nombre d’achats enregistrés."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d52edad3",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Exemple : utiliser len() sur une liste de canaux\n",
        "canaux = [\"Instagram\", \"Google Ads\", \"Email\", \"SEO\"]\n",
        "\n",
        "nombre_canaux = len(canaux)\n",
        "print(f\"Canaux : {canaux}\")\n",
        "print(f\"Nombre de canaux : {nombre_canaux}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6131c197",
      "metadata": {},
      "source": [
        "### Exercice 6 — Compter\n",
        "\n",
        "1. Crée une liste de canaux d’acquisition (`canaux = [...]`).\n",
        "2. Utilise `len(canaux)` pour afficher :\n",
        "\n",
        "   > \"Nombre de canaux différents : X\"\n",
        "\n",
        "3. Crée une autre liste de clients et affiche aussi sa longueur.\n",
        "\n",
        "---\n",
        "\n",
        "Tu peux t’arrêter ici si le groupe est fatigué. La suite (boucles, `range`, conditions) pourra être abordée dans la séance suivante."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f87cb3e4",
      "metadata": {},
      "outputs": [],
      "source": [
        "# TODO — Exercice 6 (voir l'énoncé ci-dessus)\n",
        "pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8321a869",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Correction — Exercice 6 : compter sur plusieurs listes\n",
        "\n",
        "canaux = [\"Instagram\", \"Google Ads\", \"Email\", \"SEO\"]\n",
        "clients = [\"Alice\", \"Bob\", \"Chloé\", \"David\"]\n",
        "\n",
        "print(f\"Canaux : {canaux}\")\n",
        "print(f\"Nombre de canaux différents : {len(canaux)}\")\n",
        "\n",
        "print(f\"Clients : {clients}\")\n",
        "print(f\"Nombre de clients : {len(clients)}\")"
      ]
    }
  ],
  "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
}