Articles
แนะนำ Python
การใช้งาน Regular Expressions ในภาษา Python

การใช้งาน Regular Expressions ในภาษา Python

บทความนี้อธิบายเกี่ยวกับการใช้งาน Regular Expressions ในภาษา Python

เราจะครอบคลุมหัวข้อต่างๆ ตั้งแต่การใช้งานเบื้องต้นของโมดูล re ไปจนถึงการจับคู่รูปแบบ Regular Expressions ที่ซับซ้อน

YouTube Video

การใช้งาน Regular Expressions ในภาษา Python

โมดูล re ใช้สำหรับการค้นหาและจัดการสตริงโดยใช้นิพจน์ปกติ

โมดูล re คืออะไร?

โมดูล re ถูกบรรจุในไลบรารีมาตรฐานของ Python และมีฟังก์ชันสำหรับจัดการสตริงด้วย Regular Expressions Regular Expressions ถูกใช้เพื่อค้นหา ดึงข้อมูล หรือแทนที่รูปแบบสตริงเฉพาะอย่างมีประสิทธิภาพ

รูปแบบ Regular Expressions เบื้องต้น

Regular Expressions กำหนดรูปแบบโดยใช้สัญลักษณ์พิเศษ ด้านล่างเป็นรูปแบบพื้นฐานบางส่วน

  • .: ตัวอักษรใดๆ หนึ่งตัว
  • ^: จุดเริ่มต้นของสตริง
  • $: จุดสิ้นสุดของสตริง
  • \d: ตัวเลขใดๆ (0-9)
  • \w: ตัวอักษรในคำ (a-z, A-Z, 0-9, _)
  • \s: อักขระช่องว่างใดๆ
  • *: การทำซ้ำตั้งแต่ศูนย์ครั้งขึ้นไป
  • +: การทำซ้ำตั้งแต่หนึ่งครั้งขึ้นไป
  • []: กลุ่มตัวอักษร (เช่น [a-z] จะตรงกับตัวอักษรตัวพิมพ์เล็ก)
 1import re
 2
 3pattern = r"\d{3}-\d{4}"
 4text = "My postal code is 123-4567."
 5result = re.search(pattern, text)
 6if result:
 7    print(result.group())  # Output: 123-4567
 8
 9# Define a pattern using basic regular expression symbols
10pattern = r"^\w+\s\d+\s[a-zA-Z]+$"
11
12# Example text to test the pattern
13text = "Room 23 Tokyo"
14
15# Check if the pattern matches the text
16result = re.match(pattern, text)
17if result:
18    print("Matched:", result.group())
19else:
20    print("No match")
  • โค้ดนี้จะตรวจสอบก่อนว่าข้อความตรงกับรูปแบบรหัสไปรษณีย์หรือไม่ ต่อมาจะตรวจสอบว่าข้อความทั้งหมด (ตั้งแต่ต้นจนจบ) ตรงกับรูปแบบที่ประกอบด้วย คำ ช่องว่าง ตัวเลข ช่องว่าง และคำภาษาอังกฤษ หรือไม่ สิ่งนี้ช่วยให้คุณเข้าใจว่าส่วนประกอบพื้นฐานของเรกูลาร์เอ็กซ์เพรสชันสามารถนำมาผสมกันได้อย่างไร

วิธีการใช้ฟังก์ชันสำหรับการจับคู่

re.match()

re.match() ตรวจสอบว่าส่วนเริ่มต้นของสตริงตรงกับรูปแบบที่ระบุหรือไม่

1import re
2
3pattern = r"\w+"
4text = "Python is powerful"
5match = re.match(pattern, text)
6if match:
7    print(match.group())  # Output: Python
  • โค้ดนี้ตรวจสอบว่าข้อความเริ่มต้นด้วยอักขระคำ (ตัวอักษร-ตัวเลข หรือขีดล่าง) หรือไม่ คำแรก 'Python' ตรงกับแพตเทิร์นและถูกแสดงผล

re.search()

re.search() สแกนข้อความทั้งหมดและคืนค่าการจับคู่แรก

1import re
2
3pattern = r"powerful"
4text = "Python is powerful and versatile"
5search = re.search(pattern, text)
6if search:
7    print(search.group())  # Output: powerful
  • โค้ดนี้ค้นหาคำว่า 'powerful' ทั่วทั้งสตริงและส่งคืนผลที่พบครั้งแรก ดังนั้น re.search() จึงคืนค่าสตริงที่ตรงกันคือ 'powerful'

re.findall()

re.findall() คืนค่าการจับคู่ทั้งหมดของรูปแบบในรูปแบบของลิสต์

1import re
2
3pattern = r"\b\w{6}\b"
4text = "Python is powerful and versatile"
5matches = re.findall(pattern, text)
6print(matches)  # Output: ['Python', 'strong']
  • โค้ดนี้ค้นหาคำทั้งหมดที่มีความยาวหกอักขระพอดี และส่งคืนเป็นลิสต์ 'Python' ในสตริงตรงตามเงื่อนไข และได้ผลลัพธ์เป็นลิสต์ ['Python']

re.finditer()

re.finditer() คืนค่าการจับคู่ทั้งหมดในรูปแบบของอิเทอเรเตอร์ ช่วยให้คุณสามารถดึงข้อมูลรายละเอียดสำหรับการจับคู่แต่ละครั้ง

1import re
2
3pattern = r"\b\w{6}\b"
4text = "Python is powerful and versatile"
5matches = re.finditer(pattern, text)
6for match in matches:
7    print(match.group())  # Output: Python
  • โค้ดนี้ค้นหาคำที่มีความยาวหกอักขระทั้งหมดแบบต่อเนื่อง และประมวลผลแต่ละรายการที่ตรงผ่านตัววนซ้ำ 'Python' ตรงกับแพตเทิร์นที่นี่และถูกแสดงผล

การแทนที่และการแยกส่วน

re.sub()

re.sub() แทนที่ส่วนของสตริงที่ตรงกับนิพจน์ปกติด้วยสตริงอื่น

1import re
2
3pattern = r"\d+"
4text = "There are 100 apples"
5new_text = re.sub(pattern, "many", text)
6print(new_text)  # Output: There are many apples
  • โค้ดนี้แทนที่ตัวเลขทั้งหมดในสตริงด้วยคำว่า 'many'

re.split()

re.split() แยกสตริงที่ตรงกับนิพจน์ปกติ

1import re
2
3pattern = r"\s+"
4text = "Python is powerful"
5parts = re.split(pattern, text)
6print(parts)  # Output: ['Python', 'is', 'powerful']
  • โค้ดนี้แยกสตริงโดยใช้ช่องว่างหนึ่งตัวหรือมากกว่านั้นเป็นตัวแบ่ง ผลลัพธ์คือสตริงถูกแยกเป็นคำ ได้ ['Python', 'is', 'powerful']

กลุ่มและการจับค่าที่ตรงกัน

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

1import re
2
3pattern = r"(\d{3})-(\d{4})"
4text = "My postal code is 123-4567."
5match = re.search(pattern, text)
6if match:
7    print(match.group(1))  # Output: 123
8    print(match.group(2))  # Output: 4567
  • โค้ดนี้ดึงตัวเลข 3 หลักและ 4 หลักออกมาเป็นกลุ่มแยกกันจากรหัสไปรษณีย์รูปแบบ '123-4567' group(1) คืนค่าสามหลักแรก '123' และ group(2) คืนค่าสี่หลักสุดท้าย '4567'

กลุ่มแบบมีชื่อ

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

1import re
2
3log = "2025-10-25 14:00:01 [ERROR] Something failed"
4
5pattern = r"(?P<date>\d{4}-\d{2}-\d{2}) (?P<time>\d{2}:\d{2}:\d{2}) \[(?P<level>[A-Z]+)\] (?P<msg>.*)"
6m = re.search(pattern, log)
7if m:
8    print(m.group("date"), m.group("time"), m.group("level"))
9    print("message:", m.group("msg"))
  • โค้ดนี้ใช้กลุ่มแบบมีชื่อเพื่อดึงวันที่ เวลา ระดับ และข้อความจากสตริงล็อก มันดึงค่าต่างๆ โดยใช้ชื่อที่มีความหมายแทนการใช้ดัชนี

การใช้ตัวเลือกธง (Flag Options)

โมดูล re มีตัวเลือกธงหลายตัวเพื่อควบคุมพฤติกรรมการค้นหา

  • re.IGNORECASE (re.I): ตัวเลือกธงที่ทำให้การจับคู่ไม่สนใจตัวพิมพ์เล็กใหญ่
  • re.MULTILINE (re.M): ตัวเลือกธงที่เปิดใช้งานการจับคู่ในหลายบรรทัด
  • re.DOTALL (re.S): ตัวเลือกธงที่ทำให้จุด . จับคู่อักขระขึ้นบรรทัดใหม่ได้ด้วย
1import re
2
3pattern = r"python"
4text = "Python is powerful"
5match = re.search(pattern, text, re.IGNORECASE)
6if match:
7    print(match.group())  # Output: Python
  • โค้ดนี้ค้นหาคำว่า 'python' โดยไม่คำนึงถึงตัวพิมพ์ใหญ่เล็ก ด้วยการใช้แฟล็ก re.IGNORECASE จึงตรงกับ 'Python' ได้เช่นกัน

ข้อดีของออบเจ็กต์เรกูลาร์เอ็กซ์เพรสชัน (re.compile)

การคอมไพล์แพตเทิร์นด้วย re.compile ทำให้การใช้งานซ้ำมีประสิทธิภาพมากขึ้นและช่วยให้อ่านโค้ดได้ง่ายขึ้น คุณยังสามารถกำหนดแฟล็กได้ที่นี่ด้วย

ตัวอย่างต่อไปนี้ค้นหาการจับคู่ซ้ำๆ ข้ามหลายบรรทัดโดยใช้แพตเทิร์นที่คอมไพล์แล้ว หากคุณใช้แพตเทิร์นเดียวกันบ่อยๆ การคอมไพล์ด้วย re.compile จะช่วยเพิ่มประสิทธิภาพ

1import re
2
3pattern = re.compile(r"User: (\w+), ID: (\d+)")
4text = "User: alice, ID: 1\nUser: bob, ID: 2"
5
6for m in pattern.finditer(text):
7    print(m.groups())
  • โค้ดนี้ใช้เรกูลาร์เอ็กซ์เพรสชันที่คอมไพล์แล้วเพื่อดึงชื่อผู้ใช้และรหัสจากหลายบรรทัด re.compile ช่วยเพิ่มประสิทธิภาพเมื่อใช้แพตเทิร์นเดิมซ้ำ และยังทำให้โค้ดอ่านง่ายขึ้นด้วย

การใช้งาน

ตัวอย่างเช่น พิจารณาสคริปต์ที่ดึงที่อยู่อีเมลทั้งหมดจากไฟล์ข้อความ

1import re
2
3pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
4text = "Contact us at info@example.com or support@service.com."
5emails = re.findall(pattern, text)
6print(emails)  # Output: ['info@example.com', 'support@service.com']
  • โค้ดนี้ค้นหาที่อยู่อีเมลทั้งหมดในสตริงและดึงออกมาเป็นลิสต์

สรุป

โมดูล re เป็นเครื่องมือที่ทรงพลังสำหรับการจัดการสตริงในภาษา Python ที่นี่ เราได้ครอบคลุมตั้งแต่การใช้งานพื้นฐานไปจนถึงนิพจน์ปกติขั้นสูงโดยใช้การจัดกลุ่มและตัวเลือกธง Regular Expressions ใน Python มีความทรงพลังมากและเป็นเครื่องมือสำคัญสำหรับการประมวลผลข้อความ

คุณสามารถติดตามบทความข้างต้นโดยใช้ Visual Studio Code บนช่อง YouTube ของเรา กรุณาตรวจสอบช่อง YouTube ด้วย

YouTube Video

โมดูล `copy` ของ Pythonการทำงานกับไฟล์ใน Python