1. A propos de Googletrans
Googletrans est une bibliothèque Python gratuite et illimitée qui implémente l'API Google Translate. Elle permet de traduire du texte entre différentes langues, de détecter automatiquement la langue d'un texte, et d'obtenir des informations sur les langues supportées. C'est un outil puissant pour l'internationalisation d'applications ou l'analyse de textes multilingues.
Les principales fonctionnalités incluent :
- Traduction de texte
- Détection automatique de langue
- Liste des langues supportées
- Traductions multiples en une seule requête
2. Installation et Configuration Initiale
2.1 Installation du Module
Pour commencer, vous devez installer le module googletrans via pip. La version recommandée est googletrans==4.0.0-rc1 qui est plus stable avec l'API actuelle de Google Translate.
|
1 2 3 |
# Installation de googletrans # Exécutez cette commande dans votre terminal ou invite de commandes pip install googletrans==4.0.0-rc1 |
Sortie attendue : Le système télécharge et installe le package avec ses dépendances (requests, httpx, etc.).
2.2 Importation et Création de l'Instance
Après l'installation, importez le module et créez une instance du traducteur. L'instance Translator est votre point d'entrée principal pour toutes les opérations de traduction.
|
1 2 3 4 5 6 7 8 |
from googletrans import Translator # Création d'une instance du traducteur translator = Translator() # Vérification de la création de l'instance print(type(translator)) print("Traducteur prêt à l'emploi !") |
Sortie :
|
1 2 |
<class 'googletrans.client.Translator'> Traducteur prêt à l'emploi ! |
Exemple simple
Nous allons nous amuser à traduire une petit texte anglais "Hello, how are you?" en français. A cet effet, il suffit faire une instanciation sur la classe Translator et préciser la source (langue d'origine : anglais) et la destination FR:
|
1 2 3 4 5 6 7 |
from googletrans import Translator translator = Translator() # Traduction simple de l'anglais vers le français result = translator.translate("Hello, how are you?", src='en', dest='fr') print(result.text) # output : Bonjour comment allez-vous? |
3. Fonctions de Base de Traduction
3.1 Traduction Simple
La méthode translate() est la fonction principale. Elle prend le texte à traduire, la langue source (auto-détection si non spécifiée) et la langue cible (anglais par défaut).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
from googletrans import Translator translator = Translator() # Traduction simple de l'anglais vers le français result = translator.translate("Hello, how are you?", src='en', dest='fr') """ Remarque importante! On peut utiliser directement le code suivant sans préciser la source, puisque Googletrans la détecte automatiquement : result = translator.translate("Hello, how are you?", dest='fr') """ print(f"Texte original: {result.origin}") print(f"Texte traduit: {result.text}") print(f"Langue source détectée: {result.src}") print(f"Langue cible: {result.dest}") |
Sortie :
|
1 2 3 4 |
Texte original: Hello, how are you? Texte traduit: Bonjour comment allez-vous? Langue source détectée: en Langue cible: fr |
3.2 Spécification des Langues Source et Cible
Vous pouvez préciser à la fois la langue source (si vous la connaissez) et la langue cible. Utilisez les codes de langue ISO 639-1 (comme 'en' pour anglais, 'es' pour espagnol, 'de' pour allemand).
|
1 2 3 4 5 6 7 8 9 10 11 |
# Traduction avec spécification de la langue source et cible text_espagnol = "Buenos días, ¿qué tal estás?" result = translator.translate(text_espagnol, src='es', dest='en') print(f"Texte original (es): {result.origin}") print(f"Texte traduit (en): {result.text}") print(f"Langue source: {result.src} → Langue cible: {result.dest}") # Traduction vers l'allemand result_de = translator.translate("Good morning", src='en', dest='de') print(f"\nAnglais vers Allemand: {result_de.text}") |
Sortie :
|
1 2 3 4 5 |
Texte original (es): Buenos días, ¿qué tal estás? Texte traduit (en): Good morning, how are you? Langue source: es → Langue cible: en Anglais vers Allemand: Guten Morgen |
4. Détection de Langue et Traductions Multiples
4.1 Détection Automatique de Langue
La méthode detect() identifie automatiquement la langue d'un texte. Elle retourne la langue détectée et un score de confiance.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
# Détection de langue texts = [ "Bonjour tout le monde", "Hello world", "Hallo Welt", "Ciao mondo" ] for text in texts: detection = translator.detect(text) print(f"Texte: '{text}'") print(f" Langue: {detection.lang} | Confiance: {detection.confidence:.2%}") print("-" * 40) |
Sortie :
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Texte: 'Bonjour tout le monde' Langue: fr | Confiance: 100.00% ---------------------------------------- Texte: 'Hello world' Langue: en | Confiance: 100.00% ---------------------------------------- Texte: 'Hallo Welt' Langue: de | Confiance: 100.00% ---------------------------------------- Texte: 'Ciao mondo' Langue: it | Confiance: 100.00% ---------------------------------------- |
4.2 Traduction de Listes de Textes
Vous pouvez traduire plusieurs textes en une seule requête en passant une liste à la méthode translate(). Cela est plus efficace que des appels individuels.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# Traduction de multiples textes texts_to_translate = [ "Good morning", "Thank you very much", "Where is the station?", "I love programming" ] # Traduction vers le français results = translator.translate(texts_to_translate, dest='fr') print("Traductions multiples vers le français:") print("=" * 50) for i, result in enumerate(results, 1): print(f"{i}. Original: {result.origin}") print(f" Traduit: {result.text}") print() |
Sortie :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Traductions multiples vers le français: ================================================== 1. Original: Good morning Traduit: Bonjour 2. Original: Thank you very much Traduit: Merci beaucoup 3. Original: Where is the station? Traduit: Où est la station? 4. Original: I love programming Traduit: J'adore la programmation |
5. Langues Supportées et Informations
Googletrans fournit un dictionnaire des langues supportées via LANGUAGES et LANGCODES. Ces attributs vous permettent de connaître les codes et noms complets des langues disponibles.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
from googletrans import LANGUAGES # Afficher toutes les langues supportées print(f"Nombre total de langues supportées: {len(LANGUAGES)}\n") print("Quelques langues courantes:") print("-" * 40) for code, name in list(LANGUAGES.items())[:15]: # Afficher les 15 premières print(f"{code}: {name}") print("\n" + "=" * 40 + "\n") # Recherche d'une langue spécifique langue_cherchee = 'french' print(f"Recherche du code pour '{langue_cherchee}':") # Inverser le dictionnaire pour trouver par nom from googletrans import LANGCODES if langue_cherchee in LANGCODES: print(f"Code ISO: {LANGCODES[langue_cherchee]}") |
Sortie :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
Nombre total de langues supportées: 107 Quelques langues courantes: ---------------------------------------- af: afrikaans sq: albanian am: amharic ar: arabic hy: armenian az: azerbaijani eu: basque be: belarusian bn: bengali bs: bosnian bg: bulgarian ca: catalan ceb: cebuano ny: chichewa zh-cn: chinese (simplified) ======================================== Recherche du code pour 'french': Code ISO: fr |
6. Exemples Pratiques et Cas d'Utilisation
6.1 Traducteur de Phrases avec Détection Automatique
Cet exemple combine plusieurs fonctionnalités pour créer un traducteur intelligent qui détecte la langue source et traduit vers une langue cible choisie.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
def traducteur_intelligent(texte, langue_cible='fr'): """ Fonction qui détecte et traduit un texte vers la langue cible """ # Détection de la langue source detection = translator.detect(texte) langue_source_nom = LANGUAGES.get(detection.lang, 'inconnue') # Traduction resultat = translator.translate(texte, dest=langue_cible) langue_cible_nom = LANGUAGES.get(langue_cible, 'inconnue') # Affichage des résultats print("=== RÉSULTAT DE LA TRADUCTION ===") print(f"Texte original: {texte}") print(f"Langue source détectée: {langue_source_nom} ({detection.lang})") print(f"Confiance de détection: {detection.confidence:.1%}") print(f"Traduction ({langue_cible_nom}): {resultat.text}") print("=" * 50) return resultat.text # Test de la fonction traducteur_intelligent("The weather is beautiful today", 'es') traducteur_intelligent("Das Leben ist schön", 'en') traducteur_intelligent("La vie est belle", 'it') |
Sortie :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
=== RÉSULTAT DE LA TRADUCTION === Texte original: The weather is beautiful today Langue source détectée: english (en) Confiance de détection: 100.0% Traduction (spanish): El clima es hermoso hoy ================================================== === RÉSULTAT DE LA TRADUCTION === Texte original: Das Leben ist schön Langue source détectée: german (de) Confiance de détection: 100.0% Traduction (english): Life is beautiful ================================================== === RÉSULTAT DE LA TRADUCTION === Texte original: La vie est belle Langue source détectée: french (fr) Confiance de détection: 100.0% Traduction (italian): La vita è bella ================================================== |
6.2 Traduction de Fichier Texte
Exemple pratique : lire un fichier texte, le traduire et sauvegarder le résultat. Cette approche est utile pour l'internationalisation de contenu.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
def traduire_fichier(nom_fichier_entree, nom_fichier_sortie, langue_cible='fr'): """ Traduit le contenu d'un fichier texte et sauvegarde le résultat """ try: # Lecture du fichier d'entrée with open(nom_fichier_entree, 'r', encoding='utf-8') as fichier: contenu = fichier.read() if not contenu.strip(): print("Le fichier est vide.") return # Traduction du contenu resultat = translator.translate(contenu, dest=langue_cible) # Écriture du fichier de sortie with open(nom_fichier_sortie, 'w', encoding='utf-8') as fichier: fichier.write(resultat.text) print(f"Traduction terminée!") print(f"Fichier d'entrée: {nom_fichier_entree}") print(f"Fichier de sortie: {nom_fichier_sortie}") print(f"Langue cible: {LANGUAGES.get(langue_cible, 'inconnue')}") # Aperçu de la traduction (premières 200 caractères) apercu = resultat.text[:200] + "..." if len(resultat.text) > 200 else resultat.text print(f"\nAperçu de la traduction:\n{apercu}") except FileNotFoundError: print(f"Erreur: Le fichier '{nom_fichier_entree}' n'a pas été trouvé.") except Exception as e: print(f"Une erreur s'est produite: {e}") # Exemple d'utilisation (commenté car nécessite un fichier existant) """ # Création d'un fichier d'exemple with open('exemple_texte.txt', 'w', encoding='utf-8') as f: f.write("Hello, this is a sample text for translation.\n") f.write("Python programming is very interesting.\n") f.write("Machine learning and artificial intelligence are changing the world.") # Traduction du fichier traduire_fichier('exemple_texte.txt', 'exemple_traduit_fr.txt', 'fr') """ print("Code exemple pour la traduction de fichiers. Décommentez pour l'exécuter.") |
Sortie (si exécuté) :
|
1 |
Code exemple pour la traduction de fichiers. Décommentez pour l'exécuter. |
Conclusion
Le module Googletrans est un outil extrêmement utile pour intégrer des capacités de traduction dans vos applications Python. Grâce à sa simplicité d'utilisation et à sa puissance, il permet de gérer des traductions entre plus de 100 langues avec une détection automatique fiable. Que ce soit pour internationaliser une application, analyser du contenu multilingue ou simplement apprendre des langues, Googletrans offre une solution robuste et gratuite.
Younes Derfoufi CRMEF OUJDA
