Reguljära uttryck i Python

Den här artikeln förklarar reguljära uttryck i Python.

Vi kommer att täcka ett brett spektrum av ämnen, från grundläggande användning av re-modulen till avancerad mönstermatchning med reguljära uttryck.

YouTube Video

Reguljära uttryck i Python

re-modulen används för att söka och manipulera strängar med hjälp av reguljära uttryck.

Vad är re-modulen?

re-modulen ingår i Pythons standardbibliotek och tillhandahåller funktionalitet för att manipulera strängar med hjälp av reguljära uttryck. Reguljära uttryck används för att effektivt hitta, extrahera eller ersätta specifika mönster i strängar.

Grundläggande mönster för reguljära uttryck

Reguljära uttryck definierar mönster med hjälp av specialsymboler. Nedan följer några grundläggande mönster.

• .: Vilken som helst enskild tecken
• ^: Början av en sträng
• $: Slutet av en sträng
• \d: Valfritt tal (0-9)
• \w: Vilken som helst alfabetisk eller siffertecken (a-z, A-Z, 0-9, _)
• \s: Vilken som helst blanktecken
• *: Noll eller fler upprepningar
• +: En eller fler upprepningar
• []: Teckenklass (t.ex. [a-z] matchar gemener bokstäver)

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

• Denna kod kontrollerar först om strängen matchar ett postnummersmönster. Därefter kontrollerar den om hela strängen (från början till slut) matchar ett mönster som består av ett ord, blanktecken, siffror, blanktecken och ett engelskt ord. Detta hjälper dig att förstå hur de grundläggande elementen i reguljära uttryck kan kombineras.

Hur man använder matchningsfunktioner

re.match()

re.match() kontrollerar om början av strängen matchar det angivna mönstret.

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

• Denna kod kontrollerar om strängen börjar med ett ordtecken (alfanumeriskt tecken eller understreck). Det första ordet 'Python' matchar mönstret och skrivs ut.

re.search()

re.search() genomsöker hela strängen och returnerar den första träffen.

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

• Denna kod söker igenom hela strängen efter ordet 'powerful' och returnerar den första träffen. Som resultat returnerar re.search() den matchade strängen 'powerful'.

re.findall()

re.findall() returnerar alla mönsterträffar som en lista.

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

• Denna kod hittar alla ord som är exakt sex tecken långa och returnerar dem som en lista. 'Python' i strängen uppfyller villkoret, och listan ['Python'] skrivs ut.

re.finditer()

re.finditer() returnerar alla träffar som en iterator, vilket gör det möjligt att hämta detaljerad information för varje träff.

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

• Denna kod söker sekventiellt efter alla ord som är sex bokstäver långa och bearbetar varje träff via en iterator. 'Python' matchar mönstret här och skrivs ut.

Ersättning och Delning

re.sub()

re.sub() ersätter delar av strängen som matchar reguljära uttrycket med en annan sträng.

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

• Denna kod ersätter alla siffror i strängen med 'many'.

re.split()

re.split() delar upp strängen vid delar som matchar det reguljära uttrycket.

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

• Denna kod delar upp strängen på ett eller flera blanktecken. Som resultat delas strängen upp i ord, vilket ger ['Python', 'is', 'powerful'].

Grupper och Fångster

Användning av grupperingar i reguljära uttryck gör det lätt att extrahera matchade delsträngar. Omslutning med parenteser () fångar det som en grupp.

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

• Denna kod extraherar de tre- respektive fyrsiffriga talen som separata grupper från ett postnummer i formen '123-4567'. group(1) returnerar de första tre siffrorna '123', och group(2) returnerar de sista fyra siffrorna '4567'.

Namngivna grupper

Genom att använda namngivna grupper kan du hämta värden via meningsfulla namn i stället för att förlita dig på index. Nedan finns ett konkret exempel som extraherar datum och nivå från 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"))

• Denna kod använder namngivna grupper för att extrahera datum, tid, nivå och meddelande från en loggsträng. Den hämtar värdena med meningsfulla namn i stället för index.

Använda Flaggalternativ

re-modulen har flera flaggalternativ för att kontrollera sökbeteendet.

• re.IGNORECASE (re.I): Ett flaggalternativ som gör att matchningen blir skiftlägesokänslig.
• re.MULTILINE (re.M): Ett flaggalternativ som möjliggör matchning över flera rader.
• re.DOTALL (re.S): Ett flaggalternativ där punkten . även matchar nyradstecken.

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

• Denna kod söker efter ordet 'python' skiftlägesokänsligt. Genom att använda flaggan re.IGNORECASE matchas även 'Python'.

Fördelar med objekt för reguljära uttryck (re.compile)

Att kompilera ett mönster med re.compile gör återanvändning mer effektiv och förbättrar läsbarheten. Du kan också ange flaggor här.

Följande exempel söker upprepade gånger efter träffar över flera rader med ett kompilerat mönster. Om du använder samma mönster ofta förbättrar det prestandan att kompilera det med 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())

• Denna kod använder ett kompilerat reguljärt uttryck för att extrahera användarnamn och ID:n från flera rader. re.compile ökar effektiviteten när samma mönster återanvänds och gör också koden mer lättläst.

Användningsområden

Tänk till exempel på ett skript som extraherar alla e-postadresser från en textfil.

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

• Denna kod hittar alla e-postadresser i strängen och extraherar dem som en lista.

Slutsats

re-modulen är ett kraftfullt verktyg för stränghantering i Python. Här täckte vi ett brett spektrum från grundläggande användning till avancerade reguljära uttryck med gruppering och flaggalternativ. Pythons reguljära uttryck är mycket kraftfulla och ett oumbärligt verktyg för bearbetning av text.

Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.

YouTube Video