Elenco delle parole chiave di Python e esempi

Questo tutorial fornisce informazioni brevi su tutte le parole chiave utilizzate in Python.

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

Questa è una lista di tutte le parole chiave nel linguaggio di programmazione Python

Le parole chiave possono variare tra le diverse versioni di Python. Potrebbe essere aggiunta alcune informazioni aggiuntive o eliminare alcune informazioni. Puoi sempre ottenere l'elenco delle parole chiave della versione corrente utilizzando il seguente metodo.

>>> import keyword
>>> print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally',]
　'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

Esempi di spiegazione delle parole chiave in Python

True, False

True e False sono valori veri e falsi in Python. Sono il risultato di operazioni di confronto o operazioni logiche (booleane) in Python. Ad esempio:

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

Ecco che le prime tre istruzioni sono corrette, quindi l'interprete restituisce True, mentre le altre tre istruzioni restituiscono False. True e False in Python sono uguali a 1 e 0. Questo può essere dimostrato con l'esempio seguente:

>>> True == 1
True
>>> False == 0
True
>>> True + True
2

None

None è una costante speciale in Python che rappresenta un valore inesistente o un valore vuoto.

È un oggetto di tipo NoneType a sé stante. Non possiamo creare più oggetti None, ma possiamo assegnarli a variabili. Queste variabili sono uguali.

Dobbiamo prestare particolare attenzione al fatto che None non rappresenta False, 0 o qualsiasi lista vuota, dizionario, stringa, ecc. Ad esempio:

>>> None == 0
False
>>> None == []
False
>>> None == False
False
>>> x = None
>>> y = None
>>> x == y
True

Una funzione virtuale che non restituisce alcun contenuto restituisce automaticamente un oggetto None. Le funzioni che non incontrano istruzioni return durante il flusso del programma restituiscono None. Ad esempio:

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

Risultato di output

None

Il programma, anche se esegue alcune operazioni internamente, non restituisce alcun valore. Pertanto, quando stampiamo x, otteniamo automaticamente (implicitamente) None. Allo stesso modo, ecco un altro esempio:

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

Risultato di output

None

Nonostante questa funzione abbia una dichiarazione return, non è sempre possibile realizzarla. La funzione restituisce True solo se l'input è un numero pari.

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

and, or, not

and, or, not sono operatori logici in Python. E il risultato è True solo se entrambi gli operandi sono True. La tabella di verità di and è la seguente:

or se almeno uno degli operandi è True, il risultato è True. La tabella di verità di or è la seguente:

Il operatore not viene usato per invertire il valore di verità. La tabella di verità di not è la seguente:

Di seguito sono riportati alcuni esempi di utilizzo

>>> True and False
False
>>> True or False
True
>>> not False
True

as

as viene usato per creare un alias durante l'importazione del modulo. Questo significa che, durante l'importazione del modulo, diamo al modulo un nome diverso (definito dall'utente).

Ad esempio, Python ha un modulo standard chiamato math. Supponiamo di voler calcolare cos(pi) utilizzando un alias. Possiamo farlo in questo modo:

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

In questo caso, importiamo il modulo math tramite il nome del modulo myAlias. Ora, possiamo usare questo nome per referenziare il modulo. Utilizzando questo nome, abbiamo calcolato cos(pi) e ottenuto l'answer -1.0.

assert

assert è usato per scopi di debug.

Nel programming, a volte vogliamo sapere lo stato interno o controllare se le nostre ipotesi sono corrette. L'assert ci aiuta a fare questo e a trovare gli errori più facilmente. L'assert segue una condizione.

Se la condizione è vera, non succede nulla. Ma se la condizione è falsa, viene sollevato un AssertionError. Ad esempio:

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

Per aiutarci a comprendere meglio, possiamo fornire anche un messaggio che verrà stampato insieme all'AssertionError.

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

In questo punto, possiamo notare che,

assert condition, message

è equivalente

if not condition:
　　　　raise AssertionError(message)

async, await

La libreria asyncio in Python fornisce le parole chiave async e await. Vengono utilizzate per scrivere codice concorrente in Python. Ad esempio,

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

Per eseguire il programma, utilizziamo

asyncio.run(main())

Nella programmazione asincrona, la parola chiave async specifica che la funzione verrà eseguita asincronamente.

In questo esempio, viene stampato prima Hello. La parola chiave await fa sì che il programma attenda 1 secondo prima di stampare world.

break, continue

break e continue vengono utilizzati nei cicli for e while per modificare il loro comportamento normale.

break termina il ciclo più piccolo in cui si trova, e il flusso di controllo passa direttamente alle istruzioni sotto il ciclo. continue termina l'iterazione corrente del ciclo, non l'intero ciclo.

Questo può essere illustrato con due esempi:

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

Risultato di output

1
2
3
4

In questo esempio, il ciclo for è progettato per stampare i numeri da 1 a 10. Tuttavia, se i è uguale a 5, si soddisfa la condizione e ci interrompiamo dal ciclo. Pertanto, verranno stampati solo i numeri da 1 a 4.

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

Risultato di output

1
2
3
4
6
7
8
9
10

In questo esempio, utilizziamo continue allo stesso modo del programma. Pertanto, quando si soddisfa una condizione, si salta l'iterazione corrente. Ma non esceremo dal ciclo. Pertanto, verranno stampati tutti i valori tranne quelli di 5.

Scopri di piùEsercizi break e Continue in PythonPiù informazioni.

class

class viene utilizzato per definire nuove classi definite dall'utente in Python.

Una classe è un insieme di attributi e metodi correlati che cercano di rappresentare situazioni reali. L'idea di collocare dati e funzioni in una classe è cruciale per il concetto di programmazione orientata agli oggetti (OOP).

Le classi possono essere definite in qualsiasi posizione del programma. Tuttavia, l'abitudine di definire una singola classe nel modulo è una buona pratica. Ecco un esempio di utilizzo:

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

Scopri di piùOggetti e classi PythonPiù informazioni.

def

def viene utilizzato per definire una funzione definita dall'utente.

La funzione è un insieme di istruzioni correlate, che eseguono insieme determinati compiti specifici. Aiuta a organizzare il codice in blocchi gestibili e a completare compiti ripetitivi.

def的用法如下所示：

def function_name(parameters):
　　　　...

Scopri di piùPython函数的Più informazioni.

del

del用于删除对对象的引用。一切都是Python中的对象。我们可以使用以下方式删除变量，通过引用del

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

在这里我们可以看到该变量的引用a已删除。因此，不再定义。但是b仍然存在。

del 也用于从列表或字典中删除项目：

>>> a = ['x','y','z']
>>> del a[1]
>>> a
['x', 'z']

if, else, elif

if, else, elif 用于条件分支或决策。

当我们要测试某个条件并仅在条件为真时才执行块时，我们使用if和elif。elif是else if的缩写。else是条件为假时执行的块。通过以下示例将很清楚：

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)

Risultato di output

Two
Something else
One

在此，该函数检查输入的数字（如果是1或2），并输出结果。否则，任何输入都会导致else部分代码执行。

Scopri di piùPython if and if ... else语句的Più informazioni.

except, raise, try

except, raise, try 与Python中的异常一起使用。

L'eccezione è基本上是错误，表明在执行我们的程序时出现了问题。在Python异常的几个实例IOError，ValueError，ZeroDivisionError，ImportError，NameError，TypeError等。try...except块用于捕获Python中的异常。

Possiamo usare il comando raise per lanciare esplicitamente un'eccezione. Ecco un esempio:

def reciprocal(num):
　　　　try:
　　　　　　　　r = 1/num
　　　　except:
　　　　　　　　print('Eccezione catturata')
　　　　　　　　return
　　　　return r
print(reciprocal(10))
print(reciprocal(0))

Risultato di output

0.1
Eccezione catturata
None

Qui, la funzione reciprocal() restituisce il reciproco del numero di input.

Quando inseriamo 10, l'output normale è 0.1. Ma quando inseriamo 0, viene automaticamente lanciata l'eccezione ZeroDivisionError.

Questo viene catturato dal nostro blocco try...except e restituiamo None. Possiamo anche lanciare esplicitamente ZeroDivisionError controllando l'input e gestendolo altrove come segue:

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

finally

finally viene utilizzato insieme a try...except per chiudere risorse o flussi di file.

Usiamo finally per assicurare che il blocco di codice interno venga eseguito anche se ci sono eccezioni non gestite. Ad esempio:

try:
　　　　blocco try
except exception1:
　　　　blocco Exception1
except exception2:
　　　　blocco Exception2
else:
　　　　blocco else
finally:
　　　　blocco finally

Qui, se c'è un blocco try con un'eccezione, viene gestita nel blocco except o else. Ma, indipendentemente dall'ordine di esecuzione, anche se ci sono errori, possiamo eseguire con sicurezza il blocco finally. Questo è utile per la pulizia delle risorse.

Scopri di piùGestione delle eccezioni nel programming PythonPiù informazioni.

for

for per il ciclo. Di solito, usiamo for quando conosciamo il numero di volte da eseguire.

In Python, possiamo usarlo con qualsiasi tipo di sequenza (ad esempio, elenco o stringa). Ecco un esempio di for per esplorare l'elenco names:

names = ['John','Monica','Steven','Robin']
for i in names:
　　　　print('Ciao '+i)

Risultato di output

Ciao John
Ciao Monica
Ciao Steven
Ciao Robin

Scopri di piùCiclo for in PythonPiù informazioni.

from, import

La parola chiave 'import' viene utilizzata per importare moduli nel namespace corrente. 'from…import' viene utilizzato per importare proprietà o funzioni specifiche nel namespace corrente. Ad esempio:

import math

Importiamo il modulo 'math'. Ora possiamo utilizzare la funzione 'cos()' come 'math.cos()'. Ma se vogliamo importare solo la funzione 'cos()', possiamo farlo con 'from'.

from math import cos

Ora possiamo semplicemente utilizzare la funzione 'cos()', senza dover scrivere 'math.cos()'.

Scopri di piùPiù informazioni sui moduli Python e sulle istruzioni 'import'.

global

La parola chiave 'global' viene utilizzata per dichiarare che una variabile all'interno di una funzione è una variabile globale (fuori dalla funzione).

Se è necessario leggere il valore di una variabile globale, non è necessario definirla come 'global'. Questo è il punto in cui è necessario.

Se è necessario modificare il valore di una variabile globale all'interno di una funzione, è necessario dichiarare 'global'. Altrimenti, verrà creato un variabile locale con lo stesso nome.

Esempi seguenti ci aiuteranno a chiarire questo punto.

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

Risultato di output

10
5
5

Qui, la funzione 'read1()' legge semplicemente il valore di 'globvar'. Pertanto, non dobbiamo dichiararlo come 'global'. Ma la funzione 'write1()' sta modificando il valore, quindi dobbiamo dichiarare la variabile come 'global'.

Possiamo vedere nell'output che è stato effettuato un modificazione (cambiato 10 in 5). La funzione 'write2()' tenta anche di modificare questo valore. Ma non l'abbiamo ancora dichiarato come 'global'.

Pertanto, creare una nuova variabile locale 'globvar' che non è visibile al di fuori di questa funzione. Anche se modificiamo questa variabile locale a 15, la variabile globale rimane invariata. Questo è chiaramente visibile nei nostri output.

in

L'uso di 'in' è per testare se una sequenza (elenco, tupla, stringa, ecc.) contiene un valore. Se il valore esiste, restituisce True, altrimenti False. Ad esempio:

>>> a = [1, 2, 3, 4, 5]
>>> 5 in a
True
>>> 10 in a
False

L'uso secondario di 'in' è per percorrere il ciclo for delle sequenze.

per i in 'hello':
　　　　print(i)

Risultato di output

h
e
l
l
o

is

is viene utilizzato in Python per testare l'identità degli oggetti. L'operatore == viene utilizzato per testare se due variabili sono uguali, mentre l'operatore is viene utilizzato per testare se due variabili si riferiscono allo stesso oggetto.

Restituisce True se gli oggetti sono identici, altrimenti restituisce False.

>>> True is True
True
>>> False is False
True
>>> None is None
True

Sappiamo che in Python ci sono un'unica istanza di True, False e None, quindi sono gli stessi.

>>> [] == []
True
>>> [] is []
False
>>> {} == {}
True
>>> {} is {}
False

Un elenco o dizionario vuoto è uguale a un altro elenco o dizionario vuoto. Tuttavia, non sono oggetti identici, poiché si trovano rispettivamente nella memoria. Questo è perché gli elenchi e i dizionari sono mutabili (i valori possono essere modificati).

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

Diversamente da elenchi e dizionari, le stringhe e le tuple sono immutabili (i valori una volta definiti non possono essere modificati). Pertanto, due stringhe o tuple uguali sono anche le stesse. Si riferiscono alla stessa posizione di memorizzazione.

lambda

Lambda viene utilizzata per creare funzioni anonime (funzioni senza nome). È una funzione inline che non contiene la dichiarazione return. È composta da un'espressione che viene valutata e restituita. Ad esempio:

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

Risultato di output

2
4
6
8
10

In questo caso, abbiamo creato una funzione inline, utilizzando l'espressione lambda per raddoppiare i valori. La usiamo per raddoppiare i valori di una lista che contiene valori da 1 a 5.

Scopri di piùLa funzione lamda del PythonPiù informazioni.

nonlocal

L'uso della parola chiave nonlocal è molto simile a quella di global. La parola chiave nonlocal viene utilizzata per dichiarare che le variabili all'interno delle funzioni annidate (funzioni all'interno di funzioni) non sono variabili locali, il che significa che si trovano all'interno della funzione enclosa esterna. Se si desidera modificare il valore di una variabile non locale all'interno di una funzione annidata, è necessario dichiararla con la parola chiave nonlocal. Altrimenti, verrà creato un variabile locale con lo stesso nome all'interno della funzione annidata. L'esempio seguente ci aiuterà a chiarire questo punto.

def outer_function():
　　　　a = 5
　　　　def inner_function():
　　　　　　　　nonlocal a
　　　　　　　　a = 10
　　　　　　　　print("Funzione interna: ", a)
　　　　inner_function()
　　　　print("Funzione esterna: ", a)
outer_function()

Risultato di output

Funzione interna: 10
Outer function: 10

In questo caso, inner_function() è annidato all'interno di outer_function.

La variabile a si trova all'interno di outer_function(). Pertanto, se si desidera modificare a all'interno di inner_function(), deve essere dichiarata come nonlocal. Si prega di notare che questa a non è una variabile globale.

Quindi, vediamo dall'output che la variabile è stata modificata con successo all'interno della funzione annidata inner_function(). Il risultato senza l'uso della parola chiave nonlocal è il seguente:

def outer_function():
　　　　a = 5
　　　　def inner_function():
　　　　　　　　a = 10
　　　　　　　　print("Funzione interna: ", a)
　　　　inner_function()
　　　　print("Funzione esterna: ", a)
outer_function()

Risultato di output

Funzione interna: 10
Funzione esterna: 5

In questo caso, non dichiariamo che la variabile a nell'interno della funzione annidata non è locale. Di conseguenza, verrà creata una nuova variabile locale con lo stesso nome, ma senza modificare la variabile non locale a, come mostrato nel nostro output.

pass

pass è una frase vuota in Python. Quando viene eseguita, non succede nulla. Viene utilizzata come segnaposto.

Supponiamo di avere una funzionalità non implementata ma che vogliamo implementare in futuro. Semplicemente scriviamo:

def function(args):

Nel mezzo del programma ci sarà un IndentationError. Invece, usiamo la frase pass per costruire un corpo vuoto.

def function(args):
　　　　pass

Possiamo anche fare la stessa cosa con una classe vuota.

class example:
　　　　pass

return

La frase return viene utilizzata all'interno di una funzione per uscire e restituire un valore.

Se non restituiamo esplicitamente un valore, verrà restituito automaticamente None. Il seguente esempio lo verifica.

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

Risultato di output

10
None

while

while viene utilizzato per i cicli in Python.

Le istruzioni all'interno del ciclo while continuano a eseguire fino a quando la condizione del ciclo while non è più valutata a False o fino a quando non si incontra una frase break. Il seguente programma lo dimostra.

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

Risultato di output

5
4
3
2
1

Attenzione, 0 è uguale a False.

Scopri di piùIl ciclo while in PythonPiù informazioni.

with

La frase with viene utilizzata per avvolgere l'esecuzione di un blocco di codice all'interno di un gestore di contesto.

Il gestore di contesto è una classe che implementa i metodi __enter__ e __exit__. L'uso della frase with garantisce che __exit__ venga 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. L'oggetto file è definito con i metodi __enter__ e __exit__, quindi agiscono come proprio gestore di contesto.

Prima di tutto, viene chiamato il metodo __enter__ di questo metodo, quindi viene eseguito il codice with, infine viene chiamato il metodo __exit__. Il metodo __exit__ viene chiamato anche se si verificano errori. Fondamentalmente, chiuderà lo stream di file.

yield

yield viene utilizzato all'interno di una funzione come una istruzione return. Tuttavia, yield restituisce un generatore.

Un generatore è un iteratore che genera un elemento alla volta. Un gran numero di valori occuperebbe una grande quantità di memoria. I generatori sono molto utili in questo caso perché generano un valore alla volta, invece di memorizzare tutti i valori in memoria. Ad esempio,

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

Creeremo un generatore g che genera i poteri di 2 fino a quando la somma non raggiunge 99. Possiamo generare questi numeri con la funzione next() come segue.

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

E così via... Questo tipo di generatore è restituito dalle istruzioni della funzione yield. Ecco un esempio.

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

Risultato di output

0
1
4
9
16
25

In questo esempio, la funzione generator() restituisce un generatore che genera i quadrati dei numeri da 0 a 5. Stampali nel ciclo for.