Cheat Sheet Python3
Metodi integrati
| abs(num) | Ottieni il valore assoluto |
| all(iterable) | Restituisce True se tutti gli elementi dell’iterabile sono True |
| any(iterable) | Restituisce True se almeno un elemento dell’iterabile è True |
| ascii(object) | Converte i caratteri non ASCII in un oggetto in caratteri ASCII |
| bin(num) | Converte un numero in una stringa binaria |
| bool([value]) | Converte il valore in un booleano |
| bytearray(source) | Converte source in tipo bytearray |
| bytes(source) | Converte source in tipo bytes |
| callable(object) | Verifica se un oggetto è chiamabile |
| chr(i) | Converte un codice ASCII in carattere |
| classmethod(function) | Converte un metodo in un metodo di classe |
| compile(source, filename, mode) | Compila il sorgente in un oggetto di codice eseguibile |
| complex([real[, imag]]) | Crea un numero complesso da parti reali e immaginarie |
| delattr(object, name) | Rimuove l’attributo nominato dall’oggetto; solleva un’eccezione se non esiste |
| dict() | Crea un dizionario |
| dir([object]) | Restituisce l’elenco degli attributi dell’oggetto |
| divmod(x, y) | Divide x per y; restituisce quoziente e resto |
| enumerate(iterable, start=0) | Combina un iterabile in una sequenza di indici con indici e dati |
| eval(expression) | Esegue una singola espressione stringa e restituisce il risultato |
| exec(object, globals, locals) | Esegue codice complesso (stringa o tipo di codice); nessun ritorno |
| filter(function, iterable) | Filtra l’iterabile, mantenendo gli oggetti per i quali la funzione restituisce True |
| float([x]) | Converte un numero o una stringa in un tipo a virgola mobile |
| format(value[, format_spec]) | Formatta l’oggetto come stringa |
| frozenset([iterable]) | Converte l’iterabile in un tipo insieme immutabile |
| getattr(object, name[, default]) | Ottiene l’attributo specificato dell’oggetto; restituisce default se non esiste |
| globals() | Restituisce tutte le variabili globali sotto forma di dizionario |
| hasattr(object, name) | Verifica se l’oggetto ha l’attributo specificato |
| hash(object) | Ottiene il valore hash di un oggetto |
| help(object) | Ottiene la documentazione di aiuto per un oggetto |
| hex(x) | Converte un intero in una stringa esadecimale |
| id(object) | Restituisce l’identificatore unico di un oggetto |
| input([prompt]) | Legge una riga di input dell’utente e la restituisce |
| int(x=0, base=10) | Converte un numero o una stringa in un numero intero |
| isinstance(object, classinfo) | Verifica se un oggetto è un’istanza di una classe o di una sua sottoclasse |
| issubclass(object, classinfo) | Verifica se una classe è una sottoclasse di un’altra classe |
| iter(object[, sentinel]) | Genera un iteratore da un oggetto |
| len(s) | Ottiene la lunghezza di un oggetto (s deve essere una sequenza o una collezione) |
| list([iterable]) | Converte un iterabile in una lista |
| locals() | Restituisce tutte le variabili locali sotto forma di dizionario |
| map(function, iterable, …) | Applica la funzione ad ogni elemento dell’iterabile; restituisce la lista dei risultati |
| max(arg1, arg2, *args[, key]) | Ottiene il valore massimo dall’iterabile o dagli argomenti |
| memoryview(obj) | Avvolge un oggetto in un oggetto di visualizzazione della memoria |
| min(arg1, arg2, *args[, key]) | Ottiene il valore minimo dall’iterabile o dagli argomenti |
| next(iterator, default) | Ottiene l’elemento successivo dell’iteratore; restituisce default se non ci sono più elementi |
| object() | Restituisce un nuovo oggetto |
| oct(x) | Converte un intero in una stringa ottale |
| open(file) | Apre un file e restituisce un oggetto file |
| ord(c) | Converte un carattere Unicode nel suo valore intero ASCII o Unicode |
| pow(x, y[, z]) | Calcola x elevato alla potenza di y, modulo z |
| print(*objects) | Invia gli oggetti allo standard output o a un flusso di file |
| property() | Genera un attributo da getter, setter, deleter |
| range(start, stop[, step]) | Restituisce una sequenza immutabile di numeri |
| repr(obj) | Restituisce la forma stampabile di un oggetto (adatta all’interprete) |
| reversed(seq) | Inverte una sequenza e restituisce un iteratore |
| round(number[, ndigits]) | Arrotonda un numero a virgola mobile alle cifre decimali specificate |
| set([iterable]) | Converte un iterabile in un tipo insieme |
| setattr(object, name, value) | Imposta l’attributo dell’oggetto tramite il nome |
| slice(start, stop, step) | Restituisce un oggetto slice |
| sorted(iterable[, key][, reverse]) | Ordina un iterabile e restituisce una nuova lista |
| staticmethod(function) | Converte un metodo in un metodo statico |
| str(object=’') | Converte un oggetto in tipo stringa (leggibile dall’uomo) |
| sum(iterable, start) | Somma tutti gli elementi di un iterabile |
| super(type[, object-or-type]) | Ottiene la classe genitore |
| tuple(iterable) | Converte un iterabile in una tupla |
| type(object) | Restituisce il tipo di un oggetto |
| type(name, bases, dict) | Crea un nuovo oggetto di tipo |
| vars(object) | Restituisce gli attributi e i valori dell’oggetto sotto forma di dizionario |
| zip(*iterables) | Raggruppa gli elementi di più iterabili in tuple; restituisce una lista |
| import(name) | Importa dinamicamente un modulo |
Metodi per le Liste
| append(item) | Aggiunge un elemento alla fine della lista |
| extend(lst) | Aggiunge tutti gli elementi di lst alla lista |
| insert(index, element) | Inserisce l’elemento nella posizione specificata nella lista |
| remove(element) | Trova e rimuove la prima occorrenza dell’elemento da sinistra |
| index(element) | Trova e restituisce l’indice della prima occorrenza dell’elemento da sinistra |
| count(element) | Restituisce il numero di occorrenze dell’elemento specificato |
| pop(index) | Rimuove e restituisce l’elemento nella posizione specificata |
| reverse() | Inverte la lista |
| sort(key=…, reverse=…) | Ordina la lista |
| copy() | Copia superficiale della lista |
| clear() | Rimuove tutti gli elementi dalla lista |
Metodi per i Dizionari
| clear() | Rimuove tutti gli elementi |
| copy() | Copia superficiale |
| fromkeys(sequence[, value]) | Crea un nuovo dizionario con sequence come chiavi e value come valore |
| get(key[, value]) | Restituisce il valore per la chiave; restituisce value se non esiste |
| items() | Restituisce tutte le coppie chiave-valore del dizionario (come tuple) |
| keys() | Restituisce tutte le chiavi del dizionario |
| popitem() | Rimuove e restituisce un elemento arbitrario (non casuale) |
| setdefault(key[, default_value]) | Inserisce la chiave con default_value se non esiste; restituisce il valore per la chiave |
| pop(key[, default]) | Rimuove e restituisce il valore per la chiave; restituisce default se non esiste |
| values() | Restituisce tutti i valori nel dizionario |
| update([other]) | Aggiorna il dizionario con other (dizionario o iterabile di coppie) |
Metodi per gli Insiemi (Set)
| remove(element) | Rimuove l’elemento specificato; solleva un’eccezione se non esiste |
| add(elem) | Aggiunge l’elemento; non fa nulla se esiste già |
| copy() | Copia superficiale dell’insieme |
| clear() | Rimuove tutti gli elementi dall’insieme |
| a.difference(b) | Restituisce l’insieme degli elementi in a ma non in b |
| a.difference_update(b) | Rimuove gli elementi in b da a |
| discard(x) | Rimuove l’elemento specificato se esiste |
| a.intersection(*other_sets) | Restituisce l’intersezione di a e degli altri insiemi |
| a.intersection_update(*other_sets) | Mantiene solo gli elementi trovati in a e in tutti gli altri insiemi |
| a.isdisjoint(b) | Verifica se due insiemi non hanno elementi comuni |
| a.issubset(b) | Verifica se a è un sottoinsieme di b |
| pop() | Rimuove e restituisce un elemento arbitrario (non casuale) dall’insieme |
| a.symmetric_difference(b) | Restituisce l’insieme degli elementi in a oppure b, ma non in entrambi |
| a.symmetric_difference_update(b) | Aggiorna a con la differenza simmetrica di a e b |
| a.union(*other_sets) | Restituisce l’unione di a e degli altri insiemi |
| a.update(b) | Aggiorna a con gli elementi di b |
Metodi per le Tuple
| index(element) | Trova e restituisce la posizione dell’elemento; solleva un’eccezione se non esiste |
| count(element) | Conta le occorrenze dell’elemento specificato |
Indicizzazione e Slicing
| a[x] | Ottieni l’elemento (x + 1)-esimo |
| a[-x] | Ottieni l’elemento x-esimo dalla fine |
| a[x:] | Ottieni dal (x + 1)-esimo elemento fino alla fine |
| a[:x] | Ottieni dal primo elemento fino all’elemento (x + 1)-esimo |
| a[:-x] | Ottieni dal primo elemento fino all’elemento x-esimo dalla fine |
| a[x:y] | Ottieni dall’elemento (x + 1)-esimo all’elemento (y + 1)-esimo |
| a[:] | Copia superficiale di a |
Metodi per le Stringhe
| capitalize() | Trasforma il primo carattere in maiuscolo |
| center(width[, fillchar]) | Centra la stringa e riempie con fillchar fino alla larghezza specificata |
| casefold() | Converte la stringa in minuscolo (più aggressivo di lower()) |
| count(substring[, start[, end]]) | Conta le occorrenze della sottostringa |
| endswith(suffix[, start[, end]]) | Verifica se la stringa termina con il suffisso specificato |
| expandtabs(tabsize) | Converte i \t nella stringa nel numero specificato di spazi |
| encode(encoding=‘UTF-8’, errors=‘strict’) | Codifica la stringa in qualsiasi codifica supportata |
| find(sub[, start[, end]]) | Trova la posizione della sottostringa da sinistra (-1 se non esiste) |
| format(p0, p1, …, k0=v0, k1=v1, …) | Formatta la stringa |
| index(sub[, start[, end]]) | Trova la posizione della sottostringa da sinistra (solleva un’eccezione se non esiste) |
| isalnum() | Verifica se la stringa è alfanumerica |
| isalpha() | Verifica se la stringa è alfabetica |
| isdecimal() | Verifica se la stringa consiste solo di caratteri decimali |
| isdigit() | Verifica se la stringa consiste solo di cifre |
| isidentifier() | Verifica se la stringa è un identificatore valido |
| islower() | Verifica se la stringa consiste di lettere minuscole |
| isnumeric() | Verifica se la stringa consiste solo di caratteri numerici (supporto Unicode) |
| isprintable() | Verifica se la stringa è stampabile |
| isspace() | Verifica se la stringa consiste solo di spazi vuoti |
| istitle() | Verifica se la stringa è in formato titolo |
| isupper() | Verifica se la stringa consiste solo di lettere maiuscole |
| join(iterable) | Unisce un iterabile di stringhe con il delimitatore specificato |
| ljust(width[, fillchar]) | Giustifica a sinistra e riempie la stringa |
| rjust(width[, fillchar]) | Giustifica a destra e riempie la stringa |
| lower() | Converte tutti i caratteri in minuscolo |
| upper() | Converte tutti i caratteri in maiuscolo |
| swapcase() | Inverte maiuscole e minuscole |
| lstrip([chars]) | Rimuove i caratteri specificati da sinistra |
| rstrip([chars]) | Rimuove i caratteri specificati da destra |
| strip([chars]) | Rimuove i caratteri specificati da entrambi i lati |
| partition(separator) | Divide la stringa al primo separatore; restituisce (prima, sep, dopo) |
| maketrans(x[, y[, z]]) | Crea una tabella di mappatura della traduzione |
| rpartition(separator) | Divide la stringa all’ultimo separatore; restituisce (prima, sep, dopo) |
| translate(table) | Sostituisce i caratteri utilizzando la tabella di traduzione |
| replace(old, new [, count]) | Sostituisce la sottostringa old con new, fino a count volte |
| rfind(sub[, start[, end]]) | Trova la posizione della sottostringa da destra (-1 se non esiste) |
| rindex(sub[, start[, end]]) | Trova la posizione della sottostringa da destra (solleva un’eccezione se non esiste) |
| split([separator [, maxsplit]]) | Divide da sinistra utilizzando un separatore |
| rsplit([separator [, maxsplit]]) | Divide da destra utilizzando un separatore |
| splitlines([keepends]) | Divide la stringa per righe |
| title() | Converte la stringa in formato titolo (l’iniziale di ogni parola in maiuscolo) |
| zfill(width) | Riempie la stringa a sinistra con zeri fino alla larghezza specificata |
| format_map(mapping) | Formatta la stringa utilizzando una mappatura dizionario |