Passer de Python à Go : ce que les développeurs Python doivent savoir

Vous pouvez parcourir toute la syntaxe de Go en un après-midi, et si vous écrivez déjà du Python, l'essentiel vous semblera familier. Cette familiarité est trompeuse. Les nouveaux mots-clés s'apprennent facilement. Le plus difficile, quand on passe à Go, c'est d'abandonner une poignée d'habitudes Python que Go ne permet pas. Go n'a pas d'exceptions à attraper, pas de classes dont hériter, pas de list comprehensions et pas d'interpréteur interactif. À la place, vous avez des valeurs d'erreur explicites, des structs avec des interfaces, des goroutines et un compilateur qui se plaint avant même que votre code ne s'exécute. Cet article couvre les changements qui décident si votre premier mois avec Go ressemblera à un soulagement ou à un combat.

En bref

• Les développeurs Go en sont satisfaits. 91 % des répondants se sont déclarés satisfaits de Go et environ deux tiers « très satisfaits », le meilleur résultat de l'enquête officielle de Google (Go Developer Survey 2025).
• Vous utilisez déjà l'idée derrière le plus gros changement de Go. 88 % des développeurs Python déclarent utiliser « toujours » ou « souvent » les annotations de type (type hints). Le typage statique est donc une habitude que vous avez déjà prise (Typed Python 2024 Survey, Meta).
• Les équipes qui ont migré ont obtenu de vrais gains. Quand Khan Academy a réécrit son backend Python en Go, une page qui mettait environ 28 secondes à s'afficher est descendue à 4 secondes environ (Khan Academy Engineering). En passant à un service de commentaires en Go, Reddit a divisé par deux sa latence d'écriture p99 (InfoQ).
• Python reste plus répandu, et c'est très bien ainsi. Python est utilisé par 54,8 % des développeurs professionnels, contre 17,4 % pour Go, et il domine le travail sur les données et l'IA (Stack Overflow 2025). Go se positionne sur un terrain plus étroit : les backends sensibles à la latence, les API et les CLI.

Table des matières

• Les développeurs Python devraient-ils apprendre Go ?
• Pourquoi les équipes passent de Python à Go
• Typage statique : vous avez déjà fait la moitié du chemin
• Les erreurs sont des valeurs, pas des exceptions
• Concurrence : les goroutines face au GIL
• Les structs et les interfaces remplacent les classes et l'héritage
• Moins de magie, plus de code explicite
• Aide-mémoire Python vers Go
• Outillage : un binaire, un formateur, des tests intégrés
• Ce qui vous manquera de Python
• Comment passer de Python à Go
• Questions fréquentes
• Commencez à écrire du Go dès aujourd'hui

Les développeurs Python devraient-ils apprendre Go ?

Oui, surtout si votre travail s'oriente vers les services backend, les API, l'infrastructure ou les outils en ligne de commande. Les développeurs Go affichent la plus forte satisfaction parmi tous les langages majeurs, avec 91 % de satisfaits et près de deux tiers de « très satisfaits » dans l'enquête officielle de Google (Go Developer Survey 2025). Cette satisfaction vient davantage du caractère prévisible de Go que de son ingéniosité. Et la prévisibilité, c'est justement ce que la plupart des développeurs Python commencent à rechercher dès qu'une base de code dépasse quelques milliers de lignes.

La transition est rapide parce qu'une grande partie de vos acquis se transpose. Vous raisonnez déjà en fonctions, en slices et en maps. Vous découpez déjà votre travail en packages et vous écrivez déjà des tests. Votre façon d'aborder les problèmes ne change pas. Ce qui change, c'est la rigueur avec laquelle le langage vous tient à vos décisions. Go renonce à une partie de la souplesse de Python en échange de garanties, et l'essentiel de cet article porte sur les endroits où cela se manifeste.

Pourquoi les équipes passent de Python à Go

Les équipes migrent généralement pour la même raison : un service Python rapide à écrire est devenu trop lent ou trop coûteux à faire tourner. Quand Khan Academy a réécrit son serveur en Go, la liste d'une classe de 1 000 élèves, qui mettait environ 28 secondes à charger en Python, s'affichait en 4 secondes environ, soit une amélioration de près de 7 fois. Les avertissements de contention sur le datastore sont passés d'environ 100 par heure à presque aucun (Khan Academy Engineering).

Reddit a constaté quelque chose de similaire. Après avoir migré le backend de ses arbres de commentaires vers un microservice Go en 2025, la latence d'écriture p99 était moitié moindre que celle de l'ancien système Python, qui connaissait parfois des pics jusqu'à 15 secondes (InfoQ).

Lovable, le générateur d'applications par IA, en est l'exemple récent le plus frappant. L'entreprise a réécrit l'intégralité de son backend de Python vers Go, soit 42 000 lignes de code. Le nombre d'instances serveur est passé de 200 à 10, les temps de déploiement de 15 minutes à 3, et les temps de requête moyens ont gagné 12 % (Lovable Engineering). C'est la concurrence qui a motivé la réécriture. Une seule requête de chat sur Lovable peut se démultiplier en plus de 50 appels HTTP. Go gère nativement ce genre de charge parallèle, alors que le GIL de Python la rend laborieuse.

Dans chaque cas, le runtime de Go, compilé, statiquement typé et doté d'un ramasse-miettes, abat plus de travail par serveur. Le même trafic coûte donc moins cher et se comporte de façon plus stable sous charge.

Typage statique : vous avez déjà fait la moitié du chemin

Le typage statique est ce que les développeurs Python redoutent le plus dans Go, et c'est aussi ce à quoi ils s'adaptent le plus vite, parce que la plupart l'ont déjà adopté. Dans une enquête de 2024, 88 % des développeurs Python déclaraient utiliser « toujours » ou « souvent » les annotations de type, mypy et Pydantic étant les outils les plus courants (Typed Python 2024 Survey, Meta). Si vous annotez les signatures de vos fonctions et lancez un vérificateur de types dans votre CI, vous avez déjà accepté le principe fondamental de Go. Go rend simplement la vérification obligatoire et la place dans le compilateur plutôt que dans un outil optionnel.

La différence pratique tient au moment où vous découvrez votre erreur. En Python, une incohérence de type apparaît à l'exécution, souvent en production, parfois des heures après le déploiement. En Go, la même erreur bloque le build. Vous ne pouvez pas passer une string là où un int est attendu, et vous ne pouvez pas laisser une variable inutilisée : un err que vous avez assigné sans jamais le vérifier ne compilera pas. Pour un débutant, cela ressemble à de l'acharnement. Si vous avez déjà débogué une erreur NoneType has no attribute à 2 h du matin, cela ressemble plutôt à un filet de sécurité.

Voici à quoi cela ressemble. La version Go ne compilera pas si Total a un jour le mauvais type, alors qu'une version Python se contenterait d'espérer que l'appelant a bien passé un nombre :

example.gogo
type Order struct {
	ID    string
	Total int // cents, never a float, never a string
}

func discount(o Order, pct int) int {
	return o.Total - (o.Total * pct / 100)
}

L'inférence de type évite que tout cela devienne verbeux. Avec :=, Go déduit le type à partir de la valeur, vous écrivez donc count := 0 au lieu de préciser int partout. Vous conservez la sécurité des déclarations et l'essentiel de la concision de Python.

Les erreurs sont des valeurs, pas des exceptions

C'est le plus gros ajustement, et il vous paraîtra étrange pendant une semaine environ. Go n'a pas de try, pas de except et pas d'exceptions au sens de Python. Les fonctions qui peuvent échouer renvoient une error comme dernière valeur, et vous la vérifiez à l'endroit même de l'appel. Rien n'est lancé vers le haut de la pile pour être attrapé quelque part loin de là. Vous traitez l'erreur, vous l'ignorez ou vous la transmettez, sur la ligne où elle s'est produite.

Vous taperez cet idiome des milliers de fois :

example.gogo
resp, err := http.Get(url)
if err != nil {
	return fmt.Errorf("fetch %s: %w", url, err)
}
defer resp.Body.Close()

Au début, les développeurs Python n'aiment souvent pas if err != nil. Trois lignes de gestion d'erreur après chaque appel, cela paraît bruyant à côté d'un seul try qui englobe tout un bloc. Mais cette répétition est voulue. Vous voyez chaque chemin d'échec de la fonction en la lisant de haut en bas, sans saut invisible vers un gestionnaire lointain. Le verbe %w enveloppe l'erreur d'origine pour que les appelants puissent encore l'inspecter : c'est la version Go d'une chaîne d'exceptions.

Cette habitude vous suivra aussi en Python. Une fois habitué à traiter l'échec au point d'appel, un bloc except Exception trop large commence à apparaître pour ce qu'il est : un moyen de perdre des informations sur ce qui s'est mal passé.

Concurrence : les goroutines face au GIL

C'est avec la concurrence que Go cesse d'être « du Python avec des types » pour devenir un outil différent. Le Global Interpreter Lock de CPython ne laisse qu'un seul thread exécuter du bytecode Python à la fois, si bien que les threads ne peuvent pas exécuter en parallèle du travail limité par le CPU. Des builds free-threaded, sans GIL, sont arrivés à titre expérimental avec Python 3.13 dans le cadre de la PEP 703, mais ils ne sont pas activés par défaut et l'écosystème est encore en train de s'adapter (Python docs). Pour l'instant, faire monter en charge du Python limité par le CPU implique généralement de lancer plusieurs processus et d'en payer le coût en mémoire et en coordination.

Go a été conçu autour de la concurrence dès le départ. Une goroutine est un appel de fonction précédé de go, et le runtime répartit des milliers de goroutines sur les cœurs de votre CPU sans aucun GIL pour le gêner. Les goroutines communiquent par des channels plutôt que par de la mémoire partagée. Lancer une centaine de requêtes concurrentes ne demande pas plus de code que ceci :

example.gogo
results := make(chan string)
for _, url := range urls {
	go func() {
		resp, err := http.Get(url)
		if err != nil {
			results <- "error: " + url
			return
		}
		defer resp.Body.Close()
		results <- url + " ok"
	}()
}
for range urls {
	fmt.Println(<-results)
}

Si vous avez déjà écrit du code asyncio, vous comprenez déjà l'objectif. Go l'atteint sans scinder votre code en deux moitiés « colorées », l'une async et l'autre synchrone. N'importe quelle fonction peut tourner dans une goroutine. Vous n'écrivez pas de await, vous ne démarrez pas de boucle d'événements et vous ne cherchez pas de versions async des bibliothèques. C'est en grande partie pour cela que les services Go tiennent bien la charge : le modèle de concurrence de Go est intégré au langage au lieu d'avoir été ajouté après coup.

Les structs et les interfaces remplacent les classes et l'héritage

Go n'a ni classes ni héritage, ce qui surprend plus que cela ne le devrait. Vous modélisez les données avec un struct et vous leur donnez un comportement en y attachant des méthodes. Rien ne transmet self implicitement, il n'y a pas de __init__ et pas de classe de base à étendre. Là où Python utiliserait une hiérarchie de classes, Go utilise la composition. Vous intégrez un struct dans un autre pour réutiliser ses champs et ses méthodes, au lieu d'hériter d'un parent.

C'est avec les interfaces que Go devient élégant, et elles ne fonctionnent pas comme vous pourriez vous y attendre. Un type satisfait une interface simplement en possédant les bonnes méthodes. Il n'y a pas de mot-clé implements ni d'étape d'enregistrement. Si votre struct possède une méthode Read([]byte) (int, error), c'est un io.Reader. C'est le duck typing que vous connaissez en Python, mais vérifié à la compilation :

example.gogo
type Notifier interface {
	Notify(msg string) error
}

type SlackClient struct{ webhook string }

func (s SlackClient) Notify(msg string) error {
	// any type with this method is a Notifier, automatically
	return post(s.webhook, msg)
}

Le changement de mentalité consiste à passer de « qu'est-ce que cet objet ? » à « que peut faire cet objet ? ». Vos interfaces seront plus petites que prévu, souvent une seule méthode, et vous les définirez à côté du code qui les utilise plutôt qu'à côté du type qui les satisfait. Il faut quelques jours pour que cette inversion devienne naturelle. Ensuite, elle fait souvent partie de ce qui vous manque le plus quand vous revenez à Python.

Moins de magie, plus de code explicite

Python récompense l'ingéniosité. Les décorateurs, les métaclasses, les méthodes dunder, le monkey-patching et l'accès dynamique aux attributs vous permettent de plier le langage à votre guise. Go laisse délibérément presque tout cela de côté. Il n'a pas de décorateurs, pas de métaclasses, pas de surcharge d'opérateurs et aucun moyen d'ajouter une méthode à un type qui ne vous appartient pas. Vous pouvez presque toujours savoir ce que fait une ligne sans connaître quelque chose qui se passe ailleurs.

Cela paraît contraignant le premier jour et libérateur au bout de deux mois. Lire une base de code Go inconnue revient essentiellement à lire, tout simplement, parce que rien de caché ne réécrit le comportement en coulisses. L'inconvénient, c'est que Go peut être plus verbeux. Il vous arrivera d'écrire une boucle là où Python vous offrirait une comprehension sur une ligne. La communauté Go considère que c'est un prix raisonnable. Les concepteurs du langage ont parié que le code est lu bien plus souvent qu'il n'est écrit, et ils l'ont donc optimisé pour le lecteur.

Aide-mémoire Python vers Go

La plupart des constructions Python du quotidien ont un équivalent direct en Go. Gardez ce tableau ouvert pendant votre première semaine. Les noms changent et la ponctuation devient plus stricte, mais les concepts se correspondent presque un pour un.

Les plus gros changements visuels sont les accolades et l'absence des deux-points. Comme Go est statiquement typé, le compilateur vous arrête dès qu'une traduction est incorrecte. Profitez-en. Laisser le build échouer et lire l'erreur est le moyen le plus rapide d'apprendre les correspondances.

Outillage : un binaire, un formateur, des tests intégrés

L'outillage de Go est l'une des raisons les plus sous-estimées pour lesquelles les développeurs restent. Pas de dérive du requirements.txt, pas d'environnement virtuel à activer, et pas de formateur, de linter et de lanceur de tests distincts à assembler. La commande go couvre tout cela et s'installe en une seule fois. La compilation produit un binaire statique unique, sans interpréteur ni dépendances à livrer avec lui, si bien que le déploiement se résume souvent à copier un fichier sur le serveur.

Ce que vous remarquerez en premier :

• go build produit un seul binaire. La machine cible n'a pas besoin de Python, vous n'embarquez pas d'interpréteur, et les problèmes de dépendances ne surgissent pas au moment du déploiement.
• gofmt met fin aux débats sur le formatage. Go a un style canonique unique et un outil qui l'impose, si bien que la revue de code ne débat jamais des espaces. Pensez à black, mais intégré et utilisé par tout le monde.
• go test est fourni avec la toolchain. Les tests vivent à côté de votre code dans des fichiers _test.go et s'exécutent avec une seule commande. Vous n'avez pas à installer ni à configurer pytest.
• go vet et le système de modules sont intégrés. Les dépendances sont versionnées dans go.mod et récupérées avec go get, et les builds sont reproductibles sans outil tiers.

Après des années à gérer des environnements Python, ne plus avoir à en gérer du tout est un petit soulagement au quotidien. Vous écrivez le code, vous lancez go build et vous livrez le résultat.

Ce qui vous manquera de Python

La rigueur de Go a de vrais coûts, et vous devez savoir à quoi vous renoncez. C'est le REPL qui vous manquera le plus. Go n'a pas d'interpréteur interactif pour explorer une bibliothèque ou tester un bout de code, alors explorer signifie écrire un petit main et l'exécuter. Les list comprehensions et les dict comprehensions vous manqueront aussi, car Go vous oblige à écrire la boucle à chaque fois. Et de temps en temps, c'est la souplesse de Python qui vous manquera, cette façon de remodeler les données à la volée sans déclarer de type au préalable.

L'écart d'écosystème compte davantage, parce qu'il touche votre carrière et pas seulement votre confort. Python règne sur la data science, le machine learning et le calcul scientifique. On le voit dans la manière dont les développeurs Python répartissent leur temps : l'exploration de données, le développement web et le ML arrivent en tête (JetBrains State of Python 2025). Si votre métier consiste à entraîner des modèles ou à manipuler des dataframes, Go ne remplacera pas Python dans ce domaine et ne cherche pas à le faire. Il est plus judicieux d'ajouter Go que de changer de langage. Gardez Python pour les données et l'IA, et utilisez Go quand vous avez besoin d'un service rapide et fiable, d'une CLI ou d'outils d'infrastructure. Cela correspond à ce que construisent les développeurs Go : 75 % développent des services API ou RPC et 62 % des outils en ligne de commande (Go Developer Survey 2024 H2).

Comment passer de Python à Go

Pour un développeur Python, le moyen le plus rapide d'apprendre Go est d'arrêter de lire des articles sur les différences et de s'y confronter dans du vrai code. Vous comprenez déjà les concepts. Ce qu'il vous faut, c'est de la répétition : assez de petits exercices notés pour que la syntaxe et le rythme de la gestion d'erreurs ne demandent plus de réflexion consciente. Le passage des exceptions aux erreurs comme valeurs ne s'ancre qu'après avoir tapé if err != nil quelques centaines de fois dans de vrais programmes.

Ne tombez pas dans le piège des tutoriels regardés passivement. Regarder quelqu'un d'autre écrire du Go vous apprend très peu de choses sur la façon de l'écrire vous-même, et la tentation est d'autant plus forte que le langage a l'air facile. Écrivez un peu de Go chaque jour, obtenez un retour qui vous signale immédiatement vos erreurs, et construisez quelque chose de réel dès que vous savez écrire une fonction sans rien chercher. Une petite API JSON, une CLI qui reformate un fichier ou un programme qui appelle un autre service et remodèle la réponse sont autant de projets courts en Go, et ils utilisent les patterns sur lesquels vous vous appuierez au travail.

Questions fréquentes

Go est-il plus difficile à apprendre que Python ?

Pas sa syntaxe. Go ne compte que 25 mots-clés et un seul style de formatage imposé, il y a donc moins à mémoriser qu'en Python. Le plus difficile, c'est la discipline : traiter les erreurs comme des valeurs et déclarer les types demande plus d'efforts au départ. Les développeurs Python qui utilisent déjà les annotations de type, soit 88 % d'entre eux, ont une vraie longueur d'avance (Typed Python 2024 Survey, Meta).

Pourquoi Go gère-t-il la concurrence mieux que Python ?

Le Global Interpreter Lock de CPython ne laisse qu'un seul thread exécuter du bytecode à la fois, si bien que le travail CPU en parallèle nécessite plusieurs processus (Python docs). Les goroutines de Go s'exécutent sur tous les cœurs sans GIL, communiquent par des channels et n'ont pas besoin d'un écosystème async séparé. Ce modèle explique en grande partie pourquoi les services Go restent plus stables sous charge.

Combien de temps faut-il à un développeur Python pour apprendre Go ?

La syntaxe de base s'acquiert vite, puisque les fonctions, les slices, les maps et les packages se transposent tous depuis Python. Écrire du Go qu'une équipe validerait en revue de code prend plus de temps. Ce qui rend Go idiomatique, c'est précisément ce que Python ne vous a jamais appris : les erreurs comme valeurs, les petites interfaces, la composition plutôt que l'héritage, les goroutines et les channels, et les conventions de la bibliothèque standard. La plupart des développeurs ont besoin de quelques mois concentrés sur de vrais projets avant que tout cela ne se mette en place. Lire des tutoriels ne vous fera pas passer de « je sais lire du Go » à « j'écris du Go idiomatique ». Une pratique structurée et concrète y parviendra, c'est-à-dire construire des choses et obtenir des retours sur de vrais exercices.

Pour le développement backend, ai-je encore besoin de Python si j'apprends Go ?

Non. Pour le backend, Go couvre tout à lui seul. La bibliothèque standard inclut des serveurs HTTP, le JSON, des drivers SQL et la concurrence sans framework, vous pouvez donc construire et déployer des services de production entièrement en Go. Il se compile en un binaire statique unique sans runtime à installer, démarre rapidement et gère les charges à forte concurrence grâce aux goroutines, ce qui explique pourquoi tant d'infrastructures modernes reposent sur lui. Python reste la référence pour la data science et le machine learning, mais c'est un autre métier. Pour les API, les microservices, les CLI et les outils d'infrastructure, Go suffit.

Commencez à écrire du Go dès aujourd'hui

Votre expérience de Python vous aide ici. Vous pensez déjà selon les bonnes structures. Il vous reste à assimiler un petit ensemble de nouvelles règles, et cela passe par l'écriture de code Go. La gestion d'erreurs, les interfaces et les goroutines ne sont pas difficiles, mais chacune demande de la pratique avant de devenir naturelle.

C'est exactement pour cela que LevelUpGo a été conçu. Chaque leçon est un exercice dans le navigateur qui exécute votre code avec la toolchain Go actuelle et le note instantanément, si bien que vous écrivez du vrai Go dès le premier jour.

Voici un parcours pour un développeur Python :

• Commencez par les fondamentaux. Le cours Go Fundamentals vous mène de votre premier programme aux fonctions, aux types et aux structs, et il fait pratiquer le pattern de gestion d'erreurs dès le début. Vous pouvez commencer gratuitement, sans carte bancaire.
• Apprenez le seul modèle réellement nouveau. Le cours Go Concurrency Fundamentals enseigne les goroutines, les channels et select. Python n'a pas d'équivalent direct, et c'est la partie la plus rentable sous charge.
• Apprenez à l'écrire à la manière de Go. Le parcours Clean Go Code couvre les idiomes, le nommage et la gestion d'erreurs qui font que votre Go se lit comme du Go, et non comme du Python avec des accolades.

Commencez le cours gratuit, écrivez un peu de Go chaque jour et entretenez votre série.