# Cheat sheet

Tipos, controlo, funções, coleções, recursão, estilo livre de efeitos, ficheiros e falhas.

Página: https://resumos.rgo.pt/cadeiras/fp/folha-consulta/

As tabelas reúnem operações, condições e casos limite. As ligações levam às explicações e à prática.

## Valores e expressões

| Decisão | Regra |
| --- | --- |
| Atribuir ou comparar | `x = valor` associa um nome; `x == y` compara conteúdo; `x is y` testa identidade. |
| Converter entrada | `input()` devolve `str`; `int` e `float` podem levantar `ValueError`. Decimais no código usam ponto. |
| Dividir | `/` calcula divisão; `//` arredonda o quociente para baixo; `%` dá o resto. Para inteiros e `b != 0`, `a == (a // b) * b + a % b`. |
| Interpretar precedência | `-2 ** 2` vale `-4`; `(-2) ** 2` vale `4`; a potência associa à direita. Usa parênteses. |
| Comparar aproximações | Define tolerância, como em `math.isclose`, ou o arredondamento pedido. `float` não representa todos os decimais exatamente. |

[Expressões e precedência](https://resumos.rgo.pt/cadeiras/fp/primeiros-programas/#operadores-e-preced%C3%AAncia). [Entrada e saída](https://resumos.rgo.pt/cadeiras/fp/primeiros-programas/#entrada-e-sa%C3%ADda).

## Controlo e ciclos

| Padrão | Condição ou erro a conferir |
| --- | --- |
| `if` / `elif` / `else` | Escolhe o primeiro ramo verdadeiro. Dois `if` independentes podem executar ambos. |
| `and`, `or`, `not` | `and` e `or` usam curto-circuito e devolvem operandos. Coloca a guarda antes da operação que pode falhar. |
| `range(a, b, p)` | `b` fica excluído; `p` não pode ser zero. Confere a direção do passo. |
| Acumular soma ou produto | Inicializa soma com `0`, produto com `1`. Escreve o que já foi acumulado após cada iteração. |
| `while` | Confirma uma atualização que aproxima o estado do fim. Pode executar zero vezes. |
| `break` / `continue` | `break` sai do ciclo mais interno; `continue` salta o resto da iteração. Não saltes a atualização de um `while`. |
| `else` do ciclo | Corre quando o percurso acaba normalmente, sem `break`, incluindo um percurso vazio. |

[Condições e curto-circuito](https://resumos.rgo.pt/cadeiras/fp/condicoes-ciclos/#comparar-e-combinar-condi%C3%A7%C3%B5es). [Limites de range](https://resumos.rgo.pt/cadeiras/fp/condicoes-ciclos/#ciclos-for-e-a-fun%C3%A7%C3%A3o-range). [Terminação](https://resumos.rgo.pt/cadeiras/fp/condicoes-ciclos/#ciclos-while-e-termina%C3%A7%C3%A3o).

## Funções, âmbito e efeitos

| Decisão | Regra |
| --- | --- |
| Definir ou chamar | `def` define; `f(argumento)` chama; `f` passa a função como valor. |
| Devolver ou mostrar | `return` termina a chamada e entrega o resultado. `print` escreve e devolve `None`; sem `return` explícito, também devolve `None`. |
| Passar um objeto | Não o copia. Reatribuir o parâmetro muda o nome local; alterar uma lista recebida muda o objeto partilhado. |
| Escrever o contrato | Define domínio, resultado, casos limite e efeitos. |
| Valor por defeito | Avaliado quando `def` executa. Para uma lista nova por chamada, usa `None` e cria-a no corpo. |
| Manter pureza | Depende dos valores recebidos, sem efeitos observáveis fora do cálculo. Um acumulador local não é, por si só, um efeito no chamador; sem atribuições é mais restrito. |

[Retorno e saída](https://resumos.rgo.pt/cadeiras/fp/funcoes/#return-e-print). [Passagem de argumentos](https://resumos.rgo.pt/cadeiras/fp/funcoes/#passagem-de-argumentos-e-efeitos). [Valores por defeito](https://resumos.rgo.pt/cadeiras/fp/funcoes/#argumentos-por-nome-e-valores-por-defeito). [Pureza](https://resumos.rgo.pt/cadeiras/fp/programacao-funcional/#fun%C3%A7%C3%B5es-livres-de-efeitos).

## Escolher uma coleção

*   **`str`:** texto ordenado e imutável. Índice inválido falha; fatia ajusta limites. `upper` e `replace` devolvem texto sem alterar a string.
    
*   **`tuple`:** sequência imutável. `(x,)` tem um elemento; um elemento mutável interior pode mudar.
    
*   **`list`:** conserva ordem e repetições, e pode mudar. `append` acrescenta um objeto; `extend` percorre outro iterável. Métodos mutadores costumam devolver `None`.
    
*   **`dict`:** associa chaves a valores e conserva a ordem de inserção. Chaves são hashable; `in` testa chaves; `get` não cria a chave.
    
*   **`set`:** elementos únicos, sem posição. `set()` é vazio; `{}` é dicionário. Não uses a ordem do conjunto como saída.
    
*   `b = a` cria um alias. `a.copy()` copia só o recipiente. Numa matriz, as linhas podem continuar partilhadas.
    
*   `[[0] * c] * r` repete a mesma linha; `[[0] * c for _ in range(r)]` cria linhas independentes.
    
*   `sorted(xs)` devolve outra lista; `xs.sort()` altera a existente.
    
*   `A | B` é união; `A & B`, interseção; `A - B`, diferença com direção; `A ^ B`, diferença simétrica. `A <= B` testa subconjunto.
    
*   `zip` termina no iterável mais curto por defeito; valida comprimentos iguais se o contrato exigir.
    

[Fatias](https://resumos.rgo.pt/cadeiras/fp/strings/#fatias). [Alias e cópia](https://resumos.rgo.pt/cadeiras/fp/tuplos-listas/#alias-contra-c%C3%B3pia-igualdade-contra-identidade). [Cópia superficial](https://resumos.rgo.pt/cadeiras/fp/tuplos-listas/#listas-de-listas-e-c%C3%B3pia-superficial). [Conjuntos](https://resumos.rgo.pt/cadeiras/fp/dicionarios-conjuntos/#conjuntos-e-perten%C3%A7a).

## Transformar e reduzir

| Operação | Forma e contrato |
| --- | --- |
| Transformar | `map(f, xs)` devolve um iterador com `f(x)` para cada entrada. |
| Selecionar | `filter(p, xs)` conserva as entradas onde `p(x)` é verdadeiro. |
| Acumular | `reduce(f, xs, z)` faz um fold à esquerda a partir de `z`. Com `xs` vazio devolve `z`; sem inicial, o vazio falha. |
| Compreensão | `[f(x) for x in xs if p(x)]` filtra e constrói uma lista nova; não garante ausência de efeitos se `f(x)` alterar objetos. Um `if ... else` dentro da expressão escolhe valores, não retira posições. |
| Chave de ordenação | `sorted(registos, key=lambda r: (-r[1], r[0]))` ordena pelo segundo campo decrescente e pelo primeiro crescente. |
| Devolver uma função | Uma closure conserva acesso ao âmbito envolvente. O contexto não é automaticamente uma cópia de cada valor. |

*   Um iterador consumido não recomeça. Usa lista para índices e vários percursos; gerador para consumo progressivo.
*   `(f(x) for x in xs)` é gerador; `yield` entrega um valor e suspende; o próximo pedido retoma depois de `yield`; `return` termina.
*   Filtrar positivos antes de elevar ao quadrado exclui negativos; filtrar os quadrados já não os exclui. A paridade de um inteiro, pelo contrário, mantém-se no seu quadrado.

[Compreensões](https://resumos.rgo.pt/cadeiras/fp/compreensoes-geradores/#compreens%C3%B5es-de-listas). [Geradores](https://resumos.rgo.pt/cadeiras/fp/compreensoes-geradores/#geradores-e-yield). [Map, filter e reduce](https://resumos.rgo.pt/cadeiras/fp/programacao-funcional/#map-filter-e-reduce). [Closures](https://resumos.rgo.pt/cadeiras/fp/programacao-funcional/#devolver-fun%C3%A7%C3%B5es-e-%C3%A2mbito-l%C3%A9xico).

## Recursão e pesquisa

*   Escreve o caso base e uma medida que diminui até ele.
*   Devolve o resultado da chamada recursiva.
*   Considera profundidade, chamadas repetidas e cópias de fatias. Python não elimina chamadas em posição terminal.

| Técnica | Pré-condição | Custo típico no pior caso |
| --- | --- | --- |
| Pesquisa linear | Nenhuma ordenação exigida | $O(n)$ comparações |
| Pesquisa binária | Lista ordenada | $O(\log n)$ iterações |
| Dois percursos sucessivos | Cada um visita $n$ entradas | $O(n)$ |
| Todos os pares | Há $n(n-1)/2$ pares distintos | $O(n^2)$ |

*   Escolhe uma convenção para ausência, como `None`, e não a uses como índice.
*   Uma função binária que encontra uma ocorrência não garante a primeira.
*   Pertença em dicionários e conjuntos tem custo médio esperado constante, não uma garantia de pior caso constante.
*   Define `n` e o trabalho contado antes de usar Big-O.

[Recursão](https://resumos.rgo.pt/cadeiras/fp/recursao/#o-modelo-da-recurs%C3%A3o). [Pesquisas](https://resumos.rgo.pt/cadeiras/fp/algoritmos-complexidade/#pesquisa-linear-e-pesquisa-bin%C3%A1ria). [Custo](https://resumos.rgo.pt/cadeiras/fp/algoritmos-complexidade/#contar-opera%C3%A7%C3%B5es).

## Construções para combinar

*   Dígitos de um inteiro `n >= 0`, em base inteira `b >= 2`: repete `n % b` e `n //= b`. Os restos saem do menos para o mais significativo; inverte-os para escrever o número.
*   Representa zero por `"0"`. Um inteiro invertido não conserva zeros à esquerda.
*   Frequências de ramos diferentes: soma as contagens da mesma chave, sem as substituir. Uma sublista vazia contribui com `{}`.
*   Árvore de expressões: calcula os dois operandos antes de aplicar o operador, conservando a ordem.
*   Para somar exatamente um alvo com preços positivos, retira a primeira posição nos ramos escolher e ignorar; só escolher reduz o alvo.
*   Alvo zero aceita a escolha vazia; alvo negativo falha, pois os preços são positivos. Diminuir as posições garante terminação; $n$ posições admitem $2^n$ escolhas.
*   `any` procura um verdadeiro; `all` procura um falso. `any([])` é `False` e `all([])` é `True`.
*   «Cada peça existe em alguma caixa» difere de «uma caixa contém todas as peças»: a ordem dos percursos importa. Repetir percursos interiores exige coleções reutilizáveis, não iteradores consumidos.
*   Para pares de posições distintos, usa `j > i`.
*   Reservas semiabertas $[a,b[$ e $[c,d[$, com início menor que fim, conflituam se `max(a, c) < min(b, d)`; um contacto no extremo não conta. Intervalos fechados exigem outra condição.
*   Para gerar intervalos inteiros inclusivos, percorre cada par com `range(inicio, fim + 1)` e `yield valor`. Exige `inicio <= fim`; conserva a ordem e as repetições sem guardar todos os inteiros.

[Dígitos e bases](https://resumos.rgo.pt/cadeiras/fp/condicoes-ciclos/#construir-um-n%C3%BAmero-a-partir-dos-d%C3%ADgitos). [Resultados recursivos](https://resumos.rgo.pt/cadeiras/fp/recursao/#combinar-resultados-recursivos). [Árvores de expressões](https://resumos.rgo.pt/cadeiras/fp/recursao/#express%C3%B5es-como-%C3%A1rvores). [Any e all](https://resumos.rgo.pt/cadeiras/fp/programacao-funcional/#any-all-e-condi%C3%A7%C3%B5es-sobre-cole%C3%A7%C3%B5es). [Fronteiras](https://resumos.rgo.pt/cadeiras/fp/compreensoes-geradores/#pares-de-posi%C3%A7%C3%B5es-e-fronteiras).

## Ficheiros, falhas e verificação

| Decisão | Regra |
| --- | --- |
| [Abrir e fechar](https://resumos.rgo.pt/cadeiras/fp/ficheiros-excecoes/#ler-e-escrever-ficheiros) | `with open(caminho, "r", encoding="utf-8") as f:` fecha o recurso ao sair. Caminhos relativos partem da pasta de trabalho. |
| Escolher o modo | `"w"` substitui o conteúdo; `"a"` acrescenta; `"x"` exige um ficheiro novo. Para CSV, usa `csv` e `newline=""`. |
| Distinguir o fim | `readline()` devolve `""` no fim; uma linha em branco é normalmente `"\n"`. |

| Bloco | Quando corre |
| --- | --- |
| [`except Tipo`](https://resumos.rgo.pt/cadeiras/fp/ficheiros-excecoes/#exce%C3%A7%C3%B5es-try-except-else-e-finally) | Trata a falha esperada; não escondas qualquer defeito com um tratador indiscriminado. |
| `else` | Apenas se o `try` terminar normalmente, sem `return`, `break` ou `continue`. |
| `finally` | Sempre na saída. |
| `raise` / `assert` | `raise` comunica a falha ao chamador. `assert` verifica hipóteses internas e pode ser desativado; entradas inválidas precisam de validação explícita. |

*   O primeiro tratador compatível ganha. Coloca `FileNotFoundError` antes de `OSError`, pois o primeiro é também um caso do segundo. Sem tratador compatível, a falha propaga-se ao chamador.
*   Calcula o resultado esperado antes de executar. [Testa](https://resumos.rgo.pt/cadeiras/fp/ficheiros-excecoes/#asser%C3%A7%C3%B5es-e-testes) limites, vazio, repetições e entradas inválidas. Se falhar, reduz a entrada e localiza o primeiro estado que diverge do esperado.