Pyrtugues

Python em português, feito para aprender programação.

Programação em português • lógica de Python • aprendizado progressivo

Uma linguagem educacional baseada na lógica do Python, criada para facilitar o aprendizado de programação usando comandos e estruturas em português.

Versão 1.5.0

Pyrtugues é uma linguagem de programação educacional baseada na sintaxe e na lógica do Python.

A proposta é permitir que iniciantes aprendam programação utilizando palavras em português, sem abandonar os conceitos fundamentais presentes no Python.

O Pyrtugues funciona como uma ponte:

Pyrtugues
    ↓
Motor de tradução
    ↓
Python
    ↓
Execução

Isso significa que o estudante pode aprender conceitos como:

• variáveis;
• tipos de dados;
• condições;
• repetições;
• funções;
• classes;
• exceções;
• módulos;
• arquivos;
• estruturas de dados;
• testes;
• programação gráfica;
• Pygame;

usando uma sintaxe em português e, ao mesmo tempo, entendendo como esses conceitos aparecem no Python.

Programar em português → entender a lógica → enxergar o Python → aprender Python.

O Pyrtugues possui diferentes formas de utilização:

• 🖥️ aplicação Desktop;
• 🪟 Windows;
• ♾️ Visual studio code (vs code);
• 🌐 Editor Web;
• 🎮 suporte a Pygame;
• 📚 exemplos educacionais;
• 🧪 materiais e exercícios de programação.

O código principal da aplicação Desktop está em:

Pyrtugues_code.py

No Pyrtugues:

mostrar("Olá, mundo!")

O equivalente em Python é:

print("Olá, mundo!")

A ideia não é criar uma linguagem completamente diferente do Python, mas aproximar a linguagem de quem está começando a programar em português.

Algumas das principais correspondências da linguagem:

O vocabulário da linguagem continua evoluindo conforme o desenvolvimento do projeto.

nome = "Ana"
idade = 15
altura = 1.65

mostrar(nome)
mostrar(idade)
mostrar(altura)

O Pyrtugues mantém a mesma ideia de atribuição utilizada pelo Python.

Comentários continuam utilizando #:

# Esta linha não será executada
mostrar("Código executável")

idade = 15

se idade maior que 10:
    mostrar("Pode continuar")
senão:
    mostrar("Precisa estudar mais")

Também é possível utilizar múltiplos caminhos:

nota = 8

se nota maior ou igual a 9:
    mostrar("Excelente")
senão_se nota maior ou igual a 7:
    mostrar("Bom")
senão_se nota maior ou igual a 5:
    mostrar("Recuperação")
senão:
    mostrar("Reprovado")

para numero em intervalo(1, 6):
    mostrar(numero)

Equivalente:

for numero in range(1, 6):
    print(numero)

contador = 0

enquanto contador menor que 5:
    mostrar(contador)
    contador += 1

para numero em intervalo(1, 10):
    se numero igual a 5:
        quebrar

    mostrar(numero)

para numero em intervalo(1, 8):
    se numero igual a 4:
        continuar

    mostrar(numero)

função futura():
    passar

Funções podem ser declaradas utilizando função:

função saudacao(nome):
    retornar f"Olá, {nome}!"

mensagem = saudacao("Pyrtugues")
mostrar(mensagem)

Outro exemplo:

função calcular_media(nota1, nota2):
    retornar (nota1 + nota2) / 2

media = calcular_media(8, 10)

mostrar(media)

Programas interativos podem solicitar dados:

nome = pergunte("Qual é o seu nome? ")

mostrar(f"Olá, {nome}!")

Conversões podem ser feitas utilizando os tipos traduzidos:

idade = inteiro(pergunte("Idade: "))
altura = decimal(pergunte("Altura: "))

mostrar(idade)
mostrar(altura)

O Pyrtugues mantém os operadores matemáticos tradicionais do Python:

a = 10
b = 3

mostrar(a + b)
mostrar(a - b)
mostrar(a * b)
mostrar(a / b)
mostrar(a // b)
mostrar(a % b)
mostrar(a ** b)

Também existem formas traduzidas para operadores compostos:

contador = 0

contador += 1
contador -= 1
contador *= 2
contador /= 2

nomes = ["Ana", "Bia", "Carlos"]

mostrar(nomes)
mostrar(nomes[0])

Percorrendo uma lista:

nomes = ["Ana", "Bia", "Carlos"]

para nome em nomes:
    mostrar(nome)

coordenadas = (10, 20)

mostrar(coordenadas)
mostrar(coordenadas[0])

Tuplas são úteis quando os valores representam uma coleção que não deve ser modificada.

numeros = {1, 2, 3, 3, 4}

mostrar(numeros)

Conjuntos eliminam valores duplicados.

aluno = {
    "nome": "Ana",
    "idade": 15,
    "nota": 9
}

mostrar(aluno["nome"])
mostrar(aluno["nota"])

Dicionários permitem representar informações estruturadas por chave e valor.

Strings podem ser utilizadas normalmente:

texto = "PYRTUGUES"

mostrar(texto[0])
mostrar(texto[-1])

Também podem ser usadas f-strings:

nome = "Ana"
idade = 15

mostrar(f"Nome: {nome}")
mostrar(f"Idade: {idade}")

O Pyrtugues possui estruturas para tratamento de erros.

tentar:
    numero = inteiro(pergunte("Número: "))
    mostrar(numero * 2)

exceto ValueError:
    mostrar("Valor inválido")

finalmente:
    mostrar("Fim da tentativa")

Também é possível gerar exceções:

função dividir(a, b):
    se b == 0:
        levantar ValueError("Divisor não pode ser zero")

    retornar a / b

E realizar verificações:

função quadrado(numero):
    retornar numero * numero

afirmar quadrado(4) == 16
afirmar quadrado(-2) == 4

O Pyrtugues pode utilizar módulos da biblioteca padrão do Python.

importar matemática

mostrar(matématica.sqrt(81))

Também é possível utilizar de e como:

de matemática importar sqrt como raiz

mostrar(raiz(81))

Os nomes exatos disponíveis dependem do dicionário e da versão do tradutor.

Exemplos de módulos utilizados nos materiais do projeto:

• math;
• random;
• datetime;
• time;
• os;
• sys;
• re;
• json;
• csv;
• collections;
• calendar;
• unittest;
• entre outros recursos da biblioteca padrão compatíveis com o tradutor.

Exemplo:

importar aleatório
importar datetime

numero = aleatório.randint(1, 10)
agora = datetime.datetime.now()

mostrar(numero)
mostrar(agora)

O Pyrtugues pode trabalhar com dados JSON utilizando o módulo json.

Exemplo:

importar json

dados = {
    "nome": "Ana",
    "nota": 9
}

com abrir("aluno.json", "w", encoding="utf-8") como arquivo:
    json.dump(dados, arquivo, ensure_ascii=False, indent=2)

Leitura:

com abrir("aluno.json", "r", encoding="utf-8") como arquivo:
    recuperado = json.load(arquivo)

mostrar(recuperado)

Também é possível trabalhar com arquivos CSV:

importar csv

com abrir("alunos.csv", "w", newline="", encoding="utf-8") como arquivo:
    gravador = csv.writer(arquivo)

    gravador.writerow(["nome", "nota"])
    gravador.writerow(["Ana", 9])

O Pyrtugues possui suporte a conceitos de testes automatizados.

Exemplo:

função somar(a, b):
    retornar a + b

afirmar somar(2, 2) == 4
afirmar somar(10, 5) == 15

Também podem ser utilizados recursos do unittest quando compatíveis com o ambiente:

importar testes_unitários

classe TesteSoma(testes_unitários.TestCase):

    função teste_soma(self):
        self.assertEqual(2 + 2, 4)

O Pyrtugues possui integração com Pygame, permitindo utilizar conceitos de programação gráfica e desenvolvimento de jogos.

A arquitetura pode ser entendida como:

Pyrtugues
    ↓
Tradutor
    ↓
Python
    ↓
Pygame
    ↓
Jogo / Aplicação

Entre os conceitos que podem ser explorados estão:

• janelas;
• eventos;
• teclado;
• mouse;
• imagens;
• textos;
• formas;
• cores;
• sprites;
• colisões;
• sons;
• músicas;
• animações;
• controle de tempo.

Um exemplo conceitual:

importar pygame

pygame.init()

janela = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Meu primeiro projeto")

executando = verdadeiro

enquanto executando:

    para evento em pygame.event.get():

        se evento.type == pygame.QUIT:
            executando = falso

    janela.fill((30, 30, 30))

    pygame.display.flip()

pygame.quit()

A disponibilidade de determinados recursos do Pygame depende da versão do tradutor e do ambiente em que o Pyrtugues está sendo executado.

A versão Desktop utiliza:

• Python;
• CustomTkinter;
• Tkinter;
• Pygame.

O aplicativo reúne recursos como:

• editor de código;
• execução do programa;
• terminal de saída;
• entrada interativa;
• visualização do Python gerado;
• exemplos;
• navegação;
• destaque da linha atual;
• interrupção da execução;
• carregamento de exemplos;
• interface gráfica.

O arquivo principal é:

Pyrtugues_code.py

No Desktop, o fluxo principal é:

Código Pyrtugues
       ↓
    tradução
       ↓
Código Python
       ↓
exec(...)
       ↓
resultado

O aplicativo também possui mecanismos para executar o código em uma thread separada, permitindo manter a interface responsiva durante a execução.

A entrada e a saída são integradas à interface gráfica do aplicativo.

O projeto também possui uma experiência Web para experimentar Pyrtugues diretamente no navegador.

A versão Web possui recursos como:

• editor;
• tradução Pyrtugues → Python;
• execução;
• entrada interativa;
• terminal;
• exemplos;
• visualização do Python gerado;
• cópia do código Python;
• download do código Python;
• execução do motor em Web Worker.

A arquitetura Web utiliza:

Pyrtugues
    ↓
Tradutor
    ↓
Python
    ↓
Pyodide
    ↓
Navegador

A estrutura principal do repositório inclui:

Pyrtugues/
├── assets/
│   └── logo-pyrtugues.png
├── Pyrtugues_Documentacao/
├── site-principal/
├── LICENSE
├── README.md
└── Pyrtugues_code.py

• Python
• CustomTkinter
• Tkinter
• Pygame

• HTML
• CSS
• JavaScript
• Tailwind CSS
• Pyodide
• Web Worker

Clone o projeto:

git clone https://github.com/pyrtugues/Pyrtugues.git

Entre no diretório:

cd Pyrtugues

A aplicação Desktop está em:

Pyrtugues_code.py

As dependências devem ser instaladas de acordo com o ambiente utilizado.

Exemplo:

pip install customtkinter pygame

Depois:

python Pyrtugues_code.py

O conjunto exato de dependências pode mudar conforme a versão do projeto e o sistema operacional.

função calcular(a, b, operador):

    se operador == "+":
        retornar a + b

    senão se operador == "-":
        retornar a - b

    senão se operador == "*":
        retornar a * b

    senão se operador == "/":
        retornar a / b

    senão:
        levantar ValueError("Operador inválido")


a = decimal(pergunte("Primeiro: "))
b = decimal(pergunte("Segundo: "))
operador = pergunte("Operação (+, -, *, /): ")

mostrar(calcular(a, b, operador))

função c_para_f(celsius):
    retornar celsius * 9 / 5 + 32

c = decimal(pergunte("Temperatura em C: "))

mostrar(f"{c} C = {c_para_f(c)} F")

perguntas = [
    ("Qual linguagem está na base do Pyrtugues?", "python"),
    ("Quanto é 2 + 2?", "4")
]

pontuacao = 0

para pergunta, resposta_correta em perguntas:

    resposta = pergunte(pergunta + " ")

    se resposta.lower() == resposta_correta:
        mostrar("Correto!")
        pontuacao += 1

    senão:
        mostrar("Resposta incorreta.")

mostrar(f"Pontuação: {pontuacao}/{tamanho(perguntas)}")

tarefas = []

enquanto verdadeiro:

    mostrar("1 - adicionar")
    mostrar("2 - listar")
    mostrar("3 - sair")

    opcao = pergunte("Opção: ")

    se opcao == "1":

        tarefa = pergunte("Tarefa: ")
        tarefas.adicionar(tarefa)

    senão se opcao == "2":

        para tarefa em tarefas:
            mostrar(tarefa)

    senão:

        quebrar

mostrar("Fim")

O projeto foi pensado para ensinar programação de maneira progressiva.

O estudante pode começar com:

mostrar("Olá!")

e avançar para:

variáveis
   ↓
condições
   ↓
repetições
   ↓
funções
   ↓
estruturas de dados
   ↓
exceções
   ↓
módulos
   ↓
arquivos
   ↓
testes
   ↓
Pygame
   ↓
projetos

A intenção é que os conhecimentos adquiridos sejam transferíveis para Python.

O Pyrtugues não pretende substituir o Python.

A proposta é diminuir a barreira inicial causada pela sintaxe em inglês e permitir que o estudante concentre sua atenção primeiro na lógica.

Depois, ao visualizar o Python equivalente, o estudante consegue perceber a relação:

mostrar()       → print()
se              → if
senão           → else
para            → for
enquanto        → while
função          → def
retornar        → return

Dessa forma, o Pyrtugues pode funcionar como uma ponte entre o primeiro contato com programação e o Python.

Esta documentação corresponde à versão 1.5.0 do projeto.

O Pyrtugues continua em desenvolvimento e a compatibilidade de determinados recursos pode mudar entre versões.

Para saber exatamente quais comandos estão disponíveis no ambiente utilizado, consulte o código do tradutor e os exemplos correspondentes à versão.

Contribuições podem ajudar o projeto a evoluir.

Algumas formas de contribuir:

• 🐛 reportar bugs;
• 🧪 testar recursos;
• 💡 sugerir novos comandos;
• 📖 melhorar a documentação;
• 🧩 criar exemplos;
• 🎮 criar projetos com Pygame;
• ♾️ testar no Vs code;
• 🪟 testar no Windows;
• 💻 contribuir com código.

Ao alterar o tradutor, é importante testar especialmente:

• variáveis;
• strings;
• comentários;
• f-strings;
• expressões;
• nomes que coincidem com palavras reservadas;
• imports;
• estruturas condicionais;
• loops;
• funções;
• exceções;
• código Python já existente.

O Pyrtugues possui uma licença própria.

A licença atual estabelece regras específicas para:

• uso pessoal;
• uso educacional individual;
• uso institucional;
• uso comercial;
• modificações;
• redistribuição;
• atribuição;
• marca e identidade do projeto.

Consulte o arquivo:

LICENSE

antes de utilizar, modificar ou redistribuir o projeto.

Vinicius Caracciolo

O Pyrtugues nasceu como um projeto pessoal voltado para programação e educação.

O projeto evoluiu para incluir:

• linguagem de programação em português;
• tradutor para Python;
• aplicação Desktop;
• suporte ao Vs code;
• suporte ao Windows;
• Pygame;
• Editor Web;
• materiais educacionais;
• documentação;
• exemplos e projetos.

Versão atual: 1.5.0

O Pyrtugues continua em desenvolvimento.

Entre as áreas que podem evoluir estão:

• novos comandos;
• melhorias no tradutor;
• maior compatibilidade com Python;
• melhorias no Pygame;
• tratamento de erros;
• novos exemplos;
• documentação;
• Desktop;
• Linux;
• Visual studio code
• Windows;
• Editor Web;
• materiais educacionais;
• novas plataformas.