eval() et exec() en Python : usages et précautions

Les fonctions eval() et exec() représentent des outils majeurs dans la programmation Python pour l’exécution dynamique de code. Elles permettent d’interpréter des chaînes de caractères comme du code Python, ouvrant la porte à une flexibilité exceptionnelle. Cependant, cette puissance s’accompagne de risques importants liés à la sécurité, notamment en cas d’injection de code. Comprendre leur fonctionnement, leurs différences essentielles et surtout les précautions indispensables est crucial pour tout développeur soucieux d’intégrer ces fonctions dans des projets fiables et performants en 2026.

L’usage de eval() se concentre sur l’évaluation d’expressions arbitraires pour récupérer une valeur, tandis que exec() sert à exécuter des blocs plus complexes comme des fonctions, des boucles ou des affectations, sans renvoyer de résultat direct. Leur utilisation requiert une maitrise approfondie de la validation d’entrée et des techniques de sandboxing pour éviter l’exécution de code malveillant. L’optimisation des performances dans des contextes où le code dynamique est réutilisé passe souvent par la fonction compile(), qui précompile les scripts en objets bytecode invocables.

À travers des exemples pratiques, des retours d’expérience concrets et des stratégies robustes pour limiter les risques, ce guide détaille tout ce qu’il faut savoir pour manipuler eval() et exec() en Python de manière sécurisée et efficace, en intégrant pleinement les enjeux actuels et futurs liés à la programmation dynamique.

En bref :

• eval() évalue une expression Python et renvoie sa valeur, tandis que exec() exécute un bloc de code sans retourner de résultat.
• La sécurité est primordiale : validez toujours l’entrée, privilégiez ast.literal_eval pour des données simples et limitez les namespaces pour éviter les risques d’injection de code.
• compile() optimise la performance lorsqu’un même code doit être exécuté plusieurs fois en transformant le texte en objet code.
• Les cas d’usage incluent l’évaluation de formules mathématiques, l’exécution dynamique de scripts de configuration, et la méta-programmation.
• Évitez l’exécution de code généré d’entrées non sûres, isolez l’exécution pour prévenir les effets néfastes liés au code malveillant.

Différences fondamentales entre eval() et exec() en Python

L’une des questions fréquentes chez les développeurs concerne la distinction claire entre ces deux fonctions. La fonction eval() attend une chaîne correspondant à une seule expression Python, qu’elle évalue pour restituer une valeur. Par exemple, eval('3 * 7') retourne l’entier 21. En revanche, exec() interprète un ou plusieurs blocs de code plus complexes : boucles, définitions de fonctions, assignations, sans renvoyer de valeur (retourne toujours None).

Cette différence structurelle détermine leur usage. Pour récupérer un résultat issu d’une expression, eval() est adapté. Pour produire des effets de bord, modifier l’environnement d’exécution, ou générer du code dynamique multi-instructions, exec() est incontournable.

Un comportement important à noter : si une chaîne passée à eval() contient des instructions non expressions (comme une affectation), une exception de type SyntaxError sera levée. À l’inverse, exec() ne renvoie rien mais effectue bien ces opérations.

Retour attendu et structure du code interprété

eval() renvoie toujours la valeur de l’expression évaluée, ce qui en fait un outil idéal pour intégrer des calculs ou interpréter des mini-expressions en temps réel. exec(), quant à elle, s’utilise pour exécuter toute structure de code et ne retourne pas de résultat. C’est cette absence de valeur retournée qui marque une différence clé en matière de conception de programmes nécessitant du code dynamique.

Leur utilité se complète avec la fonction compile(), qui prend une chaîne source et la transforme en un objet code exécutable, utilisable plusieurs fois. Cette méthode optimise la performance lorsque le même code est évalué ou exécuté fréquemment.

Cas pratiques et illustrations d’usage de eval() et exec()

Dans un projet de simulation, il a été nécessaire de permettre à l’utilisateur d’entrer des formules mathématiques dynamiques. eval() a été choisi pour interpréter ces expressions et retourner une valeur calculée. Pour limiter les risques, les entrées ont été rigoureusement filtrées pour exclure toute syntaxe dangereuse.

De façon complémentaire, exec() s’est avéré précieux pour charger des scripts de configuration lors de la phase de démarrage d’un outil interne. Ces scripts contenaient des définitions de fonctions et des paramètres modifiables à chaud. La gestion soigneuse des namespaces a permis de limiter la portée et les risques d’une injection de code malveillant.

Un exemple concret simple :

result = eval('42 * a') où a est une variable prédéfinie, exécute une expression mathématique.

exec('for i in range(3): print(i)') réalise une itération affichant les nombres de 0 à 2, sans retourner de valeur.

Optimisation avec compile() pour améliorer la performance

Utiliser compile() est stratégique quand le même script est appelé plusieurs fois. Cette fonction compile la chaîne de caractères dans un objet bytecode, éliminant le besoin de recompiler le même code en permanence.

Exemple :

code_obj = compile('x + 1', '<string>', 'eval')

Ce bytecode peut ensuite être passé à eval() ou exec() selon le mode attendu.

Bien distinguer le mode ‘eval’ pour une expression simple et ‘exec’ pour un bloc complet évite les erreurs de syntaxe et optimise le comportement.

Comment maîtriser les risques de sécurité avec eval() et exec()

L’exécution dynamique de code via eval() ou exec() introduit d’importantes failles lorsqu’elle traite des entrées externes non filtrées. Un code malveillant peut alors accéder à des fichiers sensibles, lancer des attaques réseau, ou détruire des données. Les vecteurs d’attaques liés à l’injection de code restent parmi les menaces les plus critiques en 2026.

Plusieurs pratiques doivent être strictement respectées :

• Validez toujours les entrées : privilégiez un contrôle strict par liste blanche (whitelist) ou expressions régulières ciblées.
• Privilégiez ast.literal_eval pour évaluer uniquement des littéraux Python sûrs (nombres, listes, dictionnaires) et évitez ainsi toute exécution de code arbitraire.
• Limitez l’environnement d’exécution en restreignant les namespaces passés à eval ou exec, par exemple en supprimant les __builtins__.
• Isoler l’exécution dans un processus séparé ou un conteneur sandbox peut prévenir les dommages dus à une exploitation.
• Enregistrez les logs et mettez en place des tests d’injection réguliers pour détecter les vulnérabilités.

Ces mesures combinées forment une barrière efficace contre les attaques complexes visant à profiter de la programmation dynamique.

Alternatives sécurisées pour parser des expressions en Python

Dans de nombreux cas, il est préférable d’éviter eval() ou exec() au profit d’autres techniques : parsing de mini-langages dédiés (DSL), utilisation de bibliothèques spécialisées ou stockage des règles métier dans des structures de données interprétables par du code validé.

L’usage d’ast.literal_eval a largement montré son efficacité pour traiter les expressions de type littéral sans ouvrir la porte à du code malveillant. Dans des contextes complexes, mettre en place des moteurs dédiés permet également de réduire considérablement les risques, tout en conservant la souplesse nécessaire.

L’expérience montre que la prudence, combinée à une architecture pensée pour limiter l’impact, prévient des incidents graves difficilement rattrapables en production.

Quelle est la différence principale entre eval() et exec() ?

Eval évalue une expression et renvoie une valeur tandis qu’Exec exécute un bloc entier de code sans retourner de résultat. Eval sert pour récupérer un calcul, exec pour produire des effets dans l’environnement d’exécution.

Comment réduire les risques d’injection de code lors de l’usage d’eval ou exec ?

Il faut valider strictement l’entrée, limiter les namespaces passés lors de l’exécution, préférer ast.literal_eval pour les expressions simples, et isoler les exécutions dans des conteneurs sécurisés.

Quand faut-il utiliser compile() avec eval()/exec() ?

Compile() est recommandé quand un bloc de code doit être évalué ou exécuté plusieurs fois, afin de précompiler l’expression en bytecode et améliorer la performance de l’application.

Existe-t-il des alternatives sécurisées à eval pour évaluer des expressions ?

Oui, ast.literal_eval permet d’évaluer uniquement des littéraux Python en toute sécurité. Pour des expressions plus complexes, il est conseillé de parser avec des mini-DSL ou d’utiliser des bibliothèques spécialisées.

Pourquoi éviter d’exécuter du code issu d’une entrée utilisateur non validée ?

Le code peut contenir des instructions malveillantes pouvant compromettre la sécurité des données, provoquer des pertes ou ouvrir des failles exploitables. La validation et l’isolation sont essentielles pour se prémunir de ces risques.