რა არის გენერატორი და yield საკვანძო სიტყვა?

Question

IT Interview Practice · Accepted Answer

A **generator** არის ფუნქცია, რომელიც აწარმოებს მნიშვნელობებს **ნელი ტემპით, ერთ ერთის მიყოლებით**, `yield` საკვანძო სიტყვის გამოყენებით `return`-ის ნაცვლად. ის თითოეული მნიშვნელობა ითვლის მოთხოვნის პირობით, ვიდრე მთელი შედეგი მეხსიერებაში აკმაყოფილებს — იდეალურია დიდი ან უსასრულო მიმდევრობებისთვის.

## yield vs return

```python
# a regular function builds the WHOLE list in memory
def get_squares(n):
    return [i ** 2 for i in range(n)]   # all n values created at once

# a generator yields values ONE AT A TIME, on demand
def gen_squares(n):
    for i in range(n):
        yield i ** 2                     # pause here, return one value, resume on next()

for sq in gen_squares(1_000_000):        # uses almost NO memory
    print(sq)
```

`yield` **შეაჩერებს** ფუნქციას, აბრუნებს მნიშვნელობას და **აგრძელებს** ზუსტი ადგილიდან შემდეგ იტერაციაზე — შეინახავს ადგილობრივ მდგომარეობას მნიშვნელობებს შორის. ვერაფერი არ ითვლება სანამ მოითხოვება.

## მეხსიერების სარგებელი

```python
sum(i ** 2 for i in range(10_000_000))   # generator expression — constant memory
sum([i ** 2 for i in range(10_000_000)]) # list — builds a huge list first (wasteful)
```

დიდი მონაცემებისთვის, გენერატორი მეხსიერებას ბრტყელი ინახავს; სიის გაგება მასალიზებს ყველაფერს ერთდროულად.

## უსასრულო მიმდევრობები (რთული სიის დროს)

```python
def count_up():
    n = 0
    while True:        # infinite — but lazy, so it's fine
        yield n
        n += 1

gen = count_up()
next(gen)   # 0
next(gen)   # 1  — only computes when asked
```

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

## როგორ მუშაობს იტერაცია ძირში

```python
gen = gen_squares(3)
next(gen)   # 0  — runs until the first yield
next(gen)   # 1  — resumes, runs to the next yield
next(gen)   # 4
next(gen)   # StopIteration — generator exhausted
```

## გენერატორის გამონათქვამები

```python
(x ** 2 for x in range(10))   # like a list comprehension but lazy (parentheses)
```

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

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

`yield` (გაჩერება/გაგრძელება დაცული მდგომარეობით) და llazy შეფასების გაგება გაძლევთ საშუალებას დაწეროთ მასშტაბური მონაცემების დამუშავების კოდი, ხოლო გენერატორის გამონათქვამები იგივე სარგებელს იძლევა კომპაქტურად.

ისინი არის კლючის ინსტრუმენტი, როდესაც მონაცემი ძალიან დიდია მეხსიერებაში გასაკსიათებლად ან როდესაც გსურთ პუნქტების დამუშავება, როგორც ისინი წარმოებულია, ვიდრე ყველა წინასწარ.

yield vs return

მეხსიერების სარგებელი

უსასრულო მიმდევრობები (რთული სიის დროს)

როგორ მუშაობს იტერაცია ძირში

გენერატორის გამონათქვამები

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

დაკავშირებული კითხვები