# Cheat sheet de Python: sintaxe, comandos e funções embutidas em tabelas

URL: https://skillaria.top/pt/guides/python/cheat-sheet-python-sintaxe-funcoes

A sintaxe do Python é baseada em recuos em vez de chaves: o bloco depois dos dois-pontos é deslocado em 4 espaços. A base são variáveis sem declaração de tipo, condições if/elif/else, laços for e while, funções def e as funções embutidas print, len, range, input e type, além dos métodos de strings, listas e dicionários.

Esta cheat sheet de Python reúne em uma única página tudo o que é bom ter à mão nos primeiros meses: a sintaxe do Python, laços, funções embutidas, métodos de strings, listas e dicionários e os comandos do terminal. Cada tabela é uma referência curta com exemplos prontos, que podem ser colados diretamente no REPL.

## Fundamentos da sintaxe Python

A principal característica da linguagem é que os blocos são definidos por recuos, e não por chaves. Depois de uma linha com dois-pontos (`if`, `for`, `def`, `class`), as linhas seguintes são deslocadas em 4 espaços. Misturar tabulações e espaços não é permitido — o resultado é `IndentationError`.

| Construção | Exemplo | Explicação |
| --- | --- | --- |

| Comentário | `# texto` | tudo depois do # até o fim da linha é ignorado |

| Variável | `age = 25` | o tipo não é declarado, ele é determinado pelo valor |

| Atribuição múltipla | `a, b = 1, 2` | desempacotamento; troca de valores: `a, b = b, a` |

| Saída | `print("Olá", name)` | os argumentos são separados por espaço |

| Entrada | `s = input("Nome: ")` | sempre devolve uma string |

| f-string | `f"{name}: {price:.2f}"` | inserção de expressões e formatação |

| Anotação de tipo | `count: int = 0` | dica para IDE e verificadores, não é checada na execução |

| Bloco vazio | `pass` | marcador onde a sintaxe exige um corpo |

| Importação | `from math import sqrt` | conexão de um módulo ou de um nome dele |

### Tipos de dados

| Tipo | Literal | Mutável |
| --- | --- | --- |

| `int` | `42`, `1_000_000` | não |

| `float` | `3.14`, `1e-3` | não |

| `bool` | `True`, `False` | não |

| `str` | `"texto"`, `'texto'`, `"""várias linhas"""` | não |

| `list` | `[1, 2, 3]` | sim |

| `tuple` | `(1, 2)`, `(1,)` | não |

| `dict` | `{"a": 1}` | sim |

| `set` | `{1, 2}`, vazio — `set()` | sim |

| `NoneType` | `None` | — |

### Operadores

| Grupo | Operadores | Exemplo → resultado |
| --- | --- | --- |

| Aritmética | `+ - * / // % **` | `7 // 2` → 3, `7 % 2` → 1, `2 ** 10` → 1024 |

| Comparação | `== != < > <= >=` | `1 < x < 10` — encadeamento de comparações |

| Lógica | `and or not` | `x or "padrão"` |

| Pertinência | `in`, `not in` | `"a" in "abc"` → True |

| Identidade | `is`, `is not` | `x is None` |

| Atribuição | `+= -= *= /=`, `:=` | `if (n := len(s)) > 10: ...` |

## Condições e correspondência de padrões

```
if score >= 90:
    grade = "A"
elif score >= 70:
    grade = "B"
else:
    grade = "C"

status = "adulto" if age >= 18 else "criança"   # operador ternário

match command:
    case "start":
        print("Iniciando")
    case "stop" | "exit":
        print("Parando")
    case _:
        print("Comando desconhecido")
```

São considerados falsos `False`, `None`, `0`, a string vazia e as coleções vazias, por isso em vez de `if len(items) > 0` basta escrever `if items`.

## Laços em Python: sintaxe de for e while

### Laço for

Sintaxe do laço for em Python: `for variável in sequência:` seguido do corpo com recuo. O laço percorre qualquer objeto iterável — string, lista, dicionário, arquivo, `range`.

```
for i in range(5):              # 0 1 2 3 4
    print(i)

for i in range(10, 0, -2):      # 10 8 6 4 2
    print(i)

for i, fruit in enumerate(["maçã", "pera"], start=1):
    print(i, fruit)

for name, score in zip(names, scores):
    print(name, score)

for key, value in prices.items():
    print(key, value)
```

### Laço while

```
attempts = 3
while attempts > 0:
    password = input("Senha: ")
    if password == "secret":
        print("Acesso concedido")
        break
    attempts -= 1
else:
    print("Tentativas esgotadas")   # executa se não houve break
```

| Comando | O que faz |
| --- | --- |

| `break` | sai do laço antecipadamente |

| `continue` | passa para a próxima iteração |

| `else` em laço | executa se o laço terminou sem `break` |

| `range(stop)`, `range(start, stop, step)` | sequência de números, `stop` não é incluído |

### Compreensões de listas (comprehensions)

```
squares = [x ** 2 for x in range(10)]
evens = [x for x in numbers if x % 2 == 0]
lengths = {word: len(word) for word in words}
unique = {c.lower() for c in text}
total = sum(x * x for x in range(100))   # expressão geradora
```

## Funções

```
def greet(name: str, greeting: str = "Olá") -> str:
    """Devolve uma saudação."""
    return f"{greeting}, {name}!"

def total(*args, **kwargs):
    return sum(args), kwargs

square = lambda x: x * x
print(greet("Ana"))                  # Olá, Ana!
print(greet("Ana", greeting="Oi"))   # Oi, Ana!
```

| Elemento | Significado |
| --- | --- |

| `def f(a, b=1)` | parâmetro com valor padrão |

| `*args` | qualquer número de argumentos posicionais (tupla) |

| `**kwargs` | qualquer número de argumentos nomeados (dicionário) |

| `return` | devolve um valor; sem ele a função devolve `None` |

| `lambda x: ...` | função anônima curta, em uma única expressão |

| `global`, `nonlocal` | alteração de variável de um escopo externo |

Não use valor padrão mutável, como em `def f(items=[])`: a lista é criada uma única vez e acumula valores entre as chamadas. O certo é `items=None` e, dentro da função, `if items is None: items = []`.

## Funções embutidas do Python

As funções embutidas do Python estão disponíveis sem importação. São as funções principais, que aparecem em quase todo script.

| Função | O que faz | Exemplo → resultado |
| --- | --- | --- |

| `print()` | exibe valores | `print(1, 2, sep="-")` → 1-2 |

| `input()` | lê uma string do teclado | `int(input())` |

| `len()` | tamanho de uma coleção ou string | `len("abc")` → 3 |

| `type()` | tipo de um objeto | `type(3.0)` → <class 'float'> |

| `isinstance()` | verificação de tipo | `isinstance(5, int)` → True |

| `int() float() str() bool()` | conversão de tipos | `int("42")` → 42 |

| `list() tuple() set() dict()` | criação de coleções | `list("ab")` → ['a', 'b'] |

| `range()` | intervalo de números | `list(range(3))` → [0, 1, 2] |

| `enumerate()` | pares (índice, elemento) | `list(enumerate("ab"))` → [(0, 'a'), (1, 'b')] |

| `zip()` | junta sequências em pares | `list(zip([1, 2], "ab"))` → [(1, 'a'), (2, 'b')] |

| `sum() min() max()` | soma, mínimo, máximo | `max([3, 7, 1])` → 7 |

| `abs() round()` | valor absoluto e arredondamento | `round(3.14159, 2)` → 3.14 |

| `sorted()` | nova lista ordenada | `sorted(words, key=len, reverse=True)` |

| `reversed()` | iterador na ordem inversa | `list(reversed([1, 2]))` → [2, 1] |

| `map() filter()` | aplicar uma função / filtrar | `list(map(str, [1, 2]))` → ['1', '2'] |

| `any() all()` | pelo menos um / todos verdadeiros | `all(x > 0 for x in nums)` |

| `open()` | abre um arquivo | `open("a.txt", encoding="utf-8")` |

| `help() dir()` | ajuda e lista de atributos | `help(str.split)`, `dir(list)` |

| `id() hash()` | identificador e hash do objeto | `hash("a")` |

A melhor referência de Python está sempre à mão: a função `help()` no REPL. `help(dict)` mostra todos os métodos do dicionário com descrição, e `dir(obj)` — a lista de nomes disponíveis.

## Métodos de strings

Sintaxe de strings em Python: a string é imutável, e cada método devolve uma nova string. Os fatiamentos funcionam como nas listas: `s[1:4]`, e `s[::-1]` inverte a string.

| Método | Exemplo → resultado |
| --- | --- |

| `upper() lower()` | `"Py".upper()` → 'PY' |

| `capitalize() title()` | `"hello world".title()` → 'Hello World' |

| `strip() lstrip() rstrip()` | `" oi \n".strip()` → 'oi' |

| `split(sep)` | `"a,b,c".split(",")` → ['a', 'b', 'c'] |

| `join(iterable)` | `"-".join(["a", "b"])` → 'a-b' |

| `replace(old, new)` | `"gato".replace("g", "p")` → 'pato' |

| `find() index()` | `"hello".find("l")` → 2; se não houver — -1 (no `index` — erro) |

| `count()` | `"banana".count("a")` → 3 |

| `startswith() endswith()` | `"file.py".endswith(".py")` → True |

| `isdigit() isalpha() isspace()` | `"123".isdigit()` → True |

| `removeprefix() removesuffix()` | `"test_a".removeprefix("test_")` → 'a' |

| `zfill() center() ljust()` | `"7".zfill(3)` → '007' |

| `format()` | `"{} + {}".format(1, 2)` → '1 + 2' |

## Comandos de listas em Python

A lista é uma coleção mutável e ordenada. A maioria dos métodos altera a lista no lugar e devolve `None`, por isso `a = a.sort()` é um erro comum.

| Operação | O que faz | Exemplo |
| --- | --- | --- |

| `append(x)` | adiciona no fim | `a.append(4)` |

| `extend(iter)` | adiciona todos os elementos | `a.extend([5, 6])` |

| `insert(i, x)` | insere pelo índice | `a.insert(0, "first")` |

| `remove(x)` | remove a primeira ocorrência do valor | `a.remove(3)` |

| `pop(i)` | remove e devolve o elemento (por padrão o último) | `last = a.pop()` |

| `clear()` | esvazia a lista | `a.clear()` |

| `index(x)` | índice da primeira ocorrência | `a.index("b")` |

| `count(x)` | número de ocorrências | `a.count(1)` |

| `sort()` | ordena no lugar | `a.sort(key=str.lower)` |

| `reverse()` | inverte no lugar | `a.reverse()` |

| `copy()` | cópia rasa | `b = a.copy()` |

| `del a[i]` | remoção por índice ou fatia | `del a[1:3]` |

| Fatias | `a[start:stop:step]` | `a[-1]` — o último, `a[:3]` — os três primeiros |

## Comandos de dicionários em Python

| Operação | O que faz | Exemplo |
| --- | --- | --- |

| `d[key]` | valor pela chave; se a chave não existe — `KeyError` | `d["name"]` |

| `get(key, default)` | valor ou valor reserva | `d.get("age", 0)` |

| `d[key] = value` | adicionar ou alterar | `d["city"] = "Curitiba"` |

| `keys() values() items()` | chaves, valores, pares | `for k, v in d.items():` |

| `update()` | mescla com outro dicionário | `d.update({"a": 1})` |

| `d1 | d2` | novo dicionário unido | `merged = defaults | user` |

| `pop(key, default)` | remove e devolve o valor | `d.pop("tmp", None)` |

| `popitem()` | remove o último par adicionado | `d.popitem()` |

| `setdefault(key, value)` | devolve o valor; se a chave não existe — cria | `d.setdefault("tags", []).append("py")` |

| `key in d` | verificação de existência da chave | `if "name" in d:` |

| `dict.fromkeys()` | dicionário a partir de chaves com um só valor | `dict.fromkeys("abc", 0)` |

| `len(d)`, `del d[key]` | tamanho e remoção | `del d["old"]` |

### Tuplas e conjuntos

| Operação | Exemplo → resultado |
| --- | --- |

| Desempacotamento de tupla | `x, y = (3, 4)` |

| Adicionar ao conjunto | `s.add(5)`, remover — `s.discard(5)` |

| União / interseção | `{1, 2} | {2, 3}` → {1, 2, 3}; `{1, 2} & {2, 3}` → {2} |

| Diferença | `{1, 2} - {2}` → {1} |

| Remover duplicatas de uma lista | `list(dict.fromkeys(items))` — mantendo a ordem |

## Exceções e arquivos

```
try:
    number = int(input("Número: "))
except ValueError as err:
    print("Não é um número:", err)
else:
    print("Sucesso")
finally:
    print("Executa sempre")

with open("data.txt", "w", encoding="utf-8") as f:
    f.write("linha\n")

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())
```

| Exceção | Quando ocorre |
| --- | --- |

| `SyntaxError`, `IndentationError` | erro de sintaxe ou de recuo |

| `NameError` | nome não definido (erro de digitação) |

| `TypeError` | operação com tipo inadequado: `"1" + 1` |

| `ValueError` | tipo correto, mas valor inválido: `int("abc")` |

| `IndexError`, `KeyError` | não existe tal índice ou chave |

| `FileNotFoundError` | arquivo não encontrado |

| `ZeroDivisionError` | divisão por zero |

## Classes

```
from dataclasses import dataclass

class Dog:
    def __init__(self, name: str):
        self.name = name

    def bark(self) -> str:
        return f"{self.name}: Au!"

@dataclass
class Point:
    x: float
    y: float

print(Dog("Rex").bark())   # Rex: Au!
print(Point(1, 2))         # Point(x=1, y=2)
```

## Módulos embutidos do Python

A biblioteca padrão é instalada junto com o interpretador — basta fazer `import`.

| Módulo | Para quê | Exemplo |
| --- | --- | --- |

| `math` | matemática | `math.sqrt(16)` → 4.0 |

| `random` | números aleatórios | `random.randint(1, 6)`, `random.choice(items)` |

| `datetime` | data e hora | `datetime.date.today()` |

| `pathlib` | caminhos e arquivos | `Path("data").glob("*.csv")` |

| `os`, `sys` | sistema, variáveis de ambiente, argumentos | `os.environ.get("HOME")`, `sys.argv` |

| `json` | leitura e escrita de JSON | `json.loads(text)`, `json.dumps(obj, ensure_ascii=False)` |

| `csv` | tabelas CSV | `csv.DictReader(f)` |

| `collections` | Counter, defaultdict, deque | `Counter("banana").most_common(1)` → [('a', 3)] |

| `itertools` | combinações e encadeamento de iteradores | `itertools.chain(a, b)` |

| `re` | expressões regulares | `re.findall(r"\d+", s)` |

| `time` | pausas e medição de tempo | `time.sleep(1)`, `time.perf_counter()` |

| `asyncio` | código assíncrono | `asyncio.run(main())` |

No Python 3.15 apareceu a importação preguiçosa (PEP 810): `lazy import pandas as pd` adia o carregamento do módulo até o primeiro uso, e um script com dependências pesadas inicia bem mais rápido.

## Comandos do Python no terminal

Um grupo separado de pedidos, "comandos python", são os comandos para executar o interpretador e instalar bibliotecas. No Windows, em vez de `python3`, costuma-se escrever `python` ou `py`.

| Comando | O que faz |
| --- | --- |

| `python3 --version` | mostra a versão |

| `python3` | abre o console interativo REPL (para sair — `exit()`) |

| `python3 script.py` | executa um arquivo |

| `python3 -c "print(2 + 2)"` | executa uma linha |

| `python3 -m venv .venv` | cria um ambiente virtual |

| `source .venv/bin/activate` / `.venv\Scripts\activate` | ativa o ambiente (Linux, macOS / Windows) |

| `python3 -m pip install requests` | instala um pacote |

| `pip list`, `pip freeze > requirements.txt` | lista os pacotes e salva a lista |

| `pip install -r requirements.txt` | instala as dependências do arquivo |

| `python3 -m http.server 8000` | servidor web simples na pasta atual |

| `uv init`, `uv add requests`, `uv run main.py` | projeto, dependência e execução pelo gerenciador uv |

## Erros comuns de iniciantes

- **Comparação com `=`** — na condição é preciso `==`; um único `=` é atribuição.
- **Dois-pontos esquecidos** depois de `if`, `for`, `def` geram `SyntaxError`.
- **Soma de string com número**: `"Idade: " + 25` é erro; escreva `f"Idade: {25}"`.
- **Alterar a lista durante o percurso** — percorra uma cópia `for x in a[:]` ou monte uma nova lista.
- **`input()` devolve uma string** — para aritmética, envolva em `int()` ou `float()`.

## Resumo

A sintaxe do Python se apoia em recuos, dois-pontos e um pequeno conjunto de construções: condições, laços for e while, funções, classes. Some a isso duas dezenas de funções embutidas e os métodos de strings, listas e dicionários — e você cobrirá a maior parte das tarefas do dia a dia. Guarde a cheat sheet e, quando as tabelas ficarem familiares, passe para módulos e programação assíncrona; tudo isso é explicado passo a passo, na prática, no curso "Python 3.15: do iniciante ao profissional".

## FAQ

**Quantos espaços usar para o recuo em Python?**

Pelo padrão PEP 8 — 4 espaços por nível. O principal é manter o mesmo recuo em todo o bloco e não misturar com tabulações.

**Qual a diferença entre lista e tupla?**

A lista é mutável: pode ser ampliada e ordenada no lugar; a tupla é imutável, por isso serve como chave de dicionário e para conjuntos fixos de valores.

**Como ver todos os métodos de um objeto direto no Python?**

Chame dir(obj) para a lista de nomes e help(obj) para a descrição — por exemplo, help(str) mostra todos os métodos de strings.

**Qual a diferença entre sort() e sorted()?**

O método list.sort() ordena a própria lista e devolve None, enquanto a função sorted() devolve uma nova lista e funciona com qualquer coleção iterável.

**É preciso colocar ponto e vírgula no fim da linha?**

Não. O ponto e vírgula é permitido para vários comandos em uma mesma linha, mas em código normal cada instrução é escrita em uma linha nova.


---
Source: Skillaria.Top (https://skillaria.top)