De Python para Go: o que todo o programador deve saber

Consegues ler toda a sintaxe de Go numa tarde e, se já escreves Python, quase tudo te vai parecer familiar. Essa familiaridade engana. As palavras-chave novas aprendem-se depressa. O difícil ao passar para Go é largar meia dúzia de hábitos de Python que o Go não suporta. O Go não tem exceções para apanhar, nem classes de onde herdar, nem list comprehensions, nem um interpretador interativo onde testar coisas. Em vez disso, ficas com valores de erro explícitos, structs com interfaces, goroutines e um compilador que se queixa antes de o teu código chegar a correr. Este artigo aborda as mudanças que decidem se o teu primeiro mês com Go vai ser um alívio ou uma luta.

Resumo rápido

• Os programadores de Go estão contentes com a linguagem. Dos inquiridos, 91 % disseram estar satisfeitos com o Go e cerca de dois terços declararam-se «muito satisfeitos», o resultado mais alto do inquérito oficial da Google (Go Developer Survey 2025).
• Já usas a ideia por trás da maior mudança do Go. Entre os programadores de Python, 88 % dizem usar anotações de tipo (type hints) «sempre» ou «muitas vezes», por isso a tipagem estática é um hábito que já começaste a ganhar (Typed Python 2024 Survey, Meta).
• As equipas que migraram tiveram ganhos reais. Quando a Khan Academy reescreveu o seu backend de Python em Go, uma página que demorava cerca de 28 segundos a renderizar passou a demorar uns 4 segundos (Khan Academy Engineering). A passagem do Reddit para um serviço de comentários em Go reduziu para metade a latência p99 de escrita (InfoQ).
• O Python continua a ser maior, e não há problema nisso. O Python é usado por 54,8 % dos programadores profissionais, contra 17,4 % no caso do Go, e domina o trabalho com dados e IA (Stack Overflow 2025). O Go compete num espaço mais específico: backends sensíveis à latência, APIs e CLIs.

Índice

• Deves aprender Go se programas em Python?
• Porque é que as equipas passam de Python para Go
• Tipagem estática: já tens meio caminho andado
• Os erros são valores, não exceções
• Concorrência: goroutines vs o GIL
• Structs e interfaces em vez de classes e herança
• Menos magia, mais código explícito
• Guia rápido de Python para Go
• Ferramentas: um binário, um formatador, testes integrados
• Do que vais sentir falta em Python
• Como fazer a mudança
• Perguntas frequentes
• Começa a escrever Go hoje

Deves aprender Go se programas em Python?

Sim, sobretudo se o teu trabalho se está a aproximar de serviços de backend, APIs, infraestrutura ou ferramentas de linha de comandos. Os programadores de Go reportam a maior satisfação entre as principais linguagens: no inquérito oficial da Google, 91 % estão satisfeitos e quase dois terços estão «muito satisfeitos» (Go Developer Survey 2025). Essa satisfação vem mais de o Go ser previsível do que de ser engenhoso. A previsibilidade é o que a maioria dos programadores de Python começa a querer quando uma base de código ultrapassa uns poucos milhares de linhas.

A transição é rápida, porque muita coisa se aproveita. Já pensas em funções, slices e maps. Já divides o trabalho em pacotes e escreves testes. A forma como abordas os problemas continua igual. O que muda é o rigor com que a linguagem te obriga a cumprir as tuas decisões. O Go abdica de parte da flexibilidade do Python em troca de garantias, e a maior parte deste artigo é sobre onde isso se nota.

Porque é que as equipas passam de Python para Go

As equipas mudam normalmente pelo mesmo motivo: um serviço em Python que foi rápido de escrever tornou-se demasiado lento ou demasiado caro de manter a correr. Quando a Khan Academy reescreveu o seu servidor em Go, a lista de uma turma de 1.000 alunos, que demorava cerca de 28 segundos a carregar em Python, passou a ser renderizada em cerca de 4 segundos, uma melhoria de quase 7 vezes. Os avisos de contenção no datastore caíram de cerca de 100 por hora para quase nenhum (Khan Academy Engineering).

O Reddit viu algo parecido. Depois de passar o backend da sua árvore de comentários para um microsserviço em Go em 2025, a latência p99 de escrita ficou em metade da do sistema antigo em Python, que chegava por vezes a picos de 15 segundos (InfoQ).

A Lovable, a plataforma de criação de apps com IA, é o exemplo recente mais marcante. Reescreveu todo o seu backend de Python para Go, 42.000 linhas de código. As instâncias de servidor passaram de 200 para 10, os tempos de deploy desceram de 15 minutos para 3 e os pedidos passaram a ser, em média, 12 % mais rápidos (Lovable Engineering). Foi a concorrência que motivou a reescrita. Um único pedido de chat na Lovable pode desdobrar-se em mais de 50 chamadas HTTP. O Go trata esse tipo de carga paralela de forma nativa, e o GIL do Python torna-a complicada.

Em todos estes casos, o runtime do Go, compilado, com tipagem estática e garbage collection, faz mais trabalho por servidor, por isso o mesmo tráfego custa menos e comporta-se de forma mais estável sob carga.

Tipagem estática: já tens meio caminho andado

Os programadores de Python tendem a temer a tipagem estática mais do que qualquer outra coisa no Go, e é a ela que se adaptam mais depressa, porque a maioria já a adotou. Num inquérito de 2024, 88 % dos programadores de Python disseram usar type hints «sempre» ou «muitas vezes», e o mypy e o Pydantic são as ferramentas mais comuns (Typed Python 2024 Survey, Meta). Se anotas as assinaturas das funções e corres um verificador de tipos no CI, já aceitaste a premissa central do Go. O Go torna essa verificação obrigatória e coloca-a no compilador, em vez de numa ferramenta opcional.

A diferença prática está no momento em que descobres que te enganaste. Em Python, um erro de tipos aparece em tempo de execução, muitas vezes em produção, às vezes horas depois do deploy. Em Go, o mesmo erro trava a compilação. Não podes passar uma string onde se espera um int e não podes deixar uma variável por usar, por isso um err que atribuíste e nunca verificaste não compila. Para quem está a começar, isto parece o compilador a implicar contigo. Se já depuraste um erro NoneType has no attribute às 2 da manhã, parece mais uma rede de segurança.

Eis como fica. A versão em Go não compila se Total alguma vez tiver o tipo errado, enquanto uma versão em Python limitar-se-ia a esperar que quem a chama lhe passasse um número:

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)
}

A inferência de tipos evita que isto fique verboso. Com :=, o Go deduz o tipo a partir do valor, por isso escreves count := 0 em vez de pores int por todo o lado. Manténs a segurança das declarações e quase toda a concisão do Python.

Os erros são valores, não exceções

Este é o maior ajuste, e vai parecer-te estranho durante mais ou menos uma semana. O Go não tem try, nem except, nem exceções no sentido do Python. As funções que podem falhar devolvem um error como último valor, e verificas esse valor exatamente onde fizeste a chamada. Nada é lançado pela stack acima para ser apanhado num sítio distante. Tratas o erro, ignora-lo ou passa-lo adiante, na linha onde aconteceu.

Vais escrever este padrão milhares de vezes:

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

Muitos programadores de Python torcem o nariz ao if err != nil ao início. Três linhas de tratamento de erros depois de cada chamada parecem ruído ao lado de um único try à volta de um bloco inteiro. Mas a repetição é intencional. Consegues ver todos os caminhos de falha da função ao ler de cima para baixo, sem saltos invisíveis para um handler distante. O verbo %w embrulha o erro original para que quem chama o possa continuar a inspecionar, e é esta a versão do Go de uma cadeia de exceções.

O hábito também passa para o Python. Quando te habituas a tratar as falhas no ponto de chamada, um bloco genérico except Exception começa a parecer aquilo que é: uma forma de perder informação sobre o que correu mal.

Concorrência: goroutines vs o GIL

A concorrência é onde o Go deixa de ser «Python com tipos» e passa a ser uma ferramenta diferente. O Global Interpreter Lock do CPython só permite que uma thread execute bytecode Python de cada vez, por isso as threads não conseguem executar trabalho intensivo de CPU em paralelo. As builds free-threaded, sem GIL, chegaram de forma experimental no Python 3.13 com a PEP 703, mas não são a opção por omissão e o ecossistema ainda está a recuperar o atraso (documentação do Python). Por agora, escalar Python com trabalho intensivo de CPU implica normalmente correr vários processos e pagar o custo de memória e de coordenação que eles trazem.

O Go foi desenhado à volta da concorrência desde o início. Uma goroutine é uma chamada de função com go à frente, e o runtime distribui milhares delas pelos núcleos do teu CPU sem nenhum GIL pelo meio. As goroutines comunicam através de channels em vez de memória partilhada. Lançar cem pedidos concorrentes exige apenas este código:

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)
}

Se já escreveste asyncio, já percebes o objetivo. O Go chega lá sem dividir o teu código em metades «coloridas» async e síncronas. Qualquer função pode correr numa goroutine. Não escreves await, não arrancas um event loop e não andas à procura de versões async das bibliotecas. Esta é uma grande parte da razão pela qual os serviços em Go aguentam bem a carga: o modelo de concorrência do Go está integrado na linguagem, em vez de ter sido acrescentado mais tarde.

Structs e interfaces em vez de classes e herança

O Go não tem classes nem herança, o que surpreende as pessoas mais do que devia. Modelas os dados com uma struct e dás-lhe comportamento associando-lhe métodos. Nada passa self implicitamente, não há __init__ e não há uma classe base para estender. Onde o Python usaria uma hierarquia de classes, o Go usa composição. Incorporas uma struct dentro de outra para reutilizar os seus campos e métodos, em vez de herdares de uma classe pai.

As interfaces são onde o Go se torna elegante, e não funcionam como estarias à espera. Um tipo satisfaz uma interface só por ter os métodos certos. Não há palavra-chave implements nem passo de registo. Se a tua struct tem um método Read([]byte) (int, error), é um io.Reader. Isto é o duck typing que conheces do Python, verificado em tempo de compilação:

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)
}

A mudança mental é passar de «o que é este objeto» para «o que é que este objeto consegue fazer». As tuas interfaces vão ser mais pequenas do que esperas, muitas vezes com um só método, e vais defini-las junto do código que as usa, e não junto do tipo que as satisfaz. Essa inversão demora uns dias a parecer natural. Depois disso, costuma ser uma das coisas de que mais sentes falta quando voltas ao Python.

Menos magia, mais código explícito

O Python recompensa a esperteza. Decorators, metaclasses, métodos dunder, monkey-patching e acesso dinâmico a atributos permitem-te moldar a linguagem como quiseres. O Go deixa deliberadamente quase tudo isso de fora. Não tem decorators, nem metaclasses, nem sobrecarga de operadores, nem forma de acrescentar um método a um tipo que não é teu. Quase sempre consegues perceber o que uma linha faz sem saberes de algo que acontece noutro sítio.

Isto parece restritivo no primeiro dia e libertador ao fim de dois meses. Ler uma base de código Go desconhecida é, na maior parte do tempo, simplesmente ler, porque nada escondido está a reescrever o comportamento nos bastidores. A desvantagem é que o Go pode ser mais verboso. Às vezes vais escrever um ciclo onde o Python te daria uma comprehension de uma linha. A comunidade Go considera isso um preço justo. Os criadores da linguagem apostaram que o código é lido muito mais vezes do que é escrito, por isso otimizaram para quem lê.

Guia rápido de Python para Go

A maioria das construções do dia a dia em Python tem um equivalente direto em Go. Mantém esta tabela aberta durante a primeira semana. Os nomes mudam e a pontuação fica mais rigorosa, mas os conceitos correspondem-se quase um para um.

As maiores mudanças visuais são as chavetas e a ausência dos dois pontos. Como o Go tem tipagem estática, o compilador apanha-te no momento em que uma tradução está errada. Aproveita isso. Deixar a compilação falhar e ler o erro é a forma mais rápida de aprender as correspondências.

Ferramentas: um binário, um formatador, testes integrados

As ferramentas do Go são uma das razões mais subestimadas para as pessoas ficarem. Não há desvios no requirements.txt, nem ambiente virtual para ativar, nem formatador, linter e test runner separados para ligar entre si. O comando go trata de tudo isso e vem numa única instalação. A compilação produz um único binário estático, sem interpretador nem dependências para enviar junto, por isso o deploy resume-se muitas vezes a copiar um ficheiro para o servidor.

As partes que vais notar primeiro:

• go build gera um único binário. A máquina de destino não precisa de ter Python instalado, não empacotas um interpretador e os problemas de dependências não aparecem na altura do deploy.
• gofmt acaba com as discussões sobre formatação. O Go tem um único estilo canónico e uma ferramenta que o impõe, por isso as revisões de código nunca discutem espaços em branco. Pensa no black, mas incluído de raiz e usado por toda a gente.
• go test vem com a toolchain. Os testes vivem ao lado do teu código em ficheiros _test.go e correm com um só comando. Não tens de instalar nem configurar o pytest.
• go vet e o sistema de módulos vêm incluídos. As dependências são versionadas no go.mod e obtidas com go get, e as builds são reproduzíveis sem ferramentas de terceiros.

Depois de anos a gerir ambientes Python, não ter de gerir nenhum é um pequeno alívio todos os dias. Escreves código, corres go build e entregas o resultado.

Do que vais sentir falta em Python

O rigor do Go tem custos reais, e deves saber aquilo de que abdicas. Do que vais sentir mais falta é do REPL. O Go não tem um interpretador interativo para explorar uma biblioteca ou testar um excerto de código, por isso explorar significa escrever um pequeno main e executá-lo. Vais sentir falta das list e dict comprehensions, porque o Go te obriga a escrever o ciclo todas as vezes. E de vez em quando vais sentir falta da flexibilidade do Python, da forma como te deixa remodelar dados no momento sem declarar primeiro um tipo.

A diferença de ecossistema pesa mais, porque afeta a tua carreira e não apenas o teu conforto. O Python domina a ciência de dados, o machine learning e a computação científica. Isso vê-se na forma como os programadores de Python ocupam o seu tempo: exploração de dados, desenvolvimento web e ML lideram a lista (JetBrains State of Python 2025). Se o teu trabalho é treinar modelos ou lutar com dataframes, o Go não vai substituir o Python aí nem tenta fazê-lo. Faz mais sentido acrescentar o Go do que trocar. Mantém o Python para o trabalho com dados e IA e usa o Go quando precisas de um serviço rápido e fiável, de uma CLI ou de ferramentas de infraestrutura. Isso bate certo com o que os programadores de Go constroem: 75 % criam serviços de API ou RPC e 62 % criam ferramentas de linha de comandos (Go Developer Survey 2024 H2).

Como fazer a mudança

A forma mais rápida de aprender Go para quem vem de Python é deixar de ler sobre as diferenças e esbarrar nelas em código real. Já compreendes os conceitos. Aquilo de que precisas é repetição: exercícios pequenos e corrigidos em número suficiente para que a sintaxe e o ritmo do tratamento de erros deixem de exigir esforço consciente. A passagem das exceções para os erros como valores só se fixa depois de teres escrito if err != nil umas centenas de vezes em programas reais.

Não caias em ver tutoriais de forma passiva. Ver outra pessoa escrever Go ensina-te muito pouco sobre escrevê-lo tu próprio, e a tentação é especialmente grande quando a linguagem parece tão fácil. Escreve um pouco de Go todos os dias, recebe feedback que te diga de imediato quando te enganas e constrói algo real assim que conseguires escrever uma função sem ires procurar nada. Uma pequena API JSON, uma CLI que reformata um ficheiro ou um programa que chama outro serviço e remodela a resposta são todos projetos curtos em Go, e usam os padrões em que te vais apoiar no trabalho.

Perguntas frequentes

O Go é mais difícil de aprender do que o Python?

A sintaxe não é. O Go tem apenas 25 palavras-chave e um único estilo de formatação obrigatório, por isso há menos para memorizar do que em Python. A parte mais difícil é a disciplina: tratar erros como valores e declarar tipos exige mais esforço logo de início. Os programadores de Python que já usam type hints, 88 % deles, partem com uma vantagem real (Typed Python 2024 Survey, Meta).

Porque é que o Go lida melhor com a concorrência do que o Python?

O Global Interpreter Lock do CPython só deixa uma thread executar bytecode de cada vez, por isso o trabalho de CPU em paralelo precisa de vários processos (documentação do Python). As goroutines do Go correm em todos os núcleos sem GIL, comunicam através de channels e não precisam de um ecossistema async separado. Esse modelo é uma grande razão para os serviços em Go se manterem mais estáveis sob carga.

Quanto tempo demora um programador de Python a aprender Go?

A sintaxe básica aprende-se depressa, já que funções, slices, maps e pacotes transitam todos do Python. Escrever Go que uma equipa aprovaria numa revisão de código demora mais. Aquilo que torna o Go idiomático é o que o Python nunca te ensinou: erros como valores, interfaces pequenas, composição em vez de herança, goroutines e channels, e as convenções da biblioteca padrão. A maioria dos programadores precisa de alguns meses focados a construir projetos reais até isto encaixar. Ler tutoriais não te leva de «consigo ler Go» a «escrevo Go idiomático». O treino estruturado e prático leva, ou seja, construir coisas e receber feedback sobre exercícios reais.

Para desenvolvimento backend, ainda preciso de Python se aprender Go?

Não. Para trabalho de backend, o Go cobre tudo por si só. A biblioteca padrão inclui servidores HTTP, JSON, drivers SQL e concorrência sem framework, por isso consegues construir e pôr em produção serviços inteiramente em Go. Compila para um único binário estático sem runtime para instalar, arranca depressa e aguenta cargas de alta concorrência com goroutines, e é por isso que tanta infraestrutura moderna corre em Go. O Python continua a ser a escolha por omissão para ciência de dados e machine learning, mas esse é outro trabalho. Para APIs, microsserviços, CLIs e ferramentas de infraestrutura, o Go chega.

Começa a escrever Go hoje

A tua experiência com Python ajuda-te aqui. Já pensas nas formas certas. O que falta é interiorizar um pequeno conjunto de regras novas, e isso consegue-se a escrever Go. O tratamento de erros, as interfaces e as goroutines não são difíceis, mas cada um precisa de prática até parecer natural.

É para isso que o LevelUpGo foi feito. Cada lição é um exercício no navegador que executa o teu código com a toolchain atual do Go e o corrige de imediato, por isso escreves Go real desde o primeiro dia.

Eis um caminho para quem vem de Python:

• Começa pelos fundamentos. O curso Go Fundamentals leva-te do teu primeiro programa às funções, aos tipos e às structs, e pratica o padrão de tratamento de erros desde o início. Podes começar grátis, sem precisares de cartão de crédito.
• Aprende o único modelo que é mesmo novo. O curso Go Concurrency Fundamentals ensina goroutines, channels e select. O Python não tem um equivalente direto, e é a parte que mais compensa sob carga.
• Aprende a escrever à maneira do Go. O percurso Clean Go Code aborda as convenções idiomáticas, a escolha de nomes e o tratamento de erros que fazem o teu Go ler-se como Go e não como Python com chavetas.

Começa o curso grátis, escreve um pouco de Go todos os dias e mantém a tua sequência.