Mga Regular Expression sa Python

Ipinaliwanag ng artikulong ito ang mga regular expression sa Python.

Tatalakayin natin ang malawak na saklaw ng mga paksa, mula sa pangunahing paggamit ng re module hanggang sa masalimuot na pattern matching ng regular expression.

YouTube Video

Mga Regular Expression sa Python

Ang re module ay ginagamit para sa paghahanap at pag-manipulate ng mga string gamit ang regular na mga ekspresyon.

Ano ang re module?

Ang re module ay kasama sa standard library ng Python at nagbibigay ng functionality para sa pagmanipula ng mga string gamit ang mga regular expression. Ginagamit ang mga regular expression upang mahusay na mahanap, makuha, o mapalitan ang mga partikular na pattern ng string.

Mga Pangunahing Pattern ng Regular Expression

Ang mga regular expression ay nagtatakda ng mga pattern gamit ang mga espesyal na simbolo. Narito ang ilan sa mga pangunahing pattern.

• .: Anumang single na karakter
• ^: Simula ng isang string
• $: Dulo ng isang string
• \d: Anumang digit (0-9)
• \w: Anumang karakter ng salita (a-z, A-Z, 0-9, _)
• \s: Anumang whitespace character
• *: Wala o higit pang pag-uulit
• +: Isa o higit pang pag-uulit
• []: Klase ng karakter (halimbawa, [a-z] tumutugma sa maliliit na titik ng alpabeto)

 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")

• Sinusuri muna ng code na ito kung tumutugma ang string sa pattern ng postal code. Pagkatapos, sinusuri nito kung ang buong string (mula simula hanggang dulo) ay tumutugma sa pattern na binubuo ng isang salita, whitespace, mga digit, whitespace, at isang salitang Ingles. Nakatutulong ito upang maunawaan kung paano maaaring pagsamahin ang mga pangunahing elemento ng regular expression.

Paano Gamitin ang Mga Panggagamitan ng Pagtutugma

re.match()

re.match() sinusuri kung ang simula ng string ay tumutugma sa tinukoy na pattern.

1import re
2
3pattern = r"\w+"
4text = "Python is powerful"
5match = re.match(pattern, text)
6if match:
7    print(match.group())  # Output: Python

• Sinusuri ng code na ito kung nagsisimula ang string sa isang word character (alphanumeric o underscore). Ang unang salitang 'Python' ay tumutugma sa pattern at inilalabas.

re.search()

re.search() ay ini-scan ang buong string at ibinabalik ang unang tugma.

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

• Hinahanap ng code na ito ang salitang 'powerful' sa buong string at ibinabalik ang unang tugma. Bilang resulta, inilalabas ng re.search() ang tumugmang string na 'powerful'.

re.findall()

re.findall() ay ibinabalik ang lahat ng tugma ng pattern bilang isang listahan.

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']

• Hinahanap ng code na ito ang lahat ng salitang eksaktong anim na karakter ang haba at ibinabalik ang mga ito bilang listahan. Ang 'Python' sa string ay tumutugma sa kondisyon, at ang listahang ['Python'] ay inilalabas.

re.finditer()

re.finditer() ay ibinabalik ang lahat ng tugma bilang isang iterator, pinahihintulutan kang makuha ang detalyadong impormasyon para sa bawat tugma.

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

• Hinahanap ng code na ito nang sunud-sunod ang lahat ng salitang may anim na titik at pinoproseso ang bawat tugma sa pamamagitan ng isang iterator. Ang 'Python' ay tumutugma sa pattern dito at inilalabas.

Pagpapalit at Pagkakahati

re.sub()

re.sub() ay pinapalitan ang bahagi ng string na tumutugma sa regular na ekspresyon gamit ang ibang string.

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

• Pinalalitan ng code na ito ang lahat ng mga digit sa string ng 'many'.

re.split()

re.split() ay hinahati ang string sa mga bahagi na tumutugma sa regular na ekspresyon.

1import re
2
3pattern = r"\s+"
4text = "Python is powerful"
5parts = re.split(pattern, text)
6print(parts)  # Output: ['Python', 'is', 'powerful']

• Hinahati ng code na ito ang string batay sa isa o higit pang mga whitespace character. Bilang resulta, nahahati ang string sa mga salita, na nagbibigay ng ['Python', 'is', 'powerful'].

Mga Grupo at Mga Pagkuha

Ang paggamit ng pagpapangkat sa regular na ekspresyon ay nagpapadali sa pagkuha ng mga tumugmang substring. Ang pagsasara sa panaklong () ay kinukuha ito bilang isang grupo.

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

• Kinukuha ng code na ito ang 3-digit at 4-digit na mga numero bilang magkahiwalay na grupo mula sa postal code na nasa anyong '123-4567'. Ang group(1) ay nagbabalik ng unang tatlong digit na '123', at ang group(2) ay nagbabalik ng huling apat na digit na '4567'.

Mga pinangalanang grupo

Ang paggamit ng mga pinangalanang grupo ay nagbibigay-daan sa iyo na kunin ang mga value batay sa makahulugang mga pangalan sa halip na umasa sa mga index. Sa ibaba ay isang konkretong halimbawa na kumukuha ng petsa at antas mula sa isang log.

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"))

• Gumagamit ang code na ito ng mga pinangalanang grupo upang kunin ang petsa, oras, antas, at mensahe mula sa isang log string. Kumukuha ito ng mga value gamit ang makahulugang mga pangalan sa halip na mga index.

Pag gamit ng Flag Options

Ang re module ay mayroong ilang flag options upang kontrolin ang kilos ng paghahanap.

• re.IGNORECASE (re.I): Isang flag option na ginagawang case-insensitive ang pagtutugma.
• re.MULTILINE (re.M): Isang flag option na nagpapahintulot ng pagtutugma sa maraming linya.
• re.DOTALL (re.S): Isang flag option kung saan ang tuldok . ay tumutugma rin sa mga newline character.

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

• Hinahanap ng code na ito ang salitang 'python' nang hindi isinasaalang-alang ang pagkakaiba ng malaki at maliit na titik. Sa pamamagitan ng flag na re.IGNORECASE, tumutugma rin ito sa 'Python'.

Mga bentahe ng mga regular expression object (re.compile)

Ang pag-compile ng pattern gamit ang re.compile ay nagpapahusay sa kahusayan ng muling paggamit at nagpapahusay sa pagiging madaling basahin. Maaari ka ring magtakda ng mga flag dito.

Ang sumusunod na halimbawa ay paulit-ulit na naghahanap ng mga tugma sa maraming linya gamit ang isang nakompilang pattern. Kung madalas mong gamitin ang parehong pattern, ang pag-compile nito gamit ang re.compile ay nagpapabuti sa pagganap.

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())

• Gumagamit ang code na ito ng nakompilang regular expression upang kunin ang mga username at ID mula sa maraming linya. re.compile ay nagpapahusay ng kahusayan kapag muling ginagamit ang parehong pattern at ginagawang mas madaling basahin ang code.

Mga Aplikasyon

Halimbawa, isaalang-alang ang isang script na kumukuha ng lahat ng email address mula sa isang text file.

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']

• Hinahanap ng code na ito ang lahat ng mga email address sa string at kinukuha ang mga ito bilang isang listahan.

Konklusyon

Ang re module ay isang makapangyarihang kasangkapan para sa manipulasyon ng string sa Python. Dito, tinalakay natin ang malawak na saklaw mula sa pangunahing paggamit hanggang sa advanced na regular expressions gamit ang pagpapangkat at mga flag options. Ang mga regular expression ng Python ay makapangyarihan at mahalagang kasangkapan para sa pagproseso ng teksto.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video