Regulære uttrykk i Python

Denne artikkelen forklarer regulære uttrykk i Python.

Vi vil dekke et bredt spekter av emner, fra grunnleggende bruk av re-modulen til kompleks mønstermatch med regulære uttrykk.

YouTube Video

Regulære uttrykk i Python

re-modulen brukes til å søke etter og manipulere strenger ved hjelp av regulære uttrykk.

Hva er re-modulen?

re-modulen er inkludert i Pythons standardbibliotek og gir funksjonalitet for strengmanipulasjon ved hjelp av regulære uttrykk. Regulære uttrykk brukes til effektivt å finne, hente ut eller erstatte bestemte strenge-mønstre.

Grunnleggende mønstre for regulære uttrykk

Regulære uttrykk definerer mønstre ved hjelp av spesielle symboler. Nedenfor er noen grunnleggende mønstre.

• .: Enhver enkelt tegn
• ^: Starten av en streng
• $: Slutten av en streng
• \d: Ethvert siffer (0-9)
• \w: Ethvert bokstavtegn (a-z, A-Z, 0-9, _)
• \s: Ethvert mellomromstegn
• *: Null eller flere repetisjoner
• +: Én eller flere repetisjoner
• []: Tegnklasse (f.eks. [a-z] samsvarer med små bokstaver)

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

• Denne koden sjekker først om strengen samsvarer med et postnummermønster. Deretter sjekker den om hele strengen (fra start til slutt) samsvarer med et mønster som består av et ord, blanktegn, sifre, blanktegn og et engelsk ord. Dette hjelper deg å forstå hvordan de grunnleggende elementene i regulære uttrykk kan kombineres.

Hvordan bruke matchende funksjoner

re.match()

re.match() sjekker om starten av strengen samsvarer med det spesifiserte mønsteret.

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

• Denne koden sjekker om strengen starter med et ordtegn (alfanumerisk eller understrek). Det første ordet «Python» samsvarer med mønsteret og skrives ut.

re.search()

re.search() skanner hele strengen og returnerer det første treffet.

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

• Denne koden søker gjennom hele strengen etter ordet «powerful» og returnerer første treff. Som resultat returnerer re.search() den samsvarende strengen «powerful».

re.findall()

re.findall() returnerer alle treff av mønsteret som en liste.

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

• Denne koden finner alle ord som er nøyaktig seks tegn lange og returnerer dem som en liste. «Python» i strengen oppfyller betingelsen, og listen ['Python'] returneres.

re.finditer()

re.finditer() returnerer alle treff som en iterator, slik at du kan hente detaljerte opplysninger for hvert treff.

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

• Denne koden søker sekvensielt etter alle ord på seks bokstaver og behandler hvert treff via en iterator. «Python» samsvarer med mønsteret her og skrives ut.

Erstatning og Splitting

re.sub()

re.sub() erstatter deler av strengen som samsvarer med det regulære uttrykket med en annen streng.

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

• Denne koden erstatter alle sifre i strengen med «many».

re.split()

re.split() splitter strengen ved deler som samsvarer med det regulære uttrykket.

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

• Denne koden deler strengen på ett eller flere blanktegn. Som resultat blir strengen delt opp i ord, noe som resulterer i ['Python', 'is', 'powerful'].

Grupper og Innfanging

Bruk av gruppering i regulære uttrykk gjør det enkelt å trekke ut samsvarende understrenger. Ved å omslutte med parenteser () fanges det opp som en gruppe.

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

• Denne koden henter ut 3-sifrede og 4-sifrede tall som separate grupper fra et postnummer på formen «123-4567». group(1) returnerer de første tre sifrene «123», og group(2) returnerer de siste fire sifrene «4567».

Navngitte grupper

Ved å bruke navngitte grupper kan du hente verdier ved hjelp av meningsfulle navn i stedet for å være avhengig av indekser. Nedenfor er et konkret eksempel som henter ut dato og nivå fra en logg.

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

• Denne koden bruker navngitte grupper for å hente ut dato, tid, nivå og melding fra en loggstreng. Den henter verdiene ved hjelp av meningsfulle navn i stedet for indekser.

Bruk av Flaggvalg

re-modulen har flere flaggvalg for å kontrollere søkeatferd.

• re.IGNORECASE (re.I): Et flaggvalg som gjør samsvarene store/små bokstav-insensitive.
• re.MULTILINE (re.M): Et flaggvalg som muliggjør samsvar på tvers av flere linjer.
• re.DOTALL (re.S): Et flaggvalg der punktumet . også samsvarer med linjeskift.

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

• Denne koden søker etter ordet «python» uten å skille mellom små og store bokstaver. Ved å bruke flagget re.IGNORECASE samsvarer den også med «Python».

Fordeler med regulære uttrykksobjekter (re.compile)

Å kompilere et mønster med re.compile gjør gjenbruk mer effektivt og forbedrer lesbarheten. Du kan også angi flagg her.

Følgende eksempel søker gjentatte ganger etter treff på tvers av flere linjer ved hjelp av et kompilert mønster. Hvis du bruker det samme mønsteret ofte, vil kompilering med re.compile forbedre ytelsen.

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

• Denne koden bruker et kompilert regulært uttrykk for å hente ut brukernavn og ID-er fra flere linjer. re.compile forbedrer effektiviteten ved gjenbruk av samme mønster og gjør også koden mer lesbar.

Bruksområder

For eksempel, vurder et skript som trekker ut alle e-postadresser fra en tekstfil.

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

• Denne koden finner alle e-postadresser i strengen og henter dem ut som en liste.

Konklusjon

re-modulen er et kraftig verktøy for strengmanipulasjon i Python. Her dekket vi et bredt spekter fra grunnleggende bruk til avanserte regulære uttrykk ved hjelp av gruppering og flaggvalg. Pythons regulære uttrykk er veldig kraftige og et uunnværlig verktøy for tekstbehandling.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video