re --- นิพจน์ทั่วไปแบบง่าย

โมดูลนี้ใช้งานการดำเนินการนิพจน์ทั่วไป ไวยากรณ์นิพจน์ทั่วไปที่รองรับเป็นส่วนหนึ่งของโมดูล re ของ CPython (และจริงๆ แล้วเป็นส่วนหนึ่งของนิพจน์ทั่วไปแบบขยาย POSIX)

ตัวดำเนินการและลำดับพิเศษที่รองรับมีดังนี้:

.

จับคู่อักขระใดก็ได้

[...]

จับคู่ชุดของอักขระ รองรับอักขระแต่ละตัวและช่วง รวมถึงชุดที่ถูกปฏิเสธ (เช่น [^a-c])

^

จับคู่จุดเริ่มต้นของสตริง

$

จับคู่จุดสิ้นสุดของสตริง

?

จับคู่รูปแบบย่อยก่อนหน้าศูนย์หรือหนึ่งครั้ง

*

จับคู่รูปแบบย่อยก่อนหน้าศูนย์หรือมากกว่าครั้ง

+

จับคู่รูปแบบย่อยก่อนหน้าหนึ่งครั้งหรือมากกว่า

??

เวอร์ชันที่ไม่โลภของ ? จับคู่ศูนย์หรือหนึ่งครั้ง โดยต้องการผลลัพธ์ศูนย์ก่อน

*?

เวอร์ชันที่ไม่โลภของ * จับคู่ศูนย์หรือมากกว่าครั้ง โดยต้องการผลลัพธ์ที่สั้นที่สุด

+?

เวอร์ชันที่ไม่โลภของ + จับคู่หนึ่งหรือมากกว่าครั้ง โดยต้องการผลลัพธ์ที่สั้นที่สุด

|

จับคู่รูปแบบย่อยทางซ้ายมือหรือทางขวามือของตัวดำเนินการนี้

(...)

การจัดกลุ่ม แต่ละกลุ่มจะถูกบันทึก (สตริงย่อยที่จับได้สามารถเข้าถึงได้ด้วยเมธอด match.group())

(?:...)

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

\d

จับคู่ตัวเลข เทียบเท่ากับ [0-9]

\D

จับคู่อักขระที่ไม่ใช่ตัวเลข เทียบเท่ากับ [^0-9]

\s

จับคู่ช่องว่าง เทียบเท่ากับ [ \t-\r]

\S

จับคู่อักขระที่ไม่ใช่ช่องว่าง เทียบเท่ากับ [^ \t-\r]

\w

จับคู่ "อักขระคำ" (ASCII เท่านั้น) เทียบเท่ากับ [A-Za-z0-9_]

\W

จับคู่อักขระที่ไม่ใช่ "อักขระคำ" (ASCII เท่านั้น) เทียบเท่ากับ [^A-Za-z0-9_]

\

อักขระหลีก อักขระอื่นๆ ที่ตามหลังแบ็กสแลช ยกเว้นอักขระที่ระบุไว้ข้างต้น จะถูกตีความตามตัวอักษร ตัวอย่างเช่น \* เทียบเท่ากับ * ตามตัวอักษร (ไม่ถือเป็นตัวดำเนินการ *) โปรดทราบว่า \r, \n ฯลฯ ไม่ได้รับการจัดการเป็นพิเศษ และจะเทียบเท่ากับตัวอักษร r, n ฯลฯ ด้วยเหตุนี้ จึงไม่แนะนำให้ใช้สตริง Python แบบ raw (r"") สำหรับนิพจน์ทั่วไป ตัวอย่างเช่น r"\r\n" เมื่อใช้เป็นนิพจน์ทั่วไปจะเทียบเท่ากับ "rn" หากต้องการจับคู่อักขระ CR ตามด้วย LF ให้ใช้ "\r\n"

ไม่รองรับ:

• การทำซ้ำแบบนับจำนวน ({m,n})

• กลุ่มที่มีชื่อ ((?P<name>...))

• การยืนยันขั้นสูงเพิ่มเติม (\b, \B)

• การหลีกอักขระพิเศษ เช่น \r, \n - ใช้การหลีกของ Python เองแทน

• ฯลฯ

ตัวอย่าง:

import re

# As re doesn't support escapes itself, use of r"" strings is not
# recommended.
regex = re.compile("[\r\n]")

regex.split("line1\rline2\nline3\r\n")

# Result:
# ['line1', 'line2', 'line3', '', '']

ฟังก์ชัน

re.compile(regex_str: str, flags: int = 0) → 'regex'

คอมไพล์นิพจน์ทั่วไป และคืนค่าออบเจ็กต์ regex

re.search(regex_str: str, string: str) → 'match | None'

คอมไพล์ regex_str และค้นหาใน string ต่างจาก match ตรงที่จะค้นหาในสตริงจากตำแหน่งแรกที่ตรงกับนิพจน์ทั่วไป (ซึ่งอาจเป็น 0 ก็ได้หากนิพจน์ทั่วไปมีการยึด)

re.sub(regex_str: str, replace: str | Callable, string: str, count: int = 0, flags: int = 0, /) → str

คอมไพล์ regex_str และค้นหาใน string โดยแทนที่การจับคู่ทั้งหมดด้วย replace แล้วคืนค่าสตริงใหม่

replace อาจเป็นสตริงหรือฟังก์ชัน หากเป็นสตริง สามารถใช้ลำดับหลีกในรูปแบบ \<number> และ \g<number> เพื่อขยายเป็นกลุ่มที่สอดคล้องกัน (หรือสตริงว่างสำหรับกลุ่มที่ไม่ตรง) หาก replace เป็นฟังก์ชัน จะต้องรับอาร์กิวเมนต์เดี่ยว (ผลการจับคู่) และควรคืนค่าสตริงแทนที่

หาก count ถูกระบุและไม่เป็นศูนย์ การแทนที่จะหยุดลงหลังจากทำการแทนที่ครบตามจำนวน อาร์กิวเมนต์ flags จะถูกละเว้น

ออบเจ็กต์ Regex

นิพจน์ทั่วไปที่คอมไพล์แล้ว อินสแตนซ์ของคลาสนี้สร้างโดยใช้ re.compile()

class re.regex

ออบเจ็กต์นิพจน์ทั่วไปที่คอมไพล์แล้ว ซึ่งคืนค่าโดย re.compile()

match(string: str, pos: int = 0, endpos: int | None = None) → 'match | None'

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

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

พารามิเตอร์ตัวเลือก endpos จำกัดระยะทางที่จะค้นหา string ราวกับว่าสตริงมีความยาว endpos อักขระ ดังนั้นจะค้นหาเฉพาะอักขระตั้งแต่ pos ถึง endpos - 1 เท่านั้น หาก endpos เป็น None (ค่าเริ่มต้น) จะค้นหาสตริงทั้งหมด

search(string: str, pos: int = 0, endpos: int | None = None) → 'match | None'

สแกนผ่าน string เพื่อหาตำแหน่งแรกที่นิพจน์ทั่วไปที่คอมไพล์แล้วนี้ให้ผลการจับคู่ และคืนค่าออบเจ็กต์ match หรือ None หากไม่มีตำแหน่งที่ตรง นี่คือตัวเทียบเท่าของรูปแบบที่คอมไพล์แล้วสำหรับฟังก์ชัน search() ระดับโมดูล และมีประสิทธิภาพสูงกว่ามากเมื่อใช้รูปแบบเดียวกันกับหลายสตริง

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

พารามิเตอร์ตัวเลือก endpos จำกัดระยะทางที่จะค้นหา string ราวกับว่าสตริงมีความยาว endpos อักขระ ดังนั้นจะค้นหาเฉพาะอักขระตั้งแต่ pos ถึง endpos - 1 เท่านั้น หาก endpos เป็น None (ค่าเริ่มต้น) จะค้นหาสตริงทั้งหมด

sub(replace: str | Callable, string: str, count: int = 0, flags: int = 0, /) → str

ค้นหานิพจน์ทั่วไปที่คอมไพล์แล้วนี้ใน string โดยแทนที่การจับคู่ทั้งหมดด้วย replace และคืนค่าสตริงใหม่ นี่คือตัวเทียบเท่าของรูปแบบที่คอมไพล์แล้วสำหรับฟังก์ชัน sub() ระดับโมดูล และมีประสิทธิภาพสูงกว่ามากเมื่อใช้รูปแบบเดียวกันกับหลายสตริง

replace อาจเป็นสตริงหรือฟังก์ชัน หากเป็นสตริง สามารถใช้ลำดับหลีกในรูปแบบ \<number> และ \g<number> เพื่อขยายเป็นกลุ่มที่สอดคล้องกัน (หรือสตริงว่างสำหรับกลุ่มที่ไม่ตรง) หาก replace เป็นฟังก์ชัน จะต้องรับอาร์กิวเมนต์เดี่ยว (ผลการจับคู่) และควรคืนค่าสตริงแทนที่

หาก count ถูกระบุและไม่เป็นศูนย์ การแทนที่จะหยุดลงหลังจากทำการแทนที่ครบตามจำนวน อาร์กิวเมนต์ flags จะถูกละเว้น

split(string: str, max_split: int = -1, /) → List[str]

แบ่ง string โดยใช้นิพจน์ทั่วไป หาก max_split ถูกระบุ จะกำหนดจำนวนสูงสุดของการแบ่งที่จะทำ คืนค่ารายการสตริง (อาจมีสูงสุด max_split+1 องค์ประกอบหากระบุไว้)

ออบเจ็กต์ผลการจับคู่

ออบเจ็กต์ผลการจับคู่เก็บผลลัพธ์ของการจับคู่ที่สำเร็จ

class re.match(regex_str: str, string: str)

จับคู่ regex_str กับ string โดยยึดที่จุดเริ่มต้นของสตริง และคืนค่าออบเจ็กต์ผลการจับคู่ หรือ None หากไม่ตรง นี่คือทางลัดระดับโมดูล: re.match(regex_str, string) เทียบเท่ากับ re.compile(regex_str).match(string)

ออบเจ็กต์ผลการจับคู่เดียวกันนี้ยังถูกคืนค่าโดย search() โดยเมธอด regex.match() / regex.search() ของรูปแบบที่คอมไพล์แล้ว และถูกส่งผ่านไปยังฟังก์ชันแทนที่ที่ใช้โดย sub()

group(index: int) → str

คืนค่าสตริง (ย่อย) ที่จับคู่ index เป็น 0 สำหรับการจับคู่ทั้งหมด 1 และสูงกว่าสำหรับแต่ละกลุ่มที่บันทึก รองรับเฉพาะกลุ่มตัวเลขเท่านั้น