สตริงใน Python: สร้าง เข้าถึง ตัดช่วง และจัดการข้อความ

เริ่มต้น25 นาที7 แบบฝึกหัด135 XP

บทเรียนนี้แปลจากต้นฉบับภาษาอังกฤษRead in English Leer en español Читать на русском Ler em português แจ้งข้อผิดพลาดในการแปล

ก่อนเริ่มเรียน

ตัวเลขใน Python: จำนวนเต็ม ทศนิยม และคณิตศาสตร์ที่ใช้จริง

0/7 แบบฝึกหัด

ลองนึกถึงโทรศัพท์ของคุณ เกือบทุกอย่างที่เห็นบนหน้าจอคือข้อความ ทั้งชื่อในรายชื่อติดต่อ ข้อความจากเพื่อน ผลการค้นหา และการแจ้งเตือน เบื้องหลังข้อความทั้งหมดนั้นจัดการด้วยสตริง

สตริง (string) คือวิธีที่ Python ใช้เก็บและทำงานกับข้อความ อาจเป็นตัวอักษรตัวเดียว ประโยคเต็ม ๆ หรือแม้แต่หนังสือทั้งเล่ม ถ้าเป็นข้อความ ก็คือสตริง

ในบทเรียนนี้ คุณจะได้เรียนรู้วิธีสร้างสตริง ดึงอักขระที่ต้องการออกมา ตัดสตริงเป็นช่วง ต่อสตริงเข้าด้วยกัน และตรวจดูว่ามีอะไรอยู่ข้างใน ทักษะเหล่านี้จะได้ใช้ในแทบทุกโปรแกรม Python ที่คุณเขียน

สตริงใน Python คืออะไร

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

ลองนึกภาพสตริงเป็นสร้อยลูกปัด ลูกปัดแต่ละเม็ดคืออักขระหนึ่งตัว ส่วนเครื่องหมายคำพูดคือตะขอที่ยึดสร้อยไว้ด้วยกัน

สามวิธีในการสร้างสตริง

# Single quotes

greeting = 'Hello, world!'

print(greeting) # Hello, world!

# Double quotes - exactly the same

greeting = "Hello, world!"

print(greeting) # Hello, world!

# Triple quotes - for multi-line text

poem = """Roses are red,

Violets are blue,

Python is awesome,

And so are you."""

print(poem)

ผลลัพธ์

Hello, world!
Hello, world!
Roses are red,
Violets are blue,
Python is awesome,
And so are you.

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

ใช้เครื่องหมายคำพูดต่างชนิดกัน

# Use double quotes when your text has single quotes

message = "It's a beautiful day"

print(message)

# Use single quotes when your text has double quotes

html = '<div class="container">Hello</div>'

print(html)

ผลลัพธ์

It's a beautiful day
<div class="container">Hello</div>

แม้แต่เครื่องหมายคำพูดเปล่า ๆ หนึ่งคู่ก็สร้างสตริงได้ สตริงว่าง (empty string) มีอักขระ 0 ตัว แต่ก็ยังเป็นสตริงที่ถูกต้อง

สตริงว่างกับสตริงที่มีช่องว่าง

empty = ""

print(type(empty)) # <class 'str'>

print(len(empty)) # 0

# A string with just a space is NOT empty

space = " "

print(len(space)) # 1

ผลลัพธ์

<class 'str'>
0
1

จะเข้าถึงอักขระแต่ละตัวในสตริงได้อย่างไร

อักขระทุกตัวในสตริงมีหมายเลขตำแหน่งที่เรียกว่า ดัชนี (index) คุณดึงอักขระตัวใดก็ได้ออกมาโดยใส่ดัชนีของอักขระนั้นไว้ในวงเล็บเหลี่ยม

ส่วนที่สำคัญคือ Python เริ่มนับจาก 0 ไม่ใช่ 1 อักขระตัวแรกอยู่ที่ดัชนี 0 ตัวที่สองอยู่ที่ดัชนี 1 ไปเรื่อย ๆ แบบนี้เรียกว่าการนับดัชนีเริ่มจากศูนย์ (zero-based indexing)

เข้าถึงอักขระด้วยดัชนีบวก

word = "Python"

# Positive indexing (left to right)

# P y t h o n

# 0 1 2 3 4 5

print(word[0]) # P - first character

print(word[1]) # y - second character

print(word[5]) # n - last character

ผลลัพธ์

P
y
n

ลองนึกถึงดัชนีของสตริงเหมือนบ้านเลขที่บนถนน บ้านหลังแรกคือเลขที่ 0 ไม่ใช่เลขที่ 1 ช่วงแรกอาจรู้สึกแปลก แต่จะชินได้เร็ว

ดัชนีติดลบใน Python คืออะไร

Python ยังให้นับถอยหลังจากท้ายสตริงได้ด้วย ดัชนีติดลบ (negative index) อักขระตัวสุดท้ายอยู่ที่ดัชนี -1 ตัวรองสุดท้ายอยู่ที่ -2 ไปเรื่อย ๆ

เข้าถึงอักขระด้วยดัชนีติดลบ

word = "Python"

# Negative indexing (right to left)

# P y t h o n

# -6 -5 -4 -3 -2 -1

print(word[-1]) # n - last character

print(word[-2]) # o - second to last

print(word[-6]) # P - first character

ผลลัพธ์

n
o
P

การตัดช่วงสตริงใน Python ทำงานอย่างไร

การใช้ดัชนีดึงอักขระออกมาหนึ่งตัว ส่วน การตัดช่วง (slicing) ดึงอักขระออกมาเป็นช่วง เหมือนการตัดขนมปังชิ้นหนึ่งออกจากกลางก้อน

รูปแบบคือ string[start:stop] ซึ่งดึงอักขระตั้งแต่ start ไปจนถึง (แต่ ไม่รวม) stop กฎ "ไปจนถึงแต่ไม่รวม" นี้เป็นหนึ่งในเรื่องที่สำคัญที่สุดที่ต้องจำ

การตัดช่วงสตริงขั้นพื้นฐาน

text = "Hello, World!"

# text[start:stop] - includes start, excludes stop

print(text[0:5]) # Hello - characters 0,1,2,3,4

print(text[7:12]) # World - characters 7,8,9,10,11

print(text[0:1]) # H - just one character

ผลลัพธ์

Hello
World
H

คุณละค่า start หรือ stop ไว้ได้ ถ้าไม่ใส่ start Python จะเริ่มจากต้นสตริง ถ้าไม่ใส่ stop Python จะไปจนสุดท้ายสตริง

ทางลัดในการตัดช่วง

text = "Hello, World!"

print(text[:5]) # Hello - from the beginning up to (not including) index 5

print(text[7:]) # World! - from index 7 to the end

print(text[:]) # Hello, World! - the whole string

ผลลัพธ์

Hello
World!
Hello, World!

พารามิเตอร์ step ในการตัดช่วงทำงานอย่างไร

ยังมีตัวเลขตัวที่สามที่ใส่เพิ่มได้ คือ string[start:stop:step] โดย step กำหนดว่าจะกระโดดจากอักขระหนึ่งไปยังตัวถัดไปไกลเท่าไร ค่า step เป็น 2 จะดึงอักขระแบบเว้นหนึ่งตัว

การตัดช่วงแบบมี step

text = "abcdefghij"

# Every other character

print(text[::2]) # acegi - step of 2

# Every third character

print(text[::3]) # adgj - step of 3

# Slice and step together

print(text[1:8:2]) # bdfh - start at 1, stop before 8, step 2

ผลลัพธ์

acegi
adgj
bdfh

การใช้ step ที่รู้จักกันมากที่สุดคือ การกลับลำดับสตริง ค่า step เป็น -1 จะเดินถอยหลังผ่านสตริงทั้งหมด

กลับลำดับสตริงด้วย [::-1]

word = "Python"

# Reverse a string with [::-1]

print(word[::-1]) # nohtyP

# This works on any string

print("racecar"[::-1]) # racecar - a palindrome!

ผลลัพธ์

nohtyP
racecar

จะรวมสตริงใน Python ได้อย่างไร

การต่อสตริง (concatenation) คือการนำสตริงมาเชื่อมกัน ใน Python ใช้ตัวดำเนินการ + เหมือนการต่อตัวต่อเลโก้สองชิ้นเข้าด้วยกันให้ยาวขึ้น

เชื่อมสตริงด้วย +

first_name = "Ada"

last_name = "Lovelace"

# Concatenation with +

full_name = first_name + " " + last_name

print(full_name) # Ada Lovelace

# You can chain as many as you want

greeting = "Hello" + ", " + "world" + "!"

print(greeting) # Hello, world!

ผลลัพธ์

Ada Lovelace
Hello, world!

การทำซ้ำ (repetition) ใช้ตัวดำเนินการ * เพื่อทำซ้ำสตริงตามจำนวนครั้งที่กำหนด มีประโยชน์เกินคาดสำหรับการสร้างเส้นคั่น ลวดลาย หรือการเติมช่องว่าง

ทำซ้ำสตริงด้วย *

# Repeat a string with *

print("Ha" * 3) # HaHaHa

print("-" * 30) # ------------------------------

print("abc " * 4) # abc abc abc abc

# Great for creating visual separators

title = "My Report"

print(title)

print("=" * len(title)) # =========

ผลลัพธ์

HaHaHa
------------------------------
abc abc abc abc 
My Report
=========

จะหาความยาวของสตริงได้อย่างไร

ฟังก์ชัน len() บอกว่าในสตริงมีอักขระกี่ตัว โดยนับรวมตัวอักษร ตัวเลข ช่องว่าง และอักขระพิเศษ ทุกอักขระถูกนับหมด

วัดความยาวของสตริง

message = "Hello, World!"

print(len(message)) # 13

# Spaces count!

print(len("a b c")) # 5 - three letters + two spaces

# Empty string has length 0

print(len("")) # 0

# Common use: get the last index

word = "Python"

last_index = len(word) - 1

print(word[last_index]) # n

ผลลัพธ์

จะตรวจว่ามีข้อความอยู่ในสตริงหรือไม่ได้อย่างไร

ตัวดำเนินการ in ตรวจว่าสตริงหนึ่งปรากฏอยู่ในอีกสตริงหนึ่งหรือไม่ และคืนค่า True หรือ False เหมือนการกด Ctrl+F เพื่อค้นหาคำในเอกสาร

ค้นหาด้วยตัวดำเนินการ in

sentence = "The quick brown fox jumps over the lazy dog"

# Check if a word is in the sentence

print("fox" in sentence) # True

print("cat" in sentence) # False

print("quick" in sentence) # True

# Check if something is NOT in the string

print("cat" not in sentence) # True

ผลลัพธ์

True
False
True
True

จัดการเรื่องตัวพิมพ์เล็กและใหญ่เมื่อใช้ in

# Case-sensitive gotcha

text = "Hello World"

print("hello" in text) # False - wrong case!

print("hello" in text.lower()) # True - convert to lowercase first

# Practical example: checking user input

user_answer = "Yes"

if "yes" in user_answer.lower():

print("User said yes!")

ผลลัพธ์

False
True
User said yes!

อักขระ escape ในสตริงของ Python คืออะไร

อักขระบางตัวพิมพ์ลงไปในสตริงตรง ๆ ไม่ได้ จะใส่การขึ้นบรรทัดใหม่ในสตริงได้อย่างไร หรือจะใส่แท็บอย่างไร คำตอบคือใช้ อักขระ escape (escape character) ซึ่งเป็นลำดับอักขระพิเศษที่ขึ้นต้นด้วยแบ็กสแลช \

อักขระ escape ที่ใช้บ่อย

# \n - new line

print("Line 1\nLine 2\nLine 3")

# \t - tab

print("Name\tAge\tCity")

print("Alice\t25\tParis")

print("Bob\t30\tTokyo")

# \\ - literal backslash

print("File path: C:\\Users\\Documents")

# \" or \' - quote inside a string

print("She said \"hello\"")

ผลลัพธ์

Line 1
Line 2
Line 3
Name	Age	City
Alice	25	Paris
Bob	30	Tokyo
File path: C:\Users\Documents
She said "hello"

ตารางสรุปอักขระ escape ที่จะได้ใช้บ่อยที่สุด:

Escape	ใช้ทำอะไร	ตัวอย่างผลลัพธ์
`\n`	ขึ้นบรรทัดใหม่	ข้อความอยู่บนบรรทัดใหม่
`\t`	แท็บ	เพิ่มระยะเว้นแบบแท็บ
`\\`	แบ็กสแลช	แสดง `\` หนึ่งตัว
`\"`	เครื่องหมายคำพูดคู่	แสดง `"` ภายในสตริงที่ใช้ `"`
`\'`	เครื่องหมายคำพูดเดี่ยว	แสดง `'` ภายในสตริงที่ใช้ `'`

ทำไมจึงเปลี่ยนอักขระในสตริงของ Python ไม่ได้

สตริงใน Python เปลี่ยนแปลงไม่ได้ (immutable) หมายความว่าเมื่อสร้างสตริงแล้ว จะเปลี่ยนอักขระตัวใดในนั้นไม่ได้เลย จะสลับตัวอักษรหรือแก้คำที่พิมพ์ผิดในสตริงที่มีอยู่แล้วก็ไม่ได้

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

สตริงแก้ไขในที่เดิมไม่ได้

word = "Hello"

# This will CRASH with a TypeError

try:

word[0] = "J" # Can't change individual characters!

except TypeError as e:

print(f"Error: {e}")

ผลลัพธ์

Error: 'str' object does not support item assignment

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

ใช้ไม่ได้: แก้ไขสตริงในที่เดิม

word = "Hello"
word[0] = "J"  # TypeError!

ใช้ได้: สร้างสตริงใหม่

word = "Hello"
new_word = "J" + word[1:]
print(new_word)  # Jello

แบบฝึกหัด

ถึงเวลาฝึกแล้ว แบบฝึกหัดเหล่านี้ครอบคลุมทุกเรื่องในบทเรียนนี้ เริ่มจากข้อง่ายแล้วค่อย ๆ ยากขึ้น

ลองทำแต่ละข้อก่อนดูคำใบ้ การทำผิดและการอ่านข้อความแจ้งข้อผิดพลาดคือวิธีที่ทำให้เรียนรู้ได้จริง

แบบฝึกหัดที่ 1: สร้างคำทักทายด้วยการต่อสตริง

เขียนโค้ด

มีตัวแปรให้สองตัว คือ first_name ที่มีค่าเป็น "Ada" และ last_name ที่มีค่าเป็น "Lovelace" ให้สร้างตัวแปรชื่อ greeting ที่รวมทั้งสองเป็นข้อความ แล้วแสดงผลออกมา

ผลลัพธ์ที่ต้องการ:

Hello, Ada Lovelace! Welcome to Python.

ใช้การต่อสตริง (+) เพื่อสร้างคำทักทาย

first_name = "Ada"

last_name = "Lovelace"

# Create the greeting using concatenation (+)

# Print the greeting

แบบฝึกหัดที่ 2: หาอักขระตัวแรกและตัวสุดท้าย

เขียนโค้ด

มีตัวแปร word ที่มีค่าเป็น "Programming" ให้แสดงอักขระตัวแรกและตัวสุดท้ายคนละบรรทัด

ผลลัพธ์ที่ต้องการ:

P
g

ใช้ดัชนีของสตริงเพื่อเข้าถึงอักขระแต่ละตัว

word = "Programming"

# Print the first character

# Print the last character

แบบฝึกหัดที่ 3: กลับลำดับสตริง

เขียนโค้ด

มีตัวแปร text ที่มีค่าเป็น "Python" ให้แสดงสตริงนี้แบบกลับลำดับ

ผลลัพธ์ที่ต้องการ:

nohtyP

ใช้การตัดช่วงเพื่อกลับลำดับในขั้นตอนเดียว

text = "Python"

# Print the reversed string using slicing

แบบฝึกหัดที่ 4: ทายผลลัพธ์ของการตัดช่วง

ทายผลลัพธ์

โดยยังไม่รันโค้ด ให้ทายว่าแต่ละบรรทัดจะแสดงอะไร อย่าลืมว่าการตัดช่วงใช้ [start:stop] โดย stop ไม่ถูกรวม

เขียนคำทายของคุณเป็นคอมเมนต์ แล้วรันโค้ดเพื่อตรวจดู

word = "Hello"

print(word[1:4]) # Your prediction:

print(word[:3]) # Your prediction:

print(word[2:]) # Your prediction:

แบบฝึกหัดที่ 5: แก้บั๊ก: การแก้ไขสตริงโดยตรง

แก้บั๊ก

โค้ดนี้พยายามแก้คำที่พิมพ์ผิดโดยเปลี่ยนอักขระโดยตรง แต่สตริงเปลี่ยนแปลงไม่ได้ โปรแกรมจึงหยุดทำงานพร้อมข้อผิดพลาด

แก้โค้ดให้แสดงผล:

Hello World

สร้างสตริง ใหม่ แทนการแก้ไขสตริงเดิม

message = "Hello Wurld"

# Fix the typo: change "u" to "o"

message[7] = "o"

print(message)

แบบฝึกหัดที่ 6: ตรวจว่ามีคำนี้อยู่ในประโยคหรือไม่

เขียนโค้ด

มี sentence และ search_word ให้ ตรวจว่าคำที่ค้นหามีอยู่ในประโยคหรือไม่ (แบบไม่สนตัวพิมพ์เล็กหรือใหญ่) แล้วแสดงผลลัพธ์

ผลลัพธ์ที่ต้องการ:

True

แปลงทั้งสองให้เป็นตัวพิมพ์แบบเดียวกันก่อนตรวจ

sentence = "The quick brown Fox jumps over the lazy Dog"

search_word = "fox"

# Check if search_word is in sentence (case-insensitive)

# Print True or False

แบบฝึกหัดที่ 7: ดึงชื่อโดเมนจากที่อยู่อีเมล

เขียนโค้ด

มีที่อยู่อีเมลเก็บไว้ใน email ให้ดึงเฉพาะ ชื่อโดเมน (ส่วนที่อยู่หลังสัญลักษณ์ @) แล้วแสดงผลออกมา

ผลลัพธ์ที่ต้องการ:

gmail.com

ใช้เมธอด .find() หาตำแหน่งของสัญลักษณ์ @ แล้วใช้การตัดช่วงดึงทุกอย่างที่อยู่หลังสัญลักษณ์นั้นออกมา

email = "alice@gmail.com"

# Find the position of the @ symbol

# Slice the string to get the domain

# Print the domain

สรุป: สตริงใน Python

ตารางสรุปทุกเรื่องที่ได้เรียนรู้:

แนวคิด	รูปแบบ	ตัวอย่าง
สร้างสตริง	`"text"` หรือ `'text'`	`name = "Alice"`
ดัชนี	`string[i]`	`"Hello"[0]` ได้ `"H"`
ดัชนีติดลบ	`string[-i]`	`"Hello"[-1]` ได้ `"o"`
การตัดช่วง	`string[start:stop]`	`"Hello"[1:4]` ได้ `"ell"`
การตัดช่วงแบบมี step	`string[::step]`	`"Hello"[::-1]` ได้ `"olleH"`
การต่อสตริง	`+`	`"Hi" + " there"` ได้ `"Hi there"`
การทำซ้ำ	`*`	`"Ha" * 3` ได้ `"HaHaHa"`
ความยาว	`len(string)`	`len("Hello")` ได้ `5`
การตรวจว่าอยู่ในสตริงหรือไม่	`in`	`"fox" in "a fox"` ได้ `True`
อักขระ escape	`\n`, `\t`, `\\`	อักขระพิเศษในสตริง

สิ่งสำคัญที่ต้องจำ: สตริง เปลี่ยนแปลงไม่ได้ คุณอ่านอักขระ ตัดช่วง ค้นหา และรวมสตริงได้ แต่จะเปลี่ยนสตริงในที่เดิมไม่ได้เลย ทุก "การเปลี่ยนแปลง" คือการสร้างสตริงใหม่ขึ้นมา

เรียนอะไรต่อ

ตอนนี้คุณสร้างและตัดช่วงสตริงได้แล้ว ถึงเวลาเรียนวิธีแปลงสตริง ในบทเรียนถัดไป เมธอดของสตริงใน Python คุณจะได้รู้จักเมธอดในตัว (built-in) เช่น .upper(), .replace(), .split() และ .strip() ที่ทำให้การทำงานกับข้อความเป็นเรื่องง่าย

สตริงใน Python คืออะไร

จะเข้าถึงอักขระแต่ละตัวในสตริงได้อย่างไร

ดัชนีติดลบใน Python คืออะไร

การตัดช่วงสตริงใน Python ทำงานอย่างไร

พารามิเตอร์ step ในการตัดช่วงทำงานอย่างไร

จะรวมสตริงใน Python ได้อย่างไร

จะหาความยาวของสตริงได้อย่างไร

จะตรวจว่ามีข้อความอยู่ในสตริงหรือไม่ได้อย่างไร

อักขระ escape ในสตริงของ Python คืออะไร

ทำไมจึงเปลี่ยนอักขระในสตริงของ Python ไม่ได้

แบบฝึกหัด

สรุป: สตริงใน Python

เรียนอะไรต่อ

บทเรียนที่เกี่ยวข้อง