python cheat sheet document, Cheat Sheet of Informatics Engineering

python cheat sheet document exam

Typology: Cheat Sheet

2025/2026

Uploaded on 06/18/2026

ace-ace-11
ace-ace-11 🇳🇱

1 document

1 / 3

Toggle sidebar

This page cannot be seen from the preview

Don't miss anything!

bg1
Prontuario Python: principali funzioni e meto di Informatica (14BHD) - Anno Accademico 2022/2023 - Politecnico di Torino
Operazioni comuni
print(x, x, x, ..., sep=’␣’, end=’\n’):sep è
il carattere separatore tra i valori (default spazio),
end il carattere finale (default a capo)
input(s): restituisce una stringa con le info inserite
da tastiera (senza ’\n’). sè il messaggio iniziale.
range(i, j, k): crea una sequenza di interi che
parte da i(compreso, default 0), arriva fino a j
(escluso, obbligatorio), con passo k(default 1).
from pprint import pprint &
pprint(...) funziona come print, ma il suo output
è più ordinato (pretty print), utile per visualizzare
il contenuto di strutture dati complesse.
Per tutti i contenitori cont:
len(cont): restituisce il numero di elementi.
x in cont: restituisce True se l’elemento xè pre-
sente in cont,False altrimenti.
sum(cont): restituisce la somma dei valori degli ele-
menti.
max(cont) /min(cont): restituisce l’elemento mag-
giore/minore (in caso di dati strutturati, vedere
itemgetter)
cont.clear(): elimina tutti gli elementi.
sorted(cont): restituisce una nuova lista contenente
gli elementi di cont ordinati. Supporta tutte le
opzioni avanzate di list.sort().
Per tutte le sequenze seq:
seq.count(x): restituisce quante volte xè presente
in seq.
seq[i]: restituisce l’elemento di indice i
(i<len(seq), altrimenti IndexError). Se i<0,
parte dal fondo.
seq[i:j]: restituisce una sottosequenza con gli ele-
menti consecutivi di seq, dalla posizione i(com-
presa, default=0) fino alla posizione j(esclusa,
default=len(seq)).
seq[i:j:k]: usa kcome “passo” per selezionare gli
elementi. Se k<0 ei>j va all’indietro.
Matematica
abs(a) =|a|
round(a),round(a, n): arrotonda il valore di a
all’intero più vicino o ad ncifre decimali
floor(a)/ceil(a):bac/dae
trunc(a): elimina parte frazionaria
import math &
math.sin(a),cos(a),tan(a),exp(a),log(a),
sqrt(a). Possono sollevare ValueError
math.isclose(a, b, rel_tol, abs_tol): restitu-
isce True se |a - b| è minore o uguale di rel_tol
(tolleranza relativa) o abs_tol (tolleranza asso-
luta).
import random &
random.random(): restituisce un numero casuale
float nell’intervallo [0,1).
random.randint(i, j): restituisce un numero in-
tero casuale tra iej(estremi compresi).
random.uniform(a, b): restituisce un numero reale
casuale tra aeb(estremi compresi).
random.choice(seq): restituisce un elemento qualsi-
asi della sequenza seq.
random.shuffle(seq): rimescola in ordine casuale
gli elementi della sequenza seq.
Stringhe
int(s): converte sin intero. Eccezione:
ValueError.
float(s): converte sin float. Eccezione:
ValueError.
str(x): converte xin stringa.
ord(s): restituisce codice Unicode (intero) di s[0].
chr(i): restituisce carattere corrispondente a codice
Unicode i. Eccezione: ValueError.
s+s1: crea e restituisce una nuova stringa concate-
nando due stringhe.
s*n: crea e restituisce una nuova stringa concate-
nando nvolte la stessa stringa.
s.lower() /s.upper(): restituisce la versione mi-
nuscola/maiuscola di s.
s.replace(s1, s2) /s.replace(s1, s2, n):
restituisce una nuova versione di sin cui ogni oc-
correnza di s1 è sostituita da s2. Se è presente n,
sostituisce al massimo noccorrenze.
s.lstrip() /s.lstrip(s1): restituisce una nuova
versione di sin cui i caratteri di spaziatura (spazi,
tab, newline) sono eliminati dall’inizio di s. Se è
presente s1, vengono eliminati i caratteri presenti
in essa invece dei caratteri di spaziatura.
s.rstrip() /s.rstrip(s1): Come lstrip, ma i
caratteri vengono eliminati dalla fine di s.
s.strip() /s.strip(s1): Come lstrip, ma i
caratteri vengono eliminati tanto a all’inizio quanto
alla fine.
s1 in s: restituisce True se scontiene s1 come sot-
tostringa, altrimenti False.
s.count(s1): restituisce il numero di occorrenze non
sovrapposte di s1 in s.
s.startswith(s1) /s.endswith(s1): restituisce
True se sinizia/termina con s1, altrimenti False.
s.find(s1) /s.find(s1, i, j): restituisce il
primo indice di sin cui inizia un’occorrenza di s1,
oppure -1 se non c’è. Se presenti iej, ricerca in
s[i:j].
s.index(s1) /s.index(s1, i, j): come find, ma
se non presente solleva ValueError.
s.isalnum(): restituisce True se scontiene sole let-
tere o cifre e ha almeno un carattere, altrimenti
False.
s.isalpha(): restituisce True se scontiene sole let-
tere e ha almeno un carattere, altrimenti False.
s.isdigit(): restituisce True se scontiene sole cifre
e ha almeno un carattere, altrimenti False.
s.islower() /s.isupper(): restituisce True se s
1
pf3

Partial preview of the text

Download python cheat sheet document and more Cheat Sheet Informatics Engineering in PDF only on Docsity!

Prontuario Python: principali funzioni e metodi Informatica (14BHD) - Anno Accademico 2022/2023 - Politecnico di Torino

Operazioni comuni

print(x, x, x, ..., sep=’␣’, end=’\n’): sep è il carattere separatore tra i valori (default spazio), end il carattere finale (default a capo) input(s): restituisce una stringa con le info inserite da tastiera (senza ’\n’). s è il messaggio iniziale. range(i, j, k): crea una sequenza di interi che parte da i (compreso, default 0 ), arriva fino a j (escluso, obbligatorio), con passo k (default 1 ).

from pprint import pprint ↘

pprint(...) funziona come print, ma il suo output è più ordinato (pretty print), utile per visualizzare il contenuto di strutture dati complesse. Per tutti i contenitori cont:

len(cont): restituisce il numero di elementi. x in cont: restituisce True se l’elemento x è pre- sente in cont, False altrimenti. sum(cont): restituisce la somma dei valori degli ele- menti. max(cont) / min(cont): restituisce l’elemento mag- giore/minore (in caso di dati strutturati, vedere itemgetter) cont.clear(): elimina tutti gli elementi. sorted(cont): restituisce una nuova lista contenente gli elementi di cont ordinati. Supporta tutte le opzioni avanzate di list.sort(). Per tutte le sequenze seq:

seq.count(x): restituisce quante volte x è presente in seq. seq[i]: restituisce l’elemento di indice i (ij va all’indietro.

Matematica

abs(a) = |a| round(a), round(a, n): arrotonda il valore di a all’intero più vicino o ad n cifre decimali floor(a)/ceil(a): bac / dae trunc(a): elimina parte frazionaria import math ↘ math.sin(a), cos(a), tan(a), exp(a), log(a), sqrt(a). Possono sollevare ValueError math.isclose(a, b, rel_tol, abs_tol): restitu- isce True se |a - b| è minore o uguale di rel_tol (tolleranza relativa) o abs_tol (tolleranza asso- luta). import random ↘ random.random(): restituisce un numero casuale float nell’intervallo [0,1). random.randint(i, j): restituisce un numero in- tero casuale tra i e j (estremi compresi). random.uniform(a, b): restituisce un numero reale casuale tra a e b (estremi compresi). random.choice(seq): restituisce un elemento qualsi- asi della sequenza seq. random.shuffle(seq): rimescola in ordine casuale gli elementi della sequenza seq.

Stringhe

int(s): converte s in intero. Eccezione: ValueError. float(s): converte s in float. Eccezione: ValueError. str(x): converte x in stringa. ord(s): restituisce codice Unicode (intero) di s[0]. chr(i): restituisce carattere corrispondente a codice Unicode i. Eccezione: ValueError.

s+s1: crea e restituisce una nuova stringa concate- nando due stringhe. s*n: crea e restituisce una nuova stringa concate- nando n volte la stessa stringa. s.lower() / s.upper(): restituisce la versione mi- nuscola/maiuscola di s. s.replace(s1, s2) / s.replace(s1, s2, n): restituisce una nuova versione di s in cui ogni oc- correnza di s1 è sostituita da s2. Se è presente n, sostituisce al massimo n occorrenze. s.lstrip() / s.lstrip(s1): restituisce una nuova versione di s in cui i caratteri di spaziatura (spazi, tab, newline) sono eliminati dall’inizio di s. Se è presente s1, vengono eliminati i caratteri presenti in essa invece dei caratteri di spaziatura. s.rstrip() / s.rstrip(s1): Come lstrip, ma i caratteri vengono eliminati dalla fine di s. s.strip() / s.strip(s1): Come lstrip, ma i caratteri vengono eliminati tanto a all’inizio quanto alla fine. s1 in s: restituisce True se s contiene s1 come sot- tostringa, altrimenti False. s.count(s1): restituisce il numero di occorrenze non sovrapposte di s1 in s. s.startswith(s1) / s.endswith(s1): restituisce True se s inizia/termina con s1, altrimenti False. s.find(s1) / s.find(s1, i, j): restituisce il primo indice di s in cui inizia un’occorrenza di s1, oppure -1 se non c’è. Se presenti i e j, ricerca in s[i:j]. s.index(s1) / s.index(s1, i, j): come find, ma se non presente solleva ValueError. s.isalnum(): restituisce True se s contiene sole let- tere o cifre e ha almeno un carattere, altrimenti False. s.isalpha(): restituisce True se s contiene sole let- tere e ha almeno un carattere, altrimenti False. s.isdigit(): restituisce True se s contiene sole cifre e ha almeno un carattere, altrimenti False. s.islower() / s.isupper(): restituisce True se s

contiene sole lettere minuscole/maiuscole e ha al- meno un carattere, altrimenti False. s.isspace(): restituisce True se s contiene soli caratteri di spaziatura (spazi, tab e newline) e ha almeno un carattere, altrimenti False. Da stringhe a liste e viceversa:

s.split(sep, maxsplit=n): restituisce una lista di sotto-stringhe ottenute suddividendo s ad ogni occorrenza della stringa sep (separatore). Se sep è omesso, per default è una sequenza di caratteri di spaziatura. Se maxsplit è specificato, saranno fatte al massimo n separazioni partendo da sinistra (la lista avrà al più n+1 elementi). s.rsplit(sep, maxsplit=n): come split, ma sud- divide s partendo da destra. s.splitlines(): come split, ma usa come separa- tore il ’\n’, suddivide quindi s in una lista conte- nente le singole righe di testo presenti in s. s.join(l): restituisce una unica stringa contenente tutti gli elementi di l (che deve essere una lista di stringhe) separati dal separatore s. Stringhe formattate f’{x:fmt}’

x è qualsiasi variabile o espressione. fmt sono codici di formattazione, che possono contenere: < ^ >: allineamento a sinistra, centrato, a destra width: numero che indica quanti caratteri in totale deve occupare il valore. Default: quanto basta. .precision: numero di cifre decimali (se float) o mas- simo numero di caratteri (se non numerico). formato: s stringa, d intero decimale, f numero reale, g numero reale in notazione scientifica Esempio: f’{n:5d}␣{a:7.2f}␣{s:>10s}’

Liste

[]: crea e restituisce una nuova lista vuota [x, ..., x]: restituisce una nuova lista con gli ele- menti forniti. list(cont): restituisce una nuova lista contenente tutti gli elementi del contenitore cont. l * n: restituisce una nuova lista replicando gli ele- menti di l per n volte.

l + l1: restituisce una nuova lista concatenando gli elementi di l ed l1. l == l1: restituisce True se le due liste contengono gli stessi elementi, nello stesso ordine, altrimenti False. l.pop(): rimuove l’ultimo elemento e lo restituisce. l.pop(i): rimuove l’elemento nella posizione i e lo restituisce. Gli elementi seguenti sono spostati indi- etro di un posto. l.insert(i, x): inserisce x nella posizione i in l. Gli elementi da quella posizione in poi sono spo- stati avanti di un posto. l.append(x): aggiunge x in coda alla lista l. l.count(x): restituisce il numero di occorrenze di x in l l.index(x): restituisce la posizione della prima oc- correnza di x in l. L’elemento deve essere presente in lista, altrimenti solleva ValueError. l.index(x, i, j): restituisce la posizione della prima occorrenza di x nella porzione di lista l[i:j]. La posizione restituita è riferita dall’inizio della lista. Se non trovata, solleva ValueError. l.remove(x): rimuove l’elemento di valore x dalla lista e sposta indietro di un posto tutti gli elementi che lo seguono. L’elemento deve essere presente in lista, altrimenti solleva ValueError. l.extend(l1): aggiunge tutti gli elementi della lista l1 alla lista l. l.reverse(): rovescia l’ordine degli elementi nella lista l. l.copy() o list(l): restituisce una nuova lista, copia della lista l. l.sort(reverse=False): ordina gli elementi della lista dal più piccolo al più grande. Se si specifica reverse=True, ordina in ordine inverso. enumerate(l): restituisce una lista di tuple di tipo [(indice, valore1), (indice2, valore2), ...], permettendo di iterare contemporaneamente su indici e valori di l. from operator import itemgetter ↘ l.sort(key=itemgetter(’k’)): ordina una lista di dizionari in base al valore del campo con chiave k. l.sort(key=itemgetter(n)): ordina una lista di

liste o di tuple in base al valore dell’elemento di in- dice n. Utile anche quando la lista l è il risultato della funzione enumerate() o dict.items(). max/min(l, key=itemgetter(’k’)) : in una lista di dizionari, restituisce l’elemento il cui valore del campo con chiave k è maggiore/minore. max/min(l, key=itemgetter(n)): in una lista di liste o tuple, restituisce l’elemento il cui valore del campo di indice n è maggiore/minore. Utile an- che quando la lista l è il risultato della funzione enumerate() o dict.items(). Nota: reverse e key si possono combinare.

Insiemi set(): restituisce un nuovo insieme vuoto. set(cont): restituisce un nuovo insieme che contiene una copia di cont (senza duplicati). {x, x, ..., x}: restituisce un nuovo insieme che contiene gli elementi indicati (senza duplicati). t.add(x): aggiunge un nuovo elemento all’insieme t. Se l’elemento è già presente, non succede nulla. t.discard(x): elimina l’elemento dall’insieme t. Se l’elemento non appartiene all’insieme, non ha ef- fetto. t.remove(x): come discard, ma se l’elemento non è presente solleva KeyError. t == t1: determina se l’insieme t è uguale all’insieme t1. t.issubset(t1) o t<=t1: determina se t ⊆ t1. t.issuperset(t1) o t>=t1: determina se t ⊇ t1. t.isdisjoint(t1): restituisce True se l’intersezione degli insiemi t e t1 è nulla. t.union(t1) o t|t1: restituisce un nuovo insieme pari a t ∪ t1. t.intersection(t1) o t&t1: restituisce un nuovo insieme pari a t ∩ t1. t.difference(t1) o t-t1: restituisce un nuovo in- sieme che contiene gli elementi che appartengono a t ma non a t1. t.symmetric_difference(t1) o t^t1: restituisce un nuovo insieme che contiene gli elementi presenti in uno solo degli insiemi e non in entrambi (x-or). t.copy() o set(t): restituisce una copia