Unpacking, *args และ **kwargs

Spread ใน TypeScript, * และ ** ใน Python

ฝั่ง TypeScript ใช้ operator ... ตัวเดียวคุมทั้ง array และ object ส่วน Python แยกออกเป็นสองตัว คือ * สำหรับ sequence (list, tuple, iterable) และ ** สำหรับ dictionary

ตัว * ใกล้เคียงกับ destructuring และ spread ที่คุณคุ้นอยู่แล้ว แต่ ** สำหรับ dict ไม่มีตัวเทียบตรง ๆ ใน TypeScript เพราะเป็นของ Python โดยเฉพาะ และยังเป็น syntax สำหรับ variadic keyword argument ใน function signature อีกด้วย

Tuple unpacking

Python ให้คุณ unpack iterable ใดก็ตามลงใน variable ในการ assign ครั้งเดียว สิ่งนี้มีความสามารถมากกว่า destructuring ของ TypeScript เพราะทำงานได้กับ iterable ทุกชนิด ไม่ใช่แค่ array และ object

// TypeScript: array destructuring
const [x, y, z] = [1, 2, 3];
console.log(x, y, z); // 1 2 3

// Rest element
const [first, ...rest] = [10, 20, 30, 40, 50];
console.log(first, rest); // 10 [20, 30, 40, 50]

// Swap with destructuring
let a = 5, b = 10;
[a, b] = [b, a];
console.log(a, b); // 10 5

# Python: tuple unpacking
x, y, z = 1, 2, 3
print(x, y, z)  # 1 2 3

# Starred assignment (captures middle or end)
first, *middle, last = [10, 20, 30, 40, 50]
print(first, middle, last)  # 10 [20, 30, 40] 50

# Swap without a temp variable
a, b = 5, 10
a, b = b, a
print(a, b)  # 10 5

starred assignment ของ Python (*middle) ยืดหยุ่นกว่า rest element ของ TypeScript เพราะวางไว้ตำแหน่งไหนก็ได้ ทั้งต้น กลาง หรือท้าย แล้ว Python จะคำนวณเองว่าค่าไหนควรตกอยู่ที่ใด

*args: variadic positional arguments

*args ใน function signature จะรวบรวม positional argument จำนวนเท่าใดก็ได้เข้าเป็น tuple ชื่อ args เป็นแค่ convention — * คือสิ่งที่สำคัญ

// TypeScript: rest parameters
function sumAll(...args: number[]): number {
  return args.reduce((acc, n) => acc + n, 0);
}

console.log(sumAll(1, 2, 3, 4, 5)); // 15

// Spreading an array into a function call
const nums = [1, 2, 3];
console.log(Math.max(...nums)); // 3

# Python: *args collects positional arguments into a tuple
def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3, 4, 5))  # 15

# Spreading a list into a function call with *
nums = [1, 2, 3]
print(max(*nums))  # 3

**kwargs: variadic keyword arguments

TypeScript ไม่มีตัวเทียบตรง ๆ กับ **kwargs ท่าที่ใกล้ที่สุดคือรับ options object เข้ามาแล้ว destructure ต่อ ส่วน **kwargs ของ Python จะรวบ keyword argument ทุกตัวที่ไม่ตรงกับ parameter ที่ประกาศชื่อไว้ มัดรวมเป็น dict ก้อนเดียว

// TypeScript: simulate kwargs with an options object
function greet(options: Record<string, string | number>): void {
  for (const [key, val] of Object.entries(options)) {
    console.log(`${key}: ${val}`);
  }
}

greet({ name: "Alice", age: 30, city: "Bangkok" });

// Object spread / merge
const defaults = { color: "blue", size: "medium" };
const overrides = { color: "red", weight: "heavy" };
const merged = { ...defaults, ...overrides };
console.log(merged);

# Python: **kwargs collects keyword arguments into a dict
def greet(**kwargs):
    for key, val in kwargs.items():
        print(f"{key}: {val}")

greet(name="Alice", age=30, city="Bangkok")

# Dict merge with **
defaults = {"color": "blue", "size": "medium"}
overrides = {"color": "red", "weight": "heavy"}
merged = {**defaults, **overrides}
print(merged)

ลองด้วยตัวเอง

Open in an online REPL

# Tuple unpacking
x, y, z = 1, 2, 3
print(x, y, z)

# Starred assignment
first, *middle, last = [10, 20, 30, 40, 50]
print(first, middle, last)

# Swap without temp variable
a, b = 5, 10
a, b = b, a
print(a, b)

def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3, 4, 5))

def greet(**kwargs):
    for key, val in kwargs.items():
        print(f"{key}: {val}")

greet(name="Alice", age=30, city="Bangkok")

defaults = {"color": "blue", "size": "medium"}
overrides = {"color": "red", "weight": "heavy"}
merged = {**defaults, **overrides}
print(merged)

🟦 กฎการเรียงลำดับ parameter: positional, *args, keyword-only, **kwargs

Python บังคับใช้ลำดับที่เข้มงวดสำหรับ function parameter การผสมกันผิดแบบจะ raise SyntaxError ตอน parse ลำดับที่อนุญาตทั้งหมดคือ:

def f(pos1, pos2, *args, kw_only1, kw_only2=default, **kwargs):

แยกย่อยออกมาได้ดังนี้:

Positional parameters — กรอกจากซ้ายไปขวาตามตำแหน่งหรือตามชื่อ
*args — รวบรวม positional argument ที่เหลือทั้งหมดเป็น tuple เมื่อกำหนดแล้ว parameter ที่อยู่หลังจากนั้นจะกลายเป็น keyword-only
Keyword-only parameters — ต้องส่งโดยระบุชื่อ อยู่หลัง *args (หรือหลัง * เดี่ยวถ้าต้องการ keyword-only โดยไม่มี variadic collector)
**kwargs — ต้องอยู่ท้ายสุด รวบรวม keyword argument ที่เหลือทั้งหมดเป็น dict

* เดี่ยวที่ไม่มีชื่อจะบังคับให้ parameter ที่ตามมาทั้งหมดเป็น keyword-only โดยไม่รวบรวม positional argument:

def connect(host, port, *, timeout=30, retries=3):
    ...

connect("localhost", 5432, timeout=10)  # OK
connect("localhost", 5432, 10)          # TypeError: too many positional arguments

นี่เป็นเทคนิคออกแบบ API ที่มีประโยชน์: ผู้เรียกต้องระบุชื่อ argument ทำให้ call site อ่านเข้าใจได้ในตัวเองและป้องกัน bug จากการใส่ argument ผิดลำดับ

เมื่อเรียก function คุณยังใช้ * และ ** เพื่อ unpack sequence และ dict เป็น argument ได้อีกด้วย:

args = (1, 2, 3)
kwargs = {"sep": "-"}
print(*args, **kwargs)  # 1-2-3