# Cheat sheet Python: sintassi, comandi e funzioni integrate in tabelle

URL: https://skillaria.top/it/guides/python/cheat-sheet-python

La sintassi di Python si basa sui rientri invece delle parentesi graffe: il blocco dopo i due punti è spostato di 4 spazi. Le basi sono variabili senza dichiarazione di tipo, condizioni if/elif/else, cicli for e while, funzioni def, e le funzioni integrate print, len, range, input, type più i metodi di stringhe, liste e dizionari.

Questo cheat sheet di Python raccoglie in un'unica pagina ciò che serve avere a portata di mano nei primi mesi: la sintassi, i cicli, le funzioni integrate, i metodi di stringhe, liste e dizionari e i comandi del terminale. Ogni tabella è un breve riferimento con esempi funzionanti che si possono incollare subito nella REPL.

## Basi della sintassi Python

La caratteristica principale del linguaggio è che i blocchi sono definiti dai rientri, non dalle parentesi. Dopo una riga con i due punti (`if`, `for`, `def`, `class`) le righe successive vengono spostate di 4 spazi. Non si possono mescolare tabulazioni e spazi — otterrete un `IndentationError`.

| Costrutto | Esempio | Spiegazione |
| --- | --- | --- |

| Commento | `# testo` | tutto dopo # fino a fine riga viene ignorato |

| Variabile | `age = 25` | il tipo non si dichiara, lo determina il valore |

| Assegnazione multipla | `a, b = 1, 2` | spacchettamento; scambio di valori: `a, b = b, a` |

| Output | `print("Ciao", name)` | gli argomenti sono separati da uno spazio |

| Input | `s = input("Nome: ")` | restituisce sempre una stringa |

| F-string | `f"{name}: {price:.2f}"` | inserimento di espressioni e formato |

| Annotazione di tipo | `count: int = 0` | suggerimento per IDE e controlli, non verificato all'avvio |

| Blocco vuoto | `pass` | segnaposto dove la sintassi richiede un corpo |

| Importazione | `from math import sqrt` | collegamento di un modulo o di un nome da esso |

### Tipi di dati

| Tipo | Letterale | Modificabile |
| --- | --- | --- |

| `int` | `42`, `1_000_000` | no |

| `float` | `3.14`, `1e-3` | no |

| `bool` | `True`, `False` | no |

| `str` | `"testo"`, `'testo'`, `"""più righe"""` | no |

| `list` | `[1, 2, 3]` | sì |

| `tuple` | `(1, 2)`, `(1,)` | no |

| `dict` | `{"a": 1}` | sì |

| `set` | `{1, 2}`, vuoto — `set()` | sì |

| `NoneType` | `None` | — |

### Operatori

| Gruppo | Operatori | Esempio → risultato |
| --- | --- | --- |

| Aritmetica | `+ - * / // % **` | `7 // 2` → 3, `7 % 2` → 1, `2 ** 10` → 1024 |

| Confronto | `== != < > <= >=` | `1 < x < 10` — catena di confronti |

| Logica | `and or not` | `x or "predefinito"` |

| Appartenenza | `in`, `not in` | `"a" in "abc"` → True |

| Identità | `is`, `is not` | `x is None` |

| Assegnazione | `+= -= *= /=`, `:=` | `if (n := len(s)) > 10: ...` |

## Condizioni e pattern matching

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

status = "adulto" if age >= 18 else "bambino"   # operatore ternario

match command:
    case "start":
        print("Avvio")
    case "stop" | "exit":
        print("Arresto")
    case _:
        print("Comando sconosciuto")
```

Sono considerati falsi `False`, `None`, `0`, la stringa vuota e le collezioni vuote, quindi al posto di `if len(items) > 0` si scrive semplicemente `if items`.

## Cicli in Python: sintassi di for e while

### Ciclo for

Sintassi del ciclo for in Python: `for variabile in sequenza:` seguito dal corpo con il rientro. Il ciclo scorre qualsiasi oggetto iterabile — stringa, lista, dizionario, file, `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(["mela", "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)
```

### Ciclo while

```
attempts = 3
while attempts > 0:
    password = input("Password: ")
    if password == "secret":
        print("Accesso eseguito")
        break
    attempts -= 1
else:
    print("Tentativi esauriti")   # eseguito se non c'è stato break
```

| Comando | Che cosa fa |
| --- | --- |

| `break` | esce dal ciclo in anticipo |

| `continue` | passa all'iterazione successiva |

| `else` del ciclo | eseguito se il ciclo termina senza `break` |

| `range(stop)`, `range(start, stop, step)` | sequenza di numeri, `stop` non è incluso |

### Comprehension

```
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))   # espressione generatore
```

## Funzioni

```
def greet(name: str, greeting: str = "Ciao") -> str:
    """Restituisce un saluto."""
    return f"{greeting}, {name}!"

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

square = lambda x: x * x
print(greet("Anna"))                 # Ciao, Anna!
print(greet("Anna", greeting="Hei"))  # Hei, Anna!
```

| Elemento | Significato |
| --- | --- |

| `def f(a, b=1)` | parametro con valore predefinito |

| `*args` | un numero qualsiasi di argomenti posizionali (tupla) |

| `**kwargs` | un numero qualsiasi di argomenti con nome (dizionario) |

| `return` | restituisce un valore; senza di esso la funzione restituisce `None` |

| `lambda x: ...` | breve funzione anonima in una sola espressione |

| `global`, `nonlocal` | modifica di una variabile da un ambito esterno |

Non usate come valore predefinito un oggetto modificabile come `def f(items=[])`: la lista viene creata una sola volta e si accumula tra le chiamate. Corretto è `items=None` e dentro `if items is None: items = []`.

## Funzioni integrate di Python

Le funzioni integrate di Python sono disponibili senza importazioni. Sono le funzioni principali che compaiono quasi in ogni script.

| Funzione | Che cosa fa | Esempio → risultato |
| --- | --- | --- |

| `print()` | stampa i valori | `print(1, 2, sep="-")` → 1-2 |

| `input()` | legge una stringa dalla tastiera | `int(input())` |

| `len()` | lunghezza di una collezione o di una stringa | `len("abc")` → 3 |

| `type()` | tipo di un oggetto | `type(3.0)` → <class 'float'> |

| `isinstance()` | verifica del tipo | `isinstance(5, int)` → True |

| `int() float() str() bool()` | conversione di tipo | `int("42")` → 42 |

| `list() tuple() set() dict()` | creazione di collezioni | `list("ab")` → ['a', 'b'] |

| `range()` | intervallo di numeri | `list(range(3))` → [0, 1, 2] |

| `enumerate()` | coppie (indice, elemento) | `list(enumerate("ab"))` → [(0, 'a'), (1, 'b')] |

| `zip()` | unisce sequenze a coppie | `list(zip([1, 2], "ab"))` → [(1, 'a'), (2, 'b')] |

| `sum() min() max()` | somma, minimo, massimo | `max([3, 7, 1])` → 7 |

| `abs() round()` | valore assoluto e arrotondamento | `round(3.14159, 2)` → 3.14 |

| `sorted()` | nuova lista ordinata | `sorted(words, key=len, reverse=True)` |

| `reversed()` | iteratore in ordine inverso | `list(reversed([1, 2]))` → [2, 1] |

| `map() filter()` | applica una funzione / filtra | `list(map(str, [1, 2]))` → ['1', '2'] |

| `any() all()` | almeno uno / tutti veri | `all(x > 0 for x in nums)` |

| `open()` | apre un file | `open("a.txt", encoding="utf-8")` |

| `help() dir()` | guida e elenco degli attributi | `help(str.split)`, `dir(list)` |

| `id() hash()` | identificatore e hash di un oggetto | `hash("a")` |

Il miglior riferimento sempre a portata di mano è la funzione `help()` nella REPL: `help(dict)` mostra tutti i metodi del dizionario con la descrizione, mentre `dir(obj)` elenca i nomi disponibili.

## Metodi delle stringhe

Sintassi delle stringhe in Python: una stringa non è modificabile, ogni metodo restituisce una nuova stringa. Le fette funzionano come per le liste: `s[1:4]`, `s[::-1]` — inversione.

| Metodo | Esempio → risultato |
| --- | --- |

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

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

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

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

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

| `replace(old, new)` | `"gatto".replace("g", "r")` → 'ratto' |

| `find() index()` | `"hello".find("l")` → 2; se non c'è — -1 (con `index` — errore) |

| `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' |

## Comandi delle liste Python

La lista è una collezione ordinata e modificabile. La maggior parte dei metodi modifica la lista sul posto e restituisce `None`, quindi `a = a.sort()` è un errore frequente.

| Operazione | Che cosa fa | Esempio |
| --- | --- | --- |

| `append(x)` | aggiunge in fondo | `a.append(4)` |

| `extend(iter)` | aggiunge tutti gli elementi | `a.extend([5, 6])` |

| `insert(i, x)` | inserisce per indice | `a.insert(0, "primo")` |

| `remove(x)` | rimuove la prima occorrenza del valore | `a.remove(3)` |

| `pop(i)` | rimuove e restituisce l'elemento (per default l'ultimo) | `last = a.pop()` |

| `clear()` | svuota la lista | `a.clear()` |

| `index(x)` | indice della prima occorrenza | `a.index("b")` |

| `count(x)` | numero di occorrenze | `a.count(1)` |

| `sort()` | ordina sul posto | `a.sort(key=str.lower)` |

| `reverse()` | inverte sul posto | `a.reverse()` |

| `copy()` | copia superficiale | `b = a.copy()` |

| `del a[i]` | rimozione per indice o fetta | `del a[1:3]` |

| Fette | `a[start:stop:step]` | `a[-1]` — l'ultimo, `a[:3]` — i primi tre |

## Comandi dei dizionari Python

| Operazione | Che cosa fa | Esempio |
| --- | --- | --- |

| `d[key]` | valore per chiave, se la chiave manca — `KeyError` | `d["name"]` |

| `get(key, default)` | valore oppure quello di riserva | `d.get("age", 0)` |

| `d[key] = value` | aggiunge o modifica | `d["city"] = "Milano"` |

| `keys() values() items()` | chiavi, valori, coppie | `for k, v in d.items():` |

| `update()` | unisce con un altro dizionario | `d.update({"a": 1})` |

| `d1 | d2` | nuovo dizionario unito | `merged = defaults | user` |

| `pop(key, default)` | rimuove e restituisce il valore | `d.pop("tmp", None)` |

| `popitem()` | rimuove l'ultima coppia aggiunta | `d.popitem()` |

| `setdefault(key, value)` | restituisce il valore; se la chiave manca, la crea | `d.setdefault("tags", []).append("py")` |

| `key in d` | verifica della presenza della chiave | `if "name" in d:` |

| `dict.fromkeys()` | dizionario dalle chiavi con un solo valore | `dict.fromkeys("abc", 0)` |

| `len(d)`, `del d[key]` | dimensione e cancellazione | `del d["old"]` |

### Tuple e insiemi

| Operazione | Esempio → risultato |
| --- | --- |

| Spacchettamento di una tupla | `x, y = (3, 4)` |

| Aggiungere a un insieme | `s.add(5)`, rimuovere — `s.discard(5)` |

| Unione / intersezione | `{1, 2} | {2, 3}` → {1, 2, 3}; `{1, 2} & {2, 3}` → {2} |

| Differenza | `{1, 2} - {2}` → {1} |

| Eliminare i duplicati da una lista | `list(dict.fromkeys(items))` — mantenendo l'ordine |

## Eccezioni e file

```
try:
    number = int(input("Numero: "))
except ValueError as err:
    print("Non è un numero:", err)
else:
    print("Successo")
finally:
    print("Viene sempre eseguito")

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

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

| Eccezione | Quando si verifica |
| --- | --- |

| `SyntaxError`, `IndentationError` | errore nella sintassi o nei rientri |

| `NameError` | nome non definito (refuso) |

| `TypeError` | operazione con un tipo non adatto: `"1" + 1` |

| `ValueError` | tipo giusto, ma valore non valido: `int("abc")` |

| `IndexError`, `KeyError` | indice o chiave inesistente |

| `FileNotFoundError` | file non trovato |

| `ZeroDivisionError` | divisione per zero |

## Classi

```
from dataclasses import dataclass

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

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

@dataclass
class Point:
    x: float
    y: float

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

## Moduli integrati di Python

La libreria standard viene installata insieme all'interprete — basta un `import`.

| Modulo | A cosa serve | Esempio |
| --- | --- | --- |

| `math` | matematica | `math.sqrt(16)` → 4.0 |

| `random` | numeri casuali | `random.randint(1, 6)`, `random.choice(items)` |

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

| `pathlib` | percorsi e file | `Path("data").glob("*.csv")` |

| `os`, `sys` | sistema, variabili d'ambiente, argomenti | `os.environ.get("HOME")`, `sys.argv` |

| `json` | lettura e scrittura di JSON | `json.loads(text)`, `json.dumps(obj, ensure_ascii=False)` |

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

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

| `itertools` | combinazioni e catene di iteratori | `itertools.chain(a, b)` |

| `re` | espressioni regolari | `re.findall(r"\d+", s)` |

| `time` | pause e misura del tempo | `time.sleep(1)`, `time.perf_counter()` |

| `asyncio` | codice asincrono | `asyncio.run(main())` |

In Python 3.15 è comparso l'import pigro (PEP 810): `lazy import pandas as pd` rinvia il caricamento del modulo fino al primo utilizzo, e lo script con dipendenze pesanti si avvia sensibilmente più in fretta.

## Comandi Python nel terminale

Un gruppo a parte di ricerche riguarda i comandi per avviare l'interprete e installare le librerie. Su Windows al posto di `python3` di solito si scrive `python` oppure `py`.

| Comando | Che cosa fa |
| --- | --- |

| `python3 --version` | mostra la versione |

| `python3` | apre la console interattiva REPL (uscita — `exit()`) |

| `python3 script.py` | avvia un file |

| `python3 -c "print(2 + 2)"` | esegue una sola riga |

| `python3 -m venv .venv` | crea un ambiente virtuale |

| `source .venv/bin/activate` / `.venv\Scripts\activate` | attiva l'ambiente (Linux, macOS / Windows) |

| `python3 -m pip install requests` | installa un pacchetto |

| `pip list`, `pip freeze > requirements.txt` | elenco dei pacchetti e salvataggio |

| `pip install -r requirements.txt` | installa le dipendenze da un file |

| `python3 -m http.server 8000` | semplice server web nella cartella corrente |

| `uv init`, `uv add requests`, `uv run main.py` | progetto, dipendenza e avvio tramite il gestore uv |

## Errori frequenti dei principianti

- **Confronto con `=`** — nella condizione serve `==`; il singolo `=` è un'assegnazione.
- **Dimenticare i due punti** dopo `if`, `for`, `def` dà `SyntaxError`.
- **Sommare stringa e numero**: `"Età: " + 25` è un errore, scrivete `f"Età: {25}"`.
- **Modificare una lista durante il ciclo** — scorrete una copia `for x in a[:]` o costruite una nuova lista.
- **`input()` restituisce una stringa** — per l'aritmetica avvolgetelo in `int()` o `float()`.

## Riepilogo

La sintassi di Python si regge su rientri, due punti e un piccolo insieme di costrutti: condizioni, cicli for e while, funzioni, classi. Aggiungete qualche decina di funzioni integrate e i metodi di stringhe, liste e dizionari, e coprirete gran parte dei compiti quotidiani. Conservate il cheat sheet e, quando le tabelle diventeranno familiari, passate ai moduli e all'asincronia; tutto questo è spiegato passo dopo passo, con esempi pratici, nel corso «Python 3.15: dal principiante al professionista».

## FAQ

**Quanti spazi usare per il rientro in Python?**

Secondo lo standard PEP 8 si usano 4 spazi per livello. L'importante è usarli in modo uniforme in tutto il blocco e senza mescolarli con le tabulazioni.

**In cosa una lista si differenzia da una tupla?**

La lista è modificabile: si può estendere e ordinare sul posto; la tupla non è modificabile, quindi può essere una chiave di dizionario e serve per insiemi di valori fissi.

**Come vedere tutti i metodi di un oggetto direttamente in Python?**

Richiamate dir(obj) per l'elenco dei nomi e help(obj) per la descrizione — per esempio help(str) mostra tutti i metodi delle stringhe.

**Qual è la differenza tra sort() e sorted()?**

Il metodo list.sort() ordina la lista stessa e restituisce None, mentre la funzione sorted() restituisce una nuova lista e accetta qualsiasi collezione iterabile.

**Serve il punto e virgola alla fine della riga?**

No. Il punto e virgola è ammesso per più istruzioni su una stessa riga, ma nel codice normale ogni istruzione va scritta su una riga nuova.


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