pyfinmodel 0.1.0__py3-none-any.whl

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/core/__init__.py

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

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/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/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']}")
+""",
+    )

pyfinmodel/cours1/python_bases.py

@@ -0,0 +1,179 @@
+"""
+Cours 1 — Bases de Python avec exemples financiers
+===================================================
+Variables, chaînes de caractères, f-strings, listes.
+"""
+
+from pyfinmodel.core.affichage import (
+    _afficher_code,
+    _afficher_definition,
+    _afficher_section,
+    _afficher_texte,
+    _afficher_titre,
+)
+
+
+def variables_types_demo() -> None:
+    """Présente les types de base Python avec exemples financiers."""
+    _afficher_titre("Variables et Types de Base en Python")
+    _afficher_section("Types primitifs courants")
+    _afficher_texte(
+        "| Type | Exemple financier | Code Python |\n"
+        "|------|-------------------|-------------|\n"
+        "| `int` | Nombre d'actions | `nb_actions = 500` |\n"
+        "| `float` | Prix d'une action | `prix = 94.54` |\n"
+        "| `str` | Ticker de l'entreprise | `ticker = 'MRU.TO'` |\n"
+        "| `bool` | Action en hausse ? | `en_hausse = True` |"
+    )
+    _afficher_code(
+        "Exemple complet",
+        """
+nom        = "Metro"
+ticker     = "MRU.TO"
+prix       = 94.54
+nb_actions = 1000
+en_hausse  = True
+
+valeur_portefeuille = prix * nb_actions
+print(f"Portefeuille {nom} ({ticker}) : {valeur_portefeuille:,.2f} $")
+""",
+    )
+
+
+def f_strings_demo() -> None:
+    """Démontre les f-strings pour le formatage financier."""
+    _afficher_titre("f-strings — Formatage de Texte en Python")
+    _afficher_definition(
+        "f-string (formatted string literal)",
+        "Syntaxe Python moderne pour insérer des expressions directement\n"
+        '     dans une chaîne de caractères. Préfixe f"...".',
+    )
+    _afficher_texte(
+        "**Méthode 1 — `.format()`**\n\n"
+        '```python\nmsg = "Prix de {} : {} $".format(ticker, prix)\n```\n\n'
+        "**Méthode 2 — f-string (recommandée ✓)**\n\n"
+        '```python\nmsg = f"Prix de {ticker} : {prix} $"\n```'
+    )
+    _afficher_section("Modificateurs de format utiles en finance")
+    _afficher_texte(
+        "| Modificateur | Effet | Exemple |\n"
+        "|-------------|-------|---------|\n"
+        "| `{prix:.2f}` | 2 décimales | `94.54` |\n"
+        "| `{valeur:,.0f}` | séparateur de milliers | `1,000,000` |\n"
+        "| `{taux:.1%}` | pourcentage | `5.3%` |\n"
+        "| `{nom.upper()}` | majuscules | `METRO` |"
+    )
+    _afficher_code(
+        "Snippet copiable — f-strings financiers",
+        _f_strings_code(),
+    )
+
+
+def listes_intro() -> None:
+    """Introduction aux listes Python avec exemples de portefeuille."""
+    _afficher_titre("Listes Python — Portefeuilles et Séries de Prix")
+    _afficher_definition(
+        "Liste",
+        "Structure de données HÉTÉROGÈNE ordonnée et modifiable.\n"
+        "     Peut contenir des éléments de types différents.",
+    )
+    _afficher_definition(
+        "Vecteur (Array NumPy)",
+        "Structure HOMOGÈNE où tous les éléments ont le même type.\n"
+        "     Optimisée pour les calculs numériques.",
+    )
+    _afficher_section("Opérations courantes sur les listes")
+    _afficher_texte(
+        "| Opération | Syntaxe | Exemple |\n"
+        "|-----------|---------|---------|\n"
+        "| Créer | `liste = [...]` | `tickers = ['AAPL', 'GOOG']` |\n"
+        "| Accéder | `liste[index]` | `tickers[0]` → `'AAPL'` |\n"
+        "| Slicing | `liste[début:fin]` | `tickers[1:3]` |\n"
+        "| Ajouter 1 élément | `liste.append(x)` | `tickers.append('MSFT')` |\n"
+        "| Ajouter plusieurs | `liste.extend([x, y])` | `tickers.extend(['META','TSLA'])` |\n"
+        "| Longueur | `len(liste)` | `len(tickers)` → `4` |"
+    )
+    _afficher_code(
+        "Snippet copiable — Listes de portefeuille",
+        _liste_code(),
+    )
+
+
+def liste_extend_demo() -> None:
+    """Démontre la méthode extend() pour fusionner des portefeuilles."""
+    _afficher_titre("liste.extend() — Fusionner des Portefeuilles")
+    _afficher_texte(
+        "`extend()` ajoute **PLUSIEURS** éléments à la fin d'une liste existante. "
+        "Différent de `append()` qui n'ajoute qu'**UN** seul élément."
+    )
+    _afficher_code(
+        "Comparaison append vs extend",
+        """
+portefeuille_a = ["AAPL", "GOOG", "MSFT"]
+portefeuille_b = ["META", "TSLA", "NVDA"]
+
+# append() ajoute la liste comme UN SEUL élément (nested)
+portefeuille_a.append(portefeuille_b)
+# Résultat: ["AAPL", "GOOG", "MSFT", ["META", "TSLA", "NVDA"]]  ← non désiré
+
+# extend() fusionne les deux listes correctement
+portefeuille_a = ["AAPL", "GOOG", "MSFT"]
+portefeuille_a.extend(portefeuille_b)
+# Résultat: ["AAPL", "GOOG", "MSFT", "META", "TSLA", "NVDA"]   ← correct
+print(portefeuille_a)
+""",
+    )
+
+
+def _liste_code() -> str:
+    """Retourne le snippet listes en tant que chaîne copiable.
+
+    Returns:
+        Code Python sous forme de chaîne de caractères.
+    """
+    return """
+# Portefeuille — liste hétérogène
+portefeuille = ["AAPL", "GOOG", "MSFT"]
+prix_actuels = [189.5, 175.2, 415.8]
+
+# Accès par index (0-basé)
+print("Premier ticker :", portefeuille[0])   # AAPL
+print("Dernier prix   :", prix_actuels[-1])  # 415.8
+
+# Ajout d'actions
+portefeuille.append("META")
+portefeuille.extend(["TSLA", "NVDA"])
+
+# Itération couplée
+for ticker, prix in zip(portefeuille[:3], prix_actuels):
+    print(f"{ticker:6s}: {prix:>8.2f} $")
+"""
+
+
+def _f_strings_code() -> str:
+    """Retourne le snippet f-strings en tant que chaîne copiable.
+
+    Returns:
+        Code Python sous forme de chaîne de caractères.
+    """
+    return """
+nom    = "Metro"
+ticker = "MRU.TO"
+prix   = 94.54
+taux   = 0.053
+
+# Méthode .format() — ancienne
+phrase1 = "Le nom est {}, ticker {} et prix {} $.".format(nom.upper(), ticker, prix)
+
+# f-string — moderne et recommandée
+phrase2 = f"Le nom est {nom.upper()}, ticker {ticker} et prix {prix:.2f} $."
+
+# Formatage avancé
+resume = (
+    f"{'Entreprise':15s}: {nom}\\n"
+    f"{'Ticker':15s}: {ticker}\\n"
+    f"{'Prix':15s}: {prix:>8.2f} $\\n"
+    f"{'Taux annuel':15s}: {taux:>8.1%}"
+)
+print(resume)
+"""

pyfinmodel/cours2/__init__.py

@@ -0,0 +1,5 @@
+"""Cours 2 — Calcul Appliqué avec Python et NumPy."""
+
+from pyfinmodel.cours2 import numpy_pandas, python_fonctionnel
+
+__all__ = ["python_fonctionnel", "numpy_pandas"]