సందర్భ నిర్వాహకుడు: తో మరియు __enter__/__exit__

సందర్భ నిర్వాహకుడు అనేది మీరు withతో ఉపయోగించే వస్తువు. అది హామీ ఇస్తుంది లోపాలు సంభవించినప్పుడు కూడా నిర్దిష్ట సెటప్/క్లీనప్ కార్యకలాపాలు ఎల్లప్పుడూ జరుగుతాయి. కానానికల్ ఉదాహరణ: ఫైల్‌ను తెరవడం మరియు మూసివేయడం.

with నమూనా

with open("note.txt", "w") as f:
    f.write("ciao")
# qui f è già chiuso, anche se write() ha sollevato un'eccezione

సాదా ఆంగ్లంలో: "తో రిసోర్స్ X f వలె తెరవండి, దీన్ని చేయండి. పూర్తయినప్పుడు (ఏం జరిగినా), Xని మూసివేయండి." with లేకుండా మీరు వ్రాయవలసి ఉంటుంది ఒక try/finally ప్రతిసారీ.

ఒక సమయంలో ఒకటి కంటే ఎక్కువ

with open("a.txt") as f, open("b.txt") as g:
    dati_a = f.read()
    dati_b = g.read()

మీ స్వంత సందర్భ నిర్వాహకుడిని వ్రాయడం (తరగతి)

మీరు రెండు డండర్ పద్ధతులను నిర్వచించాలి: __enter__ మరియు __exit__.

class Timer:
    def __enter__(self):
        import time
        self.t0 = time.perf_counter()
        return self  # è l'oggetto che finisce dopo "as"
    def __exit__(self, exc_type, exc_value, traceback):
        import time
        self.elapsed = time.perf_counter() - self.t0
        # ritornare True ingoia l'eccezione; di solito non lo vuoi
        return False

with Timer() as t:
    sum(range(10**6))
t.elapsed  # quanto è durato

• __enter__(self) బ్లాక్‌లోకి ప్రవేశించినప్పుడు పిలువబడుతుంది; తిరిగి వచ్చిన విలువ మీరు as తర్వాత పొందుతారు.
• __exit__(self, exc_type, exc_value, tb) నిష్క్రమణలో పిలువబడుతుంది (ఎల్లప్పుడూ). అది Trueని తిరిగి ఇస్తే, ఏవైనా మినహాయింపులు అణచివేయబడతాయి.

సత్వరమార్గం: @contextmanager

contextlib.contextmanager ఒక సందర్భ నిర్వాహికిని వ్రాయడానికి మిమ్మల్ని అనుమతిస్తుంది జనరేటర్ ఫంక్షన్:

from contextlib import contextmanager

@contextmanager
def timer():
    import time
    t0 = time.perf_counter()
    try:
        yield  # qui sta il blocco "with"
    finally:
        elapsed = time.perf_counter() - t0
        print(f"durata: {elapsed:.4f}s")

with timer():
    sum(range(10**6))

కోడ్ ముందు yield __enter__, కోడ్ తర్వాత __exit__. లోపాలు సంభవించినప్పుడు కూడా try/finally శుభ్రపరచడానికి హామీ ఇస్తుంది.

అణచివేయు: మినహాయింపును విస్మరించండి

from contextlib import suppress

with suppress(FileNotFoundError):
    open("forse-non-esiste.txt").read()
# se il file non c'è, nessun errore propaga

ఆపద: with దానికి మద్దతిచ్చే వస్తువులకు మాత్రమే

x = 42
with x:  # AttributeError: __enter__
    ...

@contextmanagerతో సందర్భోచిత నిర్వాహకులను వ్రాయడం

ప్రామాణిక లైబ్రరీ యొక్క contextlib మాడ్యూల్ __enter__ మరియు __AGYTOK_IN పద్ధతులను అమలు చేసే వెర్బోస్ క్లాస్‌లను వ్రాయడానికి బదులుగా, జనరేటర్ ఫంక్షన్‌లను ఉపయోగించి కాంటెక్స్ట్ మేనేజర్‌లను సృష్టించడానికి @contextmanager అనే అత్యంత అనుకూలమైన డెకరేటర్‌ను ఎగుమతి చేస్తుంది. మీరు కేవలం ఒక yieldని ఉపయోగించే జనరేటర్ ఫంక్షన్‌ని వ్రాస్తారు:

from contextlib import contextmanager

@contextmanager
def manage_resource():
    # __enter__ code
    yield resource
    # __exit__ code

మీరే ప్రయత్నించండి

వ్యాయామం సమీక్షించండి

అదనపు సవాలు