# Python cheat sheet: ไวยากรณ์ Python คำสั่ง และฟังก์ชันในตัวในรูปแบบตาราง

URL: https://skillaria.top/th/guides/python/python-cheat-sheet

ไวยากรณ์ Python อาศัยการเยื้องย่อหน้าแทนวงเล็บปีกกา บล็อกหลังเครื่องหมายโคลอนจะเยื้องเข้าไป 4 ช่องว่าง พื้นฐานคือตัวแปรที่ไม่ต้องประกาศชนิด เงื่อนไข if/elif/else ลูป for และ while ฟังก์ชัน def และฟังก์ชันในตัวอย่าง print, len, range, input, type รวมถึงเมธอดของสตริง ลิสต์ และดิกชันนารี

Cheat sheet นี้รวมทุกอย่างที่ควรมีไว้ใกล้มือในไม่กี่เดือนแรกไว้ในหน้าเดียว ได้แก่ ไวยากรณ์ Python ลูป ฟังก์ชันในตัว เมธอดของสตริง ลิสต์ และดิกชันนารี รวมถึงคำสั่งเทอร์มินัล ทุกตารางเป็นเอกสารอ้างอิงสั้นๆ พร้อมตัวอย่างที่นำไปวางใน REPL ได้ทันที

## พื้นฐานไวยากรณ์ Python

จุดเด่นหลักของภาษาคือบล็อกถูกกำหนดด้วยการเยื้องย่อหน้า ไม่ใช่วงเล็บ หลังบรรทัดที่มีเครื่องหมายโคลอน (`if`, `for`, `def`, `class`) บรรทัดถัดไปจะเยื้องเข้าไป 4 ช่องว่าง ห้ามผสมแท็บกับช่องว่าง ไม่เช่นนั้นจะได้ `IndentationError`

| โครงสร้าง | ตัวอย่าง | คำอธิบาย |
| --- | --- | --- |

| คอมเมนต์ | `# ข้อความ` | ทุกอย่างหลัง # จนถึงท้ายบรรทัดจะถูกข้าม |

| ตัวแปร | `age = 25` | ไม่ประกาศชนิด ค่าเป็นตัวกำหนดชนิดเอง |

| การกำหนดหลายค่า | `a, b = 1, 2` | การแตกค่า (unpacking) สลับค่าได้ด้วย `a, b = b, a` |

| การแสดงผล | `print("สวัสดี", name)` | อาร์กิวเมนต์คั่นด้วยช่องว่าง |

| การรับค่า | `s = input("ชื่อ: ")` | คืนค่าเป็นสตริงเสมอ |

| f-string | `f"{name}: {price:.2f}"` | แทรกนิพจน์และกำหนดรูปแบบ |

| คำอธิบายชนิด | `count: int = 0` | เป็นคำแนะนำให้ IDE และตัวตรวจ ไม่ถูกตรวจตอนรัน |

| บล็อกว่าง | `pass` | ตัวยึดที่ใช้ในที่ที่ไวยากรณ์ต้องการเนื้อหา |

| การ import | `from math import sqrt` | นำเข้าโมดูลหรือชื่อจากโมดูล |

### ชนิดข้อมูล

| ชนิด | ค่าคงที่ | เปลี่ยนแปลงได้ |
| --- | --- | --- |

| `int` | `42`, `1_000_000` | ไม่ |

| `float` | `3.14`, `1e-3` | ไม่ |

| `bool` | `True`, `False` | ไม่ |

| `str` | `"ข้อความ"`, `'ข้อความ'`, `"""หลายบรรทัด"""` | ไม่ |

| `list` | `[1, 2, 3]` | ได้ |

| `tuple` | `(1, 2)`, `(1,)` | ไม่ |

| `dict` | `{"a": 1}` | ได้ |

| `set` | `{1, 2}` ว่างใช้ `set()` | ได้ |

| `NoneType` | `None` | — |

### ตัวดำเนินการ

| กลุ่ม | ตัวดำเนินการ | ตัวอย่าง → ผลลัพธ์ |
| --- | --- | --- |

| เลขคณิต | `+ - * / // % **` | `7 // 2` → 3, `7 % 2` → 1, `2 ** 10` → 1024 |

| การเปรียบเทียบ | `== != < > <= >=` | `1 < x < 10` — การเปรียบเทียบต่อเนื่อง |

| ตรรกะ | `and or not` | `x or "ค่าเริ่มต้น"` |

| การเป็นสมาชิก | `in`, `not in` | `"a" in "abc"` → True |

| ความเป็นอัตลักษณ์ | `is`, `is not` | `x is None` |

| การกำหนดค่า | `+= -= *= /=`, `:=` | `if (n := len(s)) > 10: ...` |

## เงื่อนไขและการจับคู่รูปแบบ

```
if score >= 90:
    grade = "A"
elif score >= 70:
    grade = "B"
else:
    grade = "C"

status = "ผู้ใหญ่" if age >= 18 else "เด็ก"   # ตัวดำเนินการ ternary

match command:
    case "start":
        print("เริ่มทำงาน")
    case "stop" | "exit":
        print("หยุดทำงาน")
    case _:
        print("ไม่รู้จักคำสั่งนี้")
```

ค่าที่ถือว่าเป็นเท็จได้แก่ `False`, `None`, `0`, สตริงว่าง และคอลเลกชันว่าง ดังนั้นแทนที่จะเขียน `if len(items) > 0` ก็เขียนเพียง `if items`

## ลูปใน Python: ไวยากรณ์ for และ while

### ลูป for

ไวยากรณ์ของลูป for ใน Python คือ `for ตัวแปร in ลำดับ:` และตามด้วยเนื้อหาที่เยื้องเข้าไป ลูปวนผ่านออบเจกต์ใดก็ได้ที่วนซ้ำได้ เช่น สตริง ลิสต์ ดิกชันนารี ไฟล์ หรือ `range`

```
for i in range(5):              # 0 1 2 3 4
    print(i)

for i in range(10, 0, -2):      # 10 8 6 4 2
    print(i)

for i, fruit in enumerate(["แอปเปิล", "ลูกแพร์"], start=1):
    print(i, fruit)

for name, score in zip(names, scores):
    print(name, score)

for key, value in prices.items():
    print(key, value)
```

### ลูป while

```
attempts = 3
while attempts > 0:
    password = input("รหัสผ่าน: ")
    if password == "secret":
        print("เข้าสู่ระบบสำเร็จ")
        break
    attempts -= 1
else:
    print("หมดจำนวนครั้งที่ลองแล้ว")   # ทำงานเมื่อไม่มี break
```

| คำสั่ง | ทำอะไร |
| --- | --- |

| `break` | ออกจากลูปก่อนเวลา |

| `continue` | ข้ามไปรอบถัดไป |

| `else` ของลูป | ทำงานเมื่อลูปจบโดยไม่มี `break` |

| `range(stop)`, `range(start, stop, step)` | ลำดับของตัวเลข โดย `stop` ไม่ถูกนับรวม |

### Comprehension

```
squares = [x ** 2 for x in range(10)]
evens = [x for x in numbers if x % 2 == 0]
lengths = {word: len(word) for word in words}
unique = {c.lower() for c in text}
total = sum(x * x for x in range(100))   # นิพจน์ตัวสร้าง (generator expression)
```

## ฟังก์ชัน

```
def greet(name: str, greeting: str = "สวัสดี") -> str:
    """คืนคำทักทาย"""
    return f"{greeting}, {name}!"

def total(*args, **kwargs):
    return sum(args), kwargs

square = lambda x: x * x
print(greet("อนันต์"))                 # สวัสดี, อนันต์!
print(greet("อนันต์", greeting="ไง"))   # ไง, อนันต์!
```

| องค์ประกอบ | ความหมาย |
| --- | --- |

| `def f(a, b=1)` | พารามิเตอร์ที่มีค่าเริ่มต้น |

| `*args` | อาร์กิวเมนต์ตำแหน่งจำนวนเท่าใดก็ได้ (ทูเพิล) |

| `**kwargs` | อาร์กิวเมนต์แบบชื่อจำนวนเท่าใดก็ได้ (ดิกชันนารี) |

| `return` | คืนค่า ถ้าไม่มีฟังก์ชันจะคืน `None` |

| `lambda x: ...` | ฟังก์ชันไม่มีชื่อแบบสั้นที่มีนิพจน์เดียว |

| `global`, `nonlocal` | เปลี่ยนตัวแปรจากขอบเขตภายนอก |

อย่าใช้ค่าเริ่มต้นที่เปลี่ยนแปลงได้ เช่น `def f(items=[])` เพราะลิสต์ถูกสร้างครั้งเดียวและสะสมข้ามการเรียกแต่ละครั้ง วิธีที่ถูกคือใช้ `items=None` และภายในเขียน `if items is None: items = []`

## ฟังก์ชันในตัวของ Python

ฟังก์ชันในตัวของ Python ใช้ได้โดยไม่ต้อง import เป็นฟังก์ชันหลักที่เจอแทบทุกสคริปต์

| ฟังก์ชัน | ทำอะไร | ตัวอย่าง → ผลลัพธ์ |
| --- | --- | --- |

| `print()` | แสดงค่า | `print(1, 2, sep="-")` → 1-2 |

| `input()` | อ่านสตริงจากคีย์บอร์ด | `int(input())` |

| `len()` | ความยาวของคอลเลกชันหรือสตริง | `len("abc")` → 3 |

| `type()` | ชนิดของอ็อบเจกต์ | `type(3.0)` → <class 'float'> |

| `isinstance()` | ตรวจชนิดข้อมูล | `isinstance(5, int)` → True |

| `int() float() str() bool()` | แปลงชนิดข้อมูล | `int("42")` → 42 |

| `list() tuple() set() dict()` | สร้างคอลเลกชัน | `list("ab")` → ['a', 'b'] |

| `range()` | ช่วงของตัวเลข | `list(range(3))` → [0, 1, 2] |

| `enumerate()` | คู่ (ดัชนี, องค์ประกอบ) | `list(enumerate("ab"))` → [(0, 'a'), (1, 'b')] |

| `zip()` | จับลำดับมาคู่กันทีละตัว | `list(zip([1, 2], "ab"))` → [(1, 'a'), (2, 'b')] |

| `sum() min() max()` | ผลรวม ค่าต่ำสุด ค่าสูงสุด | `max([3, 7, 1])` → 7 |

| `abs() round()` | ค่าสัมบูรณ์และการปัดเศษ | `round(3.14159, 2)` → 3.14 |

| `sorted()` | ลิสต์ใหม่ที่เรียงแล้ว | `sorted(words, key=len, reverse=True)` |

| `reversed()` | ตัววนซ้ำในลำดับย้อนกลับ | `list(reversed([1, 2]))` → [2, 1] |

| `map() filter()` | ใช้ฟังก์ชันกับทุกค่า / กรองค่า | `list(map(str, [1, 2]))` → ['1', '2'] |

| `any() all()` | มีอย่างน้อยหนึ่งค่า / ทุกค่าเป็นจริง | `all(x > 0 for x in nums)` |

| `open()` | เปิดไฟล์ | `open("a.txt", encoding="utf-8")` |

| `help() dir()` | คู่มือและรายชื่อแอตทริบิวต์ | `help(str.split)`, `dir(list)` |

| `id() hash()` | รหัสและแฮชของอ็อบเจกต์ | `hash("a")` |

คู่มืออ้างอิงที่มีประโยชน์ที่สุดอยู่ในตัวเครื่อง ได้แก่ ฟังก์ชัน `help()` ใน REPL: `help(dict)` แสดงเมธอดทั้งหมดของดิกชันนารีพร้อมคำอธิบาย และ `dir(obj)` แสดงชื่อที่ใช้ได้

## เมธอดของสตริง

สตริงใน Python เปลี่ยนแปลงไม่ได้ ทุกเมธอดคืนสตริงใหม่ การตัดสตริง (slice) ทำงานเหมือนกับลิสต์: `s[1:4]` และ `s[::-1]` สำหรับกลับลำดับ

| เมธอด | ตัวอย่าง → ผลลัพธ์ |
| --- | --- |

| `upper() lower()` | `"Py".upper()` → 'PY' |

| `capitalize() title()` | `"hello world".title()` → 'Hello World' |

| `strip() lstrip() rstrip()` | `" hi \n".strip()` → 'hi' |

| `split(sep)` | `"a,b,c".split(",")` → ['a', 'b', 'c'] |

| `join(iterable)` | `"-".join(["a", "b"])` → 'a-b' |

| `replace(old, new)` | `"แมว".replace("แ", "ห")` → 'หมว' |

| `find() index()` | `"hello".find("l")` → 2; ถ้าไม่เจอ -1 (ส่วน `index` จะเกิดข้อผิดพลาด) |

| `count()` | `"banana".count("a")` → 3 |

| `startswith() endswith()` | `"file.py".endswith(".py")` → True |

| `isdigit() isalpha() isspace()` | `"123".isdigit()` → True |

| `removeprefix() removesuffix()` | `"test_a".removeprefix("test_")` → 'a' |

| `zfill() center() ljust()` | `"7".zfill(3)` → '007' |

| `format()` | `"{} + {}".format(1, 2)` → '1 + 2' |

## คำสั่งของลิสต์ใน Python

ลิสต์เป็นคอลเลกชันที่เปลี่ยนแปลงได้และมีลำดับ เมธอดส่วนใหญ่แก้ไขลิสต์ในตัวมันเองและคืนค่า `None` ดังนั้น `a = a.sort()` จึงเป็นข้อผิดพลาดที่พบบ่อย

| การทำงาน | ทำอะไร | ตัวอย่าง |
| --- | --- | --- |

| `append(x)` | เพิ่มต่อท้าย | `a.append(4)` |

| `extend(iter)` | เพิ่มองค์ประกอบทั้งหมด | `a.extend([5, 6])` |

| `insert(i, x)` | แทรกที่ดัชนี | `a.insert(0, "first")` |

| `remove(x)` | ลบการปรากฏแรกของค่า | `a.remove(3)` |

| `pop(i)` | ลบและคืนองค์ประกอบ (ค่าเริ่มต้นคือตัวสุดท้าย) | `last = a.pop()` |

| `clear()` | ล้างลิสต์ | `a.clear()` |

| `index(x)` | ดัชนีของการปรากฏแรก | `a.index("b")` |

| `count(x)` | จำนวนครั้งที่ปรากฏ | `a.count(1)` |

| `sort()` | เรียงลำดับในตัวเอง | `a.sort(key=str.lower)` |

| `reverse()` | กลับลำดับในตัวเอง | `a.reverse()` |

| `copy()` | สำเนาแบบตื้น (shallow copy) | `b = a.copy()` |

| `del a[i]` | ลบตามดัชนีหรือช่วง | `del a[1:3]` |

| การตัด (slice) | `a[start:stop:step]` | `a[-1]` คือตัวสุดท้าย `a[:3]` คือสามตัวแรก |

## คำสั่งของดิกชันนารีใน Python

| การทำงาน | ทำอะไร | ตัวอย่าง |
| --- | --- | --- |

| `d[key]` | ค่าจากคีย์ ถ้าไม่มีคีย์จะเกิด `KeyError` | `d["name"]` |

| `get(key, default)` | ค่า หรือค่าสำรองถ้าไม่มี | `d.get("age", 0)` |

| `d[key] = value` | เพิ่มหรือแก้ไขค่า | `d["city"] = "เชียงใหม่"` |

| `keys() values() items()` | คีย์ ค่า คู่ของทั้งสอง | `for k, v in d.items():` |

| `update()` | รวมกับดิกชันนารีอีกอัน | `d.update({"a": 1})` |

| `d1 | d2` | ดิกชันนารีใหม่ที่รวมแล้ว | `merged = defaults | user` |

| `pop(key, default)` | ลบและคืนค่า | `d.pop("tmp", None)` |

| `popitem()` | ลบคู่ที่เพิ่มล่าสุด | `d.popitem()` |

| `setdefault(key, value)` | คืนค่า ถ้าไม่มีคีย์ให้สร้างขึ้น | `d.setdefault("tags", []).append("py")` |

| `key in d` | ตรวจว่ามีคีย์หรือไม่ | `if "name" in d:` |

| `dict.fromkeys()` | ดิกชันนารีจากคีย์ที่มีค่าเดียวกัน | `dict.fromkeys("abc", 0)` |

| `len(d)`, `del d[key]` | ขนาดและการลบ | `del d["old"]` |

### ทูเพิลและเซต

| การทำงาน | ตัวอย่าง → ผลลัพธ์ |
| --- | --- |

| การแตกค่าทูเพิล | `x, y = (3, 4)` |

| เพิ่มเข้าเซต | `s.add(5)` ลบด้วย `s.discard(5)` |

| รวม / ส่วนร่วม | `{1, 2} | {2, 3}` → {1, 2, 3}; `{1, 2} & {2, 3}` → {2} |

| ผลต่าง | `{1, 2} - {2}` → {1} |

| ลบค่าซ้ำจากลิสต์ | `list(dict.fromkeys(items))` — คงลำดับเดิมไว้ |

## ข้อยกเว้นและไฟล์

```
try:
    number = int(input("ตัวเลข: "))
except ValueError as err:
    print("นี่ไม่ใช่ตัวเลข:", err)
else:
    print("สำเร็จ")
finally:
    print("ทำงานทุกครั้ง")

with open("data.txt", "w", encoding="utf-8") as f:
    f.write("บรรทัดหนึ่ง\n")

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())
```

| ข้อยกเว้น | เกิดขึ้นเมื่อ |
| --- | --- |

| `SyntaxError`, `IndentationError` | ไวยากรณ์หรือการเยื้องผิด |

| `NameError` | ไม่ได้นิยามชื่อ (พิมพ์ผิด) |

| `TypeError` | ใช้การดำเนินการกับชนิดข้อมูลที่ไม่เหมาะสม: `"1" + 1` |

| `ValueError` | ชนิดถูกต้องแต่ค่าไม่ถูกต้อง: `int("abc")` |

| `IndexError`, `KeyError` | ไม่มีดัชนีหรือคีย์นั้น |

| `FileNotFoundError` | ไม่พบไฟล์ |

| `ZeroDivisionError` | หารด้วยศูนย์ |

## คลาส

```
from dataclasses import dataclass

class Dog:
    def __init__(self, name: str):
        self.name = name

    def bark(self) -> str:
        return f"{self.name}: โฮ่ง!"

@dataclass
class Point:
    x: float
    y: float

print(Dog("ด่าง").bark())    # ด่าง: โฮ่ง!
print(Point(1, 2))           # Point(x=1, y=2)
```

## โมดูลในตัวของ Python

ไลบรารีมาตรฐานติดตั้งมาพร้อมอินเทอร์พรีเตอร์ แค่ใช้ `import` ก็พอ

| โมดูล | ใช้ทำอะไร | ตัวอย่าง |
| --- | --- | --- |

| `math` | คณิตศาสตร์ | `math.sqrt(16)` → 4.0 |

| `random` | ตัวเลขสุ่ม | `random.randint(1, 6)`, `random.choice(items)` |

| `datetime` | วันที่และเวลา | `datetime.date.today()` |

| `pathlib` | พาธและไฟล์ | `Path("data").glob("*.csv")` |

| `os`, `sys` | ระบบ ตัวแปรสภาพแวดล้อม อาร์กิวเมนต์ | `os.environ.get("HOME")`, `sys.argv` |

| `json` | อ่านและเขียน JSON | `json.loads(text)`, `json.dumps(obj, ensure_ascii=False)` |

| `csv` | ตาราง CSV | `csv.DictReader(f)` |

| `collections` | Counter, defaultdict, deque | `Counter("banana").most_common(1)` → [('a', 3)] |

| `itertools` | การรวมกันและการต่อตัววนซ้ำ | `itertools.chain(a, b)` |

| `re` | นิพจน์ปกติ | `re.findall(r"\d+", s)` |

| `time` | หยุดรอและวัดเวลา | `time.sleep(1)`, `time.perf_counter()` |

| `asyncio` | โค้ดอะซิงโครนัส | `asyncio.run(main())` |

ใน Python 3.15 มี lazy import (PEP 810): `lazy import pandas as pd` เลื่อนการโหลดโมดูลไปจนถึงการเรียกใช้ครั้งแรก ทำให้สคริปต์ที่มีไลบรารีหนักเริ่มทำงานได้เร็วขึ้นมาก

## คำสั่ง Python ในเทอร์มินัล

กลุ่มคำสั่งที่ค้นหาว่า «python commands» คือคำสั่งสำหรับเรียกอินเทอร์พรีเตอร์และติดตั้งไลบรารี บน Windows มักใช้ `python` หรือ `py` แทน `python3`

| คำสั่ง | ทำอะไร |
| --- | --- |

| `python3 --version` | แสดงเวอร์ชัน |

| `python3` | เปิดคอนโซลโต้ตอบ REPL (ออกด้วย `exit()`) |

| `python3 script.py` | รันไฟล์ |

| `python3 -c "print(2 + 2)"` | รันคำสั่งเดียวบรรทัดเดียว |

| `python3 -m venv .venv` | สร้างสภาพแวดล้อมเสมือน |

| `source .venv/bin/activate` / `.venv\Scripts\activate` | เปิดใช้สภาพแวดล้อม (Linux, macOS / Windows) |

| `python3 -m pip install requests` | ติดตั้งแพ็กเกจ |

| `pip list`, `pip freeze > requirements.txt` | รายการแพ็กเกจและการบันทึก |

| `pip install -r requirements.txt` | ติดตั้ง dependency จากไฟล์ |

| `python3 -m http.server 8000` | เว็บเซิร์ฟเวอร์อย่างง่ายในโฟลเดอร์ปัจจุบัน |

| `uv init`, `uv add requests`, `uv run main.py` | สร้างโปรเจกต์ เพิ่ม dependency และรันด้วยตัวจัดการ uv |

## ข้อผิดพลาดที่มือใหม่มักเจอ

- **เปรียบเทียบด้วย `=`** ในเงื่อนไขต้องใช้ `==` ส่วน `=` ตัวเดียวคือการกำหนดค่า
- **ลืมโคลอน** หลัง `if`, `for`, `def` ทำให้เกิด `SyntaxError`
- **บวกสตริงกับตัวเลข**: `"อายุ: " + 25` เป็นข้อผิดพลาด ให้เขียน `f"อายุ: {25}"`
- **แก้ไขลิสต์ระหว่างวนซ้ำ** ให้วนซ้ำจากสำเนา `for x in a[:]` หรือสร้างลิสต์ใหม่
- **`input()` คืนค่าเป็นสตริง** ถ้าต้องคำนวณ ให้ครอบด้วย `int()` หรือ `float()`

## สรุป

ไวยากรณ์ Python อาศัยการเยื้องย่อหน้า โคลอน และชุดโครงสร้างเล็กๆ ได้แก่ เงื่อนไข ลูป for และ while ฟังก์ชัน และคลาส เมื่อเพิ่มฟังก์ชันในตัวสองสามสิบตัวและเมธอดของสตริง ลิสต์ และดิกชันนารี คุณจะแก้โจทย์ประจำวันได้ส่วนใหญ่ เก็บ cheat sheet นี้ไว้ และเมื่อคุ้นกับตารางเหล่านี้แล้ว ค่อยไปต่อที่โมดูลและอะซิงโครนัส ทั้งหมดนี้อธิบายทีละขั้นตอนพร้อมตัวอย่างในคอร์ส «Python 3.15: จากมือใหม่สู่มืออาชีพ»

## FAQ

**ควรเยื้องกี่ช่องว่างใน Python?**

ตามมาตรฐาน PEP 8 ให้ใช้ 4 ช่องว่างต่อหนึ่งระดับ สิ่งสำคัญคือทุกบรรทัดในบล็อกเหมือนกันและไม่ผสมกับแท็บ

**ลิสต์ต่างจากทูเพิลอย่างไร?**

ลิสต์เปลี่ยนแปลงได้ เพิ่มและเรียงลำดับในตัวเองได้ ส่วนทูเพิลเปลี่ยนแปลงไม่ได้ จึงใช้เป็นคีย์ของดิกชันนารีและเก็บชุดค่าที่คงที่ได้

**จะดูเมธอดทั้งหมดของออบเจกต์ได้อย่างไรใน Python?**

เรียก dir(obj) เพื่อดูรายชื่อ และ help(obj) เพื่ออ่านคำอธิบาย เช่น help(str) แสดงเมธอดทั้งหมดของสตริง

**sort() ต่างจาก sorted() อย่างไร?**

เมธอด list.sort() เรียงลิสต์ในตัวเองและคืนค่า None ส่วนฟังก์ชัน sorted() คืนลิสต์ใหม่ และใช้ได้กับคอลเลกชันที่วนซ้ำได้ทุกชนิด

**ต้องมีเซมิโคลอนท้ายบรรทัดไหม?**

ไม่ต้อง เซมิโคลอนใช้ได้เมื่อมีหลายคำสั่งในบรรทัดเดียว แต่ในโค้ดปกติแต่ละคำสั่งเขียนขึ้นบรรทัดใหม่


---
Source: Skillaria.Top (https://skillaria.top)