# สตริงใน Python: เมธอด split, replace, strip, join, slice และ f-string

URL: https://skillaria.top/th/guides/python/python-strings

สตริง (str) ใน Python คือลำดับอักขระแบบ Unicode ที่แก้ไขไม่ได้ เมธอด split() แยกสตริงเป็นลิสต์ join() รวมลิสต์กลับเป็นสตริง replace() แทนที่ข้อความ และ strip() ตัดช่องว่างหัวท้าย โดยทุกเมธอดคืนสตริงใหม่ ส่วนการแทรกค่าทำได้สะดวกที่สุดด้วย f-string เช่น f"{name}: {price:.2f}"

สตริงอยู่ในทุกโปรแกรม Python ตั้งแต่ข้อความที่ผู้ใช้พิมพ์ ชื่อไฟล์ บรรทัดของ CSV ไปจนถึงคำตอบจาก API ชนิด `str` เก็บข้อความแบบ Unicode จึงใช้ภาษาไทย ภาษาอื่น และอีโมจิได้โดยไม่ต้องตั้งค่าเพิ่ม เมธอดที่ใช้บ่อยที่สุดคือ `split` `replace` `strip` และ `join` ส่วนการแสดงค่าออกทางจอทำได้สะดวกที่สุดด้วย f-string บทความนี้จะอธิบายทั้งหมดพร้อมตัวอย่าง

## สตริงใน Python ทำงานอย่างไร

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

```
name = "กาแฟ"
note = """บรรทัดแรก
บรรทัดที่สอง"""
print(len(name))  # 4 — ความยาวของสตริงเป็นจำนวนอักขระ
```

คุณสมบัติสำคัญของสตริงคือแก้ไขไม่ได้ เมธอดไม่ได้เปลี่ยนสตริงเดิม แต่คืนสตริงใหม่กลับมา ดังนั้น `s.replace("a", "b")` โดยไม่กำหนดค่ากลับจะไม่มีผลอะไร ต้องเขียนเป็น `s = s.replace("a", "b")` นี่คือข้อผิดพลาดที่มือใหม่พบบ่อยที่สุด

### อักขระพิเศษ การขึ้นบรรทัดใหม่ และสตริงดิบ

การขึ้นบรรทัดใหม่เขียนด้วย `\n` แท็บด้วย `\t` และแบ็กสแลชด้วย `\\` คำนำหน้า `r` ทำให้สตริงเป็น "สตริงดิบ" ซึ่งแบ็กสแลชจะไม่ถูกแปลความ เหมาะกับพาธของ Windows และนิพจน์ทั่วไป (regular expression)

```
print("ยอดรวม:\n350 บาท")
path = r"C:\new\table.csv"   # \n และ \t จะไม่กลายเป็นอักขระพิเศษ
```

นิพจน์ที่ยาวสามารถขึ้นบรรทัดใหม่ในโค้ดได้โดยห่อด้วยวงเล็บ สตริงลิเทอรัลที่อยู่ติดกันในวงเล็บจะถูกต่อกันโดย Python อัตโนมัติ

## split: แยกสตริงเป็นลิสต์

เมธอด `split()` แบ่งสตริงตามตัวคั่นและคืนค่าเป็นลิสต์ หากไม่ระบุอาร์กิวเมนต์ จะตัดตามอักขระว่างทุกชนิด และละเว้นช่องว่างที่ซ้ำกัน ซึ่งเหมาะกับการแยกคำสั่ง

```
"add  กาแฟ 250".split()        # ['add', 'กาแฟ', '250']
"2026-10-16".split("-")        # ['2026', '10', '16']
"a,b,,c".split(",")            # ['a', 'b', '', 'c']
"key=value=x".split("=", 1)    # ['key', 'value=x']
```

ข้อสังเกต: เมื่อระบุตัวคั่นเอง ชิ้นว่างจะถูกเก็บไว้ อาร์กิวเมนต์ที่สอง `maxsplit` จำกัดจำนวนครั้งที่ตัด และ `rsplit()` ตัดจากทางขวา หากต้องการแยกข้อความเป็นบรรทัด ให้ใช้ `splitlines()` ซึ่งรองรับทั้ง `\n` และ `\r\n` และไม่ทิ้งสมาชิกว่างไว้ท้ายลิสต์

```
text = "กาแฟ\nแท็กซี่\n"
text.split("\n")     # ['กาแฟ', 'แท็กซี่', '']
text.splitlines()    # ['กาแฟ', 'แท็กซี่']
```

## join: รวมลิสต์เป็นสตริง

`join()` คือการกระทำที่กลับกัน เรียกจากสตริงตัวคั่น และรับลิสต์ของสตริงเป็นอาร์กิวเมนต์:

```
items = ["กาแฟ", "แท็กซี่", "อาหารกลางวัน"]
print(", ".join(items))   # กาแฟ, แท็กซี่, อาหารกลางวัน
print("\n".join(items))   # แต่ละรายการขึ้นบรรทัดใหม่
```

สมาชิกทุกตัวต้องเป็นสตริง มิฉะนั้นจะได้ `TypeError: sequence item 0: expected str instance, int found` ให้แปลงตัวเลขก่อน: `", ".join(str(x) for x in amounts)`

### การต่อและรวมสตริง

ต่อสตริงสองตัวด้วย `+` และทำซ้ำด้วย `*` เช่น `"-" * 20` แต่การต่อสตริงหลายร้อยชิ้นในลูปด้วย `+=` ช้า เพราะทุกครั้งจะสร้างสตริงใหม่ ให้รวบรวมชิ้นส่วนไว้ในลิสต์แล้วใช้ `join()` ครั้งเดียว และไม่สามารถต่อสตริงกับตัวเลขโดยตรงได้: `"ยอดรวม: " + 5` จะเกิด `TypeError` ต้องใช้ `str()` หรือ f-string

## replace: แทนที่ข้อความย่อย

`replace(old, new)` แทนที่ทุกตำแหน่งที่พบข้อความย่อย อาร์กิวเมนต์ที่สามจำกัดจำนวนครั้งของการแทนที่

```
price = "1 250,50"
price = price.replace(" ", "").replace(",", ".")
print(float(price))                  # 1250.5

"ก-ข-ค".replace("-", "+", 1)         # 'ก+ข-ค'
```

เมธอดนี้แยกตัวพิมพ์เล็กใหญ่และค้นหาแบบตรงทุกตัวอักษร หากต้องการแทนที่ตามรูปแบบ (เช่น "ตัวเลขทั้งหมด") ให้ใช้โมดูล `re` และฟังก์ชัน `re.sub()`

## strip, lstrip, rstrip: ตัดช่องว่างหัวท้าย

`strip()` ตัดช่องว่าง แท็บ และการขึ้นบรรทัดใหม่จากทั้งสองด้าน `lstrip()` ตัดเฉพาะด้านซ้าย และ `rstrip()` ตัดเฉพาะด้านขวา นี่คือสิ่งแรกที่ควรทำกับข้อมูลที่ผู้ใช้พิมพ์และสตริงจากไฟล์

```
raw = "  กาแฟ \n"
raw.strip()       # 'กาแฟ'
raw.rstrip()      # '  กาแฟ'
"xxกาแฟxx".strip("x")   # 'กาแฟ'
```

อาร์กิวเมนต์คือชุดอักขระ ไม่ใช่ข้อความย่อยทั้งก้อน เช่น `"abcข้อความcba".strip("abc")` จะตัด a, b และ c ทุกตัวที่อยู่ริมทั้งสองด้านโดยไม่สนลำดับ หากต้องการตัดคำนำหน้าหรือคำลงท้ายโดยเฉพาะ ให้ใช้ `removeprefix()` และ `removesuffix()` (ตั้งแต่ Python 3.9)

## เมธอดอื่นของสตริงที่มีประโยชน์

| เมธอด | หน้าที่ | ตัวอย่าง → ผลลัพธ์ |
| --- | --- | --- |

| `lower()`, `upper()` | เปลี่ยนตัวพิมพ์ | `"Latte".lower()` → `'latte'` |

| `startswith()`, `endswith()` | ตรวจจุดเริ่มและจุดจบ | `"a.csv".endswith(".csv")` → `True` |

| `find()` | ตำแหน่งของข้อความย่อย หรือ -1 | `"กาแฟ".find("แ")` → `2` |

| `count()` | จำนวนครั้งที่พบ | `"banana".count("a")` → `3` |

| `isdigit()` | เป็นตัวเลขล้วนหรือไม่ | `"250".isdigit()` → `True` |

| `zfill()` | เติมเลข 0 ด้านหน้า | `"7".zfill(3)` → `'007'` |

ตรวจว่าสตริงมีข้อความย่อยหรือไม่ ใช้ตัวดำเนินการ `in` ได้ง่ายที่สุด: `if "กาแฟ" in text.lower():` การเปรียบเทียบด้วย `==` ทำทีละอักขระและแยกตัวพิมพ์ หากต้องการเทียบโดยไม่สนตัวพิมพ์ ให้แปลงทั้งคู่ด้วย `casefold()` ก่อน

## การตัดสตริงด้วย slice

สตริงเป็นลำดับ จึงเข้าถึงอักขระด้วยดัชนีเริ่มจากศูนย์ได้ และดัชนีติดลบจะนับจากท้าย การตัด `s[start:stop:step]` คืนสตริงย่อย โดยขอบเขตด้านขวาไม่รวมอยู่ด้วย

```
s = "Python"
s[0]      # 'P'
s[-1]     # 'n'
s[0:3]    # 'Pyt'
s[2:]     # 'thon'
s[::2]    # 'Pto'
s[::-1]   # 'nohtyP' — กลับลำดับของสตริง
```

การ slice ไม่ทำให้เกิดข้อผิดพลาดเมื่อเกินขอบเขต: `s[0:100]` คืนสตริงทั้งหมด แต่ `s[100]` จะได้ `IndexError` และไม่สามารถแก้อักขระตามดัชนีได้ (`s[0] = "J"` ได้ `TypeError`) ต้องสร้างสตริงใหม่: `"J" + s[1:]`

## f-string ใน Python

ตัวอักษร `f` หน้าสตริงบอกว่า นิพจน์ในวงเล็บปีกกาจะถูกคำนวณและแทรกลงในข้อความ นี่คือวิธีจัดรูปแบบสตริงหลักตั้งแต่ Python 3.6 สั้นกว่า `format()` และเร็วกว่าตัวดำเนินการ `%` แบบเก่า

```
item = "กาแฟ"
price = 250
print(f"{item}: {price} บาท")            # กาแฟ: 250 บาท
print(f"หลังลดราคา: {price * 0.9} บาท")   # หลังลดราคา: 225.0 บาท
print(f"{item=}")                         # item='กาแฟ' — มีประโยชน์ตอนดีบัก
```

### การจัดรูปแบบตัวเลขและการจัดแนว

หลังเครื่องหมายโคลอนในวงเล็บปีกกาจะเขียนตัวระบุรูปแบบ (format spec) ซึ่งกำหนดการปัดเศษ ตัวคั่นหลัก ความกว้าง และการจัดแนว:

| รูปแบบ | ผลลัพธ์ | ความหมาย |
| --- | --- | --- |

| `f"{3.14159:.2f}"` | `3.14` | ปัดเศษเหลือ 2 ตำแหน่ง |

| `f"{1250000:,}"` | `1,250,000` | ตัวคั่นหลัก |

| `f"{1250000:_}"` | `1_250_000` | ใช้ขีดล่างแทนลูกน้ำ |

| `f"{0.256:.1%}"` | `25.6%` | เปอร์เซ็นต์ |

| `f"{'Latte':<10}|"` | `Latte |` | จัดชิดซ้าย ความกว้าง 10 |

| `f"{250:>8}"` | ` 250` | จัดชิดขวา |

| `f"{7:03d}"` | `007` | เติมเลข 0 ด้านหน้า |

การจัดแนวมีประโยชน์กับตารางในเทอร์มินัล เช่น `f"{name:<12}{amount:>10.2f}"` จะจัดคอลัมน์ให้ตรงกันพอดี ควรจำไว้ว่าการจัดรูปแบบทำเฉพาะตอนแสดงผล สำหรับเงินให้เก็บเป็นสตางค์ (`int`) หรือใช้ `Decimal` แทน `float`: `0.1 + 0.2` ได้ `0.30000000000000004`

### เครื่องหมายคำพูดและการขึ้นบรรทัดใหม่ในไม่ f-string

ตั้งแต่ Python 3.12 (PEP 701) f-string มีไวยากรณ์เป็นทางการ ภายในวงเล็บปีกกาสามารถใช้เครื่องหมายคำพูดชนิดเดียวกับภายนอก แบ็กสแลช และการขึ้นบรรทัดใหม่ได้ และการซ้อนกันไม่ถูกจำกัดอีกต่อไป ข้อผิดพลาดภายในวงเล็บจะแสดงตำแหน่งที่ชัดเจนขึ้น ในเวอร์ชันเก่า ให้ใช้เครื่องหมายคำพูดต่างชนิดภายในวงเล็บ เช่น `f"{d['key']}"` และการขึ้นบรรทัดใหม่ให้ผ่านตัวแปรแยกหรือ `chr(10)`

สำหรับข้อความหลายบรรทัดใช้ f-string ที่อยู่ในเครื่องหมายคำพูดสามชั้นได้: `f"""ยอดรวม: {total}\nจำนวนรายการ: {count}"""`

### format() และ % แบบเก่า

ในโค้ดเก่าอาจพบ `"{}: {}".format(item, price)` และ `"%s: %d" % (item, price)` ตัวระบุรูปแบบของ `format()` เหมือนกับของ f-string เมธอด `format()` ยังมีประโยชน์เมื่อเทมเพลตถูกเก็บแยกจากข้อมูล เช่น อยู่ในไฟล์คอนฟิก

## การแยกสตริง: ตัวอย่างจริง

มารวมเมธอดทั้งหมดในตัวอย่างเดียว สมมุติไฟล์ได้รับบรรทัดรูปแบบ `"  2026-10-16; กาแฟ ; 250,50 \n"` และต้องการวันที่ ชื่อรายการ และจำนวนเงินเป็นสตางค์ ขั้นตอนตามปกติคือ ตัดส่วนหัวท้าย แยกตามตัวคั่น ทำความสะอาดแต่ละส่วน แล้วแปลงชนิดข้อมูล

```
line = "  2026-10-16; กาแฟ ; 250,50 \n"

date, item, raw_amount = [p.strip() for p in line.strip().split(";")]
amount_kop = round(float(raw_amount.replace(",", ".")) * 100)

print(date, item, amount_kop)            # 2026-10-16 กาแฟ 25050
print(f"{item:10.2f}")
```

หากได้ส่วนที่ไม่ใช่สามส่วน การแยกค่า (unpacking) จะล้มเหลวด้วย `ValueError: not enough values to unpack` หรือ `too many values to unpack` ในโค้ดจริงควรตรวจสอบบรรทัดเหล่านี้ล่วงหน้า หรือดักจับข้อยกเว้น และสำหรับไฟล์ CSV จริงที่มีเครื่องหมายคำพูดและการหลบอักขระ ให้ใช้โมดูลมาตรฐาน `csv` แทน `split`

### ข้อผิดพลาดที่พบบ่อยกับสตริง

- **ไม่ได้เก็บผลลัพธ์ของเมธอด** `s.strip()` โดยไม่กำหนดค่ากลับไม่เปลี่ยนแปลงอะไรเลย
- **join กับลิสต์ของตัวเลข** ได้ `TypeError` ให้ใช้ `map(str, ...)` ก่อน
- **strip กับข้อความย่อย** อาร์กิวเมนต์คือชุดอักขระ สำหรับคำนำหน้าให้ใช้ `removeprefix()`
- **การเปรียบเทียบที่สนตัวพิมพ์** `"Latte" == "latte"` ได้ `False`
- **แบ็กสแลชในพาธ Windows** หากไม่มีคำนำหน้า `r` จะกลายเป็นอักขระพิเศษ

## t-string: เทมเพลตแทนข้อความสำเร็จรูป

Python 3.14 เพิ่ม t-string ซึ่งหน้าตาคล้าย f-string แต่ใช้คำนำหน้า `t` และผลลัพธ์ต่างออกไป ได้เป็นออบเจกต์ `string.templatelib.Template` ไม่ใช่สตริงสำเร็จรูป โดยส่วนข้อความ (`.strings`) และค่าที่แทรก (`.values`) จะถูกเก็บแยกกัน

```
name = ""
tpl = t"สวัสดี {name}!"
print(tpl.strings)   # ('สวัสดี ', '!')
print(tpl.values)    # ('',)
```

ประโยชน์คือไลบรารีได้รับค่าก่อนการต่อสตริง และสามารถประมวลผลได้ เช่น escape เครื่องหมาย < > สำหรับ HTML หรือส่งพารามิเตอร์เข้า SQL อย่างถูกต้อง f-string ไม่มีโอกาสนี้ เพราะต่อสตริงไปแล้วทั้งหมด สำหรับการแสดงผลธรรมดายังใช้ f-string ได้ตามเดิม

## สรุป

สำหรับงานสตริงประจำวันใน Python ใช้เครื่องมือไม่กี่ตัว: `split()` กับ `join()` แยกและรวมข้อความ `strip()` ทำความสะอาดข้อมูลที่รับเข้า `replace()` แทนที่ชิ้นส่วน การ slice ตัดข้อความย่อย และ f-string แสดงค่าตามรูปแบบที่ต้องการ จำไว้ว่าสตริงแก้ไขไม่ได้ เมธอดคืนสตริงใหม่ ซึ่งต้องเก็บผลลัพธ์ไว้ สตริง ตัวเลข และ f-string ถูกสาธิตผ่านโปรแกรมบันทึกค่าใช้จ่ายในบทเรียนของคอร์ส Python

## FAQ

**จะรู้ความยาวของสตริงใน Python ได้อย่างไร?**

ฟังก์ชัน len(s) คืนจำนวนอักขระ สำหรับภาษาไทยและอีโมจิจะนับเป็นอักขระ Unicode ไม่ใช่ไบต์ หากต้องการขนาดเป็นไบต์ใช้ len(s.encode("utf-8"))

**จะแปลงตัวเลขเป็นสตริงและกลับกันได้อย่างไร?**

str(250) ได้ '250' และ int("250") กับ float("2.5") ทำการแปลงกลับ หากสตริงไม่ใช่ตัวเลข int() จะเกิด ValueError ดังนั้นควรตรวจข้อมูลที่รับเข้า

**ทำไม replace ไม่เปลี่ยนสตริงของฉัน?**

สตริงแก้ไขไม่ได้ replace คืนสตริงใหม่ ให้กำหนดค่ากลับ: s = s.replace("a", "b")

**จะเช็กได้อย่างไรว่าสตริงว่างหรือไม่?**

สตริงว่างถือเป็นเท็จ จึงใช้ if not s: ได้ หากสตริงอาจมีแต่ช่องว่าง ให้ตรวจด้วย if not s.strip():

**t-string ต่างจาก f-string อย่างไร?**

f-string คืน str สำเร็จรูปทันที ส่วน t-string (Python 3.14 ขึ้นไป) คืนออบเจกต์ Template ที่เก็บส่วนข้อความและค่าแยกกัน ทำให้ escape ข้อมูลสำหรับ HTML และ SQL ได้อย่างปลอดภัย


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