Gli operatori Python vi aiutano a lavorare con i valori (operandi), a mo­di­fi­car­li o a col­le­gar­li tra loro. Possono essere logici o arit­me­ti­ci.

Cosa sono gli operatori Python e come fun­zio­na­no?

Un operatore è un carattere per un’ope­ra­zio­ne, so­li­ta­men­te uti­liz­za­to per collegare diversi operandi. Di solito, viene creato un nuovo valore. L’ap­pli­ca­zio­ne di un operatore a un singolo operando lo modifica.

Pro­ba­bil­men­te l’esempio più semplice di operatori Python è il col­le­ga­men­to di due numeri mediante l’operatore di addizione, cioè un segno più tra i numeri. Python valuta l’espres­sio­ne e re­sti­tui­sce il valore cor­ri­spon­den­te:

1 + 1

Una pe­cu­lia­ri­tà di Python è che parole brevi come “and”, “or”, “is”, “not” o “in” vengono uti­liz­za­te come operatori in aggiunta ai simboli. La com­bi­na­zio­ne di operatori e operandi dà luogo a un’espres­sio­ne:

1 + 1 == 2

Quali tipi di operatori Python esistono?

Python conosce diverse classi di operatori. Agiscono su diversi tipi di operandi e re­sti­tui­sco­no risultati di un certo tipo. Di seguito vi ri­por­tia­mo i diversi tipi di operatori Python in sintesi:

Classi di operatori Python Spie­ga­zio­ne Operandi Risultato Operatori in sintesi  
Operatori arit­me­ti­ci Com­bi­na­zio­ne di due numeri per formarne uno nuovo Numeri Numero +, -, *, /, //, %, **, @  
Operatori di confronto Confronto tra due espres­sio­ni Espres­sio­ni Booleano <, >, ==, !=, <=, >=  
Operatori logici Com­bi­na­zio­ne di espres­sio­ni in un contesto booleano Espres­sio­ni Ultima espres­sio­ne valutata / Booleano and, or, not  
Operatori binari Ma­ni­po­la­zio­ne di interi come sequenze binarie Numeri Numero <<, >>, &, , ^, ~
Operatori di as­se­gna­zio­ne As­se­gna­zio­ne di un valore a un nome Valore L, valore R - / Espres­sio­ne valutata =, :=, +=, -=, *=, ecc.  
Operatori di identità De­ter­mi­na­zio­ne di due nomi se si ri­fe­ri­sco­no allo stesso oggetto Oggetti Booleano is, is not  
Operatori con­di­zio­na­li Re­sti­tu­zio­ne di uno dei due valori a seconda di una con­di­zio­ne Espres­sio­ne, con­di­zio­ne, al­ter­na­ti­va Espres­sio­ne / Al­ter­na­ti­va ... if ... else ...  
Operatori di set Col­le­ga­men­to di due set / Confronto tra set Set Set / Booleano &, , ^, -, <, >, <=, >=
Operatori di ap­par­te­nen­za Verifica di un’iterabile se contiene un par­ti­co­la­re oggetto Oggetto, Iterabile Booleano in, not in  
Operatore di con­ca­te­na­zio­ne Con­ca­te­na­zio­ne di sequenze Stringhe / Liste / Tuple Stringa / Lista / Tupla +  
Operatori di indice e di fetta Re­sti­tu­zio­ne di uno o più elementi di un iterabile Iterabile, indice / Fetta Stringa / Lista / Tupla [], [::]  

Oltre al tipo di operandi e al valore di ritorno, gli operatori sono clas­si­fi­ca­ti in base alla loro “arietà”. Il termine esprime il numero di operandi che un operatore collega. Nella maggior parte dei casi si uti­liz­za­no operatori “binari” con due operandi. Inoltre, esistono alcuni operatori “unari” con un solo operando e un operatore “ternario” che collega tre operandi:

Arietà degli operatori Numero di operandi Esempio
Unario Un operando not single_value
Binario Due operandi left_operand + right_operand
Ternario Tre operandi some_value if condition else other_value

Osservare la pre­ce­den­za degli operatori

Fon­da­men­ta­le per l’uso degli operatori Python è anche la com­pren­sio­ne della pre­ce­den­za degli operatori. Come pro­me­mo­ria, l’espres­sio­ne 3 * 8 + 2 viene in­ter­pre­ta­ta come (3 * 8) + 2 e non come 3 * (8 + 2). Come per il più e il segno per, esistono regole di pre­ce­den­za per tutti gli operatori Python. Di seguito un esempio di espres­sio­ne con gli operatori logici “and”, “or” e “not”:

if is_user and is_user_logged_in or is_admin and not login_blocked:
    ...

Senza conoscere le regole di pre­ce­den­za degli operatori Python coinvolti, è im­pos­si­bi­le decidere come i singoli termini debbano stare insieme. Se in un’espres­sio­ne vengono uti­liz­za­ti più operatori, la si­tua­zio­ne si complica ra­pi­da­men­te. In generale, è meglio non fare af­fi­da­men­to su una perfetta com­pren­sio­ne delle regole implicite. Si uti­liz­za­no, invece, parentesi esplicite per chiarire l’ap­par­te­nen­za dei termini di un’espres­sio­ne:

if (is_user and is_user_logged_in) or (is_admin and not login_blocked):
    ...

Per un confronto, di seguito gli stessi termini rag­grup­pa­ti in modo diverso, in cui l’enunciato delle due espres­sio­ni è diverso:

if (is_user and is_user_logged_in or is_admin) and not login_blocked:
    ...

Operatori so­vrac­ca­ri­ca­ti, metodi Dunder e funzioni dell’operatore in Python

Alcuni operatori Python sono uti­liz­za­ti per più di un’ope­ra­zio­ne. Un esempio im­por­tan­te è il segno più, che agisce come operatore di addizione per i numeri e allo stesso tempo come operatore di con­ca­te­na­zio­ne per con­ca­te­na­re sequenze come stringhe e liste. Sommiamo due numeri con l’operatore di addizione:

8 + 3 == 11

Con lo stesso operatore con­ca­te­nia­mo due stringhe:

"Walter" + "White" == "WalterWhite"

Con l’operatore più con­ca­te­nia­mo anche delle liste:

['Jack', 'Jim'] + ['John'] == ['Jack', 'Jim', 'John']

Il mol­te­pli­ce uso del segno più come operatore riflette un concetto comune in in­for­ma­ti­ca. Si parla di “operatori so­vrac­ca­ri­ca­ti” quando uno stesso operatore esegue ope­ra­zio­ni diverse a seconda del tipo di dati degli operandi.

Come fun­zio­na­no gli operatori so­vrac­ca­ri­ca­ti in Python? Dietro le quinte, un operatore e i suoi operandi vengono in­ter­pre­ta­ti come una chiamata a una funzione cor­ri­spon­den­te. In par­ti­co­la­re, viene ri­chia­ma­to il co­sid­det­to metodo Dunder del primo operando, che riceve gli altri operandi come argomenti. “Dunder” sta per “double un­der­sco­re”, quindi “doppio trattino basso”. Pertanto, l’operatore più cor­ri­spon­de al metodo Dunder __add__(). Gli oggetti che im­ple­men­ta­no un metodo __add__() possono essere collegati con l’operatore più. Spetta all’oggetto stesso stabilire cosa co­sti­tui­sce esat­ta­men­te il col­le­ga­men­to.

Oltre ai metodi Dunder, il modulo operator contiene funzioni che in­cap­su­la­no le fun­zio­na­li­tà degli operatori Python. Per esempio, “operator.add(a, b)” richiama il metodo Dunder a.__add__(b), che è equi­va­len­te all’espres­sio­ne a + b. Nel resto dell’articolo elen­chia­mo la funzione dell’operatore per ogni operatore, se prevista. Il nome della funzione dell’operatore equivale al nome del metodo Dunder cor­ri­spon­den­te. Uti­liz­za­te­lo come ri­fe­ri­men­to per im­ple­men­ta­re la fun­zio­na­li­tà dell’operatore:

Operatore Python Funzione dell’operatore Metodo Dunder
a + b operator.add(a, b) a.__add__(b)

Gli operatori uti­liz­za­no la co­sid­det­ta notazione infissa, che usa l’operatore tra gli operandi. Al contrario, lo stile fun­zio­na­le utilizza la notazione prefissa. Entrambe le notazioni sono equi­va­len­ti:

Notazione Uso Esempio
Infissa Operatori a + b
Prefissa Funzioni + a b / add(a, b)

Prendiamo in con­si­de­ra­zio­ne un esempio. Definiamo due numeri e li sommiamo con l’operatore, la sua funzione e il metodo Dunder cor­ri­spon­den­te:

import operator
a = 42
b = 69
assert a + b == operator.add(a, b) == a.__add__(b)

Anche espres­sio­ni più complesse possono essere scritte con le funzioni dell’operatore. Di seguito la com­bi­na­zio­ne degli operatori di addizione e ugua­glian­za di Python nella notazione prefissa:

import operator
assert 'Py' + 'thon' == 'Python'
assert operator.eq(operator.add('Py', 'thon'), 'Python')

Gli operatori Python in sintesi

Ora esa­mi­ne­re­mo undici diverse classi di operatori Python.

Operatori arit­me­ti­ci

Gli operatori arit­me­ti­ci in Python operano sui numeri, creando un nuovo numero. A eccezione degli operatori unari più e meno, sono tutti operatori binari. Qui un riepilogo:

Operatore Python Si­gni­fi­ca­to Funzione dell’operatore Esempio
+ Addizione / Più unario add(a, b) / pos(a) 5 + 3 == 8 / +8 == 4 + 4
- Sot­tra­zio­ne / Meno unario sub(a, b) / neg(a) 7 - 2 == 5 / -4 == 2 - 6
* Mol­ti­pli­ca­zio­ne mul(a, b) 2 * 3 == 6
/ Divisione “pura” truediv(a, b) 8 / 2 == 4.0, 7 / 2 == 3.5
// Divisione di un intero del numero intero im­me­dia­ta­men­te inferiore floordiv(a, b) 8 // 2 == 4, 7 // 2 == 3
% Modulo: quantità rimanente della divisione intera mod(a, b) 8 % 2 == 0, 7 % 2 == 1
** Espo­nen­zia­zio­ne pow(a, b) 2 ** 3 == 8, 10 ** -1 == 0.1
@ Mol­ti­pli­ca­zio­ne di matrici matmul(a, b) –

L’ope­ra­zio­ne modulo viene uti­liz­za­ta per im­po­sta­zio­ne pre­de­fi­ni­ta per de­ter­mi­na­re se un numero è pari. Questo perché un numero pari diviso per due dà resto zero. Definiamo una funzione Python cor­ri­spon­den­te con l’operatore modulo:

def is_even(number):
    return number % 2 == 0
# test
assert is_even(8) and not is_even(7)

La mol­ti­pli­ca­zio­ne delle matrici richiede l’uso di un pacchetto come NumPy.

Operatori di confronto Python

Gli operatori di confronto in Python for­ni­sco­no una di­chia­ra­zio­ne su come due elementi possono essere ordinati tra loro. For­ni­sco­no un risultato booleano e sono uti­liz­za­ti in par­ti­co­la­re per gli algoritmi di or­di­na­men­to:

Operatore Python Si­gni­fi­ca­to Funzione dell’operatore Esempio
< Minore di lt(a, b) 3 < 1, 'a' < 'z'
> Maggiore di gt(a, b) 4 > 2, 'z' > 'a'
== Uguale eq(a, b) 'a' == 'a'
!= Disuguale ne(a, b) 1 != 2, 'Jim' != 'Jack'
<= Minore o uguale le(a, b) 9 <= 10, 10 <= 10
>= Maggiore o uguale ge(a, b) 11 >= 10, 10 >= 10

Operatori logici

Gli operatori logici and e or in Python collegano diversi operandi secondo la logica booleana. Di con­se­guen­za, entrambi gli operatori re­sti­tui­sco­no l’ultimo oggetto valutato. L’operatore logico not in Python in­ter­pre­ta un oggetto nel contesto booleano e nega il suo valore di verità:

Operatore Python Si­gni­fi­ca­to Funzione dell’operatore Esempio
and E logica Nessun equi­va­len­te diretto True and False == False, 'name' and ... == ...
or O logico Nessun equi­va­len­te diretto False or True == True, a = '' or 'Default'; assert a == 'Default'
not Negazione not_(a) not True == False

È utile il­lu­stra­re l’effetto delle ope­ra­zio­ni logiche con le tabelle di verità. Qui viene mostrato il metodo logico AND:

and True False
True True False
False False False

Così come l’OR logico:

or True False
True True True
False True False

Gli operandi degli operatori booleani in Python non sono limitati alle variabili booleane. Piuttosto, qualsiasi oggetto Python può essere in­ter­pre­ta­to in un contesto booleano. I seguenti oggetti hanno una va­lu­ta­zio­ne falsa nel contesto booleano e sono quindi chiamati “falsy”:

Oggetto Spie­ga­zio­ne
False, None Costanti che sono false per de­fi­ni­zio­ne
0, 0.0, Decimal(0), Fraction(0, 1), etc. Numero che rap­pre­sen­ta lo zero
‘‘, (), [], {}, set(), range(0), etc. Sequenza o insieme vuoti

Operatori binari

Gli operatori binari in Python operano sui numeri interi, che vengono in­ter­pre­ta­ti come sequenze di bit. A eccezione dell’operatore NOT, sono tutti operatori binari:

Operatore Python Si­gni­fi­ca­to Funzione dell’operatore Esempio
<< Spo­sta­men­to a sinistra della sequenza di bit lshift(a, b) 5 << 3 == 5 * 2 ** 3
>> Spo­sta­men­to a destra della sequenza di bit rshift(a, b) 1 >> 1 == 0, 8 >> 1 == 4
& Col­le­ga­men­to di due sequenze di bit tramite AND and_(a, b) ``
| Col­le­ga­men­to di due sequenze di bit tramite OR or_(a, b) ``
^ Col­le­ga­men­to di due sequenze di bit tramite XOR xor(a, b) ``
~ In­ver­sio­ne della sequenza di bit con NOT invert(a) ``

Gli operatori binari sono adatti a ope­ra­zio­ni ma­te­ma­ti­che ot­ti­miz­za­te. Ad esempio, lo spo­sta­men­to a sinistra cor­ri­spon­de a una mol­ti­pli­ca­zio­ne per una potenza di due:

Espres­sio­ne 23 = 8 22 = 4 21 = 2 20 = 1 Decimale
b = 6 0 1 1 0 6
b << 1 1 1 0 0 12
b >> 1 0 0 1 1 3

Per il­lu­stra­re le ope­ra­zio­ni binarie AND, OR e NOT, co­struia­mo una tabella dei singoli bit. Le ope­ra­zio­ni vengono applicate a un numero in rap­pre­sen­ta­zio­ne binaria grazie a una maschera di bit:

Espres­sio­ne 23 = 8 22 = 4 21 = 2 20 = 1 Decimale
bits = 6 0 1 1 0 6
mask = 5 0 1 0 1 5
bits & mask 0 1 0 0 4
bits | mask 0 1 1 1 7
bits ^ mask 0 0 1 1 3

L’operatore binario NOT in Python inverte una sequenza di bit. Ogni 1 diventa uno 0 e viceversa. Inoltre, il segno del numero è invertito:

Espres­sio­ne 23 = 8 22 = 4 21 = 2 20 = 1 Decimale
b = 6 0 1 1 0 6
~ b 1 0 0 1 -7

Operatori di as­se­gna­zio­ne

Le as­se­gna­zio­ni sono tra le istru­zio­ni di base della maggior parte dei linguaggi di pro­gram­ma­zio­ne. Gli operatori di as­se­gna­zio­ne in Python legano un valore a un nome di variabile. Oltre all’istru­zio­ne di as­se­gna­zio­ne, esiste il più recente operatore “tricheco”, che consente l’as­se­gna­zio­ne all’interno di un’espres­sio­ne. Esiste anche una serie di istru­zio­ni di as­se­gna­zio­ne estese che combinano un’as­se­gna­zio­ne con un’altra ope­ra­zio­ne:

Operatore Python Si­gni­fi­ca­to Funzione dell’operatore Esempio
= Istru­zio­ne di as­se­gna­zio­ne Nessun equi­va­len­te diretto name = 'Walther'
:= Espres­sio­ne di as­se­gna­zio­ne (operatore “tricheco”) Nessun equi­va­len­te diretto [ half for x in range(10) if (half := x / 2) < 5 ]
+= As­se­gna­zio­ne di addizione avanzata iadd(a, b) x = 1; x += 4; assert x == 5

Python conosce operatori di as­se­gna­zio­ne avanzati per le ope­ra­zio­ni arit­me­ti­che e binarie. Non li elen­chia­mo sin­go­lar­men­te, ma mostriamo solo lo schema generale uti­liz­zan­do l’esempio dell’as­se­gna­zio­ne di con­ca­te­na­zio­ne avanzata. In­nan­zi­tut­to, viene mostrato un codice che aggiunge un’altra parte a una stringa esistente:

name = 'Walther'
name = name + 'White'
assert name == 'WaltherWhite'

Un esempio equi­va­len­te con l’operatore di con­ca­te­na­zio­ne avanzato “+=” in Python, in cui si ottiene lo stesso risultato, ma il codice è più stringato e più espli­ca­ti­vo:

name  = 'Walther'
name += 'White'
assert name == 'WaltherWhite'

Operatori di identità

L’operatore is in Python verifica se due variabili si ri­fe­ri­sco­no allo stesso oggetto in memoria. L’identità dell’oggetto è in contrasto con la sua ugua­glian­za, che viene ve­ri­fi­ca­ta dall’operatore di confronto Python “==”. L’operatore “is” in Python cor­ri­spon­de all’incirca all’operatore di ugua­glian­za rigorosa “===” di Ja­va­Script. Python conosce anche un test d’identità negata con l’operatore “is not”:

Operatore Python Si­gni­fi­ca­to Funzione dell’operatore Esempio
is Test d’identità is_(a, b) a = 42; b = a; assert a is b
is not Test d’identità negata is_not(a, b) assert [42] is not [42]

Vediamo alcuni esempi. Creiamo un ri­fe­ri­men­to a un oggetto in memoria. In seguito, creeremo un altro ri­fe­ri­men­to come alias. Se entrambe le variabili puntano allo stesso oggetto in memoria, l’operatore is re­sti­tui­sce “True”:

# assign value to name
a = [42]
# reference existing object
b = a
# if this holds
assert a is b
# so will this
assert a == b

Qui creiamo due ri­fe­ri­men­ti a oggetti in­di­pen­den­ti in memoria. Malgrado siano gli stessi, gli oggetti rimangono comunque distinti. Di con­se­guen­za, l’operatore is re­sti­tui­sce “False”:

# assign the same value to different names
a = [42]
b = [42]
# `a`, `b` are two different objects
assert a is not b
# that contain the same value
assert a == b

Operatore con­di­zio­na­le

L’operatore con­di­zio­na­le in Python è un altro uso delle parole chiave if-else. Viene spesso uti­liz­za­to per di­stin­gue­re tra due possibili valori nelle as­se­gna­zio­ni. Poiché questo operatore combina una con­di­zio­ne e due espres­sio­ni, è noto anche come operatore ternario.

Operatore Python Si­gni­fi­ca­to Funzione dell’operatore Esempio
... if ... else ... Espres­sio­ne con­di­zio­na­le Nessun equi­va­len­te diretto name = 'Jim' if age == 42 else 'Jack'

Vediamo prima un esempio uti­liz­zan­do l’istru­zio­ne if-else in Python. Il codice seguente imposta Celsius o Fah­ren­heit come unità di misura della tem­pe­ra­tu­ra, a seconda del sistema di misura se­le­zio­na­to:

if system == 'metric':
    unit = 'C'
else:
    unit = 'F'

Uti­liz­zan­do l’operatore con­di­zio­na­le, il codice può essere sem­pli­fi­ca­to in un singolo as­se­gna­men­to:

unit = 'C' if system == 'metric' else 'F'

Operatori di set in Python

Oltre a stringhe, tuple, liste e dizionari, Python supporta per im­po­sta­zio­ne pre­de­fi­ni­ta i set come tipo di dati composito. Gli operatori so­vrac­ca­ri­ca­ti sono definiti per le consuete ope­ra­zio­ni sui set:

Operatore Python Si­gni­fi­ca­to Funzione dell’operatore Esempio    
& Creazione dell’unione di due set and_(a, b) {'a', 'b'} & {'a', 'c'} == {'a'}    
    Creazione dell’in­ter­se­zio­ne di due set or_(a, b) {'a', 'b'} {'a', 'c'} == {'a', 'c', 'b'}
^ Creazione della dif­fe­ren­za sim­me­tri­ca di due set xor(a, b) {'a', 'b'} ^ {'a', 'c'} == {'c', 'b'}    
- Creazione della dif­fe­ren­za di due set sub(a, b) {'a', 'b'} - {'a'} == {'b'}    
> Verifica se un insieme è un vero superset gt(a, b) assert {'a', 'b'} > {'a'}    
>= Verifica se un insieme è un superset ge(a, b) assert {'a'} >= {'a'}    
< Verifica se un insieme è un vero subset lt(a, b) assert {'a'} < {'a', 'b'}    
<= Verifica se un insieme è un subset le(a, b) assert {'a'} <= {'a'}    

Operatori di ap­par­te­nen­za in Python

Gli operatori di ap­par­te­nen­za “in” e “not in” in Python for­ni­sco­no una di­chia­ra­zio­ne sull’in­clu­sio­ne di un oggetto in un insieme.

Operatore Python Si­gni­fi­ca­to Funzione dell’operatore Esempio
in Verifica se un oggetto è contenuto in un’iterabile contains(a, b) 'y' in 'Python'
not in Negazione dell’operatore in not contains(a, b) 'x' not in 'Python'

Gli operatori di ap­par­te­nen­za fun­zio­na­no con iterabili e uti­liz­za­no un controllo di ugua­glian­za per de­ter­mi­na­re se l’oggetto di de­sti­na­zio­ne è incluso nell’insieme:

'Py' in 'Python'
'Px' not in 'Python'
'Jack' in ['Jim', 'Jack']

L’uso dell’operatore in consente di evitare di scrivere il codice nella forma seguente:

def my_in(target, collection):
    for element in collection:
        if element == target:
            return True
    return False
# test
word = 'Python'
letter = 'y'
assert (my_in(letter, word)) == (letter in word)

Operatore di con­ca­te­na­zio­ne

In Python, l’operatore di con­ca­te­na­zio­ne viene uti­liz­za­to per con­ca­te­na­re sequenze dello stesso tipo. Il segno più viene uti­liz­za­to come simbolo dell’operatore.

Operatore Python Si­gni­fi­ca­to Funzione dell’operatore Esempio
+ Concatena due sequenze add(a, b) ['Jim'] + ['Jack', 'John']

Vediamo alcuni esempi. Con­ca­te­nia­mo due stringhe, due liste e due tuple:

assert "Walter" + "White" == 'WalterWhite'
assert ['a', 'b'] + ['c'] == ['a', 'b', 'c']
assert ('q', 'r') + ('s', 't') == ('q', 'r', 's', 't')

Python è uti­liz­za­to come lin­guag­gio di pro­gram­ma­zio­ne web. In questo contesto, l’operatore di con­ca­te­na­zio­ne viene uti­liz­za­to per as­sem­bla­re tag HTML:

site_title = 'Welcome'
print('<h1>' + site_title + '</h1>')

Nel confronto tra Python e PHP viene fatta una di­stin­zio­ne tra gli operatori di con­ca­te­na­zio­ne dei due linguaggi. Questo perché PHP utilizza il punto “.” come simbolo. Lo stesso esempio mostrato in PHP:

$siteTitle = 'Welcome';
echo '<h1>' . $siteTitle . '</h1>';

Operatori di indice e di fetta

L’operatore indice in Python viene uti­liz­za­to per estrarre un elemento specifico di un insieme. L’operatore fetta (“slice” in inglese) viene uti­liz­za­to per estrarre una sot­to­se­quen­za.

Operatore Python Si­gni­fi­ca­to Funzione dell’operatore Esempio
iterable[index] Re­sti­tui­sce l’elemento di un iterabile situato sotto l’indice getitem(iterable, index) 'Python'[1] == 'y'
sequence[start:stop:step] Re­sti­tui­sce una fetta di una sequenza getitem(iterable, slice(start, stop, step)) 'Python'[0:1] == 'Py', 'Python'[0:-1:2] == 'Pto'

Gli operatori indice e fetta di Python fanno uso interno del metodo Dunder __getitem__(), che viene ri­chia­ma­to con un indice numerico o con un oggetto fetta:

names = ['Jim', 'Jack', 'John']
names[0] == names.__getitem__(0)
names[0:2] == names.__getitem__(slice(0, 2))

L’operatore fetta è utile perché consente di estrarre una sot­to­se­quen­za senza usare un ciclo for in Python o un ciclo while in Python. Questo evita ai pro­gram­ma­to­ri di scrivere un codice nella forma seguente:

word = 'Python'
start, stop, step = 0, 5, 2
index, substring = start, ''
while index in range(start, stop, step):
    substring += word[index]
    index += step
# test
assert substring == word[start:stop:step]
Vai al menu prin­ci­pa­le