pyfinmodel 0.1.0__tar.gz

pyfinmodel-0.1.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.2
+Name: pyfinmodel
+Version: 0.1.0
+Summary: Documentation interactive des cours de modélisation financière avec Python
+Author: Nadir Hadji
+License: MIT
+Project-URL: Homepage, https://github.com/nadirhadji/pyfinmodel
+Project-URL: Documentation, https://github.com/nadirhadji/pyfinmodel#readme
+Project-URL: Repository, https://github.com/nadirhadji/pyfinmodel
+Keywords: finance,financial-modeling,python,CAPM,MEDAF,technical-analysis,econometrics,education
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Education
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: seaborn>=0.12
+Requires-Dist: yfinance>=0.2
+Requires-Dist: statsmodels>=0.14
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# pyfinmodel — Modélisation Financière avec Python
+
+Documentation interactive des cours FIN8524. Installez la librairie et accédez instantanément aux concepts, formules et snippets de code des cours.
+
+## Installation
+
+```bash
+pip install pyfinmodel
+```
+
+## Démarrage rapide
+
+```python
+import pyfinmodel
+
+# Vue d'ensemble du package
+pyfinmodel.aide()
+
+# Lister tous les cours
+pyfinmodel.liste_cours()
+
+# Résumé d'un cours
+pyfinmodel.resume_cours(1)
+
+# Rechercher un concept
+pyfinmodel.chercher("bêta")
+```
+
+## Structure des cours
+
+| Module | Thème | Niveau |
+|--------|-------|--------|
+| `cours1` | Introduction Python & Finance | Débutant |
+| `cours2` | Calcul Appliqué — NumPy & Pandas | Intermédiaire |
+| `cours3` | Analyse de Données Financières | Intermédiaire–Avancé |
+| `cours4` | Analyse Technique & Indicateurs | Avancé |
+| `cours5` | Économétrie & MEDAF/CAPM | Avancé |
+
+## Exemples d'utilisation
+
+```python
+# --- Cours 1 ---
+from pyfinmodel.cours1 import concepts_finance, python_bases
+
+concepts_finance.decisions_financieres()
+concepts_finance.probleme_agence()
+python_bases.f_strings_demo()
+python_bases.f_strings_code()  # retourne le snippet copiable
+
+# --- Cours 2 ---
+from pyfinmodel.cours2 import python_fonctionnel, numpy_pandas
+
+python_fonctionnel.list_comprehension_intro()
+python_fonctionnel.lambda_intro()
+numpy_pandas.numpy_array_intro()
+numpy_pandas.pandas_dataframe_intro()
+
+# --- Cours 3 ---
+from pyfinmodel.cours3 import chargement, rendements, visualisation
+
+chargement.charger_csv_demo()
+rendements.rendement_simple_demo()
+visualisation.graphique_prix_demo()
+
+# --- Cours 4 ---
+from pyfinmodel.cours4 import indicateurs, signaux
+
+indicateurs.sma_definition()
+indicateurs.ema_definition()
+indicateurs.bollinger_definition()
+signaux.signal_bollinger_definition()
+
+# --- Cours 5 ---
+from pyfinmodel.cours5 import regression_ols, medaf
+
+medaf.medaf_definition()
+medaf.beta_definition()
+regression_ols.r_carre_definition()
+regression_ols.ols_demo()
+```
+
+## Licence
+
+MIT

pyfinmodel-0.1.0/README.md

@@ -0,0 +1,84 @@
+# pyfinmodel — Modélisation Financière avec Python
+
+Documentation interactive des cours FIN8524. Installez la librairie et accédez instantanément aux concepts, formules et snippets de code des cours.
+
+## Installation
+
+```bash
+pip install pyfinmodel
+```
+
+## Démarrage rapide
+
+```python
+import pyfinmodel
+
+# Vue d'ensemble du package
+pyfinmodel.aide()
+
+# Lister tous les cours
+pyfinmodel.liste_cours()
+
+# Résumé d'un cours
+pyfinmodel.resume_cours(1)
+
+# Rechercher un concept
+pyfinmodel.chercher("bêta")
+```
+
+## Structure des cours
+
+| Module | Thème | Niveau |
+|--------|-------|--------|
+| `cours1` | Introduction Python & Finance | Débutant |
+| `cours2` | Calcul Appliqué — NumPy & Pandas | Intermédiaire |
+| `cours3` | Analyse de Données Financières | Intermédiaire–Avancé |
+| `cours4` | Analyse Technique & Indicateurs | Avancé |
+| `cours5` | Économétrie & MEDAF/CAPM | Avancé |
+
+## Exemples d'utilisation
+
+```python
+# --- Cours 1 ---
+from pyfinmodel.cours1 import concepts_finance, python_bases
+
+concepts_finance.decisions_financieres()
+concepts_finance.probleme_agence()
+python_bases.f_strings_demo()
+python_bases.f_strings_code()  # retourne le snippet copiable
+
+# --- Cours 2 ---
+from pyfinmodel.cours2 import python_fonctionnel, numpy_pandas
+
+python_fonctionnel.list_comprehension_intro()
+python_fonctionnel.lambda_intro()
+numpy_pandas.numpy_array_intro()
+numpy_pandas.pandas_dataframe_intro()
+
+# --- Cours 3 ---
+from pyfinmodel.cours3 import chargement, rendements, visualisation
+
+chargement.charger_csv_demo()
+rendements.rendement_simple_demo()
+visualisation.graphique_prix_demo()
+
+# --- Cours 4 ---
+from pyfinmodel.cours4 import indicateurs, signaux
+
+indicateurs.sma_definition()
+indicateurs.ema_definition()
+indicateurs.bollinger_definition()
+signaux.signal_bollinger_definition()
+
+# --- Cours 5 ---
+from pyfinmodel.cours5 import regression_ols, medaf
+
+medaf.medaf_definition()
+medaf.beta_definition()
+regression_ols.r_carre_definition()
+regression_ols.ols_demo()
+```
+
+## Licence
+
+MIT

pyfinmodel-0.1.0/pyfinmodel/__init__.py

@@ -0,0 +1,219 @@
+"""
+pyfinmodel — Modélisation Financière avec Python
+Documentation interactive des cours FIN8524.
+"""
+
+from pyfinmodel.core.affichage import (
+    _afficher_md,
+    _afficher_section,
+    _afficher_texte,
+    _afficher_titre,
+)
+
+__version__ = "0.1.0"
+__all__ = ["aide", "liste_cours", "resume_cours", "chercher"]
+
+_COURS_META = {
+    1: {
+        "titre": "Introduction Python & Finance d'Entreprise",
+        "niveau": "Débutant",
+        "themes": [
+            "Décisions financières",
+            "Gouvernance",
+            "Variables Python",
+            "Listes",
+            "f-strings",
+        ],
+        "librairies": ["Python natif"],
+    },
+    2: {
+        "titre": "Calcul Appliqué — NumPy & Pandas",
+        "niveau": "Intermédiaire",
+        "themes": [
+            "List comprehension",
+            "Lambda / map / filter",
+            "NumPy arrays",
+            "Pandas DataFrames",
+        ],
+        "librairies": ["numpy", "pandas"],
+    },
+    3: {
+        "titre": "Analyse de Données Financières & Visualisation",
+        "niveau": "Intermédiaire–Avancé",
+        "themes": [
+            "Chargement CSV",
+            "Rendements",
+            "Nettoyage",
+            "Matplotlib",
+            "Seaborn",
+            "Yahoo Finance",
+        ],
+        "librairies": ["pandas", "numpy", "matplotlib", "seaborn", "yfinance"],
+    },
+    4: {
+        "titre": "Analyse Technique & Indicateurs Boursiers",
+        "niveau": "Avancé",
+        "themes": ["SMA / EMA", "Bandes de Bollinger", "Signaux achat/vente"],
+        "librairies": ["yfinance", "matplotlib", "pandas"],
+    },
+    5: {
+        "titre": "Économétrie & MEDAF/CAPM",
+        "niveau": "Avancé",
+        "themes": [
+            "Régression OLS",
+            "Coefficient Bêta",
+            "R²",
+            "F-stat",
+            "t-stat",
+            "p-value",
+            "MEDAF",
+        ],
+        "librairies": ["statsmodels", "pandas", "yfinance"],
+    },
+}
+
+_INDEX_GLOBAL = {
+    "décision": (1, "cours1.concepts_finance.decisions_financieres"),
+    "investissement": (1, "cours1.concepts_finance.decision_investissement"),
+    "financement": (1, "cours1.concepts_finance.decision_financement"),
+    "dividende": (1, "cours1.concepts_finance.decision_dividendes"),
+    "gouvernance": (1, "cours1.concepts_finance.gouvernance_entreprise"),
+    "agence": (1, "cours1.concepts_finance.probleme_agence"),
+    "f-string": (1, "cours1.python_bases.f_strings_demo"),
+    "liste": (1, "cours1.python_bases.listes_intro"),
+    "list comprehension": (2, "cours2.python_fonctionnel.list_comprehension_intro"),
+    "lambda": (2, "cours2.python_fonctionnel.lambda_intro"),
+    "map": (2, "cours2.python_fonctionnel.map_demo"),
+    "filter": (2, "cours2.python_fonctionnel.filter_demo"),
+    "numpy": (2, "cours2.numpy_pandas.numpy_array_intro"),
+    "array": (2, "cours2.numpy_pandas.numpy_array_intro"),
+    "reshape": (2, "cours2.numpy_pandas.numpy_reshape_demo"),
+    "dataframe": (2, "cours2.numpy_pandas.pandas_dataframe_intro"),
+    "pandas": (2, "cours2.numpy_pandas.pandas_dataframe_intro"),
+    "csv": (3, "cours3.chargement.charger_csv_demo"),
+    "datetime": (3, "cours3.chargement.convertir_dates_demo"),
+    "yfinance": (3, "cours3.chargement.telecharger_yfinance_demo"),
+    "rendement": (3, "cours3.rendements.rendement_simple_demo"),
+    "pct_change": (3, "cours3.rendements.rendement_simple_demo"),
+    "boxplot": (3, "cours3.visualisation.boxplot_demo"),
+    "seaborn": (3, "cours3.visualisation.boxplot_demo"),
+    "matplotlib": (3, "cours3.visualisation.graphique_prix_demo"),
+    "sma": (4, "cours4.indicateurs.sma_definition"),
+    "moyenne mobile": (4, "cours4.indicateurs.sma_definition"),
+    "ema": (4, "cours4.indicateurs.ema_definition"),
+    "bollinger": (4, "cours4.indicateurs.bollinger_definition"),
+    "signal": (4, "cours4.signaux.signal_bollinger_definition"),
+    "achat": (4, "cours4.signaux.signal_bollinger_definition"),
+    "économétrie": (5, "cours5.regression_ols.ols_definition"),
+    "ols": (5, "cours5.regression_ols.ols_definition"),
+    "régression": (5, "cours5.regression_ols.ols_demo"),
+    "r²": (5, "cours5.regression_ols.r_carre_definition"),
+    "r2": (5, "cours5.regression_ols.r_carre_definition"),
+    "f-stat": (5, "cours5.regression_ols.f_statistique_definition"),
+    "t-stat": (5, "cours5.regression_ols.t_statistique_definition"),
+    "p-value": (5, "cours5.regression_ols.p_value_interpretation"),
+    "bêta": (5, "cours5.medaf.beta_definition"),
+    "beta": (5, "cours5.medaf.beta_definition"),
+    "medaf": (5, "cours5.medaf.medaf_definition"),
+    "capm": (5, "cours5.medaf.medaf_definition"),
+}
+
+
+def aide() -> None:
+    """Affiche la vue d'ensemble complète du package pyfinmodel."""
+    _afficher_titre("pyfinmodel — Documentation des Cours de Modélisation Financière")
+    _afficher_texte(
+        f"**Version :** {__version__}\n\n"
+        "**Fonctions globales :**\n\n"
+        "- `pyfinmodel.aide()` → Cette aide\n"
+        "- `pyfinmodel.liste_cours()` → Liste de tous les cours\n"
+        "- `pyfinmodel.resume_cours(n)` → Résumé du cours n (1 à 5)\n"
+        "- `pyfinmodel.chercher('terme')` → Chercher un concept"
+    )
+    _afficher_section("Modules disponibles")
+    lignes = []
+    for numero, meta in _COURS_META.items():
+        themes_courts = ", ".join(meta["themes"][:3]) + (
+            "..." if len(meta["themes"]) > 3 else ""
+        )
+        lignes.append(
+            f"**Cours {numero} : {meta['titre']}**  \n"
+            f"Niveau : {meta['niveau']} | Thèmes : {themes_courts}  \n"
+            f"`from pyfinmodel.cours{numero} import ...`"
+        )
+    _afficher_md("\n\n---\n\n".join(lignes))
+    _afficher_section("Exemple rapide")
+    _afficher_texte(
+        "```python\n"
+        "from pyfinmodel.cours5 import medaf\n"
+        "medaf.medaf_definition()\n"
+        "medaf.beta_definition()\n"
+        "```"
+    )
+
+
+def liste_cours() -> None:
+    """Affiche la liste des cours avec titre, niveau et thèmes."""
+    _afficher_titre("Cours disponibles dans pyfinmodel")
+    lignes = []
+    for numero, meta in _COURS_META.items():
+        lignes.append(
+            f"**Cours {numero} — {meta['titre']}**  \n"
+            f"🎓 Niveau : {meta['niveau']}  \n"
+            f"📌 Thèmes : {', '.join(meta['themes'])}  \n"
+            f"📦 Librairies : `{'`, `'.join(meta['librairies'])}`"
+        )
+    _afficher_md("\n\n---\n\n".join(lignes))
+
+
+def resume_cours(numero_cours: int) -> None:
+    """Affiche le résumé complet d'un cours.
+
+    Args:
+        numero_cours: Numéro du cours (1 à 5).
+    """
+    if numero_cours not in _COURS_META:
+        print(
+            f"  Erreur: le cours {numero_cours} n'existe pas. Choisissez entre 1 et 5."
+        )
+        return
+
+    meta = _COURS_META[numero_cours]
+    _afficher_titre(f"Cours {numero_cours} — {meta['titre']}")
+    themes_md = "\n".join(f"- {t}" for t in meta["themes"])
+    _afficher_texte(
+        f"**Niveau** : {meta['niveau']}  \n"
+        f"**Librairies** : `{'`, `'.join(meta['librairies'])}`\n\n"
+        f"{themes_md}"
+    )
+    _afficher_section("Pour explorer le cours")
+    _afficher_texte(f"```python\nfrom pyfinmodel.cours{numero_cours} import *\n```")
+
+
+def chercher(terme: str) -> None:
+    """Recherche un concept/terme dans l'ensemble du package.
+
+    Args:
+        terme: Mot-clé à rechercher (ex: 'bêta', 'bollinger', 'lambda').
+    """
+    terme_lower = terme.lower().strip()
+    _afficher_titre(f"Résultats pour : « {terme} »")
+
+    resultats = [
+        (cle, cours, chemin)
+        for cle, (cours, chemin) in _INDEX_GLOBAL.items()
+        if terme_lower in cle.lower()
+    ]
+
+    if not resultats:
+        _afficher_texte(
+            f"Aucun résultat pour **« {terme} »**.  \n"
+            "Conseil : essayez `bêta`, `ema`, `ols`, `rendement`, `lambda`..."
+        )
+        return
+
+    lignes = [
+        f"**Cours {cours}** — `{cle}`  \n⇒ `{chemin}()`"
+        for cle, cours, chemin in resultats
+    ]
+    _afficher_md("\n\n".join(lignes))

pyfinmodel-0.1.0/pyfinmodel/core/__init__.py

@@ -0,0 +1 @@
+"""Module core — utilitaires internes."""

pyfinmodel-0.1.0/pyfinmodel/core/affichage.py

@@ -0,0 +1,66 @@
+"""Utilitaires d'affichage communs pour pyfinmodel.
+
+Utilise IPython.display (Markdown + HTML) quand disponible (Jupyter),
+sinon bascule sur du texte brut (terminal).
+"""
+
+import textwrap
+
+
+# ── Détection de l'environnement Jupyter ────────────────────────────
+def _est_jupyter() -> bool:
+    try:
+        from IPython import get_ipython
+
+        shell = get_ipython()
+        return shell is not None and hasattr(shell, "kernel")
+    except ImportError:
+        return False
+
+
+def _afficher_md(contenu: str) -> None:
+    """Affiche du Markdown rendu dans Jupyter, texte brut sinon."""
+    if _est_jupyter():
+        from IPython.display import Markdown, display
+
+        display(Markdown(contenu))
+    else:
+        print(contenu)
+
+
+# ── API publique ─────────────────────────────────────────────────────
+
+
+def _afficher_titre(texte: str) -> None:
+    """Affiche un titre de niveau 2."""
+    _afficher_md(f"\n## 📘 {texte}\n---")
+
+
+def _afficher_section(texte: str) -> None:
+    """Affiche un titre de section (niveau 3)."""
+    _afficher_md(f"\n### {texte}")
+
+
+def _afficher_formule(nom: str, formule: str, description: str = "") -> None:
+    """Affiche une formule dans un bloc de code inline."""
+    lignes = [f"\n**📐 {nom}**", f"`{formule}`"]
+    if description:
+        lignes.append(f"*{description}*")
+    _afficher_md("\n\n".join(lignes) + "\n")
+
+
+def _afficher_code(titre: str, code: str) -> None:
+    """Affiche un snippet Python avec coloration syntaxique."""
+    code_propre = textwrap.dedent(code).strip()
+    _afficher_md(f"\n**💻 {titre}**\n\n```python\n{code_propre}\n```\n")
+
+
+def _afficher_texte(texte: str) -> None:
+    """Affiche un bloc de texte brut déjà formaté en Markdown."""
+    _afficher_md(textwrap.dedent(texte).strip())
+
+
+def _afficher_definition(terme: str, definition: str) -> None:
+    """Affiche une définition formatée."""
+    definition_propre = definition.replace("\n     ", "\n").replace("\n    ", "\n")
+    _afficher_md(f"\n> **📖 {terme}**  \n> {definition_propre}\n")

pyfinmodel-0.1.0/pyfinmodel/cours1/__init__.py

@@ -0,0 +1,5 @@
+"""Cours 1 — Introduction Python & Finance d'Entreprise."""
+
+from pyfinmodel.cours1 import concepts_finance, python_bases
+
+__all__ = ["concepts_finance", "python_bases"]

pyfinmodel-0.1.0/pyfinmodel/cours1/concepts_finance.py

@@ -0,0 +1,148 @@
+"""
+Cours 1 — Concepts de Finance d'Entreprise
+===========================================
+Les trois grandes décisions, gouvernance et problème d'agence.
+"""
+
+from pyfinmodel.core.affichage import (
+    _afficher_code,
+    _afficher_definition,
+    _afficher_section,
+    _afficher_texte,
+    _afficher_titre,
+)
+
+
+def decisions_financieres() -> None:
+    """Affiche les trois grandes décisions en finance d'entreprise."""
+    _afficher_titre("Les Trois Grandes Décisions en Finance d'Entreprise")
+    _afficher_texte(
+        "L'objectif ultime de toute décision financière est de "
+        "**MAXIMISER LA VALEUR DE LA FIRME** (mesurée par le cours de l'action)."
+    )
+
+    _afficher_section("1. Décision d'Investissement")
+    _afficher_texte(
+        "Quels projets ou actifs l'entreprise doit-elle financer ?\n\n"
+        "- Règle : accepter les projets dont la VAN (Valeur Actuelle Nette) > 0\n"
+        "- Exemples : achat d'équipements, R&D, acquisitions"
+    )
+
+    _afficher_section("2. Décision de Financement")
+    _afficher_texte(
+        "Comment l'entreprise doit-elle se financer ?\n\n"
+        "- Dettes vs Capitaux propres (structure du capital)\n"
+        "- Compromis entre avantage fiscal de la dette et coûts de détresse"
+    )
+
+    _afficher_section("3. Décision de Distribution (Dividendes)")
+    _afficher_texte(
+        "Quoi faire avec les bénéfices générés ?\n\n"
+        "- Distribuer des dividendes aux actionnaires\n"
+        "- OU réinvestir dans de nouveaux projets"
+    )
+
+
+def decision_investissement() -> None:
+    """Détail de la décision d'investissement."""
+    _afficher_titre("Décision d'Investissement")
+    _afficher_definition(
+        "Règle de la VAN",
+        "Accepter tous les projets avec une Valeur Actuelle Nette > 0.\n"
+        "     VAN = Σ [ CF_t / (1+r)^t ] - Investissement initial",
+    )
+    _afficher_texte(
+        "**Critères complémentaires :**\n\n"
+        "- TRI (Taux de Rendement Interne) > Coût du Capital\n"
+        "- Délai de récupération acceptable"
+    )
+
+
+def decision_financement() -> None:
+    """Détail de la décision de financement."""
+    _afficher_titre("Décision de Financement — Structure du Capital")
+    _afficher_definition(
+        "Structure optimale du capital",
+        "Combinaison dettes / capitaux propres qui maximise la valeur\n"
+        "     en minimisant le Coût Moyen Pondéré du Capital (CMPC/WACC).",
+    )
+    _afficher_texte(
+        "**Avantages de la dette :**\n\n"
+        "- Déductibilité fiscale des intérêts (bouclier fiscal)\n"
+        "- Discipline des dirigeants\n\n"
+        "**Inconvénients de la dette :**\n\n"
+        "- Coûts de détresse financière\n"
+        "- Problèmes d'agence dette-actionnaires"
+    )
+
+
+def decision_dividendes() -> None:
+    """Détail de la politique de dividendes."""
+    _afficher_titre("Décision de Distribution — Politique de Dividendes")
+    _afficher_definition(
+        "Théorème de Modigliani-Miller (dividendes)",
+        "En marchés parfaits, la politique de dividendes n'affecte pas\n"
+        "     la valeur de la firme.",
+    )
+    _afficher_texte(
+        "**En pratique :**\n\n"
+        "- Les dividendes envoient un signal sur la santé financière\n"
+        "- Rachat d'actions = forme alternative de distribution\n"
+        "- Ratio de distribution = Dividendes / Bénéfice net"
+    )
+
+
+def gouvernance_entreprise() -> None:
+    """Explique la gouvernance d'entreprise et ses mécanismes."""
+    _afficher_titre("Gouvernance d'Entreprise")
+    _afficher_texte(
+        "La gouvernance vise à **ALIGNER LES INTÉRÊTS** des différentes parties "
+        "prenantes : actionnaires, dirigeants et créanciers."
+    )
+
+    _afficher_section("Mécanismes de gouvernance")
+    _afficher_texte(
+        "1. **Conseil d'Administration (CA)** — Surveille les dirigeants, approuve les grandes décisions\n\n"
+        "2. **Rémunération des dirigeants** — Stock-options, bonus liés à la performance\n\n"
+        "3. **Activisme actionnarial** — Actionnaires qui exercent leur influence pour changer la stratégie\n\n"
+        "4. **Réglementation** — Lois boursières (SEC, AMF), normes comptables (IFRS, GAAP)"
+    )
+
+    _afficher_section("Efficacité de la gouvernance")
+    _afficher_texte(
+        "Dépend du contexte légal et institutionnel du pays. "
+        "Les pays avec de meilleures protections légales ont une gouvernance généralement plus efficace."
+    )
+
+
+def probleme_agence() -> None:
+    """Explique le problème d'agence en finance."""
+    _afficher_titre("Le Problème d'Agence")
+    _afficher_definition(
+        "Relation d'agence",
+        "Contrat par lequel une personne (le principal) délègue une tâche\n"
+        "     à une autre (l'agent). Conflit d'intérêts potentiel.",
+    )
+
+    _afficher_section("Les trois conflits principaux")
+    _afficher_texte(
+        "1. **Actionnaires ↔ Dirigeants** — Les dirigeants peuvent poursuivre leurs propres intérêts. "
+        "Solutions : stock-options, surveillance du CA\n\n"
+        "2. **Actionnaires ↔ Créanciers** — Les actionnaires peuvent prendre des risques excessifs. "
+        "Transfert de richesse des créanciers vers actionnaires\n\n"
+        "3. **Actionnaires majoritaires ↔ Minoritaires** — Expropriation des minoritaires par les majoritaires"
+    )
+
+    _afficher_code(
+        "Illustration Python — Modélisation d'intérêts divergents",
+        """
+acteur = {
+    "actionnaire": {"objectif": "maximiser_valeur_action", "horizon": "long_terme"},
+    "dirigeant":   {"objectif": "maximiser_bonus",          "horizon": "court_terme"},
+    "créancier":   {"objectif": "rembourser_dette",         "horizon": "fixé_par_contrat"},
+}
+
+for role, profil in acteur.items():
+    print(f"{role:12s} → objectif: {profil['objectif']}, horizon: {profil['horizon']}")
+""",
+    )