เจเนอเรเตอร์และคีย์เวิร์ด yield คืออะไร?

Question

Accepted Answer

**เจเนอเรเตอร์** คือฟังก์ชันที่สร้างค่า **อย่างช้า ๆ ทีละค่า** โดยใช้คีย์เวิร์ด `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)
```

สำหรับข้อมูลขนาดใหญ่ เจเนอเรเตอร์ช่วยให้หน่วยความจำราบเรียบ; list comprehension สร้างทุกอย่างในครั้งเดียว

## ลำดับไม่มีที่สิ้นสุด (เป็นไปไม่ได้กับลิสต์)

```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` (หยุดชั่วคราว/ดำเนินการต่อพร้อมสถานะที่รักษาไว้) และการประเมินแบบ lazy ช่วยให้คุณเขียนรหัสการประมวลผลข้อมูลที่มีความสามารถในการขยาย และนิพจน์เจเนอเรเตอร์ให้ประโยชน์เดียวกันโดยสรุป

พวกมันเป็นเครื่องมือสำคัญเมื่อข้อมูลใหญ่เกินกว่าจะใส่ในหน่วยความจำหรือเมื่อคุณต้องการประมวลผลรายการในขณะที่สร้างแทนที่จะสร้างล่วงหน้าทั้งหมด