Articles
Introduktion til Python
Regulære udtryk i Python

Regulære udtryk i Python

Denne artikel forklarer regulære udtryk i Python.

Vi vil dække en bred vifte af emner, fra grundlæggende brug af re-modulet til kompleks mønstermatching med regulære udtryk.

YouTube Video

Regulære udtryk i Python

re-modulet bruges til at søge i og manipulere strenge ved hjælp af regulære udtryk.

Hvad er re-modulet?

re-modulet er inkluderet i Pythons standardbibliotek og tilbyder funktionalitet til strengmanipulation ved hjælp af regulære udtryk. Regulære udtryk bruges til effektivt at finde, udtrække eller erstatte specifikke strengmønstre.

Grundlæggende mønstre for regulære udtryk

Regulære udtryk definerer mønstre ved hjælp af specielle symboler. Nedenfor er nogle grundlæggende mønstre.

  • .: Enhver enkelt karakter
  • ^: Starten af en streng
  • $: Slutningen af en streng
  • \d: Ethvert tal (0-9)
  • \w: Enhver bogstavkarakter (a-z, A-Z, 0-9, _)
  • \s: Ethvert mellemrumstegn
  • *: Nul eller flere gentagelser
  • +: Én eller flere gentagelser
  • []: Karakterklasse (f.eks. [a-z] matcher små bogstaver)
 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 kode kontrollerer først, om strengen matcher et postnummermønster. Derefter kontrollerer den, om hele strengen (fra start til slut) matcher et mønster bestående af et ord, blanktegn, cifre, blanktegn og et engelsk ord. Dette hjælper dig med at forstå, hvordan de grundlæggende elementer i regulære udtryk kan kombineres.

Sådan bruges match-funktioner

re.match()

re.match() kontrollerer, om starten af strengen matcher det angivne mønster.

1import re
2
3pattern = r"\w+"
4text = "Python is powerful"
5match = re.match(pattern, text)
6if match:
7    print(match.group())  # Output: Python
  • Denne kode tjekker, om strengen starter med et ordtegn (alfanumerisk eller understregningstegn). Det første ord 'Python' matcher mønsteret og udskrives.

re.search()

re.search() scannerer hele strengen og returnerer det første match.

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 kode søger i hele strengen efter ordet 'powerful' og returnerer det første match. Som resultat returnerer re.search() den matchede streng 'powerful'.

re.findall()

re.findall() returnerer alle mønstrets matches 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 kode finder alle ord, der er præcis seks tegn lange, og returnerer dem som en liste. 'Python' i strengen opfylder betingelsen, og listen ['Python'] returneres.

re.finditer()

re.finditer() returnerer alle matches som en iterator, hvilket gør det muligt at hente detaljeret information for hvert match.

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 kode søger sekventielt efter alle ord på seks bogstaver og behandler hvert match via en iterator. 'Python' matcher mønsteret her og udskrives.

Erstatning og Opdeling

re.sub()

re.sub() erstatter dele af strengen, der matcher det regulære udtryk, med en anden 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 kode erstatter alle cifre i strengen med 'many'.

re.split()

re.split() opdeler strengen ved de dele, der matcher det regulære udtryk.

1import re
2
3pattern = r"\s+"
4text = "Python is powerful"
5parts = re.split(pattern, text)
6print(parts)  # Output: ['Python', 'is', 'powerful']
  • Denne kode opdeler strengen ved et eller flere blanktegn. Som resultat opdeles strengen i ord, hvilket giver ['Python', 'is', 'powerful'].

Grupper og Fangster

Ved at bruge grupperinger i regulære udtryk bliver det nemt at udtrække matchede understrenge. At omslutte med parenteser () fanger det 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 kode udtrækker de 3-cifrede og 4-cifrede tal som separate grupper fra et postnummer i formen '123-4567'. group(1) returnerer de første tre cifre '123', og group(2) returnerer de sidste fire cifre '4567'.

Navngivne grupper

Ved at bruge navngivne grupper kan du hente værdier via meningsfulde navne i stedet for at være afhængig af indekser. Nedenfor er et konkret eksempel, der udtrækker dato og niveau fra en 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"))
  • Denne kode bruger navngivne grupper til at udtrække dato, tid, niveau og besked fra en logstreng. Den henter værdierne ved hjælp af meningsfulde navne i stedet for indekser.

Brug af Flagmuligheder

re-modulet har flere flagmuligheder til at kontrollere søgeadfærd.

  • re.IGNORECASE (re.I): En flagmulighed, der gør matchning mellem store og små bogstaver følsesløs.
  • re.MULTILINE (re.M): En flagmulighed, der aktiverer matchning på tværs af flere linjer.
  • re.DOTALL (re.S): En flagmulighed, hvor punktumet . også matcher 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 kode søger efter ordet 'python' uden hensyn til store og små bogstaver. Ved at bruge flaget re.IGNORECASE matcher den også 'Python'.

Fordele ved regulære udtryksobjekter (re.compile)

At kompilere et mønster med re.compile gør genbrug mere effektivt og forbedrer læsbarheden. Du kan også angive flag her.

Det følgende eksempel søger gentagne gange efter match på tværs af flere linjer ved hjælp af et kompileret mønster. Hvis du ofte bruger det samme mønster, forbedrer kompilering med re.compile ydeevnen.

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 kode bruger et kompileret regulært udtryk til at udtrække brugernavne og id'er fra flere linjer. re.compile forbedrer effektiviteten ved genbrug af det samme mønster og gør også koden mere læsbar.

Anvendelser

For eksempel kan man overveje et script, der udtrækker alle e-mailadresser fra en tekstdokument.

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 kode finder alle e-mailadresser i strengen og udtrækker dem som en liste.

Konklusion

re-modulet er et kraftfuldt værktøj til strengmanipulation i Python. Her har vi dækket et bredt spektrum fra grundlæggende brug til avancerede regulære udtryk ved brug af grupperinger og flagmuligheder. Pythons regulære udtryk er meget kraftfulde og et uundværligt værktøj til tekstbehandling.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video

Pythons `copy`-modul