09/03/2026, 14:07 Python para Rust

ChatGPT 5.4 Thinking Memória desativada

Sou programador Python aprendendo Rust, tenha ótima

didática e faça correlação entre as linguagens, mostre
como o rust trabalha com let e mut

Pensou por 5s

Claro. Vamos fazer a ponte Python → Rust de um jeito bem prático.

Ideia central
No Python, você escreve assim:

Python Executar

x = 10
x = 20

Isso funciona porque, no Python, a variável é reassociada livremente.

No Rust, a regra é diferente:

let cria uma variável imutável por padrão

let mut cria uma variável mutável

Isso é uma das grandes diferenças de mentalidade entre as linguagens.

1) let no Rust
Exemplo

Rust

fn main() {
let x = 10;
println!("{}", x);
}

Aqui:

let declara a variável

x recebe 10

[Link] 1/12
09/03/2026, 14:07 Python para Rust

por padrão, x não pode ser alterado

Se tentar mudar:

Rust

fn main() {
let x = 10;
x = 20;
println!("{}", x);
}

Vai dar erro de compilação.

Comparação com Python

Python

Python Executar

x = 10
x = 20
print(x)

Rust

Rust

fn main() {
let x = 10;
// x = 20; // erro
println!("{}", x);
}

O que isso significa na prática?

Rust força você a deixar claro:
“esse valor não muda”
ou “esse valor pode mudar”

Isso ajuda muito na segurança e previsibilidade do código.

2) let mut no Rust

Se você quiser alterar o valor, precisa declarar explicitamente como mutável.

[Link] 2/12
09/03/2026, 14:07 Python para Rust

Exemplo

Rust

fn main() {
let mut x = 10;
println!("Antes: {}", x);

x = 20;
println!("Depois: {}", x);
}

Comparação com Python

Python

Python Executar

contador = 0
contador = contador + 1
print(contador)

Rust

Rust

fn main() {
let mut contador = 0;
contador = contador + 1;
println!("{}", contador);
}

Ou ainda:

Rust

fn main() {
let mut contador = 0;
contador += 1;
println!("{}", contador);
}

3) Regra mental boa para decorar

Pense assim:

[Link] 3/12
09/03/2026, 14:07 Python para Rust

let = “cria uma variável fixa”

let mut = “cria uma variável que pode mudar”

4) Por que Rust faz isso?

Porque Rust foi projetado para:
evitar bugs
aumentar segurança
deixar intenção explícita
facilitar otimizações

No Python, você tem mais liberdade.

No Rust, você tem mais controle e garantias.

Essa “rigidez” no começo parece chata, mas depois vira vantagem.

5) Exemplo lado a lado

Python

Python Executar

nome = "Gandra"
print(nome)

nome = "Carlos"
print(nome)

Rust com erro

Rust

fn main() {
let nome = "Gandra";
println!("{}", nome);

// nome = "Carlos"; // erro

}

Rust correto com mutabilidade

[Link] 4/12
09/03/2026, 14:07 Python para Rust

Rust

fn main() {
let mut nome = "Gandra";
println!("{}", nome);

nome = "Carlos";
println!("{}", nome);
}

6) Atenção: mutabilidade da variável não é a mesma coisa

que mutabilidade interna do objeto
Aqui tem uma diferença importante em relação ao Python.

No Python, muita coisa é “mutável por natureza”, como listas:

Python Executar

lista = [1, 2, 3]
[Link](4)
print(lista)

No Rust, depende do tipo e da forma como a variável foi declarada.

Exemplo com String

Rust

fn main() {
let mut nome = String::from("Gandra");
nome.push_str(" Silva");
println!("{}", nome);
}

Aqui funcionou porque:

nome foi declarado com mut

String é um tipo que pode ser modificado

Se tirar o mut , dá erro:

Rust

fn main() {
let nome = String::from("Gandra");

[Link] 5/12
09/03/2026, 14:07 Python para Rust

// nome.push_str(" Silva"); // erro

}

7) let não impede “shadowing”

Esse ponto é muito importante em Rust.

Mesmo com variável imutável, você pode redeclará-la com outro let .

Exemplo

Rust

fn main() {
let x = 10;
let x = x + 5;
let x = x * 2;

println!("{}", x);
}

Saída:

Rust

30

Isso se chama shadowing.

Comparação com Python

No Python, você faria:

Python Executar

x = 10
x = x + 5
x = x * 2
print(x)

No Rust, isso pode parecer parecido, mas conceitualmente é diferente:

em Python: você reatribui
em Rust com let x = ... : você cria uma nova variável com o mesmo nome,
escondendo a anterior

[Link] 6/12
09/03/2026, 14:07 Python para Rust

8) Diferença entre mut e shadowing

Com mut

Rust

fn main() {
let mut x = 10;
x = 20;
println!("{}", x);
}

Aqui a mesma variável mudou.

Com shadowing

Rust

fn main() {
let x = 10;
let x = 20;
println!("{}", x);
}

Aqui a variável anterior foi “encoberta” por uma nova.

9) Quando usar mut e quando usar shadowing?

Use mut quando:
o valor realmente muda ao longo do processamento.

Exemplo:

Rust

fn main() {
let mut contador = 0;

contador += 1;
contador += 1;
contador += 1;

println!("{}", contador);
}

[Link] 7/12
09/03/2026, 14:07 Python para Rust

Use shadowing quando:

você quer transformar o valor em etapas, sem manter a ideia de “estado mutável”.

Exemplo:

Rust

fn main() {
let texto = "42";
let texto = [Link]();
let numero: i32 = [Link]().unwrap();

println!("{}", numero);
}

Isso é muito idiomático em Rust.

10) Exemplo muito didático: Python vs Rust

Python

Python Executar

entrada = " 123 "

entrada = [Link]()
entrada = int(entrada)
print(entrada)

Rust com shadowing

Rust

fn main() {
let entrada = " 123 ";
let entrada = [Link]();
let entrada: i32 = [Link]().unwrap();

println!("{}", entrada);
}

Perceba que isso em Rust fica elegante porque cada let representa uma nova etapa da
transformação.

[Link] 8/12
09/03/2026, 14:07 Python para Rust

11) Tipos também ficam mais explícitos

No Python:

Python Executar

x = 10
x = "agora sou texto"

Isso é permitido.

No Rust, isso não funciona com mutação comum:

Rust

fn main() {
let mut x = 10;
// x = "texto"; // erro
}

Porque Rust é fortemente tipado e estático.

Mas com shadowing, você pode mudar o tipo:

Rust

fn main() {
let x = 10;
let x = "texto";
println!("{}", x);
}

Isso funciona porque o segundo let x é uma nova variável.

12) Resumo prático

let
Cria variável imutável.

Rust

let x = 10;

let mut

[Link] 9/12
09/03/2026, 14:07 Python para Rust

Cria variável mutável.

Rust

let mut x = 10;

x = 20;

shadowing
Cria uma nova variável com o mesmo nome.

Rust

let x = 10;
let x = x + 1;

13) Mapa mental Python → Rust

Python
variável pode mudar livremente
tipo pode mudar
mutabilidade é mais “natural” e menos controlada

Rust
variável é imutável por padrão
para alterar, use mut
para recriar/transformar, use shadowing com let
tipo normalmente é fixo por variável

14) Exemplo completo

Rust

fn main() {
let idade = 25;
println!("Idade inicial: {}", idade);

let mut pontos = 0;

pontos += 10;
pontos += 5;
println!("Pontos: {}", pontos);

[Link] 10/12
09/03/2026, 14:07 Python para Rust

let texto = " 42 ";

let texto = [Link]();
let numero: i32 = [Link]().unwrap();
println!("Número convertido: {}", numero);
}

O que aconteceu aqui?

idade foi criada com let e não muda
pontos foi criada com let mut e muda

texto foi reaproveitada com shadowing para transformar string em número

15) Regra de ouro para começar bem em Rust

Quando estiver vindo de Python, pense assim:
1. primeiro tente let
2. só use mut se realmente precisar alterar
3. use shadowing para transformações em etapas

Isso vai te aproximar do estilo idiomático de Rust.

16) Exercício mental rápido

Tente prever quais funcionam:

Rust

let x = 5;
x = 6;

Resultado: erro

Rust

let mut x = 5;
x = 6;

Resultado: funciona

[Link] 11/12
09/03/2026, 14:07 Python para Rust

Rust

let x = 5;
let x = 6;

Resultado: funciona

Porque em C houve shadowing, não mutação.

17) Forma curta de memorizar

let → imutável

let mut → mutável

let de novo com mesmo nome → shadowing

Se quiser, no próximo passo eu posso te mostrar exercícios práticos em Rust

comparando com Python, incluindo String , Vec , if , for e funções.

[Link] 12/12