z oświadczeniem

Python z instrukcją jest bardzo zaawansowaną funkcją, która pomaga wdrożyć protokół zarządzania kontekstem. Kiedy programista zaczyna kodować, zasadniczo używają trybu/oprócz/wreszcie, aby utrzymać zasoby. Ale istnieje inny sposób, aby to zrobić automatycznie, zwane instrukcją „z”.

Tak więc w tym artykule omówimy, w jaki sposób możemy użyć 'z' oświadczenie.

Możemy to zrozumieć z bardzo prostym przykładem.

Ilekroć kodujemy coś do odczytania lub napisania pliku, pierwszą rzeczą, którą musimy zrobić, jest otwarcie pliku, a następnie wykonujemy operacje odczytu lub zapisu na ten temat i w końcu zamykamy plik, aby wszystkie zasoby nie będzie zajęty. Oznacza to, że musimy wydać zasób po ukończeniu naszej pracy.

Możemy to również zrozumieć z menedżera kontekstowego. Menedżer kontekstowy to obiekt, który zajmuje się zasobami, aby zapisać, przywrócić, zablokować lub odblokować zasoby, otwieranie i zamykanie plików itp. Menedżer kontekstowy jest aktywny, gdy otwieramy plik do czytania lub pisania. Jeśli nie zamykamy pliku po przeczytaniu lub pisaniu, zasób jest nadal przydzielany do tego konkretnego pliku, a dzięki temu zasób będzie zajęty, jeśli konkretny proces będzie chciał użyć tego zasobu.

Dlatego po przeczytaniu lub zapisaniu pliku nazywamy metodę Close ().

f = otwarte („demo.tekst")
Data = f.Czytać()
F.zamknąć()

Tak więc w powyższym kodzie jest to proste i nie używaliśmy żadnych obsługi wyjątków. Tak więc, jeśli wystąpi jakikolwiek błąd, program przestanie bezwarunkowo. A drugim przypadkiem jest to, że czasami zapominamy również dodać plik zamykany tak jak my.

Aby przezwyciężyć niektóre problemy, możemy użyć następującej metody do napisania powyższego kodu.

próbować:
f = Open („Demo.txt ', „r”)
Drukuj (f.Czytać())
z wyjątkiem wyjątku jako E:
Drukuj („Wystąpił błąd”, e)
Wreszcie:
F.zamknąć()

W powyższym kodzie widać, że użyliśmy próby, z wyjątkiem i wreszcie blokiem. W ten sposób możemy również kontrolować obsługę wyjątków. I w końcu zamykamy plik w bloku wreszcie. Użyliśmy również bloku oprócz, który poradzi sobie z wyjątkami. Więc jeśli użyjemy powyższego scenariusza, nasz kod nie zatrzyma się bezwarunkowo. A nasz plik z pewnością zostanie zamknięty, nawet jeśli otrzymamy błąd podczas odczytu pliku.

Ale możemy również udoskonalić powyższy kod za pomocą innej metody, którą nazwaliśmy instrukcją „z”. Oświadczenie „z” automatycznie obsługuje zamknięcie pliku i nie musimy dbać o zamknięcie pliku po przeczytaniu lub napisaniu.

Menedżer kontekstowy tworzy metodę enter () i exit () w czasie działania i wywołuje ją, gdy muszą zniszczyć plik. Wykonując prosty kod lub z próbą, z wyjątkiem bloku, wywołujemy metodę Exit () metodą Close (). Ale oświadczenie „z” automatycznie zajmuje się metodą Exit (). To jest piękno stwierdzenia „z”.

Możemy ponownie zapisać powyższy kod z instrukcją „z” jak poniżej:

z otwartym („demo.txt ") jako f:
Data = f.Czytać()

Powyższy kod jest bardzo prosty i nie musimy o tym myśleć za każdym razem, gdy zamykamy plik, który jest wykonywany przez instrukcję „z” automatycznie.

To wygląda jak magia, ale właściwie to nie jest magia. Oświadczenie „z” inicjuje dwa obiekty, które nazywaliśmy __enter__ () i __exit__ (). Oświadczenie, które następuje po „z„ z instrukcją ”nazywa się __enter__ () i zwraca obiekt przypisany jako zmienna, a po zakończeniu całego procesu blokowania wywołuje __exit__ ().

Przykład 1: Ex1.py

#ex1.py
Demo klasowe:
def __enter __ (ja):
Drukuj („Wzywa do __enter__ metoda”)
powrót „Prawda”
def __exit __ (self, exc_type, exc_val, exc_tb):
Drukuj („Wzywa do metody __exit__”)
def calling_demo ():
Return Demo ()
z calling_demo () jako f:
Drukuj („demo:”, f)

Wyjście:

➜ ~ CD Desktop
➜ Desktop Python3 Ex1.py
Wzywa do metody __enter__
Demo: prawda
dzwonienie do metody __exit__
➜ Desiktop

Wyjaśnienie:

1. Kiedy uruchamiamy powyższy kod EX1.PY, potem najpierw nazywa się metodą __enter__.
2. Następnie zwraca coś z kodu (true) przypisanego do zmiennej F.
3. Następnie wykonano blok kodu. W tym bloku drukujemy wartość F, co jest prawdą.
4. W końcu, gdy proces bloku się skończy, nazywa się go metodą __exit__.

Najlepszą rzeczą w stwierdzeniu „z” jest to, że automatycznie obsługuje on również wyjątek. Jak widać w powyższym przykładzie kodu EX1.PY, metoda __exit__ przyjmuje trzy parametry: exc_type, exc_val, exc_tb. Te parametry pomagają poradzić sobie z wyjątkami.

Składnia: __exit __ (self, exc_type, exc_value, exc_tb)

exc_type: Mówi nazwa klasy, w której występuje wyjątek.
exc_value: Mówi o rodzaju wyjątku, takiego jak podziel przez błąd zerowy itp.
exc_traceback: Traceback to pełny szczegół na temat wyjątku, podobnie jak raport, aby rozwiązać błąd, który wystąpił w programie.

Teraz zmienimy powyższy kod, aby zobaczyć, jak automatycznie obsługuje wyjątki.

Przykład_2: ZerodivisionError.py

#ZerodivisionerRor.py
Demo klasowe:
def __init __ (self, x, y):
Drukuj („Enter __init__”)
samego siebie.x = x
samego siebie.y = y
def __enter __ (ja):
Drukuj („Znajdź __enter__”)
powrót do siebie
def __exit __ (self, exc_type, exc_val, exc_tb):
wydrukuj („\ Znajdź __exit__”)
print ("\ nType:", exc_type)
print („\ nValue:”, Exc_val)
print ("\ ntraceback:", exc_tb)
def Exceptiondemo (self):
# ZerodivisionError Wyjątek
Drukuj (ja.X / Self.y)
# z oświadczeniem nie podnieś wyjątku
z demo (4, 2) jako F:
F.Exceptiondemo ()
Drukuj ("\ n \ n ======================================= \ n \ n ")
# z oświadczeniem podniesie zerodivisionError
z demo (1, 0) jako f:
F.Exceptiondemo ()

Wyjście:

➜ Desktop Python3 ZerodivisonError.py
Wpisz __init__
Znajdź __enter__
2.0
\ Znajdź __exit__
Typ: Brak
Wartość: Brak
Traceback: Brak
=======================================
Wpisz __init__
Znajdź __enter__
\ Znajdź __exit__
typ:
Wartość: podział zero
Traceback:
Traceback (najnowsze połączenie ostatnie):
Plik „ZerodivisonError.py ", linia 32, w
F.Exceptiondemo ()
Plik „ZerodivisonError.Py ", wiersz 21, w wyjątku
Drukuj (ja.X / Self.y)
ZerodivisionError: Division by Zero
➜ Desiktop

Wyjaśnienie:
W powyższym kodzie, Linia numer 25, Uruchamiamy kod z instrukcją „z”. W tym przekazujemy wartość x jako 4 i y jako 2. W sekcji wyjściowej widzimy, że najpierw wywołuje __init__method i inicjuje x i y. Następnie wywołuje metodę __enter__ i przypisał ten obiekt do zmiennej F.Następnie wywołuje metodę wyjątku, przy użyciu zmiennej F, a następnie drukuje wartość podziału, która wynosi 2. Następnie wywołuje metodę __exit__, a następnie drukuje wszystkie trzy ważne wartości parametrów Brak, ponieważ do tej pory nie mamy żadnego błędu.

W wierszu nr 31 wywoływamy tę samą metodę o wartości x jako 1 i y jako 0, ponieważ chcemy podnieść wyjątek i zobaczyć, jak instrukcja „z” obsługuje go bez próby i oprócz bloku. Widzimy, że w sekcji wyjściowej wartości trzech parametrów są różne.

Pierwszy parametr (exc_type) Rodzaje drukowania nazwy klasy, co spowodowało błąd.

Drugi parametr (exc_val) Drukuje rodzaj błędu.

Trzeci parametr (exc_tb) Drukowanie szczegółów Traceback.

Wniosek:
Widzieliśmy więc, jak instrukcja „z” faktycznie działa mądrze w celu automatycznego obsługi wyjątków. Oświadczenie „z” pomaga również odpowiednio zamknąć menedżera kontekstu, co może pozostawić otwarte podczas programowania.

Ten kod artykułu jest dostępny w linku GitHub:
https: // github.com/shekharpandey89/with-hodement