VBA Flashcards by Jorge V.C Enrique

Séance 1

How well did you know this?

Not at all

Perfectly

🟩 Fiche 1 —
[Option Explicit — déclaration obligatoire des variables]

1- Objectif et usage
– Forcer la déclaration de toutes les variables pour prévenir les fautes de frappe et conversions implicites hasardeuses.
– Standardiser la discipline de code dès la Séance 1.

2- Syntaxe essentielle (à placer en tout début de module)

Option Explicit

3- Règles et hypothèses
– S’applique au module entier où il est écrit.
– Rend obligatoire Dim/Private/Public/Static pour chaque variable.
– Toute variable non déclarée déclenche une erreur de compilation.
– VBA est insensible à la casse mais conserve la dernière casse rencontrée (utile pour repérer typos).

4- Bonnes pratiques & pièges
– Activer « Require Variable Declaration » dans l’éditeur pour l’insérer automatiquement.
– Déclarer d’abord, initialiser ensuite ; regrouper les déclarations en tête de procédure.
– Éviter les noms ambigus (x, y) en dehors d’exemples très courts ; préférer des noms métier.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 2 —
[Sub + MsgBox (usage simple d’affichage)]

1- Objectif et usage
– Créer une procédure Sub qui effectue une action sans valeur de retour.
– Afficher rapidement un message via MsgBox.

2- Syntaxe essentielle

Sub hello_world()
MsgBox “Hello world!”
End Sub

3- Règles et hypothèses
– Sub n’a pas de valeur retournée ; c’est une procédure.
– MsgBox peut être utilisée comme procédure d’affichage (nous verrons plus loin l’usage fonctionnel).

4- Bonnes pratiques & pièges
– Nommer clairement les Subs (verbe + complément).
– Garder les Subs courtes et ciblées ; déléguer à d’autres Subs/Functions au besoin.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 3 —
[Expression arithmétique directe dans MsgBox]

1- Objectif et usage
– Evaluer une expression sans variable intermédiaire puis l’afficher.

2- Exemple (calcul ponctuel)

Sub calcul1()
MsgBox 5.7 * 2.4
End Sub

3- Règles et hypothèses
– Les opérateurs arithmétiques + - * / ^ sont évalués avant l’affichage.
– Adapté aux tests rapides non réutilisables.

4- Bonnes pratiques & pièges
– Préférer une variable quand : réutilisation, débogage ou lisibilité nécessaires.
– Éviter les expressions longues directement dans MsgBox.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 4 —
[Déclaration et assignation de variables (Double)]

1- Objectif et usage
– Déclarer avec Dim et assigner avec = pour stocker et réutiliser un résultat.
– Introduire le type Double (précision usuelle en finance/sciences).

2- Exemples

Sub calcul2()
Dim x As Double
x = 5.7 * 2.4
MsgBox x
End Sub

Sub hec1()
Dim Y As Double
Y = 300 / 200
MsgBox Y
End Sub

3- Règles et hypothèses
– Double ≈ 15 chiffres significatifs.
– L’assignation = remplace la valeur courante.
– VBA n’est pas sensible à la casse pour l’exécution, mais reflète la casse la plus récente (utile pour détecter des typos sous Option Explicit).

4- Bonnes pratiques & pièges
– Toujours Option Explicit.
– Noms explicites (montant, resultat) > x, y sauf cas pédagogiques.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 5 —
[Types numériques : Single vs Double (précision)]

1- Objectif et usage
– Comprendre l’impact du type sur la précision et l’affichage.

2- Exemple (troncation observable)

Sub calcul3()
Dim x As Single
x = 5.77890257234 * 2.46798568234524
MsgBox x
End Sub

3- Règles et hypothèses
– Single ≈ 7 chiffres significatifs → arrondis/tronquations visibles.
– Double ≈ 15 chiffres significatifs → plus précis, léger coût mémoire/CPU en plus.

4- Bonnes pratiques & pièges
– Par défaut, préférer Double (finance, stats, ingénierie).
– N’utiliser Single que si la contrainte mémoire/performances le justifie et que la perte de précision est acceptable.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 6 —
[Décomposer un calcul en variables intermédiaires]

1- Objectif et usage
– Clarifier les étapes d’un calcul, faciliter le débogage et les modifications.

2- Exemple

Sub calcul4()
Dim x As Double
Dim y As Double
Dim z As Double
y = 5.7
z = 2.4
x = y * z
MsgBox x
End Sub

3- Règles et hypothèses
– Les variables intermédiaires rendent les dépendances explicites.
– Changer une constante (ex. z) ne casse pas l’expression finale.

4- Bonnes pratiques & pièges
– Isoler les constantes → plus facile à maintenir.
– Grouper les Dim en tête de procédure ; initialiser avant usage.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 7 —
[Dépassement de capacité : Integer]

1- Objectif et usage
– Visualiser la plage d’Integer et l’erreur en cas de dépassement.

2- Exemple

Sub plage1()
Dim x As Integer
x = 33000 ‘ Dépasse 32767
MsgBox x
End Sub

3- Règles et hypothèses
– Integer : de -32768 à 32767.
– Hors plage → Overflow (erreur d’exécution).

4- Bonnes pratiques & pièges
– Éviter Integer pour compteurs/identifiants → préférer Long.
– Si données externes, valider les bornes avant affectation.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 8 —
[Dépassement, littéraux et suffixes : Long & #]

1- Objectif et usage
– Comprendre la plage de Long et le rôle des suffixes sur les littéraux numériques.

2- Exemple

Sub plage2()
Dim x As Long
x = 3000000000# ‘ 3 000 000 000 en Double (suffixe #)
MsgBox x
End Sub

3- Règles et hypothèses
– Long : de -2 147 483 648 à 2 147 483 647.
– 3000000000 dépasse la plage de Long → Overflow.
– Suffixes utiles :
— % = Integer
— & = Long
— ! = Single
— # = Double
— @ = Currency

4- Bonnes pratiques & pièges
– Ne pas se fier à la présence d’un point décimal pour le type : utiliser les suffixes si nécessaire.
– Pour des grands entiers exacts (montants financiers) : Currency offre 4 décimales fixes (attention : ce n’est pas un “grand entier arbitraire”).

How well did you know this?

Not at all

Perfectly

🟩 Fiche 9 —
[Function qui retourne une valeur : mc (coupon obligataire)]

1- Objectif et usage
– Encapsuler un calcul réutilisable qui renvoie un résultat (montant de coupon).

2- Code

Private Function mc(face As Double, taux As Double, nJours As Integer) As Double
mc = face * taux * nJours / 365.25
End Function

3- Règles et hypothèses
– La valeur de retour s’affecte au nom de la fonction (mc = …).
– Private limite l’utilisation au module courant.
– Hypothèses d’unités :
— taux en décimal (ex. 0.056)
— nJours en jours calendaires ; base ici 365.25 (convention explicite).

4- Bonnes pratiques & pièges
– Documenter les unités et conventions (Base 360/365/ACT/ACT).
– Éviter les effets de bord : ne modifier que des variables locales ; pas d’E/S dans une Function pure.
– Valider les entrées (ex. nJours >= 0, taux >= 0).

How well did you know this?

Not at all

Perfectly

🟩 Fiche 10 —
[Appeler une Function depuis une Sub]

1- Objectif et usage
– Récupérer la valeur de retour d’une fonction dans une variable, puis l’utiliser/afficher.

2- Code

Sub appelle_fonction()
Dim montantcoupon As Double
montantcoupon = mc(1000000, 0.056, 91)
MsgBox montantcoupon
End Sub

3- Règles et hypothèses
– Les types d’arguments doivent être compatibles avec la signature.
– L’appel peut être imbriqué dans d’autres expressions si nécessaire.

4- Bonnes pratiques & pièges
– Stocker dans une variable nommée (débogage, lisibilité).
– Centraliser l’affichage (éviter de mélanger logique de calcul et UI partout).

How well did you know this?

Not at all

Perfectly

🟩 Fiche 11 —
[Arguments nommés et ordre des paramètres]

1- Objectif et usage
– Rendre l’appel auto-documenté et indépendant de l’ordre.

2- Code

Sub appelle_fonction_()
Dim montantcoupon As Double
montantcoupon = mc(face:=1000000, taux:=0.056, nJours:=91)
MsgBox montantcoupon
End Sub

Sub appelle_fonction__()
Dim montantcoupon As Double
montantcoupon = mc(taux:=0.056, nJours:=91, face:=1000000)
MsgBox montantcoupon
End Sub

3- Règles et hypothèses
– Avec arguments nommés, l’ordre devient libre tant que chaque nom correspond exactement au paramètre.
– Les fautes d’orthographe dans les noms → erreur de compilation.

4- Bonnes pratiques & pièges
– Utiliser les arguments nommés quand la fonction a plusieurs paramètres du même type (réduit les inversions).
– Conserver les noms de paramètres courts mais significatifs (face, taux, nJours).

How well did you know this?

Not at all

Perfectly

🟩 Fiche 12 —
[MsgBox comme Function : capturer la réponse utilisateur + constantes]

1- Objectif et usage
– Utiliser MsgBox comme fonction qui renvoie un code (ex. Oui/Non).
– Explorer les constantes retournées (vbYes, vbNo, vbCancel, vbYesNo).

2- Code (retour utilisateur)

Sub msgbox_demo()
Dim r As Long
r = MsgBox(Title:=”Question”, _
Buttons:=vbYesNo, _
Prompt:=”Aimeriez-vous continuer?”)
‘ Utiliser r (6 = vbYes, 7 = vbNo)
End Sub

3- Code (exploration des constantes)

Sub exploration()
MsgBox Prompt:=vbYes, Title:=”vbYes” ‘ 6
MsgBox Prompt:=vbNo, Title:=”vbNo” ‘ 7
MsgBox Prompt:=vbYesNo, Title:=”vbYesNo” ‘ 4
End Sub

4- Règles et hypothèses
– MsgBox retourne un Long : comparer avec les constantes (vbYes=6, vbNo=7, vbCancel=2…).
– Paramètres nommés Title, Buttons, Prompt améliorent la lisibilité.
– Les lignes longues peuvent être continuées avec _.

5- Bonnes pratiques & pièges
– Toujours tester le retour avant d’agir :
— If r = vbYes Then … Else …
– Documenter les choix offerts (texte clair, boutons adéquats).
– Éviter les MsgBox multipliées ; préférer une logique centralisée pour l’UI.

How well did you know this?

Not at all

Perfectly

Séance 2

How well did you know this?

Not at all

Perfectly

🟩 Fiche 1 —
[Constante vbNewLine — retour à la ligne dans une MsgBox]

1- Objectif et usage
– Afficher plusieurs lignes de texte dans une même boîte de message.
– Utiliser la constante vbNewLine pour insérer un saut de ligne manuel.

2- Code

Sub Démo_vbNewLine()
MsgBox “Première ligne” & vbNewLine & “Deuxième ligne”
End Sub

3- Règles et hypothèses
– vbNewLine insère un retour à la ligne dans une chaîne de caractères.
– Peut être remplacé par Chr(13) ou Chr(10) selon le système, mais vbNewLine est plus portable.
– L’opérateur & concatène les chaînes de texte.

4- Bonnes pratiques & pièges
– Utiliser vbNewLine plutôt que vbCrLf pour compatibilité accrue.
– Éviter les espaces avant/après le & sauf pour la lisibilité.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 2 —
[MsgBox simple avec arguments nommés]

1- Objectif et usage
– Créer une MsgBox avec arguments nommés (Prompt, Title, Buttons).
– Afficher un message sans capturer de choix, puisque le seul bouton est OK.

2- Code

Sub ExploreMsgBox2()
MsgBox Title:=”Décision”, Prompt:=”Continuer?”, Buttons:=vbOKOnly
End Sub

3- Règles et hypothèses
– vbOKOnly affiche uniquement le bouton OK.
– L’ordre des arguments devient libre grâce aux arguments nommés.
– Aucun retour n’est capturé, donc pas de variable associée.

4- Bonnes pratiques & pièges
– Toujours nommer les arguments pour plus de lisibilité.
– Utiliser cette forme quand il n’y a aucune décision à prendre.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 3 —
[MsgBox avec boutons multiples et variable de retour]

1- Objectif et usage
– Capturer la réponse utilisateur (Oui, Non, Annuler) grâce à une variable.
– Découvrir la constante vbYesNoCancel.

2- Code

Sub ExploreMsgBox3()
Dim r As Long
r = MsgBox(Title:=”Décision”, Prompt:=”Continuer?”, Buttons:=vbYesNoCancel)
End Sub

3- Règles et hypothèses
– MsgBox retourne un code entier (vbYes, vbNo, vbCancel).
– La variable doit être de type Long pour accueillir le code de retour.
– vbYesNoCancel correspond à la valeur 3.

4- Bonnes pratiques & pièges
– Toujours stocker la valeur de retour avant de traiter une logique conditionnelle.
– Pour vérifier : MsgBox vbYes affiche 6, vbNo 7, vbCancel 2.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 4 —
[MsgBox avec équivalent numérique des constantes]

1- Objectif et usage
– Montrer que les constantes comme vbYesNoCancel sont des entiers (ici 3).
– Prouver que la substitution par un nombre est possible, mais déconseillée.

2- Code

Sub ExploreMsgBox4()
Dim r As Long
r = MsgBox(Title:=”Décision”, Prompt:=”Continuer?”, Buttons:=3)
End Sub

3- Règles et hypothèses
– Buttons:=3 = vbYesNoCancel.
– Le comportement est identique, mais le code devient moins lisible.

4- Bonnes pratiques & pièges
– Éviter les valeurs numériques brutes : toujours employer les constantes pour la clarté.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 5 —
[Lecture d’une cellule précise dans une feuille Excel]

1- Objectif et usage
– Lire une valeur précise sur une feuille à partir de ThisWorkbook.
– Utiliser Cells(ligne, colonne) pour cibler la cellule.

2- Code

Sub Cells1()
Dim m As Double
m = ThisWorkbook.Worksheets(“Données”).Cells(1, 1).Value
MsgBox CStr(m)
End Sub

3- Règles et hypothèses
– .Cells(1,1) = cellule A1.
– .Value est la propriété par défaut d’une cellule.
– CStr() convertit un nombre en texte (type String).
– ThisWorkbook = classeur contenant le code (et non celui actif).

4- Bonnes pratiques & pièges
– Toujours préciser le classeur et la feuille pour éviter les ambiguïtés.
– Préférer CStr avant d’afficher des nombres dans MsgBox pour garder le format exact.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 6 —
[Lecture d’une cellule par index de feuille]

1- Objectif et usage
– Variante simplifiée pour accéder à une feuille via son index numérique.

2- Code

Sub Cells2()
Dim m As Double
m = ThisWorkbook.Worksheets(1).Cells(1, 1).Value
End Sub

3- Règles et hypothèses
– Worksheets(1) renvoie la première feuille du classeur (ordre visible dans Excel).
– Worksheets(“Nom”) est plus sûr si les feuilles sont renommées.
– .Value reste implicite.

4- Bonnes pratiques & pièges
– Préférer le nom de la feuille, car l’ordre peut changer.
– L’accès par index reste utile pour les boucles.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 7 —
[Function MontantDuCoupon — rappel de la distinction Function/Sub]

1- Objectif et usage
– Revoir la différence entre Function (renvoie une valeur) et Sub (exécute une action).
– Créer une Function claire et réutilisable.

2- Code

Public Function MontantDuCoupon(face As Double, taux As Double, nJours As Integer) As Double
MontantDuCoupon = face * taux * nJours / 365.25
End Function

3- Règles et hypothèses
– Identique à mc() vue à la séance 1 mais en portée publique.
– Utilisable dans tout le projet VBA (tous modules).
– Les conventions d’unité restent : taux en décimal, jours calendaires.

4- Bonnes pratiques & pièges
– Nom explicite, pas d’abréviations.
– Vérifier les types : ne jamais mélanger Double et String sans conversion.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 8 —
[With…End With — exécution groupée sur un objet]

1- Objectif et usage
– Simplifier l’écriture en répétant une référence d’objet une seule fois.
– Rendre le code plus court, plus rapide et moins sujet aux erreurs.

2- Code

Sub données1()
With ThisWorkbook.Worksheets(“Données”)
.Cells(1, 4) = MontantDuCoupon(.Cells(1, 1), .Cells(1, 2), .Cells(1, 3))
.Cells(2, 4) = MontantDuCoupon(.Cells(2, 1), .Cells(2, 2), .Cells(2, 3))
.Cells(3, 4) = MontantDuCoupon(.Cells(3, 1), .Cells(3, 2), .Cells(3, 3))
.Cells(4, 4) = MontantDuCoupon(.Cells(4, 1), .Cells(4, 2), .Cells(4, 3))
End With
End Sub

3- Règles et hypothèses
– With crée un contexte temporaire : le point . fait référence à l’objet principal.
– Sans With, chaque ligne nécessiterait ThisWorkbook.Worksheets(“Données”).
– Gagne en concision et fiabilité.

4- Bonnes pratiques & pièges
– Ne jamais imbriquer plusieurs With.
– Réserver With pour des blocs de 3 lignes ou plus afin de conserver la clarté.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 9 —
[Boucle For — traitement de plusieurs lignes de données]

1- Objectif et usage
– Automatiser une opération répétitive (ici, calcul du coupon sur plusieurs lignes).

2- Code

Sub données2()
Dim k As Integer
With ThisWorkbook.Worksheets(“Données”)
For k = 1 To 4
.Cells(k, 4) = MontantDuCoupon(.Cells(k, 1), .Cells(k, 2), .Cells(k, 3))
Next
End With
End Sub

3- Règles et hypothèses
– For k = 1 To 4 itère 4 fois (k prend les valeurs 1,2,3,4).
– .Cells(k, col) cible dynamiquement la ligne.
– Next incrémente automatiquement la variable de boucle.

4- Bonnes pratiques & pièges
– Toujours déclarer k du bon type (Long préférable à Integer pour grandes boucles).
– Utiliser .Rows.Count pour parcourir dynamiquement le nombre réel de lignes.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 10 —
[Utilisation de variables intermédiaires et concaténation dans MsgBox]

1- Objectif et usage
– Rendre la boucle plus lisible et informer l’utilisateur du résultat final.

2- Code

Sub données3()
Dim k As Integer, f As Double, t As Double, n As Integer
With ThisWorkbook.Worksheets(“Données”)
For k = 1 To 4
f = .Cells(k, 1)
t = .Cells(k, 2)
n = .Cells(k, 3)
.Cells(k, 4) = MontantDuCoupon(f, t, n)
Next
End With
MsgBox Prompt:=”Il y a “ & CStr(k - 1) & “ lignes d’information.”
End Sub

3- Règles et hypothèses
– CStr() convertit le nombre d’itérations en texte.
– L’opérateur & concatène du texte et des valeurs numériques.
– k-1 car après la dernière itération, la boucle ajoute 1 avant de sortir.

4- Bonnes pratiques & pièges
– Utiliser la conversion explicite (CStr) plutôt que laisser VBA le faire implicitement.
– Toujours vérifier la cohérence des types dans les concaténations.

How well did you know this?

Not at all

Perfectly

🟩 Fiche 11 — [Typage fort et conversions explicites] 1- Objectif et usage -- Montrer la différence entre typage faible et typage fort. -- Introduire les fonctions de conversion (CInt, CLng, CStr, CDbl, CSng). 2- Codes comparatifs Sub typage1() Dim x As Double, y As Double, z As Double x = 6.9 y = 5.2 z = x * y MsgBox z End Sub Sub typage2() Dim x As Double, y As Double, z As Double x = 6.9 y = 5.2 z = x * y MsgBox CStr(z) End Sub 3- Règles et hypothèses -- VBA autorise la conversion implicite, mais le typage fort exige des conversions explicites. -- CStr() convertit Double → String. -- Le typage fort évite les incohérences inattendues. 4- Bonnes pratiques & pièges -- Toujours utiliser une conversion explicite dans les MsgBox ou concatenations. -- Penser à CInt et CLng pour tronquer les décimales proprement.

🟩 Fiche 12 — [Structure conditionnelle IF — principes et variantes] 1- Objectif et usage -- Comprendre la logique séquentielle du bloc If...ElseIf...Else. -- Identifier la première condition vraie et exécuter le bloc correspondant. 2- Exemple générique If m > 1 Then n = 2 ElseIf m < -3 Then n = 3 Else n = 4 End If 3- Règles et hypothèses -- Les conditions sont évaluées de haut en bas. -- Dès qu’une condition est vraie, le bloc If est quitté. -- Else est facultatif, mais utile pour capturer tous les autres cas. -- Le nombre d’ElseIf est illimité. 4- Bonnes pratiques & pièges -- Utiliser des conditions mutuellement exclusives pour éviter des résultats ambigus. -- Indenter correctement pour visualiser la hiérarchie logique.

🟩 Fiche 13 — [Interaction MsgBox + Bloc If : traitement selon la réponse utilisateur] 1- Objectif et usage -- Réagir différemment selon le bouton cliqué dans une MsgBox (Oui, Non, Annuler). 2- Code Sub ExploreMsgBox5() Dim r As Long r = MsgBox(Title:="Décision", Prompt:="Continuer?", Buttons:=vbYesNoCancel) If r = vbYes Then MsgBox "Vous avez cliqué sur Oui. Alors, procédons dans le sens Oui!" ElseIf r = vbNo Then MsgBox "Vous avez cliqué sur Non. Alors, procédons dans le sens Non!" Else MsgBox "Vous avez cliqué sur Annuler. Alors, on annule!" End If End Sub 3- Règles et hypothèses -- r capture le code retour (vbYes=6, vbNo=7, vbCancel=2). -- Chaque condition du bloc If teste une réponse spécifique. -- La dernière clause Else capture toute autre réponse possible. 4- Bonnes pratiques & pièges -- Toujours tester les trois cas (Oui, Non, Annuler). -- Utiliser des messages explicites pour guider l’utilisateur.

🟩 Fiche 14 — [VarType() — identification dynamique du type de données] 1- Objectif et usage -- Identifier le type de données d’une valeur lue, même inconnue à l’avance. 2- Code Sub quelEstLeType() Dim x As Variant x = ThisWorkbook.Worksheets("Données").Cells(1, 2).Value MsgBox VarType(x) End Sub 3- Règles et hypothèses -- VarType() renvoie un code numérique correspondant à une constante : --- vbLong = 3, vbString = 8, vbBoolean = 11, vbDouble = 5, etc. -- Le type Variant peut contenir n’importe quel type de donnée. -- Utile pour diagnostiquer ou automatiser selon le type lu. 4- Bonnes pratiques & pièges -- Ne pas abuser des Variants : ils consomment plus de mémoire. -- Toujours documenter les correspondances de codes pour éviter la confusion.

Séance 3

🟩 Fiche 1 — [InputBox — saisir une valeur et la réutiliser] 1- Objectif et usage -- Demander une saisie à l’utilisateur et récupérer le texte entré. -- Réafficher ou exploiter la valeur dans le code. 2- Code Sub inputbox_() Dim inputboxRéponse As String inputboxRéponse = InputBox(Prompt:="saisissez un mot", Title:="Bienvenue", Default:="hello") MsgBox inputboxRéponse End Sub 3- Règles et hypothèses -- InputBox est une fonction qui renvoie une String. -- Paramètres principaux : Prompt, Title, Default. -- Si l’utilisateur appuie sur Annuler, InputBox renvoie "" (chaîne vide). -- Toujours convertir ensuite si un type numérique est requis (CDbl, CLng, etc.). 4- Bonnes pratiques & pièges -- Valider la saisie (vide, non numérique) avant calcul. -- Centraliser les messages (Prompt) et valeurs par défaut pour uniformiser l’UX.

🟩 Fiche 2 — [Exponentiation avec conversions explicites (version verbeuse)] 1- Objectif et usage -- Saisir deux valeurs, les convertir en Double, élever v1 à la puissance v2, puis afficher. -- Écrire “comme en typage fort” (conversions explicites, variables dédiées). 2- Code Sub exponentiation1() Dim v1AsString As String, v2AsString As String, v3AsString As String Dim v1AsDouble As Double, v2AsDouble As Double, v3AsDouble As Double v1AsString = InputBox("Valeur1", "Bonjour", "1") v2AsString = InputBox("Valeur2", "Hello", "1") v1AsDouble = CDbl(v1AsString) v2AsDouble = CDbl(v2AsString) v3AsDouble = WorksheetFunction.Power(v1AsDouble, v2AsDouble) ' ou v1AsDouble ^ v2AsDouble v3AsString = CStr(v3AsDouble) MsgBox v3AsString End Sub 3- Règles et hypothèses -- ^ réalise l’exponentiation (v1^v2). -- WorksheetFunction.Power(a, b) est l’équivalent Excel de a^b. -- Conversions explicites recommandées : CDbl pour calcul, CStr pour affichage. 4- Bonnes pratiques & pièges -- Gérer les cas non numériques et les puissances négatives ou non entières. -- Préférer ^ pour la lisibilité en VBA ; utiliser Power si vous voulez rester proche d’Excel.

🟩 Fiche 3 — [Exponentiation concise et one-liner] 1- Objectif et usage -- Réduire la verbosité : conversions en ligne, moins de variables, voire une seule ligne. 2- Codes Sub exponentiation2() Dim v1 As Double, v2 As Double v1 = CDbl(InputBox("Valeur1", "Bonjour", "1")) v2 = CDbl(InputBox("Valeur2", "Hello", "1")) MsgBox CStr(v1 ^ v2) End Sub Sub exponentiation3() MsgBox CStr(CDbl(InputBox("Valeur1", "Bonjour", "1")) ^ CDbl(InputBox("Valeur2", "Hello", "1"))) End Sub 3- Règles et hypothèses -- Les conversions en ligne gardent un typage explicite sans variables intermédiaires. -- Plus concis = moins débogable : à réserver aux scripts très simples. 4- Bonnes pratiques & pièges -- En cas d’erreur de saisie, une version verbosée facilite l’inspection (points d’arrêt, espion). -- Standardiser les titres/valeurs par défaut pour cohérence.

🟩 Fiche 4 — [MsgBox (retour Long) versus InputBox (retour String)] 1- Objectif et usage -- Distinguer les types de renvoi : MsgBox → Long (code bouton), InputBox → String (texte saisi). 2- Code Sub MsgBox_versus_InputBox() Dim r As Long Dim s As String r = MsgBox(Prompt:="Continuer?", Buttons:=2, Title:="Décision") ' MsgBox renvoie un Long (vbOK=1, vbCancel=2, vbYes=6, vbNo=7, etc.) s = InputBox(Prompt:="saisissez un mot", Title:="Bienvenue", Default:="hello") ' InputBox renvoie une String End Sub 3- Règles et hypothèses -- MsgBox sert au choix / confirmation ; InputBox sert à saisir du texte. -- Toujours comparer r aux constantes (vbYes, vbNo…) plutôt qu’à des nombres “magiques”. 4- Bonnes pratiques & pièges -- Ne pas confondre le rôle des deux fonctions ; nommer clairement les variables (r, s). -- Documenter les valeurs de retour attendues.

🟩 Fiche 5 — [Do…Loop While — boucle contrôlée par condition (interaction Oui/Non)] 1- Objectif et usage -- Répéter une action tant que la condition demeure vraie (ici, tant que l’utilisateur clique Oui). 2- Code Sub boucleWhile_1() Dim r As Long Do r = MsgBox(Prompt:="Une autre itération?", _ Title:="Bienvenue au jeu de bouclage 1", _ Buttons:=vbYesNo) Loop While r = vbYes End Sub 3- Règles et hypothèses -- La condition est testée en bas de boucle → au moins une itération. -- Sortie quand r <> vbYes. 4- Bonnes pratiques & pièges -- Afficher un titre/texte clair pour la décision. -- Éviter les boucles sans échappatoire ; toujours prévoir un cas de sortie.

🟩 Fiche 6 — [Do…Loop While — construction d’un “roman” (chaînes concaténées)] 1- Objectif et usage -- Lire des mots jusqu’à saisie vide ; concaténer pour former une phrase/texte final. 2- Code Sub boucleWhile_2() Dim nouveau_mot As String, roman As String Do nouveau_mot = InputBox(Prompt:="Saisissez un mot", _ Title:="Bienvenue au jeu de bouclage 2", _ Default:="VBA") roman = roman & nouveau_mot & " " Loop While Not (nouveau_mot = "") MsgBox Title:="Le roman est :", Prompt:=roman End Sub 3- Règles et hypothèses -- La condition d’arrêt est la chaîne vide. -- La concaténation s’effectue avec & ; prévoir un séparateur (espace, vbNewLine, etc.). 4- Bonnes pratiques & pièges -- Pour de très longues chaînes, préférer un buffer (ex. Join sur tableau) pour la performance. -- Éviter l’espace final si nécessaire (trim en fin de boucle).

🟩 Fiche 7 — [Lecture de cellules dans une boucle While — terminaison par mot-clé] 1- Objectif et usage -- Lire des cellules successives jusqu’à un mot de terminaison, construire une phrase, afficher. 2- Code Sub boucleWhile_3() Dim k As Integer, stringDansCellule As String, roman As String k = 1 Do stringDansCellule = Cells(8, k + 2).Value roman = roman & stringDansCellule & " " k = k + 1 Loop While stringDansCellule <> "Terminaison" MsgBox roman End Sub 3- Règles et hypothèses -- Cells(8, k+2) lit la ligne 8, colonnes 3,4,5… -- Référence implicite à la feuille active (risque d’ambiguïté). 4- Bonnes pratiques & pièges -- Préférer With ThisWorkbook.Worksheets("Nom") ... .Cells(...) ... End With. -- Gérer le cas où la chaîne “Terminaison” n’apparaît pas (risque de boucle infinie).

🟩 Fiche 8 — [Collection — ajout, lecture et terminaison sur cellule vide] 1- Objectif et usage -- Construire une Collection, y empiler des valeurs puis itérer pour reconstituer un texte. 2- Code Sub boucleWhile_4() Dim k As Integer, roman As String Dim c As New Collection k = 1 Do c.Add Cells(8, k + 2).Value k = k + 1 Loop While Cells(8, k + 2).Value <> "" For k = 1 To c.Count roman = roman & c(k) & " " Next MsgBox roman End Sub 3- Règles et hypothèses -- Collection est indexée à partir de 1 ; Count donne sa taille. -- La lecture/écriture sur feuille est implicite (ActiveSheet). 4- Bonnes pratiques & pièges -- Encapsuler l’accès feuille dans un With explicite. -- Pour de gros volumes, privilégier un tableau Variant plutôt qu’une Collection.

🟩 Fiche 9 — [Collection — création et inspection] 1- Objectif et usage -- Créer une Collection, y ajouter des réels, et l’inspecter dans la fenêtre “Variables locales”. 2- Code Sub Collection_1() Dim c As New Collection c.Add 3.45 c.Add 1.65 c.Add 9.24 c.Add 1.47 End Sub 3- Règles et hypothèses -- Add empile un nouvel élément en fin de collection. -- Lecture par index : c(1), c(2), … c(c.Count). 4- Bonnes pratiques & pièges -- Les collections ne sont pas typées : prudence sur les types mélangés. -- Pour clés/valeurs, envisager Scripting.Dictionary.

🟩 Fiche 10 — [Collection + boucle For — somme et Count] 1- Objectif et usage -- Itérer sur une Collection pour calculer une somme. 2- Code Sub Collection_2() Dim c As New Collection c.Add 3.45 c.Add 1.65 c.Add 9.24 c.Add 1.47 Dim k As Integer, somme As Double For k = 1 To c.Count somme = somme + c(k) Next MsgBox CStr(somme) End Sub 3- Règles et hypothèses -- c.Count fixe la borne supérieure de la boucle. -- Conversion explicite CStr pour l’affichage. 4- Bonnes pratiques & pièges -- Initialiser somme = 0 (implicite, mais le rendre explicite améliore la lisibilité). -- Gérer le cas c.Count = 0.

🟩 Fiche 11 — [EMA (écart moyen absolu) — double passage] 1- Objectif et usage -- Calculer la somme, la moyenne, puis l’écart moyen absolu sur une Collection. 2- Code Sub Collection_3() Dim c As New Collection c.Add 3.45 c.Add 1.65 c.Add 9.24 c.Add 1.47 Dim k As Integer, somme As Double, moyenne As Double, EMA As Double, N As Integer N = c.Count For k = 1 To N somme = somme + c(k) Next moyenne = somme / N For k = 1 To N EMA = EMA + Abs(c(k) - moyenne) Next EMA = EMA / N MsgBox Prompt:="Somme : " & Str(somme), _ Title:="EMA : " & Str(EMA) End Sub 3- Règles et hypothèses -- Deux passes : 1) somme → moyenne, 2) somme des écarts absolus → division par N. -- Abs renvoie la valeur absolue. -- Str() préfixe les positifs d’un espace ; CStr() garde le format usuel. 4- Bonnes pratiques & pièges -- Préférer CStr() à Str() pour un affichage “propre”. -- Vérifier N > 0 pour éviter division par zéro.

🟩 Fiche 12 — [Algorithme de Newton-Raphson — fonctions + critère d’arrêt] 1- Objectif et usage -- Approcher une racine de F(x) à l’aide de l’itération x_{k+1} = x_k - F(x_k)/F'(x_k). 2- Code (fonctions) Function F(x As Double) As Double F = x ^ 3 + 2 * x + 6 End Function Function Der(x As Double) As Double Der = 3 * x ^ 2 + 2 End Function 3- Code (procédure Newton) Sub Newton() Dim x1 As Double, x0 As Double, err As Double Do x1 = x0 - F(x0) / Der(x0) err = x1 - x0 x0 = x1 Loop While (err ^ 2 > 10 ^ (-10)) MsgBox x1, , "solution" MsgBox err, , "erreur" MsgBox F(x0), , "F évaluée à solution pour un x" End Sub 4- Règles et hypothèses -- Nécessite un point de départ raisonnable (x0), sinon divergence possible. -- Critère d’arrêt : err^2 <= 10^(-10) (équivaut à Abs(err) <= 1E-5). -- Der(x0) ne doit pas être nul (sinon division par zéro). -- F et Der doivent être cohérentes (derivée correcte de F). 5- Bonnes pratiques & pièges -- Afficher aussi un compteur d’itérations pour diagnostiquer la convergence. -- Encapsuler le critère d’arrêt dans une fonction pour réutiliser sur d’autres équations. -- Protéger contre les dépassements (limite d’itérations max).

🟩 Fiche 13 — [Quand choisir For vs While — critère de sélection] 1- Objectif et usage -- Savoir quand utiliser For ou Do…Loop While. 2- Règles et hypothèses -- For : nombre d’itérations connu avant d’entrer en boucle (parcours de plages, 1..N). -- While : le nombre d’itérations est inconnu d’avance ; dépend d’un événement (saisie, sentinelle “Terminaison”, cellule vide…). 3- Bonnes pratiques & pièges -- Éviter les boucles infinies en While : toujours prévoir condition de sortie et garde-fous. -- En For, ne pas coder en dur N si on peut le déduire (Rows.Count, UsedRange.Rows.Count, c.Count, etc.).

Séance 4

🟩 Fiche 1 — [Range — propriétés en écriture/lecture (Interior.Color, Value, Borders.Color, Row, Column)] 1- Objectif et usage -- Manipuler une Range sans variable d’objet pour illustrer propriétés écriture et lecture. -- Apprendre à cibler une plage "G2:H4" et modifier couleur, valeur, bordures, puis lire ligne/colonne d’ancrage. 2- Code Sub range_1() Range("G2:H4").Interior.Color = vbBlue ' écriture Range("G2:H4").Value = 4.5 ' écriture Range("G2:H4").Borders.Color = vbRed ' écriture Dim k_row As Long, k_col As Long k_row = Range("G2:H4").Row ' lecture k_col = Range("G2:H4").Column ' lecture MsgBox CStr(k_row) MsgBox CStr(k_col) End Sub 3- Règles et hypothèses -- Range("A1:B2") construit un objet Range (sélection logique de cellules). -- .Interior.Color, .Value, .Borders.Color sont des propriétés. -- .Row et .Column renvoient l’index de la cellule supérieure gauche de la Range. 4- Bonnes pratiques & pièges -- Toujours préciser le contexte (classeur/feuille) quand il y a risque d’ambiguïté (voir fiches suivantes). -- Éviter les accès répétés identiques : préférer une variable d’objet (voir Fiche 4).

🟩 Fiche 2 — [Range.Clear — réinitialiser contenu/format] 1- Objectif et usage -- Effacer contenu, formats et commentaires d’une plage via la méthode Clear. 2- Code Sub range_2() Range("G2:H4").Clear End Sub 3- Règles et hypothèses -- Clear est une Sub (accomplit une tâche, ne renvoie rien). -- Variantes : ClearContents (valeurs seulement), ClearFormats (formats), ClearComments, etc. 4- Bonnes pratiques & pièges -- Choisir la variante adaptée (éviter d’effacer plus que nécessaire). -- Toujours cibler précisément la plage pour limiter les effets de bord.

🟩 Fiche 3 — [Référencer explicitement Workbook et Worksheet] 1- Objectif et usage -- Éviter les ambiguïtés liées à la feuille/classeur actifs en chaînant ThisWorkbook.Worksheets("Nom").Range(...). 2- Codes Sub range_3() ThisWorkbook.Worksheets("Données").Range("G2:H4").Interior.Color = vbBlue ThisWorkbook.Worksheets("Données").Range("G2:H4").Value = 4.5 ThisWorkbook.Worksheets("Données").Range("G2:H4").Borders.Color = vbRed End Sub Sub range_4() ThisWorkbook.Worksheets("Données").Range("G2:H4").Clear End Sub 3- Règles et hypothèses -- ThisWorkbook = classeur hébergeant le code (différent de ActiveWorkbook si plusieurs classeurs ouverts). -- Worksheets("Nom") est plus robuste que l’index numérique si l’ordre change. 4- Bonnes pratiques & pièges -- Standardiser l’adresse complète Workbook → Worksheet → Range/Cells dans vos utilitaires. -- Encapsuler la cible avec With ... End With si plusieurs opérations (perf/lecture).

🟩 Fiche 4 — [Variable d’objet Range + Set] 1- Objectif et usage -- Stocker une Range dans une variable d’objet pour éviter les répétitions et gagner en clarté/performance. 2- Codes Sub range_5() Dim rg As Range Set rg = ThisWorkbook.Worksheets("Données").Range("G2:H4") rg.Interior.Color = vbBlue rg.Value = 4.5 rg.Borders.Color = vbRed MsgBox CStr(rg.Row) MsgBox CStr(rg.Column) End Sub Sub range_6() Dim rg As Range Set rg = ThisWorkbook.Worksheets("Données").Range("G2:H4") rg.Clear End Sub 3- Règles et hypothèses -- Les variables d’objet nécessitent le mot-clé Set lors de l’assignation. -- Le point rg. donne accès aux propriétés/méthodes de l’objet ciblé. 4- Bonnes pratiques & pièges -- Nommer clairement (rg, rgZone, …). -- Éviter les Set en cascade à l’intérieur de boucles très fréquentes : préparer en amont.

🟩 Fiche 5 — [Range.End — détecter la dernière ligne/colonne contiguë (xlDown, xlToRight)] 1- Objectif et usage -- Reproduire Ctrl+Flèche pour sauter à la dernière cellule non vide avant un vide (navigation contiguë). -- Trouver la dernière ligne ou dernière colonne d’un bloc de données. 2- Codes Sub End_1() Dim rg_départ As Range, rg_end As Range, dernière_ligne As Integer Set rg_départ = ThisWorkbook.Worksheets("Données").Cells(1, 1) ' A1 Set rg_end = rg_départ.End(xlDown) dernière_ligne = rg_end.Row MsgBox CStr(dernière_ligne) End Sub Sub End_2() Dim rg_départ As Range, rg_end As Range, dernière_ligne As Integer, dernière_colonne As Integer Set rg_départ = ThisWorkbook.Worksheets("Données").Cells(3, 2) ' B3 Set rg_end = rg_départ.End(xlToRight) dernière_ligne = rg_end.Row dernière_colonne = rg_end.Column MsgBox "Colonne : " & CStr(dernière_colonne) End Sub 3- Règles et hypothèses -- End(direction) retourne une Range uni-cellulaire (la cellule atteinte). -- Sensibles aux trous (cellules vides) : le saut s’arrête au premier vide. -- Directions usuelles : xlDown, xlUp, xlToRight, xlToLeft. 4- Bonnes pratiques & pièges -- Pour trouver la dernière cellule utilisée d’une colonne, préférez parfois Cells(Rows.Count, col).End(xlUp). -- Documenter le point de départ (rg_départ) : il influence fortement le résultat.

🟩 Fiche 6 — [Range.Find — rechercher une valeur (xlPart vs xlWhole)] 1- Objectif et usage -- Reproduire Ctrl+F en VBA pour localiser la première cellule contenant un motif. 2- Codes Sub desperatelySeekingIvanka_1() Dim rg_ivanka As Range, ligne As Long, colonne As Long Set rg_ivanka = ThisWorkbook.Worksheets("Données").Cells.Find(What:="Ivanka", LookAt:=xlPart) ligne = rg_ivanka.Row colonne = rg_ivanka.Column MsgBox "Ligne : " & CStr(ligne) MsgBox "Colonne : " & CStr(colonne) End Sub Sub desperatelySeekingIvanka_2() Dim rg_ivanka As Range, ligne As Long, colonne As Long Set rg_ivanka = ThisWorkbook.Worksheets("Données").Cells.Find(What:="Ivanka", LookAt:=xlWhole) ligne = rg_ivanka.Row colonne = rg_ivanka.Column MsgBox "Ligne : " & CStr(ligne), , "Ivanka" MsgBox "Colonne : " & CStr(colonne), , "Ivanka" End Sub 3- Règles et hypothèses -- Find est une fonction de la classe Range : elle renvoie une Range (ou Nothing si non trouvé). -- LookAt:=xlPart → correspondance partielle ; xlWhole → correspondance exacte. -- D’autres paramètres influents existent : LookIn, SearchOrder, SearchDirection, MatchCase, etc. 4- Bonnes pratiques & pièges -- Toujours tester If rg_ivanka Is Nothing Then ... pour éviter une erreur si non trouvé. -- Définir explicitement tous les paramètres critiques de Find dans votre procédure (Excel mémorise les précédents réglages). -- Pour toutes les occurrences, enchaîner avec FindNext.

🟩 Fiche 7 — [Énumérations utiles (XlDirection, XlLookAt, VBColor, VBMsgBoxStyle, VBMsgBoxResult)] 1- Objectif et usage -- Comprendre et utiliser les énumérations pour écrire un code clair et auto-documenté. 2- Exemples d’énumérations -- XlDirection : xlUp, xlDown, xlToRight, xlToLeft. -- XlLookAt : xlWhole, xlPart. -- VBColor : vbRed, vbBlue, vbGreen, vbBlack, vbMagenta, vbYellow, vbWhite, vbCyan. -- VBMsgBoxStyle : vbOKOnly, vbYesNo, vbYesNoCancel, vbExclamation, etc. -- VBMsgBoxResult : vbOK, vbYes, vbNo, vbCancel, etc. 3- Règles et hypothèses -- Une énumération est un ensemble de constantes nommées (lisibilité, sécurité). -- Les valeurs sous-jacentes sont des entiers, mais on ne les utilise pas directement (éviter les “nombres magiques”). 4- Bonnes pratiques & pièges -- Toujours préférer les constantes d’énumération aux valeurs numériques. -- Centraliser, dans un commentaire, les énumérations utilisées dans le module pour documentation rapide.

🟩 Fiche 8 — [Clarifier “Fonction vs Propriété vs Sub” dans les classes Excel (cas End/Find)] 1- Objectif et usage -- Comprendre la nature des membres d’une classe (ici Range) : propriétés, méthodes Sub, méthodes Function. -- Savoir lire la documentation quand l’usage est ambigu (ex. End ou Find). 2- Principes -- Propriété : retourne un état (lecture/écriture), ex. .Value, .Row, .Column, .Interior.Color. -- Sub (méthode) : exécute une action sans valeur de retour, ex. .Clear. -- Function (méthode) : exécute une action et retourne quelque chose, ex. .Find(...) As Range. -- End(direction) : membre de Range retournant une Range (comportement de navigation) → documenté comme propriété renvoyant un objet (on l’emploie comme une Function car il retourne une valeur). -- Find(...) : Function retournant une Range (ou Nothing). 3- Bonnes pratiques & pièges -- Toujours vérifier la signature officielle (documentation Microsoft) pour savoir si un membre retourne quelque chose et de quel type. -- En lecture seule/écriture seule : respecter la direction (ex. .Row lecture seule ; .Value lecture/écriture). -- Tester Nothing après toute méthode susceptible d’échec (Find, SpecialCells, etc.).

Séance 5

🟩 Fiche 1 — [Now() — date/heure système (type Date), affichage et écriture en cellule] 1- Objectif et usage -- Récupérer la date et l’heure actuelles (machine/serveur) avec Now() de type Date. -- Écrire dans une cellule et/ou afficher dans une MsgBox. 2- Code Sub date_() ThisWorkbook.Worksheets(1).Range("H1").Value = Now() End Sub Sub date__() MsgBox CStr(Now()) End Sub 3- Règles et hypothèses -- Now() renvoie un Date (composante date + heure). -- L’affichage dans une cellule dépend du NumberFormat de la cellule (Excel). -- CStr(Date) force l’affichage sous forme de chaîne (format régional). 4- Bonnes pratiques & pièges -- Pour un formatage contrôlé : .NumberFormat = "yyyy-mm-dd hh:mm:ss". -- Préférer ThisWorkbook.Worksheets("QuelquesShapes") au lieu de l’index 1 si le nom est stable.

🟩 Fiche 2 — [Actualisation (PV) — DateSerial, DateDiff, boucle sur Collections] 1- Objectif et usage -- Calculer la valeur présente d’une série de flux datés en actualisant à aujourd’hui. -- Utiliser DateSerial pour construire un Date, DateDiff pour l’écart de jours. 2- Code Sub pv() Dim dates As New Collection Dim montants As New Collection dates.Add DateSerial(2024, 6, 30) dates.Add DateSerial(2024, 7, 31) montants.Add 4.51 montants.Add 3.23 Dim dateAujourdhui As Date, r As Single dateAujourdhui = Now() r = 0.035 Dim n As Integer, k As Integer, pv As Double, date_diff As Long n = dates.Count For k = 1 To n date_diff = DateDiff("d", dateAujourdhui, dates(k)) pv = pv + montants(k) / (1 + r) ^ (date_diff / 365.25) Next MsgBox CStr(pv) End Sub 3- Règles et hypothèses -- DateSerial(y, m, d) construit un Date fiable (évite ambigüités régionales). -- DateDiff("d", d1, d2) renvoie l’écart en jours (entier). -- Convention d’actualisation ici : act/365.25 (cohérente avec les séances précédentes). 4- Bonnes pratiques & pièges -- Vérifier que les dates des flux ≥ aujourd’hui si PV “prospectif” (sinon on actualise aussi des flux passés). -- Externaliser r et la convention jour (constante/paramètre) pour réutilisation.

🟩 Fiche 3 — [RGB() — couleurs de remplissage, police et bordures (Long)] 1- Objectif et usage -- Définir une couleur avec RGB(r, g, b) et l’appliquer à Interior, Font, Borders. 2- Code Sub RGB_() With ThisWorkbook.Worksheets(1).Range("A1") .Interior.Color = RGB(200, 255, 20) ' remplissage .Font.Color = RGB(0, 0, 0) ' police noire .Borders.Color = RGB(50, 100, 200) ' bordures End With End Sub 3- Règles et hypothèses -- RGB(r, g, b) retourne un Long (r + 256 * g + 65536 * b). -- S’applique à .Interior.Color, .Font.Color, .Borders.Color (ou .Borders.LineStyle + .Borders.Color). 4- Bonnes pratiques & pièges -- Définir lisiblement les couleurs (constantes ou fonctions). -- Pour toutes les bordures : .Borders.LineStyle = xlContinuous avant la couleur si nécessaire.

🟩 Fiche 4 — [Shapes — sélectionner et manipuler un Shape] 1- Objectif et usage -- Accéder à la collection Shapes sur une feuille, récupérer un Shape, le sélectionner. 2- Code Sub shape_() Dim sh As Shape Set sh = ThisWorkbook.Worksheets("QuelquesShapes").Shapes(1) sh.Select End Sub 3- Règles et hypothèses -- Shapes est 1-based ; Shapes(1) renvoie le premier objet. -- .Select agit sur l’interface ; privilégier la manipulation directe (propriétés) quand possible. 4- Bonnes pratiques & pièges -- Éviter .Select/.Activate dans le code automatisé ; accéder aux propriétés/méthodes directement (sh.Left, sh.Top, sh.Fill.ForeColor.RGB, etc.). -- Nommer les shapes (sh.Name) pour des accès robustes : Shapes("MonShape").

🟩 Fiche 5 — [Shapes — parcourir avec For Each, Type (MsoShapeType)] 1- Objectif et usage -- Itérer sur tous les shapes d’une feuille et inspecter leur Type (énumération MsoShapeType). 2- Code Sub foreach_1() MsgBox "msoAutoShape est 1" & vbNewLine & "msoPic est 13" & vbNewLine & "msoTextBox est 17", , "MsoShapeType" Dim sh As Shape For Each sh In ThisWorkbook.Worksheets("QuelquesShapes").Shapes MsgBox sh.Type Next End Sub 3- Règles et hypothèses -- For Each sh In ...Shapes parcourt tous les objets Shape de la feuille. -- sh.Type renvoie un MsoShapeType (entier constant). 4- Bonnes pratiques & pièges -- Remplacer les MsgBox répétées par un journal (Debug.Print) pour éviter le spam d’UI. -- Filtrer selon le type avant action (ex. traiter seulement msoAutoShape).

🟩 Fiche 6 — [Shapes — lire le Name (identifiant), bonnes pratiques de nommage] 1- Objectif et usage -- Examiner le nom de chaque Shape ; base d’un ciblage robuste. 2- Code Sub foreach_2() Dim sh As Shape For Each sh In ThisWorkbook.Worksheets("QuelquesShapes").Shapes MsgBox sh.Name Next End Sub 3- Règles et hypothèses -- sh.Name est un identifiant string ; peut être modifié pour un repérage explicite. -- Beaucoup d’APIs exposent Name : c’est un pattern général à mémoriser. 4- Bonnes pratiques & pièges -- Normaliser un préfixe (img_, box_, btn_) pour faciliter les filtres. -- Éviter les noms dupliqués.

🟩 Fiche 7 — [Shapes — suppression conditionnelle (Delete) avec For Each] 1- Objectif et usage -- Supprimer uniquement certains shapes selon leur Type (ex. msoAutoShape). 2- Code Sub foreach_3() Dim sh As Shape For Each sh In ThisWorkbook.Worksheets("QuelquesShapes").Shapes If sh.Type = msoAutoShape Then sh.Delete End If Next End Sub 3- Règles et hypothèses -- .Delete retire l’objet de la collection (boucle For Each sûre ici). -- msoAutoShape filtre les formes automatiques (exclut images, textbox, etc.). 4- Bonnes pratiques & pièges -- Toujours confirmer la cible (type/nom) avant suppression massive. -- Pour des suppressions nombreuses : désactiver l’écran (Application.ScreenUpdating = False) puis réactiver.

🟩 Fiche 8 — [For Each sur Collections — variance (double passage)] 1- Objectif et usage -- Calculer la variance d’une collection de réels avec deux passages (For Each). 2- Code Sub foreach_4() Dim c As New Collection c.Add 3.44: c.Add 5.61: c.Add 2.39 Dim x As Variant, sum As Double, moyenne As Double, var As Double For Each x In c sum = sum + x Next moyenne = sum / c.Count For Each x In c var = var + (x - moyenne) ^ 2 Next var = var / c.Count End Sub 3- Règles et hypothèses -- Variant permet d’itérer sur des valeurs non typées strictement. -- Variance population ici (division par N) ; pour échantillon, diviser par N-1. 4- Bonnes pratiques & pièges -- Initialiser explicitement sum = 0, var = 0 (lisibilité). -- Pour gros volumes, préférer un tableau Variant (performance) plutôt qu’une Collection.

🟩 Fiche 9 — [Newton–Raphson (x^5−7=0) — DoEvents, critère d’arrêt et validation] 1- Objectif et usage -- Trouver une racine de f(x) = x^5 - 7 avec Newton–Raphson et garder l’UI responsive via DoEvents. 2- Code Function f(x As Double) As Double: f = x ^ 5 - 7: End Function Function der(x As Double) As Double: der = 5 * x ^ 4: End Function Sub newton_raphson() Dim x0 As Double, x1 As Double, error As Double, validation As Double x0 = 5.372 Do Interaction.DoEvents x1 = x0 - f(x0) / der(x0) error = x1 - x0 x0 = x1 Loop While error ^ 2 > 10 ^ (-10) MsgBox "Solution:" & CStr(x1) validation = f(x1) MsgBox "Validation:" & CStr(validation) End Sub 3- Règles et hypothèses -- DoEvents cède brièvement la main à l’UI (évite le gel si la boucle est longue). -- Critère d’arrêt : error^2 ≤ 1E-10 (équivaut à Abs(error) ≤ 1E-5). -- der(x) ne doit pas être nul (sinon division par zéro). 4- Bonnes pratiques & pièges -- Ajouter un max d’itérations pour sécurité (ex. i < 10_000). -- Initialisation : choisir x0 raisonnable ; sinon divergence possible. -- Vérifier la validation f(x1) proche de 0 et journaliser le nb. d’itérations.

TP1

Q2: 🟩 Fiche 1 — [Newton-Raphson pour Z-spread — fonction f(z) et paramètres d’une Function] 1- Objectif et usage -- Comprendre le rôle de f(z) dans la méthode de Newton-Raphson pour trouver le Z-spread qui égalise la valeur actuelle et le prix de marché. -- Savoir déclarer correctement une Function : identifier les paramètres d’entrée (données nécessaires) et les variables locales (calculs internes). 2- Code ' f(z) = [ 100 / (1 + s + z)^n + Σ_{i=1..n} c / (1 + s + z)^i ] - P Private Function f(z As Double, n As Integer, c As Double, P As Double, s As Double) As Double Dim i As Integer, somme As Double For i = 1 To n somme = somme + c / (1 + s + z) ^ i Next f = (100 / (1 + s + z) ^ n + somme) - P End Function 3- Règles et hypothèses -- Interprétation financière -- La somme calcule la valeur actuelle des coupons (c à chaque période), actualisés au taux (s + z). -- Le terme 100 / (1 + s + z)^n est la valeur actuelle du nominal remboursé à l’échéance. -- f(z) renvoie l’écart entre la valeur actuelle théorique et le prix observé P. -- Signe de f(z) -- f(z) > 0 : la VA est trop élevée → il faut augmenter z (discount plus fort). -- f(z) < 0 : la VA est trop faible → il faut diminuer z. -- Newton-Raphson (principe) -- Itération : z_{k+1} = z_k - f(z_k) / f'(z_k) ; on cherche f(z*) = 0. -- Conditions pratiques : départ z_0 raisonnable, dérivée non nulle au voisinage, critère d’arrêt (|Δz| ou |f(z)| petit). -- Déclaration de Function : paramètres vs locales -- Paramètres (entre parenthèses) : variables d’entrée nécessaires au calcul et connues par l’appelant (ici z, n, c, P, s). -- Variables locales (Dim dans le corps) : utilisées pour les calculs internes (ici i, somme) et non passées par l’appelant. -- On n’inclut pas somme dans la signature : c’est un résultat intermédiaire, pas une donnée d’entrée. -- Typage -- z, c, P, s en Double (précision décimale) ; n et i en Integer/Long (comptage de périodes). -- Optionnel : préciser ByVal (par défaut) pour éviter les effets de bord lors des appels. 4- Bonnes pratiques & pièges -- Clarté des unités : s et z en décimal (p. ex. 0.045), c en montant par période, n en nombre de périodes. -- Robustesse numérique : éviter 1 + s + z ≤ 0 (taux aberrant), protéger contre n ≤ 0. -- Performance/maintenance : si les flux sont hétérogènes (coupons variables), remplacer c par un vecteur/collection de flux; ici c est constant par période. -- Newton en pratique : définir un max d’itérations, un seuil (ex. Abs(f(z)) < 1E-8) et journaliser l’itération pour déboguer. -- Dérivée f'(z) : pour implémenter Newton, coder aussi fprime(z) (ou utiliser une approximation numérique sûre si la dérivée fermée est longue), et tester f'(z) ≠ 0.

Séance 6

🟩 Fiche 1 — [Shapes vs ChartObjects — suppression ciblée des objets de la feuille “Charts”] 1- Objectif et usage -- Comprendre la différence entre Shapes (tout objet flottant) et ChartObjects (conteneurs de graphiques). -- Supprimer proprement toutes les shapes ou uniquement les graphiques d’une feuille. 2- Code Sub supprimerToutesLesShapes() Dim sh As Shape For Each sh In ThisWorkbook.Worksheets("Charts").Shapes sh.Delete Next End Sub Sub supprimerLesGraphiques() Dim ws As Worksheet Set ws = ThisWorkbook.Worksheets("Charts") Dim chtObject As ChartObject For Each chtObject In ws.ChartObjects chtObject.Delete Next End Sub 3- Règles et hypothèses -- Worksheet.Shapes : collection générique (images, zones de texte, graphiques, etc.). -- Worksheet.ChartObjects : collection spécifique aux graphiques intégrés (objets chart “embarqués”). -- .Delete retire l’objet de la collection et de la feuille. 4- Bonnes pratiques & pièges -- Choisir la bonne collection selon la cible (éviter d’effacer des éléments non voulus). -- Pour des suppressions massives : Application.ScreenUpdating = False avant la boucle, puis True. -- Privilégier des filtres (type, nom) si la feuille contient des objets variés.

🟩 Fiche 2 — [Créer un graphique XY Scatter Lines — ajout, séries, marqueurs, lignes, axes] 1- Objectif et usage -- Créer un graphique XY avec lignes (type “Scatter Lines”), l’insérer dans la feuille, l’alimenter en X/Y, puis formater les séries et les axes. 2- Code Sub xlXYScatterLines_demo() Dim ws As Worksheet Set ws = ThisWorkbook.Worksheets("Charts") Dim chartObj As ChartObject Set chartObj = ws.ChartObjects.Add(Left:=50, Width:=375, Top:=260, Height:=225) Dim cht As Chart Set cht = chartObj.Chart ' cht.ChartType = xlXYScatterLines cht.ChartType = 74 ' équivalent nommé de xlXYScatterLines Dim sr1 As Series Set sr1 = cht.SeriesCollection.NewSeries sr1.XValues = ws.Range("A4:A12") sr1.Values = ws.Range("B4:B12") Dim sr2 As Series Set sr2 = cht.SeriesCollection.NewSeries sr2.XValues = ws.Range("A4:A12") sr2.Values = ws.Range("C4:C12") cht.HasTitle = True cht.ChartTitle.Text = "xlXYScatterLines Bonjour!" ' Marqueur + Ligne — Série 1 sr1.MarkerStyle = xlMarkerStyleDot sr1.MarkerSize = 3 sr1.Format.Line.DashStyle = msoLineLongDash sr1.Format.Line.Weight = 1 sr1.Format.Line.ForeColor.RGB = RGB(200, 0, 100) sr1.Name = "Je suis le nom de la série 1" ' Marqueur + Ligne — Série 2 sr2.MarkerStyle = xlMarkerStyleDiamond sr2.MarkerSize = 10 sr2.Format.Line.DashStyle = msoLineDashDot sr2.Format.Line.Weight = 3 sr2.Format.Line.ForeColor.RGB = vbGreen sr2.Format.Fill.ForeColor.RGB = RGB(0, 160, 0) sr2.Name = "Je suis le nom de la série 2" Dim ax_1 As Axis Set ax_1 = cht.Axes(xlCategory, xlPrimary) ax_1.HasTitle = True ax_1.AxisTitle.Text = "X" Dim ax_2 As Axis Set ax_2 = cht.Axes(xlValue, xlPrimary) ax_2.HasTitle = True ax_2.AxisTitle.Text = "Y" End Sub 3- Règles et hypothèses -- ChartObjects.Add(...) crée un conteneur positionné (Left/Top/Width/Height). -- chartObj.Chart retourne l’objet Chart à paramétrer. -- Chart.ChartType accepte une constante (ex. xlXYScatterLines) ou son code numérique (ici 74). -- SeriesCollection.NewSeries crée une série ; XValues et Values pointent vers des plages. -- Series.Format.Line modifie le tracé de la série ; Series.MarkerStyle/Size gère le marqueur. -- Series.Format.Fill.ForeColor pour la couleur du marqueur (intérieur). -- Axes(xlCategory/xlValue, xlPrimary) donne accès aux axes pour les titres, formats, etc. 4- Bonnes pratiques & pièges -- Préférer les constantes nommées (lisibles) aux codes numériques “magiques”. -- Vérifier la cohérence des XValues/Values (mêmes longueurs). -- Pour des séries nombreuses, factoriser le style dans une procédure utilitaire (DRY). -- Les propriétés Series.Format.Fill.ForeColor et .BackColor s’appliquent au marqueur en XY.

🟩 Fiche 3 — [Créer un XY Scatter (points seuls) — marqueurs, remplissage avant/arrière] 1- Objectif et usage -- Générer un graphique XY sans ligne (Scatter), définir le marqueur et ses couleurs avant/arrière. 2- Code Sub xlXYScatter_demo() Dim ws As Worksheet Set ws = ThisWorkbook.Worksheets("Charts") Dim chartObj As ChartObject Set chartObj = ws.ChartObjects.Add(Left:=250, Width:=375, Top:=240, Height:=225) Dim cht As Chart Set cht = chartObj.Chart cht.ChartType = -4169 ' xlXYScatter Dim sr As Series Set sr = cht.SeriesCollection.NewSeries sr.XValues = ws.Range("D4:D11") sr.Values = ws.Range("E4:E11") cht.HasTitle = True cht.ChartTitle.Text = "xlXYScatter" ' Marqueur (sans ligne) sr.MarkerStyle = xlMarkerStyleCircle sr.MarkerSize = 10 sr.Name = "Name of series" sr.Format.Fill.ForeColor.RGB = vbRed sr.Format.Fill.BackColor.RGB = vbBlue End Sub 3- Règles et hypothèses -- xlXYScatter (code -4169) produit des points uniquement (pas de ligne). -- Series.Format.Fill.ForeColor = couleur de face du marqueur ; BackColor = arrière-plan (pertinent selon le style du marqueur). -- Si une ligne apparaît, vérifier Series.Format.Line.Visible et le type de graphique. 4- Bonnes pratiques & pièges -- Adapter la taille du marqueur (MarkerSize) à la densité des points. -- Prévoir une légende ou des noms de séries explicites (Series.Name)

🟩 Fiche 4 — [Histogramme (xlColumnClustered) — alimentation et remplissage] 1- Objectif et usage -- Créer un histogramme groupé (colonnes) et colorer l’intérieur des barres via Format.Fill. 2- Code Sub xlColumnClustered_demo() Dim ws As Worksheet Set ws = ThisWorkbook.Worksheets("Charts") Dim chartObj As ChartObject Set chartObj = ws.ChartObjects.Add(Left:=500, Width:=375, Top:=40, Height:=225) Dim cht As Chart Set cht = chartObj.Chart cht.ChartType = 51 ' xlColumnClustered Dim sr As Series Set sr = cht.SeriesCollection.NewSeries sr.XValues = ws.Range("F4:F8") sr.Values = ws.Range("G4:G8") cht.HasTitle = True cht.ChartTitle.Text = "Histogram: xlColumnClustered" ' Intérieur des barres (remplissage) sr.Name = "Nom de la série" sr.Format.Fill.ForeColor.RGB = vbRed End Sub 3- Règles et hypothèses -- xlColumnClustered (code 51) crée des colonnes groupées ; Series.Format.Fill vise le corps des barres. -- Les catégories proviennent de XValues; les hauteurs de Values. 4- Bonnes pratiques & pièges -- Vérifier l’alignement des catégories (texte vs nombres). -- Pour plusieurs séries, jouer sur couleur, transparence, et GapWidth pour la lisibilité.

🟩 Fiche 5 — [Composer plusieurs graphiques d’un coup — orchestration d’appels] 1- Objectif et usage -- Appeler en séquence les procédures de création pour produire un ensemble de graphiques. 2- Code Sub makeGraphs() xlXYScatterLines_demo xlXYScatter_demo xlColumnClustered_demo End Sub 3- Règles et hypothèses -- Chaque Sub appelée insère son propre ChartObject avec ses coordonnées. -- Les positions (Left/Top) peuvent chevaucher : ajuster si nécessaire. 4- Bonnes pratiques & pièges -- Centraliser la gestion du layout (positions et tailles) dans un module dédié. -- Avant de générer, proposer une Sub de nettoyage (supprimerLesGraphiques) pour repartir d’une feuille propre.

🟩 Fiche 6 — [Séries : rappel sur le modèle de format (marker vs line)] 1- Objectif et usage -- Savoir où régler marqueur et ligne d’une série (objets Series, Format, Fill, Line). 2- Règles et repères rapides -- Series.Format.Fill : intérieur du marqueur (en XY), intérieur des barres (en colonnes). -- Series.Format.Line : style de ligne (traits, couleur, épaisseur). -- Series.MarkerStyle / Series.MarkerSize : type et taille du marqueur. -- Series.Fill.Fore... et Series.Fill.Back... font partie de l’habillage du marqueur (XY). -- Series.Format.Fill.ForeColor.RGB et BackColor.RGB : couleurs avant/arrière. 3- Bonnes pratiques & pièges -- Toujours valider le type de graphique, car le même membre d’objet peut cibler un visuel différent (ex. fill d’une barre vs fill d’un marqueur). -- Éviter les “nombres magiques” : utiliser les constantes (xlXYScatterLines, xlXYScatter, xlColumnClustered, xlMarkerStyleX…).

🟩 Fiche 7 — [Création d’un tableau structuré (ListObject) et utilisation de With] 1- Objectif et usage -- Créer un tableau structuré dans Excel (ListObject) à partir d’une plage, en le nommant “Écoles”. -- Comparer deux syntaxes : avec une variable d’objet (méthode classique) et avec le mot-clé With (syntaxe compacte). 2- Code Sub Macro1() Dim ws As Worksheet ' Variable d’objet Set ws = ThisWorkbook.Worksheets("Feuil1") ws.ListObjects.Add(xlSrcRange, ws.Range("$B$2:$D$7"), , xlYes).Name = "Écoles" End Sub Sub Macro2() With ThisWorkbook.Worksheets("Feuil1") .ListObjects.Add(xlSrcRange, .Range("$B$2:$D$7"), , xlYes).Name = "Écoles" End With End Sub 3- Règles et hypothèses -- ListObjects.Add crée un tableau structuré (objet ListObject) à partir d’une plage. -- Arguments : xlSrcRange → indique que la source est une plage de la feuille. Range("$B$2:$D$7") → plage de cellules à transformer en tableau. xlYes → confirme que la première ligne contient les en-têtes. -- .Name = "Écoles" attribue un nom explicite au tableau pour le réutiliser facilement. -- Le mot-clé With permet de répéter moins souvent la référence à l’objet cible (ThisWorkbook.Worksheets("Feuil1")). 4- Bonnes pratiques & pièges -- Toujours utiliser des références absolues ($B$2:$D$7) pour éviter les erreurs lors du déplacement du tableau. -- Si la feuille ou le classeur change, préférer des références dynamiques (par nom ou variable). -- Avec le mot-clé With, n’oubliez pas le point (.) devant chaque propriété/méthode de l’objet concerné. -- Nommer les tableaux (.Name) facilite les requêtes via VBA, Power Query ou formules structurées Excel. -- Pour supprimer un tableau structuré : .ListObjects("Écoles").Delete.

🟩 Fiche 8 — [Histogramme + courbe théorique (mélange de types de séries, tableaux dynamiques, Option Base)] 1- Objectif et usage -- Créer un histogramme groupé (colonnes) depuis des plages Excel et superposer une courbe théorique (série en ligne) calculée par une Function. -- Illustrer l’usage de tableaux dynamiques (Variant / Double), de ReDim, d’UBound, et le piège de Option Base 1 avec Array(). 2- Code Option Explicit Option Base 1 Function Theoretical(ByVal x As Double) As Double Theoretical = x * 10 + 2 End Function Sub xlColumnClustered_() Dim ws As Worksheet Set ws = ThisWorkbook.Worksheets("Histogram w Theoretical Curve") Dim chartObj As ChartObject Set chartObj = ws.ChartObjects.Add(Left:=200, Width:=375, Top:=40, Height:=225) Dim cht As Chart Set cht = chartObj.Chart cht.ChartType = 51 ' xlColumnClustered Dim sr As Series Set sr = cht.SeriesCollection.NewSeries sr.XValues = ws.Range("A4:A8") sr.Values = ws.Range("B4:B8") cht.HasTitle = True cht.ChartTitle.Text = "Histogram: xlColumnClustered" ' Les barres de l'histogramme sr.Name = "Nom de la série" sr.Format.Fill.ForeColor.RGB = vbRed ' Courbe théorique (série en ligne) Dim srCurve As Series Set srCurve = cht.SeriesCollection.NewSeries Dim xs() As Variant xs = Array(1, 3, 5, 7, 9) srCurve.XValues = xs Dim Ys() As Double Dim k As Integer ReDim Ys(1 To UBound(xs)) For k = 1 To UBound(Ys) Ys(k) = Theoretical(xs(k)) Next srCurve.Values = Ys srCurve.ChartType = xlLine srCurve.Name = "Theoretical" End Sub 3- Règles et hypothèses -- Mélange de types de séries dans un même graphique : l’objet Chart accepte une série en colonnes (histogramme) et une autre en ligne (srCurve.ChartType = xlLine). -- Function Theoretical -- Paramètre ByVal x As Double : la fonction est pure (ne modifie rien hors d’elle) et renvoie un Double. -- Ici, la relation est linéaire : y = 10*x + 2 (exemple de courbe théorique). -- Tableaux et bornes -- Array(…) renvoie un Variant() 0-based en VBA, même si Option Base 1 est présent. -- ReDim Ys(1 To UBound(xs)) crée un tableau 1-based pour Ys. -- La boucle For k = 1 To UBound(Ys) n’utilise pas xs(0) → le premier x (1) est ignoré ici. -- Séries -- XValues et Values doivent avoir la même longueur. -- Pour l’histogramme : Format.Fill cible l’intérieur des barres. 4- Bonnes pratiques & pièges -- Éviter l’erreur d’indexation avec Array() : base 0. Toujours coder avec LBound/UBound pour rester robuste : Dim xs() As Variant, Ys() As Double, k As Long xs = Array(1, 3, 5, 7, 9) ' 0-based ReDim Ys(LBound(xs) To UBound(xs)) ' même base que xs For k = LBound(xs) To UBound(xs) Ys(k) = Theoretical(CDbl(xs(k))) Next -- Si vous voulez un tableau 1-based, déclarez-le explicitement plutôt que de compter sur Option Base : Dim xs1b(1 To 5) As Double: xs1b(1)=1: xs1b(2)=3: xs1b(3)=5: xs1b(4)=7: xs1b(5)=9 -- Lisibilité : factoriser la création d’une série “courbe théorique” (construction des X, calcul des Y) dans une Sub dédiée. -- Mise à l’échelle : si les ordres de grandeur diffèrent, envisager un axe secondaire pour la courbe (AxisGroup = xlSecondary). -- Performance : éviter .Select, préparer les tableaux en mémoire puis affecter XValues/Values en une fois.

🟩 Fiche 9 — [Deux échelles verticales (Primary/Secondary) avec AxisGroup sur un XY Scatter Lines] 1- Objectif et usage -- Créer un graphique XY avec lignes comportant deux axes Y indépendants (primaire et secondaire) pour juxtaposer des séries de grandeurs/ordres de magnitude différents. -- Paramétrer AxisGroup des séries, titrer les axes, activer la légende et le titre du graphique. 2- Code Option Explicit Sub Two_Vertical_Scales() Dim ws As Worksheet Set ws = ThisWorkbook.Worksheets("Two Vertical Scales") Dim chartObj As ChartObject Set chartObj = ws.ChartObjects.Add(Left:=50, Width:=375, Top:=260, Height:=225) Dim cht As Chart Set cht = chartObj.Chart Dim sc As SeriesCollection Set sc = cht.SeriesCollection ' Données (peuvent être aussi des Ranges) Dim xs As Variant, y1s As Variant, y2s As Variant xs = Array(4, 5, 6, 7, 8, 9, 10, 11, 12) y1s = Array(34, 33, 31, 29, 25, 26, 25, 23, 22) y2s = Array(190, 230, 250, 270, 290, 300, 310, 320, 320) ' Série 1 → Axe primaire Dim sr1 As Series Set sr1 = sc.NewSeries sr1.ChartType = xlXYScatterLines sr1.AxisGroup = xlPrimary sr1.XValues = xs sr1.Values = y1s ' Série 2 → Axe secondaire Dim sr2 As Series Set sr2 = sc.NewSeries sr2.ChartType = xlXYScatterLines sr2.AxisGroup = xlSecondary sr2.XValues = xs sr2.Values = y2s ' Axes et titres Dim ax_1 As Axis, ax_2 As Axis, ax_3 As Axis Set ax_1 = cht.Axes(xlCategory, xlPrimary): ax_1.HasTitle = True: ax_1.AxisTitle.Text = "X" Set ax_2 = cht.Axes(xlValue, xlPrimary): ax_2.HasTitle = True: ax_2.AxisTitle.Text = "Y_primary" Set ax_3 = cht.Axes(xlValue, xlSecondary): ax_3.HasTitle = True: ax_3.AxisTitle.Text = "Y_secondary" cht.HasTitle = True cht.ChartTitle.Text = "Deux échelles verticales" sr1.Name = "Name of series 1" sr2.Name = "Name of series 2" cht.HasLegend = True End Sub 3- Règles et hypothèses -- AxisGroup contrôle sur quel axe Y la série est tracée : xlPrimary ou xlSecondary. -- Les deux séries peuvent partager le même X mais avoir des échelles Y différentes. -- Les types utilisés ici sont xlXYScatterLines pour visualiser des courbes continues. 4- Bonnes pratiques & pièges -- Toujours titrer clairement les axes pour éviter les confusions d’unités. -- Si les gammes sont très différentes, appliquer des formats numériques adaptés sur chaque axe (ex. pourcent vs unités). -- Vérifier que XValues et Values ont exactement la même longueur pour chaque série.

🟩 Fiche 10 — [SeriesCollection : alimenter les séries avec Array ou Range, et garantir la cohérence des données] 1- Objectif et usage -- Savoir alimenter Series.XValues et Series.Values via tableaux en mémoire (Variant) ou via plages Excel (Range). -- Garantir la cohérence de longueur et la compatibilité de types pour éviter les erreurs silencieuses. 2- Exemples de sources de données ' 1) Tableaux en mémoire (0-based via Array) Dim xs As Variant, y1s As Variant xs = Array(4, 5, 6, 7, 8, 9, 10, 11, 12) y1s = Array(34, 33, 31, 29, 25, 26, 25, 23, 22) sr1.XValues = xs sr1.Values = y1s ' 2) Plages Excel sr1.XValues = ws.Range("A3:A11") sr1.Values = ws.Range("B3:B11") 3- Règles et hypothèses -- Array(...) crée un Variant() à base 0 (LBound=0) ; pas d’impact pour XValues/Values, mais utile à savoir si vous bouclez dessus. -- XValues et Values doivent avoir même nombre d’éléments et correspondre position par position. -- Les Range sont évaluées à l’instant de l’affectation (snap de la plage actuelle). 4- Bonnes pratiques & pièges -- Pour construire des tableaux dynamiquement, utiliser LBound/UBound pour boucler sans erreur d’index. -- Si vous mixez colonnes de types différents (texte vs nombre), normaliser les types avant l’affectation (conversion explicite si besoin). -- Préférer les tableaux en mémoire quand les données sont calculées par le code : c’est plus rapide et évite les aller-retours avec la feuille. -- Quand vous utilisez des Range, verrouiller les adresses (ex. A3:A11) ou construire les plages de façon programmée (ex. Range(Cells(r1, c), Cells(r2, c))).

🟩 Fiche 11 — [Calcul de la valeur et de la dérivée d’une obligation — fonctions Val() et Der()] 1- Objectif et usage -- Créer deux fonctions permettant de calculer la valeur théorique d’une obligation et la dérivée de cette valeur par rapport au taux du marché. -- Ces fonctions sont ensuite utilisées pour estimer la durée en points de base, soit la sensibilité du prix à une variation du taux. 2- Code Function Val(Face, coupon, n, taux_marché) As Double Dim k As Integer, somme As Double For k = 1 To n somme = somme + coupon / (1 + taux_marché) ^ k Next somme = somme + 1 / (1 + taux_marché) ^ n Val = somme * Face / 10000 ' en points de base End Function Function Der(Face, coupon, n, taux_marché) As Double Dim k As Integer, somme As Double For k = 1 To n somme = somme - k * coupon / (1 + taux_marché) ^ (k + 1) Next somme = somme - n / (1 + taux_marché) ^ (n + 1) Der = -somme * Face / 10000 ' en points de base End Function 3- Règles et hypothèses -- Val(Face, coupon, n, taux_marché) -- Calcule la valeur actualisée de tous les flux (coupons + principal) d’une obligation. -- coupon / (1 + taux_marché)^k actualise le coupon à la période k. -- 1 / (1 + taux_marché)^n actualise le remboursement du nominal (facteur de 1 car 100 % du capital). -- Le tout est multiplié par Face / 10000 pour convertir en points de base. -- Der(Face, coupon, n, taux_marché) -- Calcule la dérivée de la fonction précédente, soit la variation de la valeur de l’obligation par rapport à une variation du taux d’intérêt. -- La dérivée de chaque flux est -k * coupon / (1 + taux_marché)^(k + 1) et celle du principal est -n / (1 + taux_marché)^(n + 1). -- Le signe négatif final (-somme) garantit que la dérivée (durée) est positive : la valeur diminue quand le taux augmente. 4- Bonnes pratiques & pièges -- Les arguments Face, coupon, n et taux_marché doivent être de type Double pour éviter les arrondis. -- Bien noter que le résultat est exprimé en points de base et non en pourcentage. -- Toujours vérifier que (1 + taux_marché) > 0 pour éviter les divisions invalides. -- Ces fonctions supposent que le coupon est fixe et payé une fois par période.

🟩 Fiche 12 — [Calcul de la durée totale d’un portefeuille — Sub CalculDurée()] 1- Objectif et usage -- Automatiser la lecture de données d’obligations à partir d’un fichier externe, appliquer la fonction Der() pour chaque ligne, et calculer la durée totale du portefeuille. -- Générer automatiquement une nouvelle feuille de résultats datée. 2- Code Sub CalculDurée() Dim wb As Workbook Dim p As String p = "C:\Users\PC\OneDrive\Documents\HEC TECH40732 2025A\Séances VBA\" MsgBox p Set wb = Workbooks.Open(p & "DonnéesObligations.xlsx") Dim lastLine As Integer lastLine = wb.Worksheets(1).Cells(1, 1).End(xlDown).Row Dim RangeDonnées As Range Set RangeDonnées = Range(wb.Worksheets(1).Cells(1, 1), wb.Worksheets(1).Cells(lastLine, 3)) Dim matrice As Variant matrice = RangeDonnées.Value wb.Close Dim ws As Worksheet Set ws = ThisWorkbook.Worksheets.Add ws.Name = Strings.Replace(CStr(Now()), ":", "") Range(ws.Cells(1, 1), ws.Cells(lastLine, 3)).Value = matrice Dim k As Integer, duréePointsDeBase As Double, duréeTotale As Double For k = 1 To lastLine duréePointsDeBase = Der(ws.Cells(k, 1), ws.Cells(k, 2), ws.Cells(k, 3), 0.046) ws.Cells(k, 4) = duréePointsDeBase duréeTotale = duréeTotale + duréePointsDeBase Next ws.Columns("D").NumberFormat = "0" MsgBox Prompt:=Format(duréeTotale, "0") & " points de base", Title:="DuréeTotale" End Sub 3- Règles et hypothèses -- Workbooks.Open ouvre le fichier contenant les données d’obligations (Face, coupon, n). -- Cells(1,1).End(xlDown).Row détecte la dernière ligne des données. -- RangeDonnées.Value copie les données dans une matrice Variant en mémoire (plus rapide que cellule par cellule). -- Une nouvelle feuille est créée, nommée selon la date et heure du calcul (Strings.Replace retire les “:”). -- La boucle For k applique la fonction Der() à chaque ligne, écrit la durée en colonne D, et cumule la durée totale. -- Le format numérique "0" affiche les durées en points de base sans décimales. 4- Bonnes pratiques & pièges -- Vérifier le chemin du fichier et les permissions d’accès avant l’exécution. -- Fermer le fichier source (wb.Close) avant d’écrire dans la nouvelle feuille pour libérer les ressources. -- Utiliser Application.ScreenUpdating = False pour accélérer le traitement si beaucoup de lignes. -- Utiliser une constante de taux (Const taux_marche As Double = 0.046) au lieu d’une valeur codée en dur. -- Si le portefeuille contient plusieurs types d’obligations (annuelles, semestrielles), adapter Der() et Val() pour inclure la fréquence de paiement.

🟩 Fiche 13 — [WorksheetFunction.Frequency — calcul d’une distribution de fréquences par classes] 1- Objectif et usage -- Utiliser la fonction Frequency() d’Excel via VBA pour calculer la répartition des observations dans des intervalles de classes (bornes). -- Comprendre le comportement du tableau renvoyé et la logique de classification automatique d’Excel. 2- Code Sub Frequency_demo() Dim échantillon As Variant échantillon = Array(-0.8, 0.3, 0.4, 0.5, 0.6, 0.7, 1.4, 1.5, 1.6, 2.2, 2.3, 2.4, 2.5, 3.4) Dim bornes As Variant bornes = Array(0, 1, 2, 3) Dim fréquences As Variant fréquences = WorksheetFunction.Frequency(échantillon, bornes) ' Visualisez les fréquences dans la fenêtre de variables locales. ' Résultat attendu : (1, 5, 3, 4, 1) End Sub 3- Règles et hypothèses -- WorksheetFunction.Frequency est une fonction vectorielle d’Excel qui retourne un tableau de fréquences. -- Le premier argument (échantillon) est le vecteur de données à classer. -- Le second argument (bornes) définit les limites supérieures des classes (bords inclus). -- Le tableau renvoyé contient (nb de bornes + 1) valeurs : 1 classe pour les valeurs inférieures à la première borne, 1 classe par intervalle défini entre les bornes, 1 classe pour les valeurs supérieures à la dernière borne. -- Dans l’exemple, bornes = (0, 1, 2, 3) → 5 classes, d’où la sortie (1, 5, 3, 4, 1). 4- Bonnes pratiques & pièges -- Le résultat de WorksheetFunction.Frequency est un tableau unidimensionnel (Variant), même s’il contient plusieurs valeurs. -- Pour exploiter les résultats dans VBA, il faut souvent boucler sur le tableau : Dim i As Integer For i = LBound(fréquences) To UBound(fréquences) Debug.Print "Classe " & i & ": " & fréquences(i) Next -- Si les bornes ne sont pas triées en ordre croissant, le résultat sera incohérent. -- Toujours vérifier que les types de données (Double, Integer) sont cohérents entre échantillon et bornes. -- Frequency() ne renvoie rien directement dans Excel tant que le résultat n’est pas affiché ou traité en boucle. 5- Application pratique -- Outil statistique rapide pour construire un histogramme de distribution sans devoir utiliser de formules Excel manuelles. -- Peut servir à visualiser la dispersion de données financières (rendements, écarts-types, scores de crédit, etc.).

🟩 Fiche 14 — [Création d’un tableau structuré (ListObject) via enregistreur de macro] 1- Objectif et usage -- Créer un tableau structuré Excel à partir d’une plage sélectionnée, nommé automatiquement “Table1”. -- Illustrer la version “enregistreur de macro” d’une opération équivalente à la méthode .ListObjects.Add. 2- Code Sub Macro1() ' ' Macro1 Macro ' Range("B1:D6").Select Application.CutCopyMode = False ActiveSheet.ListObjects.Add(xlSrcRange, Range("$B$1:$D$6"), , xlYes).Name = _ "Table1" Range("Table1[#All]").Select End Sub 3- Règles et hypothèses -- ListObjects.Add crée un tableau structuré à partir d’une plage (ici $B$1:$D$6). -- xlSrcRange indique que la source du tableau est une plage existante. -- xlYes spécifie que la première ligne contient les en-têtes de colonnes. -- .Name = "Table1" donne un nom à ce tableau pour référence ultérieure. -- Le sélecteur "Table1[#All]" représente la plage entière du tableau, incluant les en-têtes et les données. 4- Bonnes pratiques & pièges -- Ce code provient d’un enregistreur de macro : il fonctionne mais n’est pas optimal. -- La commande Range(...).Select est inutile : on peut supprimer la sélection et référencer directement les objets. -- Version optimisée : Sub Créer_Table() With ActiveSheet .ListObjects.Add(xlSrcRange, .Range("$B$1:$D$6"), , xlYes).Name = "Table1" End With End Sub -- Toujours nommer les tableaux avec un nom explicite (ex. “Ventes_Q1” ou “Écoles”) pour éviter les conflits. -- Vérifier que la feuille ne contient pas déjà un tableau du même nom, sinon une erreur survient. -- Utiliser .ListObjects("Nom").Delete pour le supprimer proprement avant d’en créer un nouveau. 5- Application pratique -- Les ListObjects permettent de gérer des plages dynamiques et structurées : facilitation des formules avec noms de colonnes, intégration avec Power Query et les Tableaux croisés dynamiques, automatisation de filtres et de mises en forme conditionnelles via VBA.

VBA Flashcards

(100 cards)