Corso Python

Le fondamenta: dichiarare variabili, riconoscere i tipi, fare calcoli, prendere decisioni e stampare in console.

1. 1.1Variabili e tipiDare un nome a un valore, scoprire il tipo con type(), conoscere int / float / str / bool / None.~10 min
2. 1.2OperatoriAritmetica (incluso // e **), confronto, logica booleana con and / or / not, precedenza.~10 min
3. 1.3Condizionali: if, elif, elseEseguire codice diverso a seconda di una condizione; il ruolo dell’indentazione.~10 min
4. 1.4Stampa e f-stringprint() per mostrare valori, f-string per comporre testo con interpolazione `{var}`.~8 min

Ripetere, saltare, gestire errori: i costrutti che fanno reagire il programma ai dati e ai problemi.

1. 2.1Cicli for e rangeIterare su una sequenza con for, generare intervalli numerici con range(start, stop, step).~10 min
2. 2.2Cicli whileRipetere finché una condizione resta vera; quando preferire while invece di for.~8 min
3. 2.3break, continue ed else nei cicliUscire in anticipo da un loop, saltare un’iterazione, usare il particolare for…else.~10 min
4. 2.4Gestione errori: try/exceptCatturare eccezioni specifiche, distinguere try/except/else/finally, sollevare errori con raise.~12 min

Le quattro collezioni built-in: list (sequenza mutabile), tuple (sequenza immutabile), dict (mappa chiave-valore) e set (collezione di elementi unici).

1. 3.1ListeCreare, accedere per indice e slice, aggiungere e rimuovere, ordinare. La sequenza che userai di più.~12 min
2. 3.2Tuple e unpackingSequenze immutabili, packing e unpacking, swap senza variabile temporanea, * per il resto.~10 min
3. 3.3DizionariMappe chiave→valore, accesso con [] e .get, iterare su keys/values/items, dict.setdefault.~12 min
4. 3.4SetCollezioni di elementi unici, operazioni insiemistiche (& | - ^), test di appartenenza O(1).~10 min

Lavorare con testo (metodi, slicing) e numeri (math, conversioni di tipo) in modo idiomatico.

1. 4.1Metodi delle stringheI metodi più usati: upper/lower, strip, split/join, replace, startswith/endswith, find/in.~12 min
2. 4.2Slicing e indicizzazioneIndici positivi e negativi, slice [start:stop:step], inversione di stringa, sottostringhe.~10 min
3. 4.3Numeri e modulo mathint, float, divisione vera vs intera, modulo %, abs/round/min/max, math.sqrt, math.pi.~10 min
4. 4.4Conversioni di tipoint(), float(), str(), bool(): casting esplicito, parsing di input, truthiness dei valori.~10 min

Definire funzioni con def, restituire valori, gestire parametri di default, *args/**kwargs e lambda.

1. 5.1def e returnSintassi def, return (esplicito e implicito None), parametri posizionali, docstring.~12 min
2. 5.2Parametri di default e keywordDefault values, chiamate con keyword arguments, ordine posizionali-prima-keyword, pitfall mutable default.~12 min
3. 5.3*args e **kwargsFunzioni a numero variabile di argomenti: *args raccoglie posizionali, **kwargs raccoglie keyword. Unpack in chiamata.~12 min
4. 5.4Lambda e funzioni higher-orderFunzioni anonime con lambda, uso con sorted/max/min, quando preferire def, sorted(..., key=...).~10 min

List/dict/set comprehensions, generator expressions e i tool fondamentali del modulo itertools.

1. 6.1List comprehensionSintassi [espressione for x in iter if cond], trasformazione, filtraggio, nested.~12 min
2. 6.2Dict e set comprehensionSintassi {k: v for ...} e {x for ...} per costruire dict e set in modo dichiarativo.~10 min
3. 6.3Generator expressionSintassi (... for ... in ...), lazy iteration, memoria costante, sum/any/all su generatori.~10 min
4. 6.4itertools essenzialiLe funzioni più usate: enumerate, zip, chain, count, repeat, combinations.~12 min

Programmazione orientata agli oggetti in Python: classi, ereditarietà, metodi speciali (dunder), import e organizzazione in moduli.

1. 7.1Classi e istanzeclass, __init__, attributi e metodi di istanza, self, attributi di classe vs di istanza.~14 min
2. 7.2EreditarietàSottoclassi, super(), override di metodi, isinstance, MRO base.~12 min
3. 7.3Metodi speciali (dunder)__str__, __repr__, __eq__, __len__: integrare i tuoi oggetti con il linguaggio.~12 min
4. 7.4import e moduliimport, from ... import, alias as, organizzazione in moduli, if __name__ == "__main__".~10 min

I moduli della standard library che incontrerai ogni giorno: json, datetime, collections, re.

1. 8.1JSON: serialize e parsejson.dumps / json.loads, mappatura tipi Python ↔ JSON, indent, sort_keys, default.~10 min
2. 8.2datetime: date e oraridatetime.now(), date/time/datetime/timedelta, formatting con strftime, parsing con strptime, aritmetica.~12 min
3. 8.3collections: Counter e defaultdictCounter per conteggi, defaultdict per dict auto-inizializzati, namedtuple come record leggero.~12 min
4. 8.4Modulo re: regex in Pythonre.search / re.match / re.findall / re.sub, flag, raw string r"...", gruppi nominati.~12 min

Le pratiche moderne di Python: type hints, dataclass, context manager e decoratori. Il codice che scrivi nel 2025.

1. 9.1Type hints: annotare i tipiAnnotazioni di parametri e return, list[int] / dict[str, int], Optional, Union, cenni a mypy.~12 min
2. 9.2dataclass: classi-dati senza boilerplate@dataclass, field(default_factory=...), frozen=True, equivalente di __init__/__repr__/__eq__.~12 min
3. 9.3Context manager: with e __enter__/__exit__with open(...), scrivere il proprio context manager con __enter__/__exit__, contextlib.contextmanager.~12 min
4. 9.4Decoratori: funzioni che modificano funzioniFunzioni di ordine superiore, sintassi @decorator, functools.wraps, esempio @timeit.~14 min