Le parole chiave sono le parole riservate in Python. Non possiamo usare una parola chiave come nome di variabile, nome di funzione o qualsiasi altro identificatore.

Ecco un elenco di tutte le parole chiave nella programmazione Python

Le suddette parole chiave possono essere modificate in diverse versioni di Python. Alcune in più potrebbero essere aggiunte o alcune potrebbero essere rimosse. Puoi sempre ottenere la lista delle parole chiave nella tua versione corrente digitando quanto segue nel prompt.

>>> import keyword>>> print(keyword.kwlist)

Descrizione delle parole chiave in Python con esempi

Vero, Falso

True e False sono valori di verità in Python. Sono i risultati di operazioni di confronto o operazioni logiche (booleane) in Python. Per esempio:

>>> 1 == 1True>>> 5 > 3True>>> True or FalseTrue>>> 10 <= 1False>>> 3 > 7False>>> True and FalseFalse

Qui possiamo vedere che le prime tre affermazioni sono vere quindi l’interprete restituisce True e restituisce False per le altre tre affermazioni. True e False in python è uguale a 1 e 0. Questo può essere giustificato con il seguente esempio:

>>> True == 1True>>> False == 0True>>> True + True2

Nessuno

None è una costante speciale in Python che rappresenta l’assenza di un valore o un valore nullo.

È un oggetto del proprio tipo di dato, il NoneType. Non possiamo creare più oggetti None ma possiamo assegnarlo a delle variabili. Queste variabili saranno uguali l’una all’altra.

Dobbiamo fare particolare attenzione che None non implichi False, 0 o qualsiasi elenco vuoto, dizionario, stringa ecc. Per esempio:

>>> None == 0False>>> None == False>>> None == FalseFalse>>> x = None>>> y = None>>> x == yTrue

Le funzioni vuote che non restituiscono nulla restituiranno automaticamente un oggetto None. None è anche restituito da funzioni in cui il flusso del programma non incontra una dichiarazione di ritorno. Per esempio:

def a_void_function(): a = 1 b = 2 c = a + bx = a_void_function()print(x)

Output

None

Questo programma ha una funzione che non restituisce un valore, sebbene faccia alcune operazioni al suo interno. Così, quando stampiamo x, otteniamo None che viene restituito automaticamente (implicitamente). Allo stesso modo, ecco un altro esempio:

def improper_return_function(a): if (a % 2) == 0: return Truex = improper_return_function(3)print(x)

Output

None

Anche se questa funzione ha una dichiarazione return, non viene raggiunta in ogni caso. La funzione restituirà True solo quando l’input è pari.

Se diamo alla funzione un numero dispari, None viene restituito implicitamente.

e, o , non

and, or, not sono gli operatori logici in Python. and risulterà in True solo se entrambi gli operandi sono True. La tabella della verità per and è data qui sotto:

or risulterà in True se uno degli operandi è True. La tabella della verità per or è data di seguito:

not operatore viene utilizzato per invertire il valore di verità. La tabella di verità per not è data qui sotto:

alcuni esempi del loro uso sono dati qui sotto

>>> True and FalseFalse>>> True or FalseTrue>>> not FalseTrue

as

as è usato per creare un alias mentre si importa un modulo. Significa dare un nome diverso (definito dall’utente) a un modulo mentre lo si importa.

Come per esempio, Python ha un modulo standard chiamato math. Supponiamo di voler calcolare qual è il coseno pi greco usando un alias. Possiamo farlo come segue usando as:

>>> import math as myAlias>>>myAlias.cos(myAlias.pi)-1.0

Qui abbiamo importato il modulo math dandogli il nome myAlias. Ora possiamo fare riferimento al modulo math con questo nome. Usando questo nome abbiamo calcolato cos(pi) e abbiamo ottenuto -1.0 come risposta.

assert

assert è usato per scopi di debug.

Durante la programmazione, a volte vogliamo conoscere lo stato interno o controllare se le nostre ipotesi sono vere. assert ci aiuta a fare questo e a trovare i bug più comodamente. assert è seguito da una condizione.

Se la condizione è vera, non succede niente. Ma se la condizione è falsa, viene sollevato AssertionError. Per esempio:

>>> a = 4>>> assert a < 5>>> assert a > 5Traceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>AssertionError

Per una migliore comprensione, possiamo anche fornire un messaggio da stampare con il AssertionError.

>>> a = 4>>> assert a > 5, "The value of a is too small"Traceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>AssertionError: The value of a is too small

A questo punto possiamo notare che,

assert condition, message

è equivalente a,

if not condition: raise AssertionError(message)

async, await

Le parole chiave async e await sono fornite dalla libreria asyncio di Python. Sono usate per scrivere codice concorrente in Python. Per esempio,

import asyncioasync def main(): print('Hello') await asyncio.sleep(1) print('world')

Per eseguire il programma, usiamo

asyncio.run(main())

Nel programma sopra, la parola chiave async specifica che la funzione sarà eseguita in modo asincrono.

Qui, viene stampato prima Hello. La parola chiave await fa aspettare il programma per 1 secondo. E poi viene stampato il mondo.

break, continue

break e continue sono usati all’interno dei cicli for e while per alterare il loro normale comportamento.

break terminerà il ciclo più piccolo in cui si trova e il controllo passerà alla dichiarazione immediatamente sotto il ciclo. continue fa terminare l’iterazione corrente del ciclo, ma non l’intero ciclo.

Questo può essere illustrato con i seguenti due esempi:

for i in range(1,11): if i == 5: break print(i)

Output

1234

Qui, il ciclo for intende stampare numeri da 1 a 10. Ma la condizione if è soddisfatta quando i è uguale a 5 e si esce dal ciclo. Così, solo l’intervallo da 1 a 4 viene stampato.

for i in range(1,11): if i == 5: continue print(i)

Output

1234678910

Qui usiamo continue per lo stesso programma. Così, quando la condizione è soddisfatta, quell’iterazione viene saltata. Ma non usciamo dal ciclo. Quindi, tutti i valori tranne 5 vengono stampati.

Impara di più su Python break e continue statement.

class

class è usato per definire una nuova classe definita dall’utente in Python.

La classe è una collezione di attributi e metodi correlati che cercano di rappresentare una situazione del mondo reale. Questa idea di mettere insieme dati e funzioni in una classe è centrale per il concetto di programmazione orientata agli oggetti (OOP).

Le classi possono essere definite ovunque in un programma. Ma è una buona pratica definire una singola classe in un modulo. Di seguito un esempio d’uso:

class ExampleClass: def function1(parameters): … def function2(parameters): …

Impara di più sugli oggetti e le classi di Python.

def

def è usato per definire una funzione definita dall’utente.

La funzione è un blocco di istruzioni correlate, che insieme svolgono un compito specifico. Ci aiuta ad organizzare il codice in pezzi gestibili e anche a fare qualche compito ripetitivo.

L’uso di def è mostrato sotto:

def function_name(parameters): …

Impara di più sulle funzioni Python.

del

del è usato per cancellare il riferimento ad un oggetto. Tutto è oggetto in Python. Possiamo cancellare un riferimento a una variabile usando del

>>> a = b = 5>>> del a>>> aTraceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>NameError: name 'a' is not defined>>> b5

Qui possiamo vedere che il riferimento della variabile a è stato cancellato. Quindi, non è più definita. Ma b esiste ancora.

del è anche usato per cancellare elementi da una lista o da un dizionario:

>>> a = >>> del a>>> a

if, else, elif

if, else, elif sono usati per la ramificazione condizionale o per prendere decisioni.

Quando vogliamo testare qualche condizione ed eseguire un blocco solo se la condizione è vera, allora usiamo if e elif. elif è l’abbreviazione di else if. else è il blocco che viene eseguito se la condizione è falsa. Questo sarà chiaro con il seguente esempio:

def if_example(a): if a == 1: print('One') elif a == 2: print('Two') else: print('Something else')if_example(2)if_example(4)if_example(1)

Output

TwoSomething elseOne

Qui la funzione controlla il numero in ingresso e stampa il risultato se è 1 o 2. Qualsiasi input diverso da questo causerà l’esecuzione della parte elsedel codice.

Impara di più su Python if e if…else Statement.

except, raise, try

except, raise, try sono usati con le eccezioni in Python.

Le eccezioni sono fondamentalmente errori che suggeriscono che qualcosa è andato male durante l’esecuzione del nostro programma. IOError, ValueError, ZeroDivisionError, ImportError, NameError, TypeError ecc. sono alcuni esempi di eccezioni in Python. I blocchi try...except sono usati per catturare le eccezioni in Python.

Possiamo sollevare un’eccezione esplicitamente con la parola chiave raise. Ecco un esempio:

def reciprocal(num): try: r = 1/num except: print('Exception caught') return return rprint(reciprocal(10))print(reciprocal(0))

Output

0.1Exception caughtNone

Qui la funzione reciprocal() restituisce il reciproco del numero immesso.

Quando immettiamo 10, otteniamo il normale output di 0,1. Ma quando immettiamo 0, si verifica un raise. Ma quando inseriamo 0, un ZeroDivisionError viene sollevato automaticamente.

Questo viene catturato dal nostro blocco try…except e restituiamo None. Avremmo anche potuto sollevare il ZeroDivisionError esplicitamente controllando l’input e gestirlo altrove come segue:

if num == 0: raise ZeroDivisionError('cannot divide')

finalmente

finally è usato con il blocco try…except per chiudere risorse o flussi di file.

L’uso di finally assicura che il blocco di codice al suo interno venga eseguito anche se c’è un’eccezione non gestita. Per esempio:

try: Try-blockexcept exception1: Exception1-blockexcept exception2: Exception2-blockelse: Else-blockfinally: Finally-block

Qui se c’è un’eccezione nel Try-block, viene gestita nel blocco except o else. Ma non importa in quale ordine scorre l’esecuzione, possiamo essere sicuri che il Finally-block viene eseguito anche se c’è un errore. Questo è utile per pulire le risorse.

Impara di più sulla gestione delle eccezioni nella programmazione Python.

per

for è usato per il looping. Generalmente usiamo for quando conosciamo il numero di volte che vogliamo fare il loop.

In Python possiamo usarlo con qualsiasi tipo di sequenza come una lista o una stringa. Ecco un esempio in cui for è usato per attraversare una lista di nomi:

names = for i in names: print('Hello '+i)

Output

Hello JohnHello MonicaHello StevenHello Robin

Impara di più su Python for loop.

from, import

import parola chiave è usata per importare moduli nel namespace corrente. from…import è usata per importare attributi o funzioni specifiche nello spazio dei nomi corrente. Per esempio:

import math

importerà il modulo math. Ora possiamo usare la funzione cos() al suo interno come math.cos(). Ma se volessimo importare solo la funzione cos(), questo può essere fatto usando from as

from math import cos

ora possiamo usare la funzione semplicemente come cos(), senza bisogno di scrivere math.cos().

Impara di più sui moduli Python e la dichiarazione import.

global

global si usa per dichiarare che una variabile all’interno della funzione è globale (fuori dalla funzione).

Se abbiamo bisogno di leggere il valore di una variabile globale, non è necessario definirla come global. Questo è compreso.

Se abbiamo bisogno di modificare il valore di una variabile globale all’interno di una funzione, allora dobbiamo dichiararla con global. Altrimenti, viene creata una variabile locale con quel nome.

L’esempio seguente ci aiuterà a chiarirlo.

globvar = 10def read1(): print(globvar)def write1(): global globvar globvar = 5def write2(): globvar = 15read1()write1()read1()write2()read1()

Output

1055

Qui, la funzione read1() sta solo leggendo il valore di globvar. Quindi, non abbiamo bisogno di dichiararla come global. Ma la funzione write1() sta modificando il valore, quindi dobbiamo dichiarare la variabile come global.

Possiamo vedere nel nostro output che la modifica ha avuto luogo (10 è cambiato in 5). Anche il write2() cerca di modificare questo valore. Ma non l’abbiamo dichiarato come global.

Quindi, viene creata una nuova variabile locale globvar che non è visibile fuori da questa funzione. Anche se modifichiamo questa variabile locale a 15, la variabile globale rimane invariata. Questo è chiaramente visibile nel nostro output.

in

in è usato per verificare se una sequenza (lista, tupla, stringa ecc.) contiene un valore. Restituisce True se il valore è presente, altrimenti restituisce False. Per esempio:

>>> a = >>> 5 in aTrue>>> 10 in aFalse

L’uso secondario di in è quello di attraversare una sequenza in un ciclo for.

for i in 'hello': print(i)

Output

hello

is

is è usato in Python per testare l’identità degli oggetti. Mentre l’operatore == è usato per testare se due variabili sono uguali o no, is è usato per testare se le due variabili si riferiscono allo stesso oggetto.

Ritorna True se gli oggetti sono identici e False in caso contrario.

>>> True is TrueTrue>>> False is FalseTrue>>> None is NoneTrue

Sappiamo che c’è solo un’istanza di True, False e None in Python, quindi sono identici.

>>> == True>>> is False>>> {} == {}True>>> {} is {}False

Un elenco o un dizionario vuoto è uguale ad un altro vuoto. Ma non sono oggetti identici perché si trovano separatamente in memoria. Questo perché lista e dizionario sono mutabili (il valore può essere cambiato).

>>> '' == ''True>>> '' is ''True>>> () == ()True>>> () is ()True

A differenza di lista e dizionario, stringa e tupla sono immutabili (il valore non può essere modificato una volta definito). Quindi, due stringhe o tuple uguali sono anche identiche. Si riferiscono alla stessa posizione di memoria.

lambda

lambdaè usato per creare una funzione anonima (funzione senza nome). È una funzione in linea che non contiene una dichiarazione return. Consiste in un’espressione che viene valutata e restituita. Per esempio:

a = lambda x: x*2for i in range(1,6): print(a(i))

Output

246810

Qui abbiamo creato una funzione inline che raddoppia il valore, usando la dichiarazione lambda. L’abbiamo usata per raddoppiare i valori in una lista che contiene da 1 a 5.

Impara di più sulla funzione lamda di Python.

nonlocal

L’uso della parola chiave nonlocal è molto simile alla parola chiave global. nonlocal è usata per dichiarare che una variabile all’interno di una funzione annidata (funzione all’interno di una funzione) non è locale, cioè si trova nella funzione esterna che la racchiude. Se abbiamo bisogno di modificare il valore di una variabile non locale all’interno di una funzione annidata, allora dobbiamo dichiararla con nonlocal. Altrimenti viene creata una variabile locale con quel nome all’interno della funzione annidata. Il seguente esempio ci aiuterà a chiarire questo.

def outer_function(): a = 5 def inner_function(): nonlocal a a = 10 print("Inner function: ",a) inner_function() print("Outer function: ",a)outer_function()

Output

Inner function: 10Outer function: 10

Qui, il inner_function() è annidato dentro il outer_function.

La variabile a è nel outer_function(). Quindi, se vogliamo modificarla nella inner_function(), dobbiamo dichiararla come nonlocal. Notate che a non è una variabile globale.

Quindi, vediamo dall’output che la variabile è stata modificata con successo all’interno del inner_function() annidato. Il risultato di non usare la parola chiave nonlocal è il seguente:

def outer_function(): a = 5 def inner_function(): a = 10 print("Inner function: ",a) inner_function() print("Outer function: ",a)outer_function()

Output

Inner function: 10Outer function: 5

Qui, non dichiariamo che la variabile a dentro la funzione annidata è nonlocal. Quindi, viene creata una nuova variabile locale con lo stesso nome, ma la non locale a non viene modificata come si vede nel nostro output.

pass

pass è una dichiarazione nulla in Python. Non succede nulla quando viene eseguita. È usata come segnaposto.

Supponiamo di avere una funzione che non è ancora implementata, ma vogliamo implementarla in futuro. Scrivendo semplicemente,

def function(args):

nel mezzo di un programma si ottiene IndentationError. Invece di questo, costruiamo un corpo vuoto con l’istruzione pass.

def function(args): pass

Possiamo fare la stessa cosa anche in un class vuoto.

class example: pass

l’istruzionereturn

return si usa all’interno di una funzione per uscirne e restituire un valore.

Se non restituiamo un valore esplicitamente, None viene restituito automaticamente. Questo è verificato con il seguente esempio.

def func_return(): a = 10 return adef no_return(): a = 10print(func_return())print(no_return())

Output

10None

while

while è usato per il looping in Python.

Le istruzioni all’interno di un ciclo while continuano ad essere eseguite fino a quando la condizione per il ciclo while valuta a False o si incontra un’istruzione break. Il seguente programma illustra questo.

i = 5while(i): print(i) i = i – 1

Output

54321

Nota che 0 è uguale a False.

Impara di più sul ciclo while di Python.

con

with l’istruzione è usata per avvolgere l’esecuzione di un blocco di codice all’interno di metodi definiti dal gestore del contesto.

Il gestore del contesto è una classe che implementa __enter__ e __exit__ metodi. L’uso della dichiarazione with assicura che il metodo __exit__ sia chiamato alla fine del blocco annidato. Questo concetto è simile all’uso del blocco try…finally. Ecco un esempio.

with open('example.txt', 'w') as my_file: my_file.write('Hello world!')

Questo esempio scrive il testo Hello world! nel file example.txt. Gli oggetti file hanno i metodi __enter__ e __exit__ definiti al loro interno, quindi agiscono come un proprio gestore di contesto.

Prima viene chiamato il metodo __enter__, poi viene eseguito il codice all’interno della dichiarazione with e infine viene chiamato il metodo __exit__. Il metodo __exit__ viene chiamato anche se c’è un errore. Fondamentalmente chiude il file stream.

yield

yield è usato all’interno di una funzione come una dichiarazione return. Ma yield restituisce un generatore.

Generatore è un iteratore che genera un elemento alla volta. Una grande lista di valori occuperà molta memoria. I generatori sono utili in questa situazione perché generano solo un valore alla volta invece di memorizzare tutti i valori in memoria. Per esempio,

>>> g = (2**x for x in range(100))

creerà un generatore g che genera potenze di 2 fino al numero due elevato alla potenza 99. Possiamo generare i numeri usando la funzione next() come mostrato qui sotto.

>>> next(g)1>>> next(g)2>>> next(g)4>>> next(g)8>>> next(g)16

E così via… Questo tipo di generatore è restituito dall’istruzione yield da una funzione. Ecco un esempio.

def generator(): for i in range(6): yield i*ig = generator()for i in g: print(i)

Output