როგორ მუშაობს გამონაკლისების დამუშავება Python-ში?

Question

Accepted Answer

Python აკეთებს შეცდომების დამუშავებას **`try`/`except`** ბლოკებით, პლუს ოპციონალური `else` და `finally`. Python იყენებს **EAFP** პრინციპს — "უფრო ადვილია ბოდიშის სთხოვნა, ვიდრე ნებართვის" — ეკიდება მცდელობას და დამუშავებს გამონაკლისებს ზემოთ პირობების ჯერ დამოწმებაზე.

## ძირითადი სტრუქტურა

```python
try:
    result = risky_operation()
except ValueError as e:           # catch a SPECIFIC exception type
    print(f"bad value: {e}")
except (KeyError, IndexError):    # catch multiple types
    print("lookup failed")
except Exception as e:            # catch-all (use sparingly, last)
    print(f"unexpected: {e}")
else:
    print("ran only if NO exception occurred")
finally:
    cleanup()                     # ALWAYS runs (success or failure)
```

- **`except SpecificError`** — დამჭერი კონკრეტული ტიპები (რეკომენდირებული უფრო ზეწელი catch-all-ზე).
- **`else`** — გაიშვება მხოლოდ თუ გამონაკლისი არ აღმოჩნდა.
- **`finally`** — ყოველთვის გაიშვება (წმენდა, რესურსების გათავისუფლება), მაშინაც კი, თუ გამონაკლისი ვრცელდება.

## EAFP vs LBYL — პითონური სტილი

```python
# LBYL ("Look Before You Leap") — check first
if key in my_dict:
    value = my_dict[key]

# EAFP ("Easier to Ask Forgiveness") — try it, handle failure — more Pythonic
try:
    value = my_dict[key]
except KeyError:
    value = default
```

Python იდიომატურად ფასდება **EAFP** — მცდელობა მოახდინოს ოპერაციის გაკეთება და დამჭერი გამონაკლისი — რაც თავს აარიდებს კონკურენციის პრობლემებს და ხშირად უფრო სუფთაა ვიდრე წინასწარი დამოწმება.

## გამონაკლისის აძვრა და მომხმარებელთა გამონაკლისები

```python
if amount < 0:
    raise ValueError("amount must be positive")    # raise a built-in

class InsufficientFundsError(Exception):           # custom exception type
    pass
raise InsufficientFundsError("balance too low")
```

## საუკეთესო პრაქტიკა

```python
# ❌ bare except hides bugs (catches EVERYTHING, even typos/KeyboardInterrupt)
try: ...
except: pass

# ✅ catch specific exceptions; re-raise what you can't handle
try: ...
except ValueError as e:
    logger.error(e)
    raise                  # re-raise to propagate
```

```text
✓ Catch SPECIFIC exceptions, not bare except
✓ Don't silently swallow errors (except: pass) — log or handle them
✓ Use finally / context managers (with) for cleanup
✓ Raise meaningful, specific exception types
```

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

მძლავრი შეცდომის დამუშავება აუცილებელია საიმედო პროგრამებისთვის, და Python-ის მიდგომას აქვს განსხვავებული იდიომები, რომელიც ღირს იცოდეთ: `try/except/else/finally` სტრუქტურა, **EAFP** ფილოსოფია (spробა-და-დამუშავება ნაცვლად შემოწმება-პირველი, რომელიც უფრო პითონური და თავს აარიდებს კონკურენციის პრობლემებს), კონკრეტული გამონაკლისების დამჭერი (*არა* უფრო `except`, რომელიც დამალავს ბუგებს), და `finally`/context მენეჯერების გამოყენება წმენდისთვის.

ამის გაგება გაკვეთილობს როგორც ჩამონგებული შეცდომებისგან ჩამოვარდნას, ასევე დელიკატური, რთული-გასაკვირი პრობლემებს, რომელიც გამოწვეულია ზედმეტი ან ჩუმი გამონაკლის დამუშავებით — საიმედო კოდის ხშირი წყარო.