Parole chiave Python

In Python, alcune parole chiave non possono essere utilizzate come nomi di variabili o funzioni. Le parole chiave sono parole riservate con funzioni/usi specifici. Il numero totale di parole chiave può cambiare a seconda della versione Python. Ad esempio, in Python 3.7, c'erano solo 33 parole chiave. In Python 3.10.4, ci sono circa 35 parole chiave. In questo tutorial, impareremo le parole chiave di Python.

Verificare le parole chiave

In Python, è possibile utilizzare il modulo parole chiave per verificare le parole chiave. Parola chiave.KWList elencherà tutte le parole chiave in Python.

principale.Py
Importa parola chiave
# questo stampare tutte le parole chiave
var = parola chiave.kwlist
Stampa (var)

Produzione:

; Del ',' elif ',' else ',' tranne ',' finalmente ',' per ',' da ',' globale ',' se ',' import ',' in ', è', 'lambda' , "non locale", "non", "o", "pass", "alza", "return", "prova", "mentre", "con", "resa"
Processo finito con il codice di uscita 0

Se, d'altra parte, non sei sicuro se una parola è una parola chiave, puoi usare la parola chiave.iskeyword (s) per scoprire:

principale.Py
Importa parola chiave
Word_1 = "Break"
word_2 = "funzione"
word_3 = "variabile"
# questo viene utilizzato per verificare se una parola è una parola chiave
var_1 = parola chiave.iskeyword (word_1)
Stampa (var_1)
var_2 = parola chiave.iskeyword (word_2)
Stampa (var_2)
var_3 = parola chiave.iskeyword (word_3)
Stampa (var_3)

Produzione:

VERO
Falso
Falso
Processo finito con il codice di uscita 0

Quindi ora, diamo un'occhiata a diverse parole chiave!

Parola chiave: afferma

IL affermare La parola chiave viene utilizzata in Python per il debug. Qui, una condizione viene passata dopo il affermare parola chiave. Se questa condizione è vera, va tutto bene; Se, d'altra parte, la condizione è falsa, viene sollevato un assertionerror.

Ecco due esempi distinti. Al primo tentativo del blocco tranne, la condizione è vera, quindi non viene sollevato alcun errore. Nel secondo tentativo del blocco tranne, la condizione (2+3 == 10) è falsa e quindi viene sollevata una affermazione.

principale.Py
Tentativo:
Affermare 2+3 == 5
print ("Assert 2+3 == 5 non ha aumentato un assertionerror")
Tranne AssertionError:
print ("Assert 2+3 == 5 ha aumentato un assertionerror")
Tentativo:
Affermare 2+3 == 10
print ("Assert 2+3 == 10 non ha aumentato un assertionerror")
Tranne AssertionError:
print ("Assert 2+3 == 10 ha aumentato un assertionerror")

Produzione:

Affermare 2+3 == 5 non ha sollevato un Assertionerror
Asserzione 2+3 == 10 ha sollevato un assertionerror
Processo finito con il codice di uscita 0

Parole chiave: passare, continuare e rompere

La parola chiave Pass si traduce in un'operazione nulla; Fondamentalmente non fa nulla. Viene in genere usato quando si inizia a scrivere il codice come segnaposto. Fondamentalmente, lo bypasserà.

principale.Py
Classe Person ():
passaggio

Produzione:

Processo finito con il codice di uscita 0

D'altra parte, la parola chiave continua viene utilizzata per terminare l'iterazione in un loop o mentre si passa alla successiva iterazione. Quindi, se il Continua Viene utilizzata la parola chiave, salterà un'iterazione.

principale.Py
Numeri = [10, 15, 20, 25, 30, 35, 40]
Per numeri in numeri:
Se Numb/2 == 5:
Continua
Stampa (intorpidito)

Produzione:

15
20
25
30
35
40
Processo finito con il codice di uscita 0

In questo esempio, stiamo dicendo che se un numero diviso per 2 è uguale a 5, quindi continua e 10 diviso per 2 è uguale a 5, quindi lo ha saltato.

IL rottura La parola chiave viene utilizzata per uscire da un ciclo

principale.Py
i = 1
mentre io < 9:
i = i + 1
se io != 5:
Stampa (i)
Se i == 5:
rottura
Stampa ("fuori dal gabinetto")

Produzione:

2
3
4
Fuori dal ciclo
Processo finito con il codice di uscita 0

Come puoi vedere, quando colpisce 5, uscirà dal loop.

Parole chiave: se, altrimenti ed elif

Abbiamo incontrato tutti il se altro, E Elif dichiarazioni. Queste sono le basi.

principale.Py
Numeri = [15, 20, 25]
Per numeri in numeri:
Se intorpidito> 20:
Stampa (" % s è maggiore del 20" % (NUMB))
Elif Numb < 20:
Stampa (" % s è inferiore al 20" % (Numb))
altro:
Stampa (" % s è pari al 20" % (Numb))

Produzione:

15 è inferiore a 20
20 è uguale a 20
25 è maggiore di 20
Processo finito con il codice di uscita 0

Parole chiave: prova, tranne, e infine

Tentativo tranne Le dichiarazioni vengono utilizzate per catturare errori. Quindi, diciamo di provare questo, e se fallisce, possiamo catturare l'errore in tranne dichiarazione.

principale.Py
x = "2"
Tentativo:
Se x == "2":
Stampa ("Primo blocco di prova è andato bene")
tranne:
stampa ("errore si è verificato")
Tentativo:
Se x/0 == 1:
Stampa (x/2)
Tranne TypeEerror:
Stampa ("C'era un tyleeerror nel secondo blocco di prova")

Produzione:

Il primo blocco di prova è andato bene
C'era un typeerror nel secondo blocco
Processo finito con il codice di uscita 0

Come puoi vedere, nel primo blocco, non ci sono stati errori, quindi il Tentativo Il blocco è stato eseguito e il tranne Il blocco è stato ignorato. Nel secondo Tentativo blocco, c'è stato un errore e questo errore è stato catturato dal tranne bloccare.

IL Finalmente Il blocco viene eseguito dopo il Tentativo E tranne bloccare. Viene sempre eseguito indipendentemente da ciò che accade.

principale.Py
Tentativo:
i = 4
b = i/0
Stampa (b)
Tranne ZerodivisionError:
Stampa ("Errore")
Finalmente:
Stampa ("Dopo il tentativo tranne il blocco")

Produzione:

Errore
Dopo il tentativo tranne il blocco
Processo finito con il codice di uscita 0

Parole chiave: è e dentro

La parola chiave è usata per determinare se due oggetti sono identici.

principale.Py
x = ["auto", "razza", "incidente"]
y = ["auto", "razza", "incidente"]
stampa (x is y)

Produzione:

Falso
Processo finito con il codice di uscita 0

Quest'ultimo è così perché questi elenchi sono mutabili e allocati separatamente nella memoria.

IL In La parola chiave viene utilizzata per verificare se un valore è contenuto in un elenco o qualcosa di simile.

Principale.Py
x = ["auto", "razza", "incidente"]
Se "auto" in x:
Stampa ("La parola auto è nell'elenco x")
altro:
Stampa ("La parola auto non è nell'elenco x")

Produzione:

La parola auto è nell'elenco x
Processo finito con il codice di uscita 0

Parole chiave: vero, falso e nessuna

VERO E Falso sono valori booleani; Nessuno è un valore nullo.

Principale.Py
Stampa (nessuno == 0)
Stampa (nessuno == false)
Stampa (nessuno == nessuno)
Stampa (2+3 == 5)
Stampa (2+3 == 10)

Produzione:

Falso
Falso
VERO
VERO
Falso
Processo finito con il codice di uscita 0

Quindi, questo significa che nessuno non è uguale a 0, non uguale a falso, ed è un valore proprio.

Parole chiave: e, o, e non

Questi sono abbastanza semplici. Ed è E, o è O, E non è usato per negare qualcosa.

principale.Py
a = 3
B = 5
c = 30
Se A> 1 e A 6 o B < 20:
Stampa ("B è maggiore di 6 o meno di 20")
altro:
stampa ("b non è né maggiore di 6 né meno di 20")
Stampa (non vero)

Produzione:

a è tra 1 e 20
b è maggiore di 6 o meno di 20
Falso
Processo finito con il codice di uscita 0

Ricordalo per "E", Entrambe le dichiarazioni devono essere vere per restituire un vero. Per "O", Hai solo bisogno di uno per essere vero.

Parole chiave: per e while

Entrambi per E Mentre sono usati per looping. Noi usiamo per Quando sappiamo quante volte vogliamo loop. Noi usiamo Mentre Quando vogliamo che il ciclo continui fino a quando non colpisce una pausa o un punto di terminazione preimpostata.

principale.Py
# per loop
x = ["auto", "razza", "incidente"]
per i membri in x:
Stampa (membri)
# mentre loop
i = 1
mentre io<3:
i = i + 1
Stampa (i)

Produzione:

auto
gara
incidente
2
3
Processo finito con il codice di uscita 0

Parole chiave: importazione, da e come

Sappiamo tutti e usiamo la parola chiave importare. Viene utilizzato per importare moduli. Inoltre, sappiamo "da"Dal momento che viene utilizzato nell'istruzione di importazione. IL COME La parola chiave viene utilizzata per l'aliasing.

principale.Py
Dall'importazione di parole chiave kwlist
dalla parola chiave importazione iskeyword come chiave
Stampa (kwlist)
Stampa (Key ("Race"))

Produzione:

; Del ',' elif ',' else ',' tranne ',' finalmente ',' per ',' da ',' globale ',' se ',' import ',' in ', è', 'lambda' , "non locale", "non", "o", "pass", "alza", "return", "prova", "mentre", "con", "resa"
Falso
Processo finito con il codice di uscita 0

Quindi qui, la parola chiave come viene utilizzata COME Un alias per la parola iskeyword.

Parole chiave: classe, def, return e rendimento

IL classe La parola chiave viene utilizzata per mettere insieme dati e funzioni. IL def La parola chiave viene utilizzata per definire una funzione. E ritorno viene utilizzato per restituire un valore.

principale.Py
Area di classe:
# funzione
def __init __ (self, larghezza, altezza):
se stesso.larghezza = larghezza
se stesso.altezza = altezza
DEF RETAREA (SELE):
Restituisci se stessi.larghezza * self.altezza
var = area (3, 4)
Stampa (var.Rettatari ())

Produzione:

12
Processo finito con il codice di uscita 0

A differenza di ritorno che fornisce un output e successivamente si ferma, prodotto fornirà un output e continuerà. IL prodotto La parola chiave viene utilizzata all'interno di una funzione e restituisce un generatore.

principale.Py
# Funzione di ritorno
def returnFunc ():
per i nell'intervallo (3):
Stampa ("returnfunc: % s" % i)
ritorno i
returnFunc ()
# funzione di rendimento
def remiefunc ():
per i nell'intervallo (3):
resa i
per membro in remyfunc ():
Print ("REDDFUNC: % S" % Member)

Produzione:

returnfunc: 0
REDEFUNC: 0
REDEFUNC: 1
REDEFUNC: 2
Processo finito con il codice di uscita 0

Notare come per il prodotto Scenario, continua, mentre per lo scenario di ritorno, si ferma una volta che colpisce la parola chiave di ritorno.

Parole chiave: globale e non locale

IL globale è possibile accedere a una parola chiave ovunque. In genere, una variabile al di fuori di una funzione può essere facilmente letta e stampata all'interno di una funzione. Ma, quando si tratta di modificarlo, è necessario utilizzare la parola chiave globale, altrimenti riceverai un errore.

principale.Py
x = 8
Tentativo:
def aggiungi ():
x = x + 8
Stampa (x)
aggiungere()
Tranne UnboundLocalerror:
Print ("Errore sollevato perché non è possibile scherzare con una variabile globale in un contesto locale")
Tentativo:
def minus ():
Global x
X = X-4
Stampa (x)
meno()
Tranne UnboundLocalerror:
Stampa ("Errore sollevato")

Produzione:

Errore sollevato perché non è possibile scherzare con una variabile globale in un contesto locale
4
Processo finito con il codice di uscita 0

IL non locale La parola chiave viene utilizzata con le funzioni nidificate.

principale.Py
# senza usare non locali
def esterno_func ():
x = 2
def interner_func ():
x = 3
Print ("Inner_func: % s" % x)
Inner_func ()
Print ("Outer_func: % s" % x)
esterno_func ()
# ora usando non -local
def esterno_func2 ():
x = 10
def interner_func2 ():
non locale x
x = 20
Print ("Inner_func2: % s" % x)
Inner_func2 ()
Print ("Outer_func2: % s" % x)
esterno_func2 ()

Produzione:

Inner_func: 3
esterno_func: 2
Inner_func2: 20
esterno_func2: 20
Processo finito con il codice di uscita 0

Parole chiave: Del

IL Del La parola chiave viene utilizzata per eliminare.

principale.Py
x = ["razza", "auto", "incidente"]
Del X [2]
Stampa (x)

Produzione:

['auto da corsa']
Processo finito con il codice di uscita 0

Parola chiave: con

IL con La parola chiave semplifica il codice.

principale.Py
con Open ('File.txt ',' w ') come file:
file.Scrivi ("LinuxHint")

Produzione:

Processo finito con il codice di uscita 0

Parole chiave: asincroni e aspetta

Qui, la funzione verrà eseguita con un divario di cinque secondi tra la prima istruzione di stampa e la seconda.

principale.Py
Importa asyncio
Async def ayncfunc ():
print ("prima istruzione")
Aspetta Asyncio.sonno (5)
print ("seconda istruzione")
Asyncio.run (ayncfunc ())

Produzione:

Prima affermazione
Seconda dichiarazione
Processo finito con il codice di uscita 0

Parola chiave: solleva

IL aumentare La parola chiave viene utilizzata per sollevare un'eccezione o un errore.

principale.Py
X = [5, 10, 15, 20]
per i membri in x:
z = membri/5
Se z == 1:
solleva l'eccezione ("hai un 1")

Produzione:

solleva l'eccezione ("hai un 1")
Eccezione: hai un 1
Processo terminato con il codice di uscita 1

Parola chiave: lambda

IL Lambda La parola chiave viene utilizzata per creare una funzione senza nome.

principale.Py
a = lambda x, y, z: x + y + z
Stampa (A (1,2,3))

Produzione:

6
Processo finito con il codice di uscita 0

Conclusione

Le parole chiave di Python sono parole cruciali che non possono essere utilizzate come nomi di variabili o funzioni. Ci sono 35 parole chiave in Python 3.10.4 e ogni parola chiave è importante quanto il resto. In questo tutorial, abbiamo appreso di ognuna di queste 35 parole chiave. Quindi, usa ognuno in modo efficiente!