Comprehensions และ Generator Expressions

Syntax เดียวสำหรับการแปลง collection ทั้งหมด

นักพัฒนา TypeScript ใช้ .map(), .filter(), และ .reduce() ต่อกันบน array วิธีนี้ใช้ได้ แต่ต้องสร้าง array กลางทางขึ้นมาใหม่ในแต่ละขั้น และไม่สามารถสร้าง Set หรือ object ได้โดยตรงตามธรรมชาติ Python มี comprehension syntax ฝังอยู่ในภาษาเลยสำหรับ 4 รูปแบบ ได้แก่ list, dict, set, และ generator แนวคิดหลักคือ [expression for item in iterable if condition]

List comprehension เทียบกับ map/filter

กรณีที่พบบ่อยที่สุดคือการแปลง collection พร้อมกรองค่าไปด้วย ใน TypeScript ต้องเรียก method สองตัวแยกกัน แต่ใน Python เป็น expression เดียว

// TypeScript: chained .map() and .filter()
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// squares of even numbers
const result = numbers
  .filter(n => n % 2 === 0)
  .map(n => n ** 2);

console.log(result); // [4, 16, 36, 64, 100]

// Building an object from an array requires reduce or Object.fromEntries
const words = ["hello", "world", "typescript"];
const wordLengths = Object.fromEntries(
  words.map(w => [w, w.length])
);
console.log(wordLengths); // { hello: 5, world: 5, typescript: 10 }

# Python: comprehensions for list, dict, set, and generator

numbers = list(range(1, 11))

# squares of even numbers — single expression
result = [n ** 2 for n in numbers if n % 2 == 0]
print(result)  # [4, 16, 36, 64, 100]

# Dict comprehension — no need for Object.fromEntries
words = ["hello", "world", "python"]
word_lengths = {word: len(word) for word in words}
print(word_lengths)  # {'hello': 5, 'world': 5, 'python': 6}

# Set comprehension — duplicates are automatically removed
unique_lengths = {len(word) for word in words}
print(unique_lengths)  # {5, 6}

ครบทั้ง 4 รูปแบบ

List comprehension — สร้าง list แบบ eager:

squares = [x ** 2 for x in range(1, 6)]
# [1, 4, 9, 16, 25]

Dict comprehension — สร้าง dict:

word_lengths = {word: len(word) for word in ["hello", "world", "python"]}
# {'hello': 5, 'world': 5, 'python': 6}

Set comprehension — สร้าง set (ไม่มีค่าซ้ำ):

unique_lengths = {len(word) for word in ["hi", "hello", "hey", "world"]}
# {2, 3, 5}

Generator expression — สร้าง lazy generator (ใช้วงเล็บ ไม่ใช่ bracket):

gen = (x ** 2 for x in range(5))
# Nothing is computed yet. Values are produced only when iterated.
print(list(gen))  # [0, 1, 4, 9, 16]

Syntax เหมือนกันทุกรูปแบบ ต่างกันแค่ตัวคั่นด้านนอก: [] สำหรับ list, {} พร้อม colon สำหรับ dict, {} ไม่มี colon สำหรับ set, และ () สำหรับ generator

ลองทดสอบ

Open in an online REPL

# List comprehension
squares = [x ** 2 for x in range(1, 6)]
print(squares)

# With filter condition
evens = [x for x in range(10) if x % 2 == 0]
print(evens)

# Dict comprehension
word_lengths = {word: len(word) for word in ["hello", "world", "python"]}
print(word_lengths)

# Set comprehension -- unique values only
unique_lengths = {len(word) for word in ["hi", "hello", "hey", "world"]}
print(sorted(unique_lengths))

# Generator expression -- lazy
gen = (x ** 2 for x in range(5))
print(list(gen))

🟦 Generator expression เป็น lazy — list comprehension ไม่ใช่

ความต่างนี้สำคัญต่อทั้งประสิทธิภาพและความถูกต้อง

List comprehension [expr for x in iterable] ทำงานแบบ eager: Python วน iterable ทั้งหมดทันทีและสร้าง list เก็บไว้ในหน่วยความจำ ถ้า iterable มี 10 ล้านรายการ ผลลัพธ์ทั้ง 10 ล้านตัวจะถูกเก็บไว้พร้อมกัน

Generator expression (expr for x in iterable) ทำงานแบบ lazy: มันคืนค่า generator object ทันทีโดยยังไม่คำนวณอะไรเลย ค่าจะถูกสร้างทีละตัวก็ต่อเมื่อถูกขอผ่านการวนซ้ำ (for, next(), list() ฯลฯ)

# Eager — builds the full list in memory immediately
big_list = [x ** 2 for x in range(10_000_000)]

# Lazy — no memory allocated for results yet
big_gen = (x ** 2 for x in range(10_000_000))

# Only the first value is computed:
print(next(big_gen))  # 0

เมื่อควรใช้แต่ละแบบ:

ใช้ list comprehension เมื่อต้อง index เข้าไปในผลลัพธ์, วนซ้ำมากกว่าหนึ่งครั้ง, ต้องรู้ความยาว, หรือส่งให้อะไรบางอย่างที่ต้องการ list
ใช้ generator expression เมื่อต้องวนซ้ำแค่ครั้งเดียว, ส่งผลลัพธ์ให้ function ที่รับ iterable ใด ๆ ก็ได้ (sum(), max(), join(), any(), all()), หรือ iterable ต้นทางใหญ่มากจนการสร้างทั้งหมดพร้อมกันจะเปลืองหน่วยความจำ

หนึ่งใน idiom ที่พบบ่อยของ Python คือการส่ง generator expression เข้า function โดยตรง:

total = sum(x ** 2 for x in range(1000))   # no extra list created

สังเกตว่า generator จะ exhausted หลังวนซ้ำครบหนึ่งรอบ — การวนซ้ำครั้งที่สองจะไม่ได้ค่าอะไรเลย ถ้าต้องการวนซ้ำผลลัพธ์หลายครั้งให้ใช้ list comprehension แทน

🟦 เมื่อควรใช้ comprehension และเมื่อไม่ควรใช้

Comprehension ทำให้โค้ดอ่านง่ายขึ้นในกรณีส่วนใหญ่ แต่มีแนวทางปฏิบัติที่ดีบางประการที่ควรรู้:

ใช้เมื่อ:

การแปลงหรือกรองนั้นสั้นและอ่านในบรรทัดเดียวได้ง่าย
คุณต้องการ list, dict, หรือ set ใหม่จาก iterable ที่มีอยู่
คุณต้องการประสิทธิภาพที่ดีกว่า loop ธรรมดาที่เรียก .append() ซ้ำ

หลีกเลี่ยงเมื่อ:

Logic ซับซ้อนจนต้องซ้อน comprehension หลายชั้น (comprehension ซ้อนสองชั้นมักอ่านยาก)
คุณต้องการ side effect เช่น logging — ใช้ loop ธรรมดาแทน
Collection มีขนาดใหญ่และคุณต้องการเพียงครั้งเดียว — ใช้ generator expression แทน

Comprehension ซ้อน อ่านจากซ้ายไปขวาตามลำดับ loop:

# [row[i] for row in matrix for i in range(len(row))]
# is equivalent to:
# for row in matrix:
#     for i in range(len(row)):
#         yield row[i]
matrix = [[1, 2], [3, 4], [5, 6]]
flat = [n for row in matrix for n in row]
print(flat)  # [1, 2, 3, 4, 5, 6]