როგორ მუშაობს ფუნქციის პარამეტრები და ნაგულისხმები არგუმენტები?

Question

Accepted Answer

Python ფუნქციები მხარდაჭერს **პოზიციურ** და **სახელობით** არგუმენტებს, პლუს **ნაგულისხმები მნიშვნელობები**. მათი ურთიერთკომბინაციის გაგება — და ერთი ცნობილი ნაგულისხმები-არგუმენტების პრობლემა — არის ძირითადი.

## პოზიციური, სახელობით და ნაგულისხმები არგუმენტები

```python
def greet(name, greeting="Hello", punctuation="!"):
    return f"{greeting}, {name}{punctuation}"

greet("Ann")                          # positional → "Hello, Ann!"
greet("Ann", "Hi")                    # "Hi, Ann!"
greet("Ann", punctuation=".")          # keyword arg → "Hello, Ann."
greet(name="Ann", greeting="Hey")      # all by keyword
```

პარამეტრები ნაგულისხმები მნიშვნელობებით არის არჩევითი; შეგიძლიათ არგუმენტები გადასცეთ პოზიციით ან სახელით (სახელობით არგუმენტები აუმჯობესებს წაკითხულობას და საშუალებას გაძლევთ გამოტოვოთ უფრო ადრე არჩევითი პარამეტრები).

## ცნობილი პრობლემა: მუტაბელი ნაგულისხმები არგუმენტები

```python
# ❌ DANGER — the default list is created ONCE and SHARED across all calls
def add_item(item, items=[]):
    items.append(item)
    return items

add_item("a")   # ["a"]
add_item("b")   # ["a", "b"]  ← surprise! the SAME list persisted
```

ნაგულისხმები მნიშვნელობები შეფასდება **ერთხელ** ფუნქციის განსაზღვრისას, არა თითოეული გამოძახების დროს. მუტაბელი ნაგულისხმი (სია/dict) შესაბამისად გაზიარდება გამოძახებებს შორის — კლასიკური ხარვეზი. გამოსწორება:

```python
# ✅ use None as the default and create a fresh object inside
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items
```

## მხოლოდ სახელობით და მხოლოდ პოზიციური პარამეტრები

```python
def f(a, b, *, key):       # `*` → `key` MUST be passed by keyword
    ...
f(1, 2, key=3)             # ✅   f(1, 2, 3) ❌

def g(a, b, /, c):         # `/` → a, b MUST be positional
    ...
```

`*` და `/` მარკები საშუალებას გაძლევთ აიძულოთ, თუ როგორ გადაიცემა არგუმენტები — სასარგებლო მკაფიო, სტაბილური API-ებისთვის.

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

პარამეტრების დამუშავების გაგება ფუნდამენტალური თავისთავად Python ფუნქციების სწორად დაწერისა და გამოძახებისთვის.

ნაგულისხმები აქცევს ფუნქციებს მოქნილ, და სახელობით არგუმენტები ხდის გამოძახებებს თვით-დოკუმენტირებული.

მნიშვნელოვანია, რომ **მუტაბელი-ნაგულისხმე-არგუმენტის ხაფანგი** Python-ის ერთ-ერთი ყველაზე ხშირი და დამაბნეველი ხარვეზია — იმის ცოდნა, რომ ნაგულისხმები შეფასდება ერთხელ (ამიტომ მუტაბელი ნაგულისხმები რჩება გამოძახებებს შორის) და `None`-sentinel სამკურნალო ხელი აბრკოლებს დახვეწილი შეცდომების მთელ კატეგორიას.

ეს ცოდნა საფუძველს აკეთებს깔끔한, წინასწარ ხილვადი ფუნქციის API-ების დიზაინისთვის.