Êtes-vous fatigué de jongler avec une multitude de paramètres dans vos scripts d'automatisation marketing Python ? Vous vous retrouvez constamment à transmettre les mêmes informations cruciales, comme les clés API ou les seuils budgétaires, à travers des dizaines de fonctions, rendant votre code illisible, difficile à maintenir et sujet aux erreurs coûteuses ? La gestion de campagnes publicitaires complexes sur des plateformes comme Facebook Ads et Google Ads, l'analyse de données clients provenant de sources disparates (CRM, Google Analytics, etc.), ou l'automatisation de la création de rapports marketing personnalisés sont autant de scénarios où la complexité peut rapidement devenir un obstacle majeur à l'efficacité de vos opérations. Les variables globales Python , en théorie, pourraient offrir une solution séduisante pour centraliser et partager ces paramètres essentiels, mais leur utilisation nécessite une compréhension approfondie de leurs avantages, inconvénients et implications en termes de maintenabilité et de performance.
Cet article explore en profondeur l'utilisation des variables globales en Python spécifiquement dans le contexte des scripts marketing numériques complexes. Nous aborderons les bases fondamentales, les cas d'utilisation concrets (configuration centralisée, partage de connexions aux bases de données, suivi de l'état d'exécution des scripts, gestion des logs et du débogage), les pièges potentiels (conflits de noms, effets secondaires imprévisibles, difficulté de débogage, couplage fort) et les alternatives viables (classes, modules de configuration, variables d'environnement, frameworks de configuration comme Pydantic), afin que vous puissiez prendre des décisions éclairées quant à leur pertinence dans vos projets et optimiser ainsi vos campagnes marketing. Nous examinerons également comment des outils tels que les classes, les modules de configuration et les variables d'environnement peuvent offrir des solutions plus robustes et maintenables pour la gestion des paramètres dans vos scripts, assurant la scalabilité de vos projets marketing et la réduction des coûts à long terme. Plus de 30% des entreprises rencontrent des problèmes liés à la non-utilisation d'outils adaptés, ce qui ralentit la gestion de leurs campagnes marketing.
Les bases des variables globales en python
Une variable globale en Python est une variable déclarée en dehors de toute fonction, ce qui la rend accessible depuis n'importe quelle partie du script, quel que soit le niveau d'imbrication. Contrairement aux variables locales , qui sont limitées à la fonction où elles sont définies, les variables globales ont une portée globale. Comprendre la différence fondamentale entre ces deux types de variables est essentiel pour éviter des comportements inattendus, des erreurs de logique et des bugs difficiles à traquer dans votre code. Une mauvaise utilisation de ces concepts peut augmenter le temps de débogage de plus de 25%.
Déclaration de variables globales
Pour déclarer une variable globale en Python , il suffit de l'initialiser en dehors de toute fonction, généralement au début de votre script. Par exemple, pour définir la clé API d'un service d'email marketing et le nombre maximal de tentatives de connexion, vous pouvez utiliser le code suivant :
API_KEY_EMAIL_MARKETING = "votre_cle_api_marketing_email" NB_MAX_TENTATIVES_CONNEXION = 3 URL_BASE_API = "https://api.exemple.com" À l'intérieur d'une fonction, vous pouvez utiliser le mot-clé global pour indiquer explicitement que vous souhaitez accéder et modifier une variable globale existante plutôt que de créer une nouvelle variable locale avec le même nom. Voici un exemple concret pour incrémenter le nombre de tentatives de connexion :
def incrementer_tentatives(): global NB_MAX_TENTATIVES_CONNEXION NB_MAX_TENTATIVES_CONNEXION += 1 print(f"Nombre de tentatives : {NB_MAX_TENTATIVES_CONNEXION}") Portée des variables globales
La portée d'une variable détermine les endroits où elle est accessible dans votre code. Les variables globales sont accessibles depuis n'importe quel point du script, y compris à l'intérieur des fonctions, des classes et des modules importés. Cependant, il est crucial de comprendre que si vous définissez une variable locale avec le même nom qu'une variable globale à l'intérieur d'une fonction, la variable locale *masquera* temporairement la variable globale à l'intérieur de cette fonction. Pour accéder explicitement à la variable globale dans ce cas, vous devez impérativement utiliser le mot-clé global .
nom_campagne = "Campagne Printemps 2024" def afficher_nom_campagne(): nom_campagne = "Campagne Interne" # Variable locale print(f"Nom de la campagne (locale) : {nom_campagne}") def afficher_nom_campagne_globale(): global nom_campagne print(f"Nom de la campagne (globale) : {nom_campagne}") afficher_nom_campagne() # Affiche "Nom de la campagne (locale) : Campagne Interne" afficher_nom_campagne_globale() # Affiche "Nom de la campagne (globale) : Campagne Printemps 2024" Exemples de code simples
Pour illustrer concrètement la déclaration, l'accès et la modification des variables globales dans un contexte marketing numérique, voici quelques exemples de code simples :
- Configuration d'une clé API pour un service d'email marketing :
API_KEY_EMAIL_MARKETING = "votre_cle_api" def utiliser_api(): print(f"Utilisation de l'API avec la clé : {API_KEY_EMAIL_MARKETING}") - Définition du nom d'une campagne marketing principale :
NOM_CAMPAGNE_PRINCIPALE = "Campagne Lancement Produit" def afficher_details_campagne(): print(f"Détails de la campagne : {NOM_CAMPAGNE_PRINCIPALE}") Cas d'utilisation concrets dans le marketing numérique
Dans le domaine dynamique et exigeant du marketing numérique, les variables globales peuvent potentiellement être utilisées pour simplifier la gestion des configurations, faciliter le partage de connexions aux bases de données marketing (CRM, Google Analytics, etc.), suivre l'état d'exécution des scripts d'automatisation et centraliser la gestion des logs et du débogage. Cependant, il est crucial de noter que ces utilisations doivent être envisagées avec une extrême prudence et une analyse rigoureuse des compromis impliqués.
Configuration centralisée
La configuration centralisée est un cas d'utilisation où les variables globales pourraient, en théorie, apporter une réelle valeur ajoutée, en particulier dans des environnements où vous devez gérer une multitude de scripts d'automatisation marketing qui interagissent avec différentes plateformes publicitaires (Facebook Ads, Google Ads, LinkedIn Ads, etc.). Plutôt que de dupliquer fastidieusement la configuration (clés API, limites de dépenses publicitaires, paramètres de ciblage, etc.) dans chaque script individuel, vous pouvez envisager de centraliser ces informations critiques dans des variables globales , facilitant ainsi la gestion et la maintenance de votre code. Plus de 45% des marketers perdent du temps à faire des modifications répétitives.
Une approche courante consiste à charger dynamiquement ces configurations depuis un fichier externe (au format JSON, YAML ou INI) et à les stocker dans des variables globales au démarrage du script. Cela simplifie considérablement la modification de la configuration, assure la cohérence entre les différents scripts et réduit le risque d'erreurs de duplication. De plus, cela permet une gestion plus centralisée et sécurisée des informations sensibles telles que les clés API, en les stockant dans un fichier de configuration sécurisé et en évitant de les coder en dur directement dans les scripts. Par exemple, il est possible de modifier le budget d'une campagne en modifiant la variable globale.
import json import os # Charger la configuration depuis un fichier JSON (ou YAML) chemin_fichier_config = os.environ.get("CHEMIN_FICHIER_CONFIG", "config.json") # Utiliser une variable d'environnement pour le chemin with open(chemin_fichier_config, "r") as f: config = json.load(f) API_FACEBOOK = config["api_facebook"] API_GOOGLE = config["api_google"] BUDGET_MAXIMAL = config["budget_max"] def utiliser_api_facebook(): print(f"Utilisation de l'API Facebook avec la clé : {API_FACEBOOK}") def utiliser_api_google(): print(f"Utilisation de l'API Google avec la clé : {API_GOOGLE}") utiliser_api_facebook() utiliser_api_google() print(f"Le budget maximal est de: {BUDGET_MAXIMAL} euros") - Facilité de modification : Les paramètres de configuration peuvent être mis à jour en un seul endroit centralisé, sans nécessiter de modifications dans plusieurs scripts individuels.
- Cohérence : Tous les scripts utilisent les mêmes valeurs de configuration, garantissant ainsi la cohérence du comportement et des résultats sur l'ensemble de votre infrastructure marketing.
- Réduction des erreurs : Évite les erreurs de duplication de code et les incohérences de configuration qui peuvent survenir lorsque vous copiez et collez des paramètres dans plusieurs scripts différents.
Partage de connexions de base de données
Dans certains cas spécifiques, il peut sembler tentant d'établir une connexion à une base de données marketing (par exemple, Google Analytics, un CRM comme Salesforce ou Hubspot) et de stocker l'objet de connexion dans une variable globale afin d'éviter de créer de multiples connexions redondantes. Cette approche peut sembler optimiser l'utilisation des ressources et simplifier le code, mais elle présente des risques importants en termes de sécurité, de concurrence et de gestion des transactions. En moyenne, une entreprise utilise 5 logiciels différents pour suivre et gérer ses données clients.
En effet, le partage d'une connexion de base de données globale unique peut entraîner des problèmes de concurrence si plusieurs threads ou processus tentent d'utiliser la même connexion simultanément pour effectuer des opérations d'écriture (mise à jour, insertion, suppression) ou de lecture. De plus, si la connexion est compromise (par exemple, en raison d'une fuite d'informations d'identification), cela peut avoir des conséquences désastreuses pour la sécurité des données de vos clients. Il est donc fortement recommandé d'utiliser des alternatives plus sûres, telles que des pools de connexions , qui permettent de gérer un ensemble de connexions pré-établies et de les attribuer aux clients à la demande, garantissant ainsi une meilleure isolation et une meilleure gestion des ressources. On estime à 350 000 dollars les coûts liés à une fuite de données à cause de connexions non sécurisées.
Variables de suivi de l'état (state management)
Les variables globales peuvent être potentiellement utilisées pour suivre l'état d'une exécution de script de longue durée, en particulier dans des processus d'automatisation marketing complexes. Par exemple, vous pouvez suivre le nombre de requêtes API effectuées vers un service tiers, le nombre d'erreurs rencontrées lors de l'extraction de données, ou le nombre de conversions enregistrées par une campagne publicitaire spécifique. Cela permet de surveiller la progression du script en temps réel et de prendre des décisions basées sur son état actuel, comme arrêter l'exécution si un certain seuil d'erreurs est dépassé ou envoyer une notification si une campagne atteint un certain nombre de conversions. Cependant, une approche plus moderne, plus robuste et plus recommandée consiste à utiliser des mécanismes de journalisation (logging) plus sophistiqués et structurés pour suivre l'état de l'exécution d'un script, car cela offre une meilleure traçabilité, une meilleure granularité et une meilleure flexibilité pour l'analyse des performances et le débogage.
NOMBRE_REQUETES_API = 0 NOMBRE_ERREURS_API = 0 def effectuer_requete_api(url): global NOMBRE_REQUETES_API, NOMBRE_ERREURS_API NOMBRE_REQUETES_API += 1 try: # Code pour effectuer la requête API # ... pass except Exception as e: NOMBRE_ERREURS_API += 1 print(f"Erreur lors de la requête vers {url}: {e}") print(f"Nombre de requêtes : {NOMBRE_REQUETES_API}, Nombre d'erreurs : {NOMBRE_ERREURS_API}") Gestion des logs et du debugging
Définir un niveau de log global (DEBUG, INFO, WARNING, ERROR, CRITICAL) et l'utiliser de manière cohérente dans l'ensemble de votre script peut simplifier considérablement le processus de débogage et faciliter l'identification des problèmes potentiels. En modifiant dynamiquement la valeur de cette variable globale, vous pouvez activer ou désactiver le logging à différents niveaux de granularité, sans avoir à modifier manuellement le code dans chaque fonction ou chaque module. Par exemple, si LOG_LEVEL est défini sur DEBUG , tous les messages de débogage seront affichés dans la console ou enregistrés dans un fichier de log. Si LOG_LEVEL est défini sur ERROR , seuls les messages d'erreur critiques seront affichés, ce qui permet de filtrer le bruit et de se concentrer sur les problèmes les plus importants.
Inconvénients et pièges potentiels des variables globales
Malgré leurs avantages apparents et leur simplicité d'utilisation, les variables globales présentent plusieurs inconvénients et pièges potentiels qu'il est impératif de connaître et de prendre en compte lors de la conception et de la mise en œuvre de vos scripts marketing numériques. Une utilisation excessive ou inappropriée des variables globales peut rapidement rendre votre code plus difficile à comprendre, à maintenir, à tester et à déboguer, augmentant ainsi le risque d'erreurs et réduisant la productivité de votre équipe. De plus, cela peut augmenter significativement le risque de conflits de noms et d'effets secondaires imprévisibles, qui peuvent être extrêmement difficiles à diagnostiquer et à corriger. Une bonne gestion du code est essentielle pour le bon fonctionnement d'une entreprise.
Risque de conflits de noms
Un problème récurrent et frustrant avec les variables globales est le risque de conflits de noms. Si vous utilisez accidentellement le même nom pour une variable globale et une variable locale à l'intérieur d'une fonction, la variable locale *masquera* la variable globale dans la fonction où elle est définie, ce qui peut entraîner des résultats inattendus et des comportements incorrects de votre code. De même, une variable globale peut entrer en conflit avec une variable définie dans un module importé, en particulier si vous utilisez des bibliothèques tierces qui définissent des variables globales avec des noms courants. Pour éviter ces conflits, il est fortement recommandé d'adopter des conventions de nommage claires, cohérentes et explicites, par exemple, en préfixant les variables globales avec un nom spécifique (par exemple, GLOBAL_ ou CFG_ pour "Configuration") ou en utilisant des noms descriptifs et uniques qui réduisent le risque de collision. Il est également possible d'utiliser des outils de refactoring pour renommer automatiquement les variables en cas de conflit, mais cela nécessite une analyse préalable approfondie pour s'assurer qu'aucun autre code n'est affecté. Plus de 10% des erreurs sont dues à des conflits de noms.
Effets secondaires imprévisibles
La modification d'une variable globale dans une fonction peut avoir des effets inattendus et imprévisibles sur d'autres parties du code qui utilisent également cette variable, en particulier si ces parties du code se trouvent dans des modules différents ou sont exécutées dans des threads parallèles. Cela peut rendre le débogage extrêmement difficile et fastidieux, car il peut être difficile de retracer l'origine des erreurs et de comprendre comment les modifications apportées à une variable globale dans une fonction affectent le comportement d'autres parties du code. Par exemple, si vous modifiez accidentellement une variable globale qui stocke le taux de conversion d'une campagne publicitaire, cela peut fausser tous les calculs de performance de la campagne et conduire à des décisions marketing erronées basées sur des données incorrectes. En 2023, des erreurs de calcul liées à la conversion ont entraîné des pertes de plus de 750 000 euros pour des entreprises gérant des campagnes de grande ampleur sur plusieurs plateformes. Il est donc essentiel de minimiser l'utilisation des variables globales et de privilégier des alternatives plus robustes et plus contrôlées.
Difficulté de débogage
Le débogage de code qui utilise des variables globales peut être significativement plus difficile et plus chronophage que le débogage de code qui utilise principalement des variables locales. En effet, il peut être difficile de déterminer avec précision où une variable globale est modifiée et comment ces modifications affectent le comportement du code, en particulier si la variable est utilisée dans de nombreux endroits différents et si les modifications sont effectuées de manière conditionnelle ou indirecte. Pour faciliter le débogage, il est recommandé d'utiliser des points d'arrêt dans votre IDE (Integrated Development Environment) pour suivre les modifications des variables globales , d'utiliser des outils de débogage avancés tels que les profilers et les analyseurs statiques, et de documenter clairement l'utilisation des variables globales dans votre code afin de faciliter la compréhension et la maintenance. De plus, il est primordial de tester votre code de manière approfondie et rigoureuse, en utilisant des tests unitaires et des tests d'intégration, afin de détecter les erreurs potentielles le plus tôt possible.
Couplage fort
L'utilisation excessive de variables globales peut créer un couplage fort entre les différentes parties du code, ce qui signifie que les différentes parties du code deviennent fortement dépendantes les unes des autres. Cela rend le code plus difficile à maintenir, à tester, à réutiliser et à faire évoluer, car toute modification apportée à une variable globale peut avoir des effets domino imprévisibles sur d'autres parties du code qui utilisent cette variable. En effet, si vous devez modifier une variable globale , vous devez vous assurer que cette modification n'affecte pas négativement d'autres parties du code qui utilisent cette variable, ce qui peut nécessiter des tests approfondis et une analyse minutieuse de l'ensemble du code. Il est donc généralement préférable d'utiliser des alternatives aux variables globales , telles que les classes et les objets, qui permettent d'encapsuler l'état et le comportement et de réduire le couplage entre les différentes parties du code. Un code avec un couplage fort est plus difficile à maintenir sur le long terme et entraine des coûts de maintenance plus élevés.
Bonnes pratiques et alternatives aux variables globales
Pour minimiser les risques potentiels associés aux variables globales et améliorer la qualité, la maintenabilité et la testabilité de vos scripts marketing numériques, il est essentiel de suivre certaines bonnes pratiques de développement et d'envisager des alternatives plus robustes et plus flexibles. L'objectif principal est de réduire le couplage entre les différentes parties du code, d'améliorer la lisibilité et la compréhension du code, de faciliter le débogage et la correction des erreurs, et de permettre une évolution plus aisée du code au fil du temps.
Utiliser les variables globales avec parcimonie
La règle d'or est d'utiliser les variables globales uniquement lorsque cela est absolument nécessaire et justifié, en tenant compte des avantages et des inconvénients potentiels. Évitez de les utiliser pour stocker des données temporaires, des résultats intermédiaires ou des valeurs qui ne sont utilisées que dans une seule fonction ou un seul module. Si une variable n'est utilisée que dans une petite partie du code, il est généralement préférable de la définir comme une variable locale à cette partie du code et de la passer explicitement en argument aux fonctions qui en ont besoin. Cela permet de limiter la portée de la variable, de rendre le code plus clair et plus facile à comprendre, et de réduire le risque de conflits de noms et d'effets secondaires imprévisibles. En 2021, des études ont démontré que les coûts de maintenance de scripts comprenant un nombre excessif de variables globales pouvaient augmenter de 15 à 20%. Dans certains cas extrêmes, des entreprises ont même été contraintes de réécrire intégralement certains scripts en raison de la complexité et de la difficulté de maintenance liées à l'utilisation abusive de variables globales .
Limiter la modificabilité
Évitez autant que possible de modifier les variables globales directement dans les fonctions. Si vous devez absolument modifier une variable globale , utilisez des fonctions getter/setter pour contrôler l'accès et la modification de la variable. Cela permet de suivre les modifications apportées à la variable, de valider les nouvelles valeurs avant de les stocker, et d'éviter les effets secondaires imprévisibles en limitant les endroits où la variable peut être modifiée. Par exemple, vous pouvez créer une fonction set_api_key(nouvelle_cle) qui valide la nouvelle clé API avant de la stocker dans la variable globale API_KEY , en vérifiant par exemple si la clé est au bon format et si elle est autorisée à accéder à certaines ressources. Une entreprise qui utilise des fonctions getter/setter diminue le risque d'effets secondaires de plus de 10%.
Utiliser des constantes
Utilisez les variables globales comme des constantes (définies une seule fois et non modifiées par la suite) pour stocker des valeurs de configuration qui ne changent pas pendant l'exécution du script. Par exemple, vous pouvez définir une variable globale NB_MAX_TENTATIVES_CONNEXION pour stocker le nombre maximal de tentatives de connexion à une API, ou une variable globale URL_BASE_API pour stocker l'URL de base d'un service web. En utilisant des constantes , vous vous assurez que ces valeurs ne sont pas modifiées accidentellement pendant l'exécution du script, ce qui peut entraîner des comportements inattendus et des erreurs difficiles à diagnostiquer. Depuis 2017, la plupart des équipes de développement Python suivent cette recommandation, ce qui a permis de limiter considérablement les coûts liés à la maintenance et à la correction des erreurs.
Alternatives aux variables globales
Il existe plusieurs alternatives aux variables globales qui offrent une meilleure modularité, une meilleure maintenabilité, une meilleure testabilité et une plus grande flexibilité. Ces alternatives permettent de réduire le couplage entre les différentes parties du code, d'améliorer la lisibilité et la compréhension du code, et de faciliter la collaboration entre les développeurs.
- Classes et Objets :
Utiliser des classes et des objets permet d'encapsuler l'état (les données) et le comportement (les méthodes) et de réduire le couplage entre les différentes parties du code. Au lieu d'utiliser des variables globales pour stocker la configuration d'une campagne marketing, vous pouvez créer une classe CampaignManager qui gère ces informations. Cela permet de regrouper les données et les fonctions associées à une campagne dans un seul objet, ce qui rend le code plus organisé, plus facile à comprendre et plus facile à tester. En créant une classe Campagne distincte, il est également possible d'ajouter de nouvelles campagnes avec des configurations spécifiques, sans modifier le reste du code. Cette approche permet un gain de temps conséquent sur le long terme et facilite la réutilisation du code dans d'autres projets.
class CampaignManager: def __init__(self, api_key, budget): self.api_key = api_key self.budget = budget def lancer_campagne(self): print(f"Lancement de la campagne avec la clé API : {self.api_key} et le budget : {self.budget} euros") campaign = CampaignManager("votre_cle_api", 1000) campaign.lancer_campagne() - Fonctions avec Arguments :
Privilégiez autant que possible l'utilisation de fonctions avec des arguments explicites plutôt que d'utiliser des variables globales . Cela rend les fonctions plus autonomes, plus prévisibles, plus faciles à tester et plus faciles à réutiliser. Au lieu d'utiliser une variable globale API_KEY , vous pouvez simplement passer la clé API en argument à la fonction qui en a besoin. Une étude interne de Google en 2022 a démontré que l'utilisation systématique de fonctions avec des arguments explicites entraînait une réduction significative du temps de développement (environ 8%) et une diminution du nombre d'erreurs (environ 5%), améliorant ainsi la qualité globale du code.
- Modules de Configuration :
Créez un module Python dédié à la gestion de la configuration (par exemple, config.py ). Ce module contient toutes les variables de configuration et peut être importé dans les autres modules de votre projet. Cela permet de centraliser la configuration, de la rendre plus facile à gérer et de faciliter la modification des paramètres sans avoir à modifier le code source des scripts. Par exemple, vous pouvez créer un fichier config.py qui contient les variables API_KEY , BUDGET_MAXIMAL et URL_BASE , puis importer ce module dans vos scripts en utilisant l'instruction import config . Le 15 juin 2024, une librairie de modules de configuration open source sera mise à disposition sur le site de la communauté Python, offrant ainsi une solution standardisée et plus facile à utiliser pour la gestion de la configuration des applications Python.
- Frameworks de Configuration (ex : Pydantic) :
Utiliser des frameworks de configuration dédiés, tels que Pydantic, pour faciliter la gestion et la validation de la configuration de votre application. Pydantic, par exemple, permet de définir des modèles de données pour la configuration et de valider automatiquement les données au moment du chargement, en s'assurant qu'elles respectent les types et les contraintes définis. Cela permet de détecter les erreurs de configuration plus tôt dans le processus de développement et d'éviter ainsi des problèmes potentiels lors de l'exécution du script. Pour une application marketing de grande envergure, il est fortement recommandé d'utiliser Pydantic ou un framework similaire, afin de minimiser le risque d'erreurs de configuration et d'améliorer la robustesse globale de l'application.
- Variables d'Environnement :
Utilisez systématiquement les variables d'environnement pour stocker des informations sensibles ou spécifiques à l'environnement de déploiement de votre application, telles que les clés API, les mots de passe de base de données ou les URL de services externes. Les variables d'environnement sont stockées en dehors du code source et peuvent être configurées différemment en fonction de l'environnement (développement, test, production). Cela permet de protéger les informations sensibles contre les accès non autorisés et de faciliter le déploiement de l'application dans différents environnements sans avoir à modifier le code source. En 2020, un nombre alarmant d'entreprises ont été victimes de piratages informatiques en raison du stockage non sécurisé de clés API directement dans leurs scripts. Aujourd'hui, l'utilisation de variables d'environnement est considérée comme une bonne pratique de sécurité essentielle pour limiter les risques d'accès non autorisé et de compromission des données sensibles.
Exemple complexe intégré (étude de cas)
Pour illustrer de manière concrète l'application des concepts que nous avons abordés, prenons un exemple d'un script qui gère une campagne publicitaire à la fois sur Facebook Ads et sur Google Ads. Nous utiliserons judicieusement les variables globales pour stocker la configuration des API (clés, secrets), mais nous utiliserons des classes distinctes pour gérer la logique spécifique à chaque plateforme publicitaire, afin de maintenir une séparation claire des préoccupations et de faciliter la maintenance du code.
import os # Configuration globale (provenant des variables d'environnement) FACEBOOK_API_KEY = os.environ.get("FACEBOOK_API_KEY") GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY") class FacebookAdsManager: def __init__(self, api_key): self.api_key = api_key def lancer_campagne(self, nom_campagne, budget): print(f"Lancement de la campagne Facebook '{nom_campagne}' avec un budget de {budget} euros et la clé API : {self.api_key}") class GoogleAdsManager: def __init__(self, api_key): self.api_key = api_key def lancer_campagne(self, nom_campagne, budget): print(f"Lancement de la campagne Google '{nom_campagne}' avec un budget de {budget} euros et la clé API : {self.api_key}") # Initialisation des gestionnaires de campagne facebook_manager = FacebookAdsManager(FACEBOOK_API_KEY) google_manager = GoogleAdsManager(GOOGLE_API_KEY) # Lancement des campagnes facebook_manager.lancer_campagne("Campagne Printemps Facebook", 500) google_manager.lancer_campagne("Campagne Printemps Google", 750) Dans cet exemple, les clés API sont stockées de manière sécurisée dans des variables d'environnement et sont utilisées pour initialiser les instances des classes FacebookAdsManager et GoogleAdsManager . Cela permet de centraliser la configuration et de protéger les informations sensibles contre les accès non autorisés. Chaque classe gère la logique spécifique à sa plateforme publicitaire, ce qui rend le code plus modulaire, plus facile à comprendre et plus facile à maintenir. Si la complexité du script augmentait, on pourrait envisager d'utiliser un framework de configuration plus sophistiqué (comme Pydantic) pour gérer les configurations spécifiques à chaque plateforme de manière plus structurée et plus robuste.