Convertisseur snake_case : Générateur de noms de variables Python

Transformez instantanément n'importe quel texte au format snake_case. Que vous écriviez du code Python, nommiez des champs de base de données ou veilliez à la cohérence de vos conventions de nommage, notre outil convertit automatiquement votre texte au format snake_case tout en respectant les meilleures pratiques de programmation.

Évaluez-nous
0.00sur5(0 évaluations)
Caractéristiques et avantages

Convertit n'importe quel texte au format snake_case valide en temps réel : collez un en-tête de colonne, une phrase ou un identifiant au format mixte pour obtenir un résultat en minuscules séparées par des underscores, prêt à être intégré directement dans votre code.

Détecte les limites de mots à partir des espaces, des traits d'union, des majuscules internes (camelCase) et des traits de soulignement existants, permettant ainsi aux données provenant de sources multiples de produire un résultat cohérent sans nettoyage préalable.

Supprime ou remplace les caractères qui rendraient les identifiants Python invalides — parenthèses, barres obliques, esperluettes — afin que chaque résultat soit immédiatement utilisable, sans nécessiter de traitement ultérieur par expression régulière.

Gère les acronymes en les passant entièrement en minuscules (HTTP → http, API → api), conformément à la PEP 8, qui recommande de traiter les acronymes comme des mots ordinaires pour en faciliter la lecture.

Produit une sortie compatible avec Python, Ruby, PHP, SQL et tout environnement traitant les traits de soulignement comme le séparateur de mots standard dans les identifiants.

S'exécute entièrement dans le navigateur : aucun aller-retour serveur ni limite de débit ; idéal pour coller en une seule fois une liste complète de noms de colonnes de base de données.

Mode d'emploi

Étape 01

Saisissez votre texte ou le nom de la variable

Étape 02

Prévisualisez votre résultat en snake_case

Étape 03

Copier le texte prêt pour le code

Cas d'utilisation

Développement en Python

  • Noms de variables
  • Noms de fonctions
  • Noms de fichiers
  • Noms de modules

Développement de bases de données

  • Noms de table
  • Noms de colonnes
  • Identifiants de champ
  • Paramètres de requête

Fichiers de configuration

  • Variables d'environnement
  • Clés de configuration
  • Noms des paramètres
  • Chemins de fichiers
Exemples
Texte originalRésultat
User Name
user_name
first Name
first_name
background-color
background_color
API Response Data
api_response_data
Compatibilité des plateformes

Langages de programmation

  • Python
  • Ruby
  • PHP
  • SQL

Cadres

  • Django
  • Fiole
  • Rails
  • PostgreSQL
Conseils de pro

Lorsque vous rédigez des modèles Django ou des schémas SQLAlchemy, convertissez au préalable vos descriptions de champs (lisibles par l'humain) au format `snake_case` avant de les utiliser comme noms de colonnes ; les migrations de base de données sont bien plus faciles à examiner lorsque les identifiants sont cohérents dès le départ.

PostgreSQL et MySQL traitent tous deux les identifiants non délimités sans distinction de casse et les convertissent en minuscules en interne ; le style *snake_case* est le seul qui reste identique, que la base de données effectue ou non cette conversion, ce qui rend votre code SQL plus portable.

Pour les fichiers de configuration et les variables d'environnement en Python, l'utilisation de clés en `snake_case` (converties en `SCREAMING_SNAKE_CASE` pour les variables d'environnement) constitue la convention, tant dans la bibliothèque standard (`os.environ`) que dans des bibliothèques telles que Pydantic et Dynaconf ; passez votre liste de clés de configuration dans cet outil avant de rédiger votre module de paramètres.

Lorsque vous générez automatiquement des champs de dataclass ou de TypedDict Python à partir d'une charge utile JSON à la casse incohérente, commencez par coller toutes les clés ici : la normalisation au format snake_case rend le corps de la classe résultante bien plus facile à lire et à comparer (diff).

Ruby on Rails adopte la même convention *snake_case* que Python pour les attributs de modèle, les routes et les méthodes d'assistance ; cet outil s'avère tout aussi utile lorsqu'on passe d'un écosystème à l'autre au sein d'un même projet.

Meilleures pratiques

Veillez à ce que les noms en *snake_case* soient suffisamment explicites pour se suffire à eux-mêmes : « user_shipping_address » est verbeux mais sans ambiguïté, tandis que « u_s_addr » n'offre aucun gain réel tout en nuisant à la compréhension de tout lecteur futur.

Suivez les recommandations de la PEP 8 selon lesquelles les noms de fonctions et de variables doivent être en minuscules avec des traits de soulignement, tandis que les constantes au niveau du module doivent utiliser le format SCREAMING_SNAKE_CASE ; considérez ces conventions comme distinctes et non interchangeables.

Évitez les traits de soulignement en début ou en fin de nom, sauf si vous souhaitez utiliser la sémantique propre à Python : un seul trait de soulignement au début indique un membre privé, tandis qu'un double trait de soulignement au début déclenche une altération de nom (*name mangling*) dans les classes.

En SQL, veillez à la cohérence de l'ensemble de votre schéma : mélanger des tables en `snake_case` et des colonnes en `camelCase` est l'une des pratiques les plus déroutantes pour les développeurs qui rejoignent un projet, et cela génère des difficultés lors de la configuration des mappings ORM.

Lors de la conversion de données importées (exports CSV, charges utiles d'API tierces) au format snake_case pour un usage interne, effectuez cette conversion au point d'entrée dans une fonction unique, plutôt que de la disperser entre plusieurs gestionnaires.

FAQ

Foire aux questions

Trouvez des réponses aux questions fréquentes sur nos outils et services.

Guide approfondi

Comprendre snake_case

Le terme « snake_case » tire son nom de la ressemblance visuelle entre les traits de soulignement et un serpent allongé à plat : les mots sont reliés au niveau du sol plutôt que par des bosses ou des tirets. Cette convention est bien antérieure à Python, puisqu'elle est apparue dès les années 1970 dans les fonctions de la bibliothèque standard du langage C (comme `printf`, `malloc` ou `fopen`) ainsi que dans les noms d'outils Unix. La PEP 8 de Python, publiée en 2001, en a fait le style obligatoire pour les noms de fonctions, de variables et de modules ; c'est pourquoi cette convention est aujourd'hui associée à Python dans l'esprit de la plupart des développeurs, bien qu'elle soit tout aussi répandue en Ruby, en PHP, en SQL et dans les scripts shell.

L'usage le plus courant de ce convertisseur en conditions réelles est la correspondance entre les bases de données et le code. Lorsqu'un analyste de données exporte un fichier CSV depuis un outil de Business Intelligence, les en-têtes de colonnes se présentent sous forme de libellés lisibles par l'humain, tels que « Customer First Name », « Order Shipping Date » ou « Total Revenue (USD) ». Convertir manuellement ces libellés en identifiants Python ou SQL valides — en passant en minuscules, en remplaçant les espaces par des underscores et en supprimant les parenthèses — est une tâche répétitive et source d'erreurs lorsqu'elle est effectuée à grande échelle. Il vous suffit de coller la ligne d'en-tête ici, d'effectuer la conversion en une seule étape et d'utiliser le résultat directement dans le dictionnaire de renommage de votre DataFrame Pandas ou dans les définitions de colonnes SQLAlchemy.

Un deuxième cas d'usage courant consiste à rédiger des modèles Django ou Flask à partir d'un document de spécifications. Les exigences produit décrivent souvent les champs en langage courant ; les développeurs doivent les convertir en identifiants au format *snake_case* avant d'écrire la classe du modèle. Passer la liste des champs dans ce convertisseur dès le début permet d'éviter les incohérences de nommage (certains champs convertis manuellement, d'autres non) qui s'accumulent au fil du projet et dont la correction devient coûteuse une fois que des migrations ont été créées.

L'alternative manuelle consiste à utiliser une substitution par expression régulière : par exemple `re.sub(r'(?<!^)(?=[A-Z])', '_', name).lower()` pour une entrée en camelCase, ou `name.replace(' ', '_').lower()` pour une entrée avec des espaces. Ces solutions en une ligne fonctionnent pour des entrées propres, mais échouent silencieusement dans des cas particuliers : majuscules consécutives (HTMLParser devient h_t_m_l_parser), espaces en début ou en fin de chaîne, ou mélange de séparateurs. Cet outil gère tous ces cas de figure sans vous obliger à mémoriser l'expression régulière.

Le format `snake_case` est le choix approprié en Python (pour tous les identifiants non constants), en Ruby (méthodes, variables locales, symboles), en SQL (tables et colonnes dans tous les principaux systèmes de gestion de bases de données), dans les scripts shell (noms de variables et de fonctions) et en Rust (variables et fonctions — le compilateur émettra un avertissement en cas d'utilisation du `camelCase`). En revanche, son utilisation est explicitement déconseillée en JavaScript/TypeScript, Java et C# pour les identifiants non constants, ainsi qu'en CSS pour tout type d'identifiant. Lorsque vous travaillez avec plusieurs langages au sein d'un même projet, adopter la convention adaptée à chaque contexte est l'une de ces petites habitudes qui garantissent la lisibilité du code source.

Des outils pour tous les besoins