Metadata-Version: 2.4
Name: portugython
Version: 0.4.0
Summary: A Portuguese translation of Python: functions, modules and syntax
Project-URL: Homepage, https://github.com/spacemany2k38/portugython
Project-URL: Bug Tracker, https://github.com/spacemany2k38/portugython/issues
Author: Victor Kolis
Maintainer: Victor Kolis
License: MIT
License-File: LICENSE
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Education
Classifier: License :: OSI Approved :: MIT License
Classifier: Natural Language :: Portuguese (Brazilian)
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Requires-Python: >=3.10
Provides-Extra: dev
Requires-Dist: pytest; extra == 'dev'
Requires-Dist: ruff; extra == 'dev'
Description-Content-Type: text/markdown

# Portugython

[![PyPI version](https://img.shields.io/pypi/v/portugython.svg)](https://pypi.org/project/portugython/)
[![Python versions](https://img.shields.io/pypi/pyversions/portugython.svg)](https://pypi.org/project/portugython/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Escreva Python em Portugues. Portugython traduz funcoes, tipos e modulos da biblioteca padrao do Python para nomes em portugues.

## Instalacao

```bash
pip install portugython
```

## Uso basico

```python
from portugython import *

escreva("Ola, Mundo!")
nome = leia("Qual e seu nome? ")
escreva("Ola,", nome)

numeros = Lista([1, 2, 3, 4, 5])
numeros.adicione(6)
numeros.classifique(reverso=Verdadeiro)
escreva(numeros)

pares = filtro(lambda x: x % 2 == 0, numeros)
escreva("Pares:", pares)

resultado = se(tamanho(pares) > 0, "tem pares", "sem pares")
escreva(resultado)
```

## Modulos da biblioteca padrao

Cada modulo da stdlib tem uma versao em portugues que pode ser importada separadamente.

### aleatorio (random)

```python
from portugython import aleatorio

aleatorio.semente(42)
n = aleatorio.inteiro_aleatorio(1, 100)
item = aleatorio.escolha(["pedra", "papel", "tesoura"])
lista = [1, 2, 3, 4, 5]
aleatorio.embaralhe(lista)
amostra = aleatorio.amostra(range(50), k=5)
```

### matematica (math)

```python
from portugython import matematica

print(matematica.PI)
print(matematica.raiz_quadrada(16))
print(matematica.fatorial(10))
print(matematica.seno(matematica.PI / 2))
print(matematica.mdc(48, 18))
print(matematica.combinacoes(10, 3))
```

### sistema (os + sys)

```python
from portugython import sistema

pasta = sistema.diretorio_atual()
arquivos = sistema.listar_diretorio(".")
sistema.criar_diretorios("nova/pasta", existe_ok=Verdadeiro)
sistema.renomear("antigo.txt", "novo.txt")

print(sistema.versao)
print(sistema.plataforma)
db = sistema.variavel_ambiente("DATABASE_URL", "sqlite:///app.db")
```

### tempo (time + datetime)

```python
from portugython import tempo

agora = tempo.agora()
print(agora.formatar("%d/%m/%Y %H:%M"))

hoje = tempo.hoje()
print(hoje.ano, hoje.mes, hoje.dia)

dur = tempo.Duracao.de(dias=7, horas=2)
print(dur.total_segundos)

tempo.dormir(0.1)
```

### colecoes (collections)

```python
from portugython import colecoes

# Contagem
votos = colecoes.Contador(["sim", "nao", "sim", "sim", "nao"])
print(votos.mais_comuns(1))

# Fila dupla
d = colecoes.Deque([1, 2, 3])
d.adicione_esquerda(0)
d.adicione_direita(4)

# Pilha
pilha = colecoes.Pilha()
pilha.empurre("a")
pilha.empurre("b")
print(pilha.retire())

# Fila
fila = colecoes.Fila()
fila.enfileire("primeiro")
fila.enfileire("segundo")
print(fila.desenfileire())

# Tupla com campos nomeados
Ponto = colecoes.tupla_com_nome("Ponto", ["x", "y"])
p = Ponto(3, 4)
print(p.x, p.y)
```

### iteradores (itertools)

```python
from portugython import iteradores

# Combinatoria
for combo in iteradores.combine([1, 2, 3, 4], 2):
    print(combo)

# Produto cartesiano
for par in iteradores.produto("AB", "12"):
    print(par)

# Acumulacao
totais = list(iteradores.acumule([1, 2, 3, 4, 5]))

# Encadeamento
unido = list(iteradores.encadeie([1, 2], [3, 4], [5]))
```

### funcional (functools)

```python
from portugython import funcional

# Reducao
total = funcional.reduzido(lambda a, b: a + b, range(1, 11))

# Funcao parcial
multiplicar_por_3 = funcional.parcial(lambda a, b: a * b, 3)
print(multiplicar_por_3(7))

# Memoizacao
@funcional.cache
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

# Composicao
dobrar = lambda x: x * 2
somar_um = lambda x: x + 1
dobrar_e_somar = funcional.compor(somar_um, dobrar)
print(dobrar_e_somar(5))
```

### expressao (re)

```python
from portugython import expressao

# Busca simples
m = expressao.buscar(r"\d+", "pagina 42")
if m:
    print(m.group())

# Todos os resultados
numeros = expressao.encontrar_todos(r"\d+", "1 mais 2 igual 3")

# Substituicao
limpo = expressao.substituir(r"\s+", " ", "texto  com   espacos")

# Padrao reutilizavel
email = expressao.Padrao(r"[\w.+-]+@[\w-]+\.[a-z]{2,}")
if email.encontrar("contato@example.com"):
    print("Email valido")
```

## Referencia de builtins

### Entrada / Saida
| Portugues | Python |
|-----------|--------|
| `escreva` | `print` |
| `leia` | `input` |
| `abra` | `open` |

### Tipos
| Portugues | Python |
|-----------|--------|
| `inteiro` | `int` |
| `texto` | `str` |
| `decimal` | `float` |
| `logico` | `bool` |
| `lista` | `list` |
| `dicionario` | `dict` |
| `conjunto` | `set` |
| `tupla` | `tuple` |
| `intervalo` | `range` |

### Constantes
| Portugues | Python |
|-----------|--------|
| `Verdadeiro` | `True` |
| `Falso` | `False` |
| `Nenhum` | `None` |

### Funcoes de sequencia
| Portugues | Python |
|-----------|--------|
| `tamanho` | `len` |
| `soma` | `sum` |
| `maximo` | `max` |
| `minimo` | `min` |
| `absoluto` | `abs` |
| `classificado` | `sorted` |
| `reverso` | `reversed` |
| `enumerado` | `enumerate` |
| `comprimido` | `zip` |
| `mapeado` | `map` |
| `filtrado` | `filter` |

### Operadores logicos
| Portugues | Python |
|-----------|--------|
| `nao(x)` | `not x` |
| `e(a, b)` | `a and b` |
| `ou(a, b)` | `a or b` |

### Funcoes utilitarias
| Portugues | Python |
|-----------|--------|
| `se(c, a, b)` | `a if c else b` |
| `para_cada(f, it)` | `list(map(f, it))` |
| `filtro(f, it)` | `list(filter(f, it))` |
| `reduzido(f, it)` | `functools.reduce(f, it)` |

## Transpilador de palavras-chave

Portugython inclui um transpilador completo que traduz a sintaxe do Python
(palavras-chave) para portugues. Isso permite escrever programas Python
inteiramente em portugues.

### CLI: ptpy

```bash
ptpy meu_programa.ptpy               # executa um arquivo .ptpy
ptpy -c 'para i em intervalo(3): escreva(i)'   # executa inline
ptpy --mostrar meu_programa.ptpy     # imprime o Python equivalente
```

### API Python

```python
from portugython import traduzir, executar_texto, executar_arquivo

# Traduzir uma string
codigo_pt = """
defina fatorial(n):
    se n <= 1:
        retorne 1
    senao:
        retorne n * fatorial(n - 1)
"""
print(traduzir(codigo_pt))
# def fatorial(n):
#     if n <= 1:
#         return 1
#     else:
#         return n * fatorial(n - 1)

# Executar diretamente
executar_texto("para i em intervalo(3):\n    escreva(i)")

# Executar um arquivo .ptpy
executar_arquivo("meu_programa.ptpy")
```

### Programa completo em portugues (.ptpy)

```python
# fatorial.ptpy
importe portugython

defina fatorial(n):
    se n <= 1:
        retorne 1
    senao:
        retorne n * fatorial(n - 1)

defina verificar_primo(n):
    se n < 2:
        retorne Falso
    para i em intervalo(2, n):
        se n % i == 0:
            retorne Falso
    retorne Verdadeiro

primos = [x para x em intervalo(2, 20) se verificar_primo(x)]
escreva("Primos:", primos)

para n em intervalo(1, 8):
    escreva(f"{n}! = {fatorial(n)}")

tente:
    resultado = 10 / 0
exceto ZeroDivisionError como err:
    escreva("Erro capturado:", err)
finalmente:
    escreva("Pronto!")
```

### Tabela de palavras-chave

| Portugues | Python | | Portugues | Python |
|-----------|--------|-|-----------|--------|
| `se` | `if` | | `senao` | `else` |
| `senaose` | `elif` | | `para` | `for` |
| `enquanto` | `while` | | `parar` | `break` |
| `continuar` | `continue` | | `passar` | `pass` |
| `defina` | `def` | | `classe` | `class` |
| `retorne` | `return` | | `produzca` | `yield` |
| `anonima` | `lambda` | | `importe` | `import` |
| `de` | `from` | | `como` | `as` |
| `tente` | `try` | | `exceto` | `except` |
| `finalmente` | `finally` | | `levante` | `raise` |
| `com` | `with` | | `nao` | `not` |
| `e` | `and` | | `ou` | `or` |
| `em` | `in` | | `eh` | `is` |
| `excluir` | `del` | | `afirmar` | `assert` |
| `global` | `global` | | `naolocal` | `nonlocal` |
| `assincronico` | `async` | | `aguardar` | `await` |
| `Verdadeiro` | `True` | | `Falso` | `False` |
| `Nenhum` | `None` | | | |

> **Nota**: Palavras como `e`, `ou`, `de`, `com` e `em` sao palavras-chave
> reservadas no contexto de arquivos `.ptpy`. Evite usa-las como nomes de
> variaveis nesses arquivos, assim como nao se usa `if` ou `for` como
> variaveis em Python normal.

## Contribuir

1. Crie um fork deste repositorio
2. Crie uma branch nova a partir de main
3. Envie um pull request

## Licenca

MIT
