Palavras -chave Python

No Python, certas palavras -chave não podem ser utilizadas como nomes de variáveis ​​ou funções. Palavras -chave são palavras reservadas com funções/usos específicos. O número total de palavras -chave pode mudar dependendo da sua versão python. Por exemplo, em Python 3.7, havia apenas 33 palavras -chave. Em Python 3.10.4, existem cerca de 35 palavras -chave. Neste tutorial, aprenderemos sobre palavras -chave Python.

Verificando palavras -chave

No Python, você pode usar o módulo de palavra -chave para verificar as palavras -chave. Palavra -chave.Kwlist listará todas as palavras -chave no Python.

principal.py
Importar palavra -chave
# Esta impressão todas as palavras -chave
var = palavra -chave.Kwlist
impressão (var)

Saída:

['False', 'nenhum', 'verdadeiro', 'e', ​​'como', 'assert', 'assíncrono', 'aguardar', 'quebrar', 'classe', 'continuar', 'def', ' del ',' elif ',' else ',' exceto ',' finalmente ',' para ',' de ',' global ',' se ',' importar ',' em ',' é ',' lambda ' , 'não -local', 'não', 'ou', 'passa', 'raise', 'return', 'tente', 'while', 'com', 'rendimento']
Processo terminado com o código de saída 0

Se, por outro lado, você não tem certeza se uma palavra é uma palavra -chave, você pode usar a palavra -chave.ISKEYWORD (s) para descobrir:

principal.py
Importar palavra -chave
word_1 = "quebra"
word_2 = "função"
word_3 = "variável"
# Isso é usado para verificar se uma palavra é uma palavra -chave
var_1 = palavra -chave.iskeyword (word_1)
Imprimir (var_1)
var_2 = palavra -chave.iskeyword (word_2)
Imprimir (var_2)
var_3 = palavra -chave.iskeyword (word_3)
Imprimir (var_3)

Saída:

Verdadeiro
Falso
Falso
Processo terminado com o código de saída 0

Então agora, vamos conferir várias palavras -chave!

Palavra -chave: afirme

O afirmar A palavra -chave é usada no Python para depurar. Aqui, uma condição é passada após o afirmar palavra -chave. Se essa condição for verdadeira, está tudo bem; Se, por outro lado, a condição é falsa, um terror de assertion for aumentado.

Aqui estão dois exemplos distintos. Na primeira tentativa do bloco, exceto, a condição é verdadeira, então nenhum erro é levantado. Na segunda tentativa do bloco exceto, a condição (2+3 == 10) é falsa e, portanto, um terror de assertion é elevado.

principal.py
tentar:
afirmar 2+3 == 5
Print ("Assert 2+3 == 5 não aumentou um assertionError")
Exceto AssertionError:
Print ("Assert 2+3 == 5 aumentou um assertionError")
tentar:
afirmar 2+3 == 10
print ("Assert 2+3 == 10 não aumentou um assertionError")
Exceto AssertionError:
print ("Assert 2+3 == 10 elevou um assertionError")

Saída:

Afirmar 2+3 == 5 não aumentou um terror de assertion
Afirmar 2+3 == 10 elevou um assertionError
Processo terminado com o código de saída 0

Palavras -chave: passe, continue e quebre

A palavra -chave PASS resulta em uma operação nula; basicamente não faz nada. Normalmente é usado ao começar a escrever o código como um espaço reservado. Basicamente, isso irá ignorá -lo.

principal.py
Pessoa de classe ():
passar

Saída:

Processo terminado com o código de saída 0

Por outro. Então, se o continuar A palavra -chave é usada, vai pular uma iteração.

principal.py
números = [10, 15, 20, 25, 30, 35, 40]
Para entorpecer em números:
Se Numb/2 == 5:
continuar
Imprimir (entorpecido)

Saída:

15
20
25
30
35
40
Processo terminado com o código de saída 0

Neste exemplo, estamos dizendo se um número dividido por 2 é igual a 5, então continue e 10 dividido por 2 é igual a 5, então pulou.

O quebrar A palavra -chave é usada para sair de um loop

principal.py
i = 1
enquanto eu < 9:
i = i + 1
se eu != 5:
impressão (i)
Se eu == 5:
quebrar
Imprimir ("fora do banheiro")

Saída:

2
3
4
Fora do loop
Processo terminado com o código de saída 0

Como você pode ver, quando atingir 5, sai do loop.

Palavras -chave: se, else, e elif

Todos nós encontramos o Se, mais, e Elif declarações. Estes são o básico.

principal.py
números = [15, 20, 25]
Para entorpecer em números:
Se entorpecido> 20:
print (" % s é superior a 20" % (entorpece))
elif entorpecido < 20:
print (" % s é inferior a 20" % (entorpece))
outro:
print (" % s é igual a 20" % (entorpece))

Saída:

15 é menor que 20
20 é igual a 20
25 é maior que 20
Processo terminado com o código de saída 0

Palavras -chave: tente, exceto e finalmente

Tentar exceto As declarações são usadas para capturar erros. Então, dizemos que tente isso e, se falhar, podemos pegar o erro no exceto declaração.

principal.py
x = "2"
tentar:
Se x == "2":
Print ("Primeiro Bloco de Tente foi certo")
exceto:
Imprimir ("Ocorreu o erro")
tentar:
Se x/0 == 1:
Imprimir (x/2)
Exceto TypeError:
Print ("Havia um TypeError no segundo bloco de tentativa")

Saída:

Primeira tentativa Block foi bem
Havia um TypeError no segundo bloco de tentativa
Processo terminado com o código de saída 0

Como você pode ver, no primeiro bloco, não houve erro, então o tentar Block foi executado e o exceto O bloco foi ignorado. No segundo tentar bloco, houve um erro, e esse erro foi capturado pelo exceto bloquear.

O finalmente O bloco é executado após o tentar e exceto bloquear. É sempre executado independentemente do que acontece.

principal.py
tentar:
i = 4
b = i/0
impressão (b)
Exceto ZerodivisisionError:
print ("erro")
finalmente:
Imprima ("Após a tentativa, exceto o bloco")

Saída:

Erro
Após a tentativa, exceto o bloco
Processo terminado com o código de saída 0

Palavras -chave: é e em

A palavra -chave IS é usada para determinar se dois objetos são idênticos.

principal.py
x = ["carro", "raça", "acidente"]
y = ["carro", "raça", "acidente"]
impressão (x é y)

Saída:

Falso
Processo terminado com o código de saída 0

O último é assim porque essas listas são mutáveis ​​e alocadas separadamente na memória.

O em A palavra -chave é usada para verificar se um valor está contido em uma lista ou algo semelhante.

Principal.py
x = ["carro", "raça", "acidente"]
Se "carro" em x:
Imprimir (“A palavra carro está na lista X”)
outro:
Imprimir (“A palavra carro não está na lista X”)

Saída:

A palavra carro está na lista x
Processo terminado com o código de saída 0

Palavras -chave: verdadeira, falsa e nenhuma

Verdadeiro e Falso são valores booleanos; Nenhum é um valor nulo.

Principal.py
Imprimir (nenhum == 0)
imprimir (nenhum == false)
Imprimir (nenhum == Nenhum)
Imprimir (2+3 == 5)
Imprimir (2+3 == 10)

Saída:

Falso
Falso
Verdadeiro
Verdadeiro
Falso
Processo terminado com o código de saída 0

Portanto, isso significa que nenhum não é igual a 0, não igual a falso, e é um valor próprio.

Palavras -chave: e, ou, e não

Estes são bastante diretos. E é e, ou é ou, e não é usado para negar algo.

principal.py
a = 3
b = 5
c = 30
Se A> 1 e A 6 ou B < 20:
Impressão ("B é superior a 6 ou menos que 20")
outro:
Print ("B não é superior a 6 nem menos de 20")
Imprimir (não é verdade)

Saída:

a está entre 1 e 20
B é superior a 6 ou menos de 20
Falso
Processo terminado com o código de saída 0

Lembre -se disso para “e”, Ambas as declarações precisam ser verdadeiras para retornar um verdadeiro. Para "ou”, Você só precisa de um para ser verdadeiro.

Palavras -chave: para e enquanto

Ambos para e enquanto são usados ​​para looping. Nós usamos para Quando sabemos quantas vezes queremos fazer loop. Nós usamos enquanto Quando queremos que o loop continue até atingir uma pausa ou um ponto de terminação predefinido.

principal.py
# para loop
x = ["carro", "raça", "acidente"]
Para membros em X:
Impressão (membros)
# enquanto loop
i = 1
enquanto eu<3:
i = i + 1
impressão (i)

Saída:

carro
corrida
acidente
2
3
Processo terminado com o código de saída 0

Palavras -chave: importar, de e como

Todos nós sabemos e usamos a palavra -chave importar. É usado para importar módulos. Além disso, sabemos “de”Uma vez que é usado na declaração de importação. O como A palavra -chave é usada para alias.

principal.py
Da palavra -chave Importar Kwlist
Da palavra -chave importar iskeyword como chave
Imprimir (Kwlist)
Imprimir (Key ("Race"))

Saída:

['False', 'nenhum', 'verdadeiro', 'e', ​​'como', 'assert', 'assíncrono', 'aguardar', 'quebrar', 'classe', 'continuar', 'def', ' del ',' elif ',' else ',' exceto ',' finalmente ',' para ',' de ',' global ',' se ',' importar ',' em ',' é ',' lambda ' , 'não -local', 'não', 'ou', 'passa', 'raise', 'return', 'tente', 'while', 'com', 'rendimento']
Falso
Processo terminado com o código de saída 0

Então, aqui, a palavra -chave como é usada como um pseudônimo para a palavra iskeyword.

Palavras -chave: classe, def, retorno e rendimento

O aula A palavra -chave é usada para montar dados e funções. O def A palavra -chave é usada para definir uma função. E retornar é usado para retornar um valor.

principal.py
Área de aula:
# função
def __init __ (self, largura, altura):
auto.largura = largura
auto.altura = altura
Def Rectarea (self):
retornar a si mesmo.largura * self.altura
var = área (3, 4)
Imprimir (var.retácio ())

Saída:

12
Processo terminado com o código de saída 0

Diferente retornar Isso fornece uma saída e subsequentemente para, colheita fornecerá uma saída e continuará. O colheita A palavra -chave é usada em uma função e retorna um gerador.

principal.py
# Função de retorno
def returnfunc ():
para i no intervalo (3):
print ("returnfunc: % s" % i)
retornar i
returnfunc ()
# função de rendimento
def hieldfunc ():
para i no intervalo (3):
rendimento i
para membro em hieldfunc ():
Print ("rendefunc: % s" % membro)

Saída:

returnfunc: 0
rendimentofunc: 0
rendimentofunc: 1
rendimentofunc: 2
Processo terminado com o código de saída 0

Observe como o colheita Cenário, continua, enquanto que para o cenário de retorno, ele para quando atingir a palavra -chave de retorno.

Palavras -chave: global e não -local

O global A palavra -chave pode ser acessada em qualquer lugar. Normalmente, uma variável fora de uma função pode ser facilmente lida e impressa em uma função. Mas, quando se trata de modificá -lo, você precisa usar a palavra -chave global, caso contrário, você receberá um erro.

principal.py
x = 8
tentar:
def add ():
x = x + 8
impressão (x)
adicionar()
Exceto não -atirado, terror:
Imprima ("Erro levantado porque você não pode mexer com uma variável global em um contexto local")
tentar:
def menos ():
global x
x = x-4
impressão (x)
menos()
Exceto não -atirado, terror:
print ("Erro levantado")

Saída:

Erro levantado porque você não pode mexer com uma variável global em um contexto local
4
Processo terminado com o código de saída 0

O não -local A palavra -chave é usada com funções aninhadas.

principal.py
# sem usar não -local
def Outer_func ():
x = 2
def interior_func ():
x = 3
print ("Inner_func: % s" % x)
INNER_FUNC ()
print ("Outer_func: % s" % x)
Outer_func ()
# agora usando não -local
def Outer_func2 ():
x = 10
DEF INNER_FUNC2 ():
não -local x
x = 20
print ("Inner_func2: % s" % x)
Inner_func2 ()
print ("Outer_func2: % s" % x)
Outer_func2 ()

Saída:

INNER_FUNC: 3
Outer_func: 2
INNER_FUNC2: 20
Outer_func2: 20
Processo terminado com o código de saída 0

Palavra -chave: del

O del A palavra -chave é usada para excluir.

principal.py
x = ["raça", "carro", "acidente"]
Del X [2]
impressão (x)

Saída:

['raça', 'carro']
Processo terminado com o código de saída 0

Palavra -chave: com

O com A palavra -chave simplifica o código.

principal.py
com open ('arquivo.txt ',' w ') como arquivo:
arquivo.Write ("Linuxhint")

Saída:

Processo terminado com o código de saída 0

Palavras -chave: assíncrona e aguardar

Aqui, a função será executada com uma lacuna de cinco segundos entre a primeira declaração de impressão e a segunda.

principal.py
importar asyncio
assíncrono def ayncfunc ():
print ('Primeira declaração')
Aguarda Asyncio.sono (5)
print ('Segunda declaração')
ASYNCIO.Run (Ayncfunc ())

Saída:

Primeira declaração
Segunda declaração
Processo terminado com o código de saída 0

Palavra -chave: aumente

O elevação A palavra -chave é usada para aumentar uma exceção ou um erro.

principal.py
x = [5, 10, 15, 20]
Para membros em X:
z = membros/5
se z == 1:
Levante exceção ("Você tem 1")

Saída:

Levante exceção ("Você tem 1")
Exceção: você tem 1
Processo terminado com o código de saída 1

Palavra -chave: Lambda

O Lambda A palavra -chave é usada para criar uma função sem nome.

principal.py
a = lambda x, y, z: x + y + z
Impressão (a (1,2,3))

Saída:

6
Processo terminado com o código de saída 0

Conclusão

Palavras -chave do Python são palavras cruciais que não podem ser usadas como nomes de variáveis ​​ou funções. Existem 35 palavras -chave no Python 3.10.4, e cada palavra -chave é tão importante quanto o resto. Neste tutorial, aprendemos sobre cada uma dessas 35 palavras -chave. Então, use cada um com eficiência!