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

Operazioni comuni Stringhe

s.index(s1) / s.index(s1, i, j): come find, ma
print(x, x, x, ..., sep=’␣’, end=’\n’): sep int(s): converte s in intero. Eccezione: se non presente solleva ValueError.
è il carattere separatore tra i valori (default spazio), ValueError. s.isalnum(): restituisce True se s contiene sole let-
end il carattere finale (default a capo) float(s): converte s in float. Eccezione: tere o cifre e ha almeno un carattere, altrimenti
input(s): restituisce una stringa con le info inserite ValueError. False.
da tastiera (senza ’\n’). s è il messaggio iniziale. str(x): converte x in stringa. s.isalpha(): restituisce True se s contiene sole let-
range(i, j, k): crea una sequenza di interi che ord(s): restituisce codice Unicode (intero) di s[0]. tere e ha almeno un carattere, altrimenti False.
parte da i (compreso, default 0), arriva fino a j chr(i): restituisce carattere corrispondente a codice s.isdigit(): restituisce True se s contiene sole cifre
(escluso, obbligatorio), con passo k (default 1). Unicode i. Eccezione: ValueError. e ha almeno un carattere, altrimenti False.
s+s1: crea e restituisce una nuova stringa concate- s.islower() / s.isupper(): restituisce True se s
Per tutti i contenitori cont: contiene sole lettere minuscole/maiuscole e ha al-
nando due stringhe.
len(cont): restituisce il numero di elementi. s*n: crea e restituisce una nuova stringa concate- meno un carattere, altrimenti False.
x in cont: restituisce True se l’elemento x è pre- nando n volte la stessa stringa. s.isspace(): restituisce True se s contiene soli
sente in cont, False altrimenti. s.lower() / s.upper(): restituisce la versione mi- caratteri di spaziatura (spazi, tab e newline) e ha
sum(cont): restituisce la somma dei valori degli ele- nuscola/maiuscola di s. almeno un carattere, altrimenti False.
menti. s.replace(s1, s2) / s.replace(s1, s2, n): Da stringhe a liste e viceversa:
max(cont) / min(cont): restituisce l’elemento mag- restituisce una nuova versione di s in cui ogni
giore/minore. occorrenza di s1 è sostituita da s2. Se è presente s.split(sep, maxsplit=n): restituisce una lista di
cont.clear(): elimina tutti gli elementi. n, sostituisce al massimo n occorrenze. sotto-stringhe ottenute suddividendo s ad ogni oc-
sorted(cont): restituisce una nuova lista conte- s.lstrip() / s.lstrip(s1): restituisce una nuova correnza della stringa sep (separatore). Se sep
nente gli elementi di cont ordinati. Supporta tutte versione di s in cui i caratteri di spaziatura (spazi, è omesso, per default è una sequenza di caratteri
le opzioni avanzate di list.sort(). tab, newline) sono eliminati dall’inizio di s. Se è di spaziatura. Se maxsplit è specificato, saranno
presente s1, vengono eliminati i caratteri presenti fatte al massimo n separazioni partendo da sinistra
Per tutte le sequenze seq:
in essa invece dei caratteri di spaziatura. (la lista avrà al più n+1 elementi).
seq.count(x): restituisce quante volte x è presente s.rstrip() / s.rstrip(s1): Come lstrip, ma i s.rsplit(sep, maxsplit=n): come split, ma
in seq. caratteri vengono eliminati dalla fine di s. suddivide s partendo da destra.
seq[i]: restituisce l’elemento di indice i s.strip() / s.strip(s1): Come lstrip, ma i s.splitlines(): come split, ma usa come separa-
(i<len(seq), altrimenti IndexError). Se caratteri vengono eliminati tanto a all’inizio quanto tore il ’\n’, suddivide quindi s in una lista conte-
i<0, parte dal fondo. alla fine. nente le singole righe di testo presenti in s.
seq[i:j]: restituisce una sottosequenza con gli ele- s1 in s: restituisce True se s contiene s1 come sot- s.join(l): restituisce una unica stringa contenente
menti consecutivi di seq, dalla posizione i (com- tostringa, altrimenti False. tutti gli elementi di l (che deve essere una lista di
presa, default=0) fino alla posizione j (esclusa, s.count(s1): restituisce il numero di occorrenze stringhe) separati dal separatore s.
default=len(seq)). non sovrapposte di s1 in s. Stringhe formattate f’{x:fmt}’
seq[i:j:k]: usa k come “passo” per selezionare gli s.startswith(s1) / s.endswith(s1): restituisce
elementi. Se k<0 e i>j va all’indietro. True se s inizia/termina con s1, altrimenti False. x è qualsiasi variabile o espressione. fmt sono codici
s.find(s1) / s.find(s1, i, j): restituisce il di formattazione, che possono contenere:
primo indice di s in cui inizia un’occorrenza di s1, < ^ >: allineamento a sinistra, centrato, a destra
oppure -1 se non c’è. Se presenti i e j, ricerca in width: numero che indica quanti caratteri in totale
s[i:j]. deve occupare il valore. Default: quanto basta.
.precision: numero di cifre decimali (se float) o mas-
 simo numero di caratteri (se non numerico). False. di dizionari, restituisce l’elemento il cui valore del
formato: s stringa, d intero decimale, f numero l.pop(): rimuove l’ultimo elemento e lo restituisce. campo con chiave k è maggiore/minore.
reale, g numero reale in notazione scientifica l.pop(i): rimuove l’elemento nella posizione i e lo max/min(l, key=itemgetter(n)): in una lista di
Esempio: f’{n:5d}␣{a:7.2f}␣{s:>10s}’ restituisce. Gli elementi seguenti sono spostati in- liste o tuple, restituisce l’elemento il cui valore del
dietro di un posto. campo di indice n è maggiore/minore. Utile an-
l.insert(i, x): inserisce x nella posizione i in l. che quando la lista l è il risultato della funzione
Matematica
Gli elementi da quella posizione in poi sono spostati enumerate().
abs(a) = |a| avanti di un posto. Nota: reverse e key si possono combinare.
round(a), round(a, n): arrotonda il valore di a l.append(x): aggiunge x in coda alla lista l.
all’intero più vicino o ad n cifre decimali l.count(x): restituisce il numero di occorrenze di x
floor(a): intero inferiore, ceil(a): intero superi- in l
ore, trunc(a): elimina parte frazionaria l.index(x): restituisce la posizione della prima oc-
correnza di x in l. L’elemento deve essere presente File
import math &
in lista, altrimenti solleva ValueError. f = open(s, modalita, encoding=’utf-8’):
math.sin(a), cos(a), tan(a), exp(a), log(a), l.index(x, i, j): restituisce la posizione della apre il file di nome s. modalita: ’r’ lettura,
sqrt(a). Possono sollevare ValueError prima occorrenza di x nella porzione di lista ’w’ scrittura. Restituisce un “oggetto file” f.
math.isclose(a, b, rel_tol, abs_tol): restitu- l[i:j]. La posizione restituita è riferita dall’inizio Eccezioni: FileNotFoundError se il file non esiste,
isce True se |a - b| è minore o uguale di rel_tol della lista. Se non trovata, solleva ValueError. in generale OSError.
(tolleranza relativa) o abs_tol (tolleranza asso- l.remove(x): rimuove l’elemento di valore x dalla f.close(): chiude il file f.
luta). lista e sposta indietro di un posto tutti gli elementi f.readline(): restituisce una stringa con i caratteri
che lo seguono. L’elemento deve essere presente in letti dal file f fino a ’\n’ (compreso). Restituisce
import random &
lista, altrimenti solleva ValueError. "" se a fine file.
random.random(): restituisce un numero casuale l.extend(l1): aggiunge tutti gli elementi della lista f.read(num): restituisce una stringa con (al mas-
float nell’intervallo [0,1). l1 alla lista l. simo) num caratteri letti dal file f. Senza argomenti
random.randint(i, j): restituisce un numero in- l.reverse(): rovescia l’ordine degli elementi nella restituisce l’intero file come un’unica stringa.
tero casuale tra i e j (estremi compresi). lista l. f.readlines(): restituisce il contenuto dell’intero
random.choice(seq): restituisce un elemento qual- l.copy() o list(l): restituisce una nuova lista, file sotto forma di lista di stringhe, una per riga.
siasi della sequenza seq. copia della lista l. f.write(s): scrive s nel file f. Nota: non aggiunge
random.shuffle(seq): rimescola in ordine casuale l.sort(reverse=False): ordina gli elementi della automaticamente il fine linea ’\n’.
gli elementi della sequenza seq. lista dal più piccolo al più grande. Se si specifica print(..., file=f): come print, ma scrive nel file
reverse=True, ordina in ordine inverso. f anziché su schermo.
enumerate(l): restituisce una lista di tuple di tipo
Liste import csv &
[(indice, valore1), (indice2, valore2), ...],
[]: crea e restituisce una nuova lista vuota permettendo di iterare contemporaneamente su csv.reader(f): restituisce un oggetto ’CSV reader’,
[x, ..., x]: restituisce una nuova lista con gli ele- indici e valori di l. su cui iterare con un ciclo for, che restituisce ad
menti forniti. from operator import itemgetter & ogni iterazione una lista i cui elementi sono i campi
list(cont): restituisce una nuova lista contenente della prossima riga del file f
tutti gli elementi del contenitore cont. l.sort(key=itemgetter(’k’)): ordina una lista di csv.DictReader(f, fieldnames=[...]): restitu-
l * n: restituisce una nuova lista replicando gli ele- dizionari in base al valore del campo con chiave k. isce un oggetto ’CSV dictionary reader’, su cui it-
menti di l per n volte. l.sort(key=itemgetter(n)): ordina una lista di erare con un ciclo for, che restituisce ad ogni iter-
l + l1: restituisce una nuova lista concatenando gli liste o di tuple in base al valore dell’elemento di azione un dizionario i cui valori sono i campi della
elementi di l ed l1. indice n. Utile anche quando la lista l è il risultato prossima riga del file f, e le cui chiavi sono gli el-
l == l1: restituisce True se le due liste contengono della funzione enumerate(). ementi di fieldnames (se omesso, le chiavi sono
gli stessi elementi, nello stesso ordine, altrimenti max/min(l, key=itemgetter(’k’)) : in una lista prese dalla prima riga del file).
Insiemi Dizionari Legenda (tipi degli argomenti/oggetti accettati)
set(): restituisce un nuovo insieme vuoto. k = chiave: stringa, numero, tupla s, s1: stringa
set(cont): restituisce un nuovo insieme che con- dict(): restituisce un nuovo dizionario vuoto. a, b, c, ...: intero o float
tiene una copia di cont (senza duplicati). {}: restituisce un nuovo dizionario vuoto. i, j, k, n: intero
{x, x, ..., x}: restituisce un nuovo insieme che {k:x, ..., k:x}: restituisce un nuovo dizionario x: qualsiasi
contiene gli elementi indicati (senza duplicati). contenente le coppie chiave/valore specificate. l, l1: lista
t.add(x): aggiunge un nuovo elemento all’insieme k in d: restituisce True se la chiave k appartiene al d: dizionario
t. Se l’elemento è già presente, non succede nulla. dizionario d, altrimenti False. t, t1: set
t.discard(x): elimina l’elemento dall’insieme t. Se d[k] = x: aggiunge una nuova coppia chiave/valore seq: sequenza (lista, tupla, stringa)
l’elemento non appartiene all’insieme, non ha ef- al dizionario d, se k non è già presente, altrimenti cont: contenitore (lista, tupla, stringa, set, dict)
fetto.
t.remove(x): come discard, ma se l’elemento non modifica il valore associato alla chiave k.
è presente solleva KeyError. d[k]: restituisce il valore associato alla chiave k, se
t == t1: determina se l’insieme t è uguale è presente in d, altrimenti solleva KeyError.
all’insieme t1. d.get(k, x): restituisce il valore associato alla chi-
t.issubset(t1) o t<=t1: determina se t ⊆ t1. ave k, se è presente in d, altrimenti restituisce il
t.issuperset(t1) o t>=t1: determina se t ⊇ t1. valore di default x.
t.isdisjoint(t1): restituisce True se l’intersezione d.pop(k): elimina da d la chiave k e il valore ad
degli insiemi t e t1 è nulla. essa associato; se non è presente, solleva KeyError.
t.union(t1) o t|t1: restituisce un nuovo insieme Restituisce il valore eliminato.
pari a t ∪ t1. d.items(): restituisce una listaa di tuple (k,x) di
t.intersection(t1) o t&t1: restituisce un nuovo tutti gli elementi di d, in ordine di inserimento.
insieme pari a t ∩ t1. d.values(): restituisce una listaa contenente tutti i
t.difference(t1) o t-t1: restituisce un nuovo in- valori presenti in d.
sieme che contiene gli elementi che appartengono a d.keys(): restituisce una listaa con le chiavi del
t ma non a t1. dizionario, in ordine di inserimento.
t.symmetric_difference(t1) o t^t1: restituisce sorted(d): restituisce una lista ordinata delle chiavi
un nuovo insieme che contiene gli elementi presenti del dizionario.
in uno solo degli insiemi e non in entrambi (opera- sorted(d.items()): restituisce una lista, ordinata
tore x-or). per chiave, di tuple (k,x) di tutti gli elementi di
t.copy() o set(t): restituisce una copia d.
dell’insieme t. d.copy() o dict(d): restituisce una copia del
dizionario.
a per la precisione, restituisce una vista, che può essere con-
vertita in lista con list(...) o che può essere iterata con
un ciclo for...in

vers. 2.4 - ultimo aggiornamento 19/12/2021