რა არის context managers და with statement?

Question

Accepted Answer

**Context manager** არის ობიექტი, რომელიც განსაზღვრავს setup და teardown ლოგიკას და გამოიყენება **`with`** statement-ის ერთად. ის გარანტიას იძლევა რომ cleanup (ფাილების დახურვა, locks-ის გათავისუფლება, transactions-ის rollback) ხდება ავტომატურად — თუნდაც ხარვეზი მოხდეს.

## პრობლემა, რომელსაც ის წყვეტს

```python
# ❌ manual cleanup — error-prone; if processing throws, the file never closes
f = open("file.txt")
data = f.read()
process(data)        # if this raises, f.close() below is skipped → leaked file handle
f.close()

# ✅ with statement — guarantees the file is closed, no matter what
with open("file.txt") as f:
    data = f.read()
    process(data)
# f is automatically closed here — even if process() raised an exception
```

`with` ბლოკი უზრუნველყოფს, რომ `f.close()` გაეშვას, როდესაც ბლოკი დასრულდება, მიუხედავად იმისა ნორმალურად დამთავრდა თუ exception-ის მეშვეობით — აღმოფხვრის გარღეული რესურსებს დავიწყებული ან გამოტოვებული cleanup-ის შედეგად.

## Common context managers

```python
with open("f.txt") as f: ...           # files (auto-close)
with lock:                              # threading locks (auto-release)
    shared_resource += 1
with db.transaction():                  # DB transactions (auto-commit/rollback)
    ...
with open("a") as a, open("b") as b:    # multiple at once
    ...
```

## საკუთრის შექმნა — class მეთოდი

```python
class Timer:
    def __enter__(self):                 # SETUP — runs at `with` entry
        self.start = time.perf_counter()
        return self                       # the value bound to `as`
    def __exit__(self, exc_type, exc_val, tb):  # TEARDOWN — runs at exit (even on error)
        print(f"took {time.perf_counter() - self.start:.3f}s")
        # return False → propagate any exception; True → suppress it

with Timer():
    do_work()
```

Context manager იმპლემენტაციას აქვს `__enter__` (setup) და `__exit__` (cleanup, რომელიც იღებს exception ინფორმაციას).

## უფრო მარტივი გზა — contextlib

```python
from contextlib import contextmanager

@contextmanager
def timer():
    start = time.perf_counter()
    try:
        yield                            # everything before yield = setup; after = teardown
    finally:
        print(f"took {time.perf_counter() - start:.3f}s")

with timer():
    do_work()
```

`@contextmanager` decorator გადაქცევს generator-ს context manager-ში — setup `yield`-მდე, cleanup მის შემდეგ (უსაფრთხოების სახით `finally`-ში).

## რატომ აქვს მნიშვნელობა

Context managers და `with` არის Pythonic გზა **რესურსების უსაფრთხო მართვისთვის** — უზრუნველყოფს ფაილების დახურვას, locks-ის გათავისუფლებას, connections-ის დაბრუნებას და transactions-ის დასრულებას, თუნდაც exception-ები მოხდეს.

ეს აცილებს რესურსების გარღეულობას და არათანმიმდევრობას, რომელიც მხედელობის შედეგია manual cleanup-ის პროცესში.

ისინი მუდმივად გამოიყენება (ყველა ფაილის ოპერაცია უნდა გამოიყენოს `with`), და თუ იცით, თუ როგორ დაწეროთ საკუთარი (via `__enter__`/`__exit__` ან უფრო მარტივი `@contextmanager`) შეგიძლია ნებისმიერი setup/teardown ნიმუშის깔끔ად და საიმედოდ ინკაპსულირება.