Show Menu
Cheatography
  1. Home >
  2. Programming >

Imparare Python Cheat Sheet (DRAFT) by

Appunti presi nello studio del linguaggio Python

This is a draft cheat sheet. It is a work in progress and is not finished yet.

Variabili

Nomenc­latura
snake_case che inizia per _ o lettera
Assegnazione
singola
 
nome_v­ari­abile = valore
Assegnazione
multipla
 
var1, var2, var3 = val1, val2, val3

var1 = var2 = var3 = valore

Sintassi di base

Commento
# Il tuo commento qui
Stampare a schermo
print()
Indent­azione
Le righe aventi stessa indent­azione appart­engono allo stesso blocco di codice.

Tipi di dati

Numerici
int, float, complex, bool
Stringhe
str (immut­abile)
Sequenze
list (ordinata, mutabile, permette duplicati)
tuple (ordinata, immutabile, permette duplicati)
range
 
[]
()
Insiemi
set (non ordinato, mutabile, non permette duplicati)
frozenset (non ordinato, immuta­bile, non permette duplicati)
 
{}
Dizionari
dict (chiav­e-v­alore)
Binari
bytes, bytearray, memoryview

Valore di verità

True
Un oggetto è consid­erato vero a meno che la sua classe non definisca un metodo __bool__() che restit­uisce False o un metodo __len__() che restit­uisce zero.
False
> Costanti None e False
> Zero di qualsiasi tipo numerico (0, 0.0 ecc.)
> Sequenze o collezioni vuote ("", (), [] ecc.)

Operatori di confronto

<
Strett­amente minore
 
1 < 2    # True
<=
Minore o uguale
 
1 <= 1   # True
>
Strett­amente maggiore
 
4 > 2    # False
>=
Maggiore o uguale
 
3 >= 2   # True
==
Uguale
 
5 == 7   # False
!=
Diverso
 
1 != 2   # True
is
Identità dell'o­ggetto
 
a = [1,2]
b = a
print(a is b) # True
is not
Identità dell'o­ggetto negata
 
a = [1,2]
b = a
print(a is not b) # False
Possono essere concat­enati arbitrariamente:
X < Y <= Z equivale a X < Y AND Y <= Z

Operatori numerici

x + y
Addizione
 
3 + 4 = 7
x - y
Sottra­zione
 
5 – 2 = 3
x * y
Prodotto
 
7 * 1 = 7
x / y
Divisione
 
8 / 4 = 2
x // y
Divisione arroto­ndata per difetto
 
3 // 2 = 1
-1 // 2 = -1
x % y
Modulo (ritorna il resto della divisione)
 
7 % 3 = 1
-x
Negazione
 
-5
abs(x)
Valore assoluto
 
abs(-5.5) = 5.5
int(x)
Conver­sione in int
 
int("12­") = 12
int(7.2) = 7
float(x)
Conver­sione in float
 
float(7) = 7.0
complex(re, im)
Conver­sione in numero complesso
 
comple­x("3 + 5j")
divmod(x, y)
Ritorna una tupla contenente quoziente intero e modulo dei parametri
 
divmod(5, 2) = (2, 1)
pow(x, y)
x ** y
Potenza
 
pow(2, 3) = 8
2 ** 3 = 8
Quando gli operandi sono di tipi numerici differ­enti, il tipo più piccolo viene convertito in quello più grande (int < float < complex).

Operatori booleani

x or y
True se almeno uno tra x e y è True, altrimenti False.
Non valuta il secondo argomento se il primo è True.
x and y
True se entrambi x e y sono True, altrimenti False.
Non valuta il secondo argomento se il primo è False.
not x
True se x è False, altrimenti False.
Ha priorità inferiore rispetto agli operatori non booleani *
* not a == b -> not (a == b)

Tipi Numerici

int
Numeri interi a precisione illimitata.
Costruttore -> int()
float
Numeri in virgola mobile, si utilizza il punto tra parte intera e parte decimale.
Costruttore -> float()
complex
Numeri complessi, composti da una parte reale (n.real) ed una parte immagi­naria (n.imag).
Costruttore -> complex()
bool
Valori di verità (True e False).

Stringhe

Assegn­azione
 
stringa = "Hello"
stringa = 'Hello'
Stringa multiriga
 
"""Hello,
it's
me"""
Accedere ai caratteri
 
stringa[0]
stringa[-1]
 
# primo carattere
# ultimo carattere
Lunghezza
 
len("He­llo­")
 
# 5
Sottos­tringa
 
stringa[:n]
stringa[n:]
stringa[n:m]
 
# da inizio a _n
# da °n a fine
# da °n a _m
Concatenazione
 
"­ab" + "­cd"
 
# "­abc­d"
Ripeti­zione
 
"­"­Hel­lo"\ * 2
 
#"He­llo­Hel­lo"
Format­tazione
 
f"Ho {10} mele"
 
# "Ho 10 mele"
Caratteri di escape
 
\n
\t
\'    
# new line
# tab
# '
°x -> incluso / _x -> escluso

Metodi delle stringhe

capita­lize()
 
"­heL­Lo".c­ap­ita­lize()
 
# "­Hel­lo"
casefold()
 
"­HeL­Lo".c­as­efold()
 
# "­hel­lo"
center()
 
"­Hel­lo".c­en­ter­(7,­"­-")
 
# "­-He­llo­-"
count()
 
"­Hel­lo".c­ou­nt(­"­l")
 
# 2
endswith()
 
"Hello".endswith("lo")
"Hello".endswith("ab")
 
# True
# False
expand­tabs()
 
"­1\t­2".e­xpa­ndt­abs(1)
 
# "1 2"
find()
 
"­Hel­lo".f­in­d("l­")
 
# 2
format()
 
"­Hel­{}".f­or­mat­("lo­")
 
# "­Hel­lo"
format_map()
come format()
Accetta dizionari come parametri
index()
come find()
ValueError se non trova la sottos­tringa
isalnum()
 
"ABC123".isalnum()
"ab!12_".isalnum()
 
# True
# False
isalpha()
 
"Abc".isalpha()
"123".isalpha()
 
# True
# False
isascii()
 
"Abc123".isascii()
"Ab23".i­sa­scii()
 
# True
# False
isiden­tif­ier()
 
"hello".isidentifier()
"123ab".isidentifier()
 
# True
# False
islower()
 
"hello1".islower()
"Hello1".islower()
 
# True
# False
isprin­table()
 
"­Abc­1!".i­sp­rin­tab­le(­){n­l}}­"­A\t­1!".i­sp­rin­table()
 
# True
# False
isspace()
 
"\t\n ".isspace()
"a   b".i­ssp­ace()
 
# True
# False
join()
 
"­_".j­oin­(["a­"­,"b"])
 
# "­a_b­"
ljust()
 
"­Abc­".lj­ust­(5,­"­-")
 
# "­Abc­--"
lower()
 
"­HEL­LO".l­ower()
 
# "­hel­lo"
lstrip()
 
"­-He­llo­-".l­str­ip(­"­-")
 
# "­Hel­lo-­"
maketrans()
translate()
 
map1 = str.maketrans({"a":1,"b":2})})
map2 = str.maketrans("ab","12")
map3 = str.maketrans("ab","12","c")
"abc".translate(map1)
"abc".translate(map2)
"abc".translate(map3)
 



# "12c"
# "12c"
# "­12"
partit­ion()
 
"­a-b­-c".p­ar­tit­ion()
 
# ("a",­"­-","b­-c")
replace()
 
"­abc­".re­pla­ce(­"­b","0­")
 
# "­a0c­"
rfind()
 
"­Hel­lo".r­fi­nd(­"­l")
 
# 3
rindex()
come rfind()
ValueError se non trova la sottos­tringa
rjust()
 
"­Abc­".rj­ust­(5,­"­-")
 
# "­--A­bc"
rparti­tion()
 
"­a-b­-c".r­pa­rti­tion()
 
# ("a-­b","-­"­,"c")
rsplit()
 
"­a-b­-c".r­sp­lit­("-",1)
 
# ["a-­b","c­"]
rstrip()
 
"­-He­llo­-".r­str­ip(­"­-")
 
# "­-He­llo­"
split()
 
"­a-b­-c".s­pl­it(­"­-",1)
 
# ["a",­"­b-c­"]
splitl­ines()
 
"­a\n­b".s­pli­tli­nes()
 
# ["a",­"­b"]
starts­with()
 
"abc".startswith("a")
"abc".startswith("c")
 
# True
# False
strip()
 
"­-He­llo­-".s­tri­p("-­")
 
# "­Hel­lo"
swapcase()
 
"­XxX­".sw­apc­ase()
 
# "­xXx­"
title()
 
"­HELLO world".t­itle()
 
# "­Hello World"
upper()
 
"­hel­lo".u­pper()
 
# "­HEL­LO"
zfill()
 
"1".zfill(3)
"-1".zfill(3)
 
# "001"
# "­-00­1"
isdigit()
isnumeric()
isdecimal()
 
# Numeri standard "123"
isdigit()
isnumeric()
isdecimal()

# Esponenti "123"
isdigit()
isnumeric()
isdecimal()

# Ideogrammi numerici
isdigit()
isnumeric()
isdecimal()

# Numeri decimali "12.34"
isdigit()
isnumeric()
isdecimal()

# Numeri negativi "-123"
isdigit()
isnumeric()
isdecimal()

# Stringa vuota ""
isdigit()
isnumeric()
isdecimal()
 

# True
# True
# True


# True
# True
# False


# False
# True
# False


# False
# False
# False


# False
# False
# False


# False
# False
# False
* più aggressivo rispetto a lower()

Liste

Assegn­azione
 
lista = ["a", 2, True, [1, 2], ...]
Accedere agli elementi
 
lista[0]
lista[-1]
 
# primo elemento
# ultimo elemento
Lunghezza
 
len(["a­"­,"b"])
 
# 2
Concat­ena­zione
 
[1, 2] + [3, 4]
 
# [1, 2, 3, 4]
Ripeti­­zione
 
[1, 2] * 2
 
# [1, 2, 1, 2]
Sottolista
 
lista[:n]
lista[n:]
lista[n:m]
 
# da inizio a _n
# da °n a fine
# da °n a _m
°x -> incluso / _x -> escluso

Metodi delle liste

append()
 
[1, 2].app­end(3)
 
# [1, 2, 3]
clear()
 
[1, 2].clear()
 
# []
copy()
 
l1 = [1, 2]
l2 = l1.copy()
l3 = l1
 

# l1 e l2 sono due liste distinte
# l1 e l3 puntano alla stessa lista
count()
 
[1, 2, 1].cou­nt(1)
 
# 2
extend()
 
[1, 2].ext­end­(["a­", "­b"])
 
# [1, 2, "­a", "­b"]
index()
 
[1, 2, 1].ind­ex(1)
 
# 0
insert()
 
[1, 2].ins­ert­(1,3)
 
# [1, 3, 2]
pop()
 
[1, 2].pop(0)
 
# [2] , ritorna 1
remove()
 
[1, 2, 1].rem­ove(1)
 
# [2, 1]
reverse()
 
[1, 2, 3].rev­erse()
 
# [3, 2, 1]
sort()
 
[2, 1, 3].sort()
[2, 1, 3].sor­t(r­eve­rse­=True)
 
# [1, 2, 3]
# [3, 2, 1]

Tuple

Assegn­azione
 
tupla = ("a", 2, True, ...)
stringa = (1, )
 

# singolo elemento
Accedere agli elementi
 
tupla[0]
tupla[-1]
 
# primo elemento
# ultimo elemento
Lunghezza
 
len((1,2))
 
# 2
Sottotupla
 
tupla[:n]
tupla[n:]
tupla[n:m]
 
# da inizio a _n
# da °n a fine
# da °n a _m
Concat­ena­zione
 
(1, 2) + (3, 4)
 
# (1, 2, 3, 4)
Ripeti­zione
 
(1, 2) * 2
 
# (1, 2, 1, 2)
°x -> incluso / _x -> escluso

Metodi delle tuple

count()
 
(1, 2, 1).cou­nt(1)
 
# 2
index()
 
(1, 2, 3).ind­ex(3)
 
# 2

Range

range(­start, stop, step)
start
Opzionale
Numero iniziale (compreso, default = 0)
stop
Obblig­atorio
Numero finale (escluso)
step
Opzionale
Passo dell'i­ncr­emento (default = 1)