Kontekst menejerlarini çuqurroq örganiş

Nimalarni örganasiz
- Aniq kontekst menejeri protokoli (context manager protocol):
__enter__nima qaytaradi va__exit__(exc_type, exc, tb)nima qabul qiladi __exit__ning qaytaradigan qiymati istisno yutilişi (swallow) yoki yuqoriga uzatilişini (propagate) qanday hal qiladicontextlib.ExitStacközgaruvçan sondagi resurslarni va tozalaş callbacklarini qanday boşqaradiclosing,redirect_stdoutvanullcontextqaçon kerak böladi- Nega
@contextmanagerobyekti bir martalik va öz menejerlaringizni qanday loyihalaş
Nega bu muhim
with operatori darsida siz with open(...) va kiçik @contextmanager funksiyasini işlatgansiz. Haqiqiy dasturlarga muvaffaqiyatli bölganda saqlaydigan, xato bölganda esa bekor qiladigan tranzaksiya, sekin qadam atrofidagi taymer, nima bölsa ham qayta tiklanişi kerak bölgan sozlama kerak böladi. Protokolni aniq bilsangiz, har qanday "bajar, keyin ortga qaytar" jufti bitta işonçli with qatoriga siğadi.
Protokol qadamma-qadam
with EXPR as name: tört iş bajaradi:
- Menejerni oliş uçun
EXPRni hisoblaydi. __enter__()ni çaqiradi va uning qaytargan qiymatininamega boğlaydi.- Blokni bajaradi.
__exit__(exc_type, exc, tb)ni çaqiradi: blok odatdagidek tugasa uçtaNone, aks holda istisno klassi, obyekti va traceback.
Mana klass körinişidagi Timer:
import time
class Timer:
def __init__(self, label):
self.label = label
self.elapsed = None
def __enter__(self):
self.start = time.perf_counter()
return self # pastdagi `t` aynan şu böladi
def __exit__(self, exc_type, exc, tb):
self.elapsed = time.perf_counter() - self.start
print(f"{self.label}: {self.elapsed:.1f} s, xato: {exc_type}")
with Timer("narxlarni yuklaş") as t:
time.sleep(0.1)
print("Obyektda saqlandi:", round(t.elapsed, 1))narxlarni yuklaş: 0.1 s, xato: None
Obyektda saqlandi: 0.1self ni qaytariş odatiy tanlov, lekin __enter__ istalgan narsani qaytarişi mumkin, masalan quyidagi Transaction dagi luğatni.
Yutiş yoki yuqoriga uzatiş
__exit__ rost qiymat qaytarsa, istisno yutiladi. None yoki False esa uni yuqoriga uzatadi. Aksariyat menejerlar heç narsa qaytarmaydi, şuning uçun xatolar yuqoriga uzatiladi.
Bu Transaction hisoblarning nusxasi bilan işlaydi, blok muvaffaqiyatli tugasa özgarişlarni saqlaydi (commit), xato bölsa bekor qiladi (rollback) va faqat ValueError ni yutadi:

class Transaction:
def __init__(self, accounts):
self.accounts = accounts
def __enter__(self):
self.draft = dict(self.accounts)
return self.draft
def __exit__(self, exc_type, exc, tb):
if exc_type is None:
self.accounts.update(self.draft)
print("saqlandi")
return False
print(f"bekor qilindi: {exc}")
return issubclass(exc_type, ValueError) # True uni yutadi
accounts = {"Aziza": 500_000, "Bobur": 100_000}
with Transaction(accounts) as draft:
draft["Aziza"] -= 200_000
draft["Bobur"] += 200_000
print(accounts)
with Transaction(accounts) as draft:
draft["Bobur"] -= 900_000
if draft["Bobur"] < 0:
raise ValueError("pul yetarli emas")
print(accounts)
try:
with Transaction(accounts) as draft:
draft["Dilnoza"] += 1
except KeyError as e:
print("baribir çaqirildi:", repr(e))saqlandi
{'Aziza': 300000, 'Bobur': 300000}
bekor qilindi: pul yetarli emas
{'Aziza': 300000, 'Bobur': 300000}
bekor qilindi: 'Dilnoza'
baribir çaqirildi: KeyError('Dilnoza')ValueError yutildi; KeyError esa try gaça yetib bordi.
__enter__ istisno çaqirganda
__enter__ istisno çaqirsa, blok umuman bajarilmaydi va __exit__ çaqirilmaydi. Çala qolgan tayyorlaş uçun tozalaş __enter__ ning özida bajarilişi kerak:
import os
class ChangeDirectory:
def __init__(self, path):
self.path = path
def __enter__(self):
self.old = os.getcwd()
os.chdir(self.path) # xato berişi mumkin
return self.path
def __exit__(self, exc_type, exc, tb):
os.chdir(self.old)
print("eski papkaga qaytdik")
os.makedirs("reports", exist_ok=True)
with ChangeDirectory("reports"):
print("içida:", os.path.basename(os.getcwd()))
try:
with ChangeDirectory("no_such_folder"):
print("heç qaçon çop etilmaydi")
except FileNotFoundError:
print("__enter__ muvaffaqiyatsiz, __exit__ ötkazib yuborildi")içida: reports
eski papkaga qaytdik
__enter__ muvaffaqiyatsiz, __exit__ ötkazib yuborildiExitStack: istalgan miqdordagi resurslar
Bitta with da menejerlarni vergul bilan sanab yoziş uçun resurslar soni oldindan maʼlum bölişi kerak. Fayllar röyxati maʼlumotlardan kelsa, contextlib.ExitStack dan foydalaning. enter_context(cm) menejerga kiradi va uni eslab qoladi; oxirida hammasi teskari tartibda yopiladi, hatto uçinçi faylni oçiş muvaffaqiyatsiz bölsa ham. callback(func, *args) istalgan funksiyani tozalaş sifatida röyxatdan ötkazadi:
from contextlib import ExitStack
cities = ["toşkent", "samarqand", "buxoro"]
with ExitStack() as stack:
files = [stack.enter_context(open(f"{c}.txt", "w", encoding="utf-8")) for c in cities]
stack.callback(print, "barça fayllar yopildi")
for city, f in zip(cities, files):
f.write(f"{city.title()} hisoboti\n")
print("oçiq fayllar:", len(files))
print("yopildimi:", all(f.closed for f in files))oçiq fayllar: 3
barça fayllar yopildi
yopildimi: TrueCallback birinçi bölib bajarildi, çunki u oxirgi bölib röyxatdan ötkazilgan.
contextlib dagi qulay menejerlar
suppress ni allaqaçon bilasiz. Yana uçtasi:
closing(obj)oxiridaobj.close()ni çaqiradi;close()metodi bor, lekinwithni qöllamaydigan obyektlar uçun.redirect_stdout(target)printnatijasini boşqa joyga, masalanio.StringIOga yönaltiradi.nullcontext(value)heç narsa qilmaydi: menejer ixtiyoriy bölganda uning örnini bosadi.
import io
from contextlib import closing, nullcontext, redirect_stdout
class Connection:
def close(self):
print("ulaniş yopildi")
with closing(Connection()):
print("maʼlumot yuborilmoqda")
buffer = io.StringIO()
with redirect_stdout(buffer):
print("Somsa: 8,000 söm")
print("uşlandi:", buffer.getvalue().strip())
def report(lock=None):
with lock if lock is not None else nullcontext():
print("hisobot yozildi")
report()maʼlumot yuborilmoqda
ulaniş yopildi
uşlandi: Somsa: 8,000 söm
hisobot yozildiBir martalik, qayta işlatiladigan va reentrant
Qayta işlatiladigan (reusable) menejer ketma-ket kelgan bir neça with da işlaydi; reentrant menejer esa hatto özining içida ham işlaydi (suppress, redirect_stdout). @contextmanager obyekti bitta generatorni öraydi, generator esa faqat bir marta bajariladi, şuning uçun u bir martalik. Uni qayta işlatsangiz, tuşunarsiz xato olasiz:
from contextlib import contextmanager
@contextmanager
def tag(name):
print(f"<{name}>")
yield
print(f"</{name}>")
bold = tag("b")
with bold:
print("Palov")
with bold: # aynan şu obyektdan ikkinçi marta foydalaniş
print("Lağmon")AttributeError: '_GeneratorContextManager' object has no attribute 'args'Har bir with uçun tag("b") ni qaytadan çaqiring. yield ga yetib bormasdan tugaydigan generator, masalan yield şarti yolğon bölgan if içida turganda, RuntimeError: generator didn't yield çaqiradi. Har bir yöl aynan bir marta yield qilişi kerak.
async with
Tarmoqni kutadigan kod __aenter__ va __aexit__ metodlari bor asinxron menejerlardan foydalanadi, ularga async with bilan kiriladi. contextlib.asynccontextmanager xuddi @contextmanager kabi async def generatoridan şunday menejer yasaydi. Ular bilan Async va await darsida tanişasiz.
Dizayn vositasi sifatida kontekst menejerlari
Har qanday "özgartir, keyin ortga qaytar" jufti menejerga mos keladi: vaqtinçalik sozlama, çekiniş darajasi, qulf (lock). Masalan, threading.Lock bilan with lock: qulfni oladi va uni har doim böşatadi (qulflar bilan Oqimlar va jarayonlar darsida tanişasiz).
from contextlib import contextmanager
settings = {"currency": "söm", "debug": False}
@contextmanager
def temporary_setting(key, value):
old = settings[key]
settings[key] = value
try:
yield
finally:
settings[key] = old
with temporary_setting("debug", True):
print("içida:", settings["debug"])
print("keyin:", settings["debug"])içida: True
keyin: FalseÖzingiz sinab köring
Tranzaksiya KeyError ni ham yutadigan qiling yoki saqlaşdan oldin xato çaqirib, balanslarni kuzating.
Köp uçraydigan xatolar
1. __enter__ dan self ni qaytarişni unutiş
class Timer:
def __enter__(self):
self.start = 0 # return yöq, şuning uçun None qaytaradi
def __exit__(self, exc_type, exc, tb):
pass
with Timer() as t:
print(t.start)AttributeError: 'NoneType' object has no attribute 'start'Tuzatiş: __enter__ ni return self bilan (yoki blok işlatişi kerak bölgan boşqa obyekt bilan) tugating.
2. Tasodifan True qaytaradigan __exit__
class Quiet:
def __enter__(self):
return self
def __exit__(self, exc_type, exc, tb):
print("tozalanmoqda")
return True # Yomon: barça xatolarni yaşiradi
with Quiet():
total = 150_000 / 0
print("hammasi joyida körinadi, lekin jami heç qaçon hisoblanmadi")tozalanmoqda
hammasi joyida körinadi, lekin jami heç qaçon hisoblanmadiTuzatiş: exc_type ni tekşirib, bitta aniq istisnoni ataylab yutmasangiz, __exit__ dan heç narsa qaytarmang.
3. Istisno çaqiradigan tozalaş kodi
class Upload:
def __enter__(self):
return self
def __exit__(self, exc_type, exc, tb):
self.connection.close() # self.connection mavjud emas
with Upload():
raise ValueError("fayl juda katta")Traceback (most recent call last):
ValueError: fayl juda katta
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
AttributeError: 'Upload' object has no attribute 'connection'Tozalaşdagi xato haqiqiy xatoning örnini egallaydi; ValueError faqat kontekst sifatida saqlanib qoladi. Tuzatiş: __exit__ ni sodda saqlang va undagi xato berişi mumkin bölgan har bir narsani himoyalang.
4. try/finally siz @contextmanager
from contextlib import contextmanager
settings = {"debug": False}
@contextmanager
def debug_on():
settings["debug"] = True
yield # Yomon: try/finally yöq
settings["debug"] = False
try:
with debug_on():
raise ValueError("notöğri kiritiş")
except ValueError:
pass
print("debug:", settings["debug"])debug: TrueXato yield da çaqiriladi, şuning uçun undan keyingi qator heç qaçon bajarilmaydi. Tuzatiş: temporary_setting dagidek yield ni try/finally ga öring.
Maşqlar
1. Timer klassi
__enter__ taymerning özini qaytaradigan, __exit__ esa elapsed ni saqlaydigan Timer klassini yozing. sum(range(100_000)) vaqtini ölçang, jamini çop eting va elapsed manfiy bölmagan float ekanini çop eting (qiymatning özi har işga tuşirişda özgaradi).
Yeçim
import time
class Timer:
def __enter__(self):
self.start = time.perf_counter()
return self
def __exit__(self, exc_type, exc, tb):
self.elapsed = time.perf_counter() - self.start
with Timer() as t:
total = sum(range(100_000))
print(total)
print(isinstance(t.elapsed, float) and t.elapsed >= 0)4999950000
True2. Içma-iç bölimlar
Kirişda sarlavhasini klass darajasidagi depth qadar çekiniş bilan çop etadigan va depth ga bir qöşadigan, çiqişda esa birni ayiradigan Section klassini yozing. Hisobot, Toşkent va Savdo bölimlarini içma-iç joylang va içida summani çop eting.
Yeçim
class Section:
depth = 0
def __init__(self, title):
self.title = title
def __enter__(self):
print(" " * Section.depth + self.title)
Section.depth += 1
return self
def __exit__(self, exc_type, exc, tb):
Section.depth -= 1
with Section("Hisobot"):
with Section("Toşkent"):
with Section("Savdo"):
print(" " * Section.depth + "1,200,000 söm")Hisobot
Toşkent
Savdo
1,200,000 söm3. temporary_attr
Atributni özgartiradigan va çiqişda, hatto blok istisno çaqirsa ham, eski qiymatni tiklaydigan temporary_attr(obj, name, value) @contextmanager funksiyasini yozing. Uni discount = 0 bölgan Shop da sinang: içida çegirmani (15) çop eting va ValueError çaqiring; keyin xatoni va çegirmani çop eting.
Yeçim
from contextlib import contextmanager
@contextmanager
def temporary_attr(obj, name, value):
old = getattr(obj, name)
setattr(obj, name, value)
try:
yield obj
finally:
setattr(obj, name, old)
class Shop:
discount = 0
shop = Shop()
try:
with temporary_attr(shop, "discount", 15):
print("aksiya paytida:", shop.discount)
raise ValueError("kassa işdan çiqdi")
except ValueError as e:
print("xato:", e)
print("aksiyadan keyin:", shop.discount)aksiya paytida: 15
xato: kassa işdan çiqdi
aksiyadan keyin: 04. Köp fayllarga yoziş
names = ["aziza.txt", "bobur.txt", "jasur.txt"] berilgan. ExitStack yordamida hammasini yoziş uçun oçing va har biriga Imtihon duşanba kuni deb yozing. N ta fayl yopildi deb çop etadigan callback röyxatdan ötkazing, keyin har bir faylning mazmunini çop eting.
Yeçim
from contextlib import ExitStack
from pathlib import Path
names = ["aziza.txt", "bobur.txt", "jasur.txt"]
with ExitStack() as stack:
files = [stack.enter_context(open(n, "w", encoding="utf-8")) for n in names]
stack.callback(print, f"{len(files)} ta fayl yopildi")
for f in files:
f.write("Imtihon duşanba kuni\n")
for n in names:
print(n, "->", Path(n).read_text(encoding="utf-8").strip())3 ta fayl yopildi
aziza.txt -> Imtihon duşanba kuni
bobur.txt -> Imtihon duşanba kuni
jasur.txt -> Imtihon duşanba kuni5. Yutiş va qayd qiliş
Istisno turlarini qabul qiladigan, faqat ularni yutadigan va har birini records röyxatiga "TurNomi: xabar" körinişida yozib qöyadigan ErrorLog klassini yozing. Boşqa istisnolar yuqoriga uzatilişi kerak. Bitta ErrorLog obyektini uçta blok uçun qayta işlating: int("abc"), {}["palov"] va 1 / 0 (röyxatda yöq). Qoçib çiqqan xatoni, keyin yozuvlarni çop eting.
Yeçim
class ErrorLog:
def __init__(self, *types):
self.types = types
self.records = []
def __enter__(self):
return self
def __exit__(self, exc_type, exc, tb):
if exc_type is not None and issubclass(exc_type, self.types):
self.records.append(f"{exc_type.__name__}: {exc}")
return True
return False
log = ErrorLog(ValueError, KeyError)
with log:
int("abc")
with log:
{}["palov"]
try:
with log:
1 / 0
except ZeroDivisionError as e:
print("qoçib çiqdi:", e)
for record in log.records:
print(record)qoçib çiqdi: division by zero
ValueError: invalid literal for int() with base 10: 'abc'
KeyError: 'palov'issubclass klasslar kortejini qabul qiladi. Bu klass har bir blok uçun alohida holat saqlamaydi, şuning uçun @contextmanager obyektidan farqli ravişda uni qayta işlatiş mumkin.
Xulosa
with__enter__qaytargan qiymatni nomga boğlaydi, keyin blok qanday tugaşidan qatʼi nazar__exit__(exc_type, exc, tb)ni çaqiradi.__exit__rost qiymat qaytarsa, istisno yutiladi;None/Falseuni yuqoriga uzatadi.__enter__istisno çaqirsa,__exit__heç qaçon bajarilmaydi.ExitStackistalgan sondagi menejerlar va callbacklarga kiradi hamda ularni teskari tartibda yopadi.closing,redirect_stdoutvanullcontextwithni qöllamaydigan obyektlar, uşlangan natija va ixtiyoriy menejerlar uçun.@contextmanagerobyekti bir martalik; uningyieldinitry/finallyiçiga qöying.- Sozlamalar va qulflar kabi har qanday "özgartir, keyin ortga qaytar" juftini menejer qilib yozing.