com declaração

O Python com declaração é um recurso muito avançado que ajuda a implementar o protocolo de gerenciamento de contexto. Quando o programador começa a codificar, eles estão basicamente usando a tentativa/exceto/finalmente para manter os recursos. Mas há outra maneira de fazer isso automaticamente, chamado de declaração 'com'.

Então, neste artigo, discutiremos como podemos usar o 'com' declaração.

Podemos entender isso com um exemplo muito simples.

Sempre que codificamos algo para ler ou escrever um arquivo, a primeira coisa que precisamos fazer é abrir o arquivo e depois executamos as operações de leitura ou gravação sobre isso e, finalmente, fechamos o arquivo para que todos os recursos não estará ocupado. Então isso significa que temos que lançar o recurso depois de concluir nosso trabalho.

Isso também podemos entender do gerente de contexto. Um gerente de contexto é um objeto que cuida dos recursos para salvar, restaurar, bloquear ou desbloquear recursos, abrir e fechar arquivos, etc. O gerente de contexto está ativo quando abrimos um arquivo para ler ou escrever. Se não fecharmos o arquivo após ler ou escrever, o recurso ainda será alocado para esse arquivo específico e, devido a isso, o recurso estará ocupado se um processo específico quiser usar esse recurso.

É por isso que chamamos o método Close () depois de ler ou escrever o arquivo.

f = aberto ("demonstração.TXT")
dados = f.ler()
f.fechar()

Então, no código acima, é direto, e não há manipulador de exceção que usamos. Portanto, se ocorrer algum erro, o programa interromperá incondicionalmente. E o segundo caso é que às vezes também esquecemos de adicionar o arquivo de fechamento como fizemos.

Portanto, para superar alguns dos problemas, podemos usar o seguinte método para escrever o código acima.

tentar:
f = aberto ('Demo.txt ',' r ')
impressão (f.ler())
Exceto exceção como e:
Imprimir ("Ocorreu o erro", e)
finalmente:
f.fechar()

No código acima, você pode ver que usamos a tentativa, exceto e finalmente bloqueando. Então, dessa maneira, podemos controlar o manuseio de exceção também. E finalmente fechamos o arquivo no bloco finalmente. Também usamos o bloco exceto, que lidará com as exceções. Portanto, se usarmos o cenário acima, nosso código não parará incondicionalmente. E nosso arquivo certamente fechará mesmo se recebermos algum erro durante a leitura do arquivo.

Mas também podemos refinar o código acima através de outro método que chamamos de declaração 'com'. A declaração 'com' lidará automaticamente com o fechamento do arquivo, e não precisamos nos preocupar em fechar o arquivo depois de ler ou escrever.

O gerenciador de contexto cria um método Enter () e Exit () no tempo de execução e o chama quando eles precisam destruir o arquivo. Ao fazer código simples ou com uma tentativa, exceto o bloco, chamamos o método Exit () através do método Close (). Mas a declaração 'with' cuida automaticamente do método de saída (). Então esta é a beleza da declaração 'com'.

Podemos reescrever o código acima com a declaração 'com' como abaixo:

com open ("demonstração.txt ") como f:
dados = f.ler()

O código acima é muito simples e não precisamos pensar nisso toda vez que fechamos o arquivo, o que é feito pela declaração 'com' automaticamente.

Parece mágico, mas na verdade isso não é mágico. A declaração 'com' inicia dois objetos que chamamos de __enter__ () e __exit__ (). A declaração que segue as declarações 'com' é chamada __enter__ () e retorna um objeto atribuído a como variável e, depois que todo o processo de bloco é feito, ele chama o __Exit__ ().

Exemplo 1: Ex1.py

#ex1.py
Demonstração de classe:
def __enter __ (self):
print ("Chamando para __enter__ Método")
retornar "True"
def __exit __ (self, exc_type, exc_val, exc_tb):
print ("Chamando para __Exit__ Método")
Deft Calling_Demo ():
Demoção de retorno ()
com Calling_demo () como f:
print ("Demo:", f)

Saída:

➜ ~ CD Desktop
➜ Desktop python3 ex1.py
Chamando para __enter__ método
Demo: verdadeiro
Chamando para __Exit__ Método
➜ Desktop

Explicação:

1. Quando executamos o código acima ex1.Py, então é chamado de Método __enter__.
2. Em seguida, ele retorna algo do código (true) atribuído à variável f.
3. Então, o bloco do código foi executado. Nesse bloco, estamos imprimindo o valor do F, que é verdadeiro.
4. Por fim, quando o processo do bloco termina, então é chamado de método __Exit__.

A melhor coisa sobre a declaração 'com' é que ele também lida automaticamente com a exceção. Como você pode ver no exemplo de código acima ex1.Py, o método __Exit__ leva três parâmetros: exc_type, exc_val, exc_tb. Esses parâmetros ajudam a lidar com as exceções.

Sintaxe: __Exit __ (self, exc_type, exc_value, exc_tb)

EXC_TYPE: Diz o nome da classe onde ocorre uma exceção.
exc_value: Diz o tipo de exceção como dividir por zero erro, etc.
exc_traceback: O Traceback é detalhes completos sobre a exceção, assim como um relatório para resolver o erro que ocorreu no programa.

Agora, mudaremos o código acima para ver como ele lidará automaticamente com as exceções.

Exemplo_2: ZerodivisionError.py

#ZerodivisionError.py
Demonstração de classe:
def __init __ (self, x, y):
print ("Enter __init__")
auto.x = x
auto.y = y
def __enter __ (self):
Imprima ("Encontre o __enter__")
retornar a si mesmo
def __exit __ (self, exc_type, exc_val, exc_tb):
print ("\ encontre o __Exit__")
print ("\ ntype:", exc_type)
print ("\ nvalue:", exc_val)
print ("\ \ ntraceback:", exc_tb)
Def ExceptionDemo (self):
# ZerodivisionError Exception
Imprima (self.x / self.y)
# com declaração não levantar exceção
com demonstração (4, 2) como f:
f.ExceptionDemo ()
print ("\ n \ n ======================================== \ n \ n ")
# com a declaração aumentará um zerodivisionError
com demonstração (1, 0) como f:
f.ExceptionDemo ()

Saída:

➜ Desktop Python3 ZerodivisonError.py
Digite __init__
Encontre o __enter__
2.0
\ Encontre o __Exit__
Tipo: Nenhum
Valor: Nenhum
Traceback: Nenhum
========================================
Digite __init__
Encontre o __enter__
\ Encontre o __Exit__
tipo:
Valor: Divisão por zero
Traceback:
Traceback (chamada mais recente):
Arquivo "ZerodivisonError.py ", linha 32, em
f.ExceptionDemo ()
Arquivo "ZerodivisonError.py ", linha 21, em ExceptionDemo
Imprima (self.x / self.y)
ZerodivisisionError: divisão por zero
➜ Desktop

Explicação:
No código acima, linha número 25, Nós executamos o código com a declaração 'com'. Nisso, passamos o valor de x como 4 e y como 2. Na seção de saída, podemos ver que primeiro chama o __init__method e inicializa x e y. Em seguida, ele chama o método __enter__ e atribuiu esse objeto à variável f.Em seguida, ele chama o método ExceptionDemo usando a variável f e depois imprime o valor da divisão, que é 2. Depois disso, ele chama o método __Exit__ e depois imprime todos os três parâmetros importantes valoriza nenhum porque não temos nenhum erro até agora.

Na linha número 31, chamamos o mesmo método com o valor de x como 1 e y como 0, porque queremos aumentar a exceção e ver como a declaração 'com' lida sem a tentativa e exceto em bloco. Podemos ver que na seção de saída, os valores de três parâmetros são diferentes.

O primeiro parâmetro (EXC_TYPE) tipos de impressão do nome da classe, que causou um erro.

O segundo parâmetro (exc_val) imprime o tipo de erro.

O terceiro parâmetro (exc_tb) Imprimir os detalhes do Traceback.

Conclusão:
Então, vimos como a declaração 'com' realmente tem um desempenho inteligente para lidar com o manuseio de exceção automaticamente. A declaração 'com' também ajuda a fechar o gerente de contexto corretamente, o que pode estar deixando aberto durante a programação.

Este código do artigo está disponível no link do GitHub:
https: // github.com/shekharpandey89/with-statement