Svep för att visa menyn

I det här kapitlet kommer du att utforska hur du kan utnyttja kraften i reguljära uttryck i avancerade Python-sammanhang, inklusive arbete med nästlade funktioner, omvändning av strängar och sammanfogning av strängar. Dessa tekniker gör det möjligt att manipulera och analysera textdata mer effektivt och flexibelt, vilket öppnar upp nya möjligheter för automatisering, datarensning och komplex mönstermatchning.

Du kommer att lära dig hur reguljära uttryck kan:

Förbättra funktionaliteten hos nästlade funktioner för att extrahera eller transformera data;
Förenkla processen att vända strängar baserat på specifika mönster;
Möjliggöra dynamisk och anpassningsbar sammanfogning av strängar med hjälp av mönsterbaserade regler.

Att behärska dessa tillämpningar hjälper dig att skriva mer koncis, läsbar och kraftfull Python-kod för ett brett spektrum av verkliga uppgifter, från bearbetning av loggfiler till att bygga datapipelines.

Använda reguljära uttryck i nästlade funktioner

När du använder reguljära uttryck i Python definierar du ofta mönster och söklogik inuti funktioner. Ibland kan du behöva använda reguljära uttryck i nästlade funktioner — funktioner som är definierade inuti andra funktioner. Att förstå hur scope och variabelåtkomst fungerar i detta sammanhang hjälper dig att skriva tydlig och återanvändbar kod.

Definition: Nästlade funktioner

En nästlad funktion är en funktion som definieras inom en annan funktion. Den inre funktionen kan komma åt variabler från den omslutande funktionen tack vare Pythons lexikala scope (även kallat closure).

Scope och reguljära uttryck

Den inre funktionen kan använda reguljära uttrycksmönster och kompilerade objekt som definieras i den yttre funktionen;
Du kan skicka reguljära uttrycksmatchningar eller resultat från den yttre till den inre funktionen för vidare bearbetning;
Att kompilera ett regex-mönster i den yttre funktionen förbättrar effektiviteten om den inre funktionen använder samma mönster flera gånger.

Praktiskt exempel: Filtrering och extrahering av data

Anta att du vill bearbeta en lista med e-postadresser, filtrera ut giltiga och extrahera användarnamnet. Du kan använda en nästlad funktion för att kapsla in extraheringslogiken:

import re

def filter_and_extract_usernames(emails):
    pattern = re.compile(r"([\w.-]+)@[\w.-]+\.\w+")
    
    def extract_username(email):
        match = pattern.match(email)
        if match:
            return match.group(1)
        return None
    
    usernames = []
    for email in emails:
        username = extract_username(email)
        if username:
            usernames.append(username)
    return usernames

emails = [
    "alice.smith@example.com",
    "bob99@invalid",
    "carol.jones@domain.org"
]

print(filter_and_extract_usernames(emails))
# Output: ['alice.smith', 'carol.jones']

Viktiga punkter:

pattern kompileras en gång i den yttre funktionen och återanvänds i den nästlade extract_username-funktionen;
Den inre funktionen får tillgång till regex-mönstret från det omslutande scopet;
Denna struktur håller koden organiserad och effektiv, särskilt vid hantering av komplex dataparsering.

Att använda reguljära uttryck i nästlade funktioner är en kraftfull teknik för att bygga modulär, underhållbar kod som bearbetar textdata effektivt.


              123456789101112131415
            
import re

def find_and_replace(text, pattern, replacement):
    def inner_replace():
        # Use re.sub to replace all matches of the pattern in the text
        result = re.sub(pattern, replacement, text)
        return result
    return inner_replace()

sample_text = "The rain in Spain stays mainly in the plain."
pattern = r"ain"
replacement = "###"

result = find_and_replace(sample_text, pattern, replacement)
print(result)

Omvända strängar i Python

Att omvända en sträng är en vanlig uppgift som kan uppstå vid bearbetning av textdata. Python erbjuder ett enkelt sätt att vända strängar med hjälp av slicing, och du kan även kombinera detta med reguljära uttryck för avancerad textmanipulation.

Hur man vänder en sträng

Du kan vända vilken sträng som helst i Python med slicing:

text = "Hello, world!"
reversed_text = text[::-1]
print(reversed_text)  # Output: !dlrow ,olleH

Förklaring:

text[::-1] skapar en ny sträng genom att ta alla tecken från text men i omvänd ordning.

Användningsområden

Att vända strängar är användbart i flera situationer:

Kontrollera om en sträng är ett palindrom;
Dölja känslig information genom att visa den baklänges;
Skapa roliga texteffekter för användargränssnitt.

Kombinera regex med strängomvändning

Du kan använda reguljära uttryck för att hitta specifika mönster i en sträng och sedan vända endast dessa delar. Detta är användbart när du vill vända vissa ord eller mönster, inte hela strängen.

Exempel: Vänd alla ord som börjar med stor bokstav

import re

def reverse_capital_words(text):
    def reverse_match(match):
        return match.group()[::-1]
    # Find all words starting with a capital letter
    pattern = r'\b[A-Z][a-zA-Z]*\b'
    return re.sub(pattern, reverse_match, text)

sentence = "Alice and Bob went to Wonderland."
result = reverse_capital_words(sentence)
print(result)  # Output: "ecilA and boB went to .dnalrednoW"

Så fungerar det:

Regex-mönstret \b[A-Z][a-zA-Z]*\b matchar ord som börjar med stor bokstav.
Funktionen reverse_match vänder varje matchat ord.
re.sub ersätter varje träff med dess omvända version.

Att kombinera reguljära uttryck med strängomvändning gör det möjligt att utföra komplexa texttransformationer på ett koncist och flexibelt sätt.


              123456789101112131415161718
            
import re

# Original string
txt = "Python 3.12 is powerful!"

# Reverse the string
reversed_txt = txt[::-1]
print("Reversed string:", reversed_txt)

# Regex pattern to find all sequences of digits in the reversed string
pattern = r"\\d+"
digits = re.findall(pattern, reversed_txt)
print("Digits found in reversed string:", digits)

# Regex pattern to find all words in the reversed string
word_pattern = r"[A-Za-z]+"
words = re.findall(word_pattern, reversed_txt)
print("Words found in reversed string:", words)

Sammanfoga strängar i Python

Att sammanfoga strängar är en vanlig uppgift vid arbete med textdata. Ofta behöver du kombinera flera strängar till en, till exempel genom att slå ihop ord, rader eller resultat från en sökning med reguljära uttryck.

Använda `join()` för att kombinera en lista av strängar

Metoden str.join() är standardmetoden för att slå ihop en lista av strängar till en enda sträng. Du anger en avgränsare och anropar join() på den med listan du vill kombinera.

words = ['Python', 'is', 'fun']
sentence = ' '.join(words)
print(sentence)  # Output: Python is fun

Viktiga punkter om join():

Avgränsaren (som ett mellanslag, komma eller radbrytning) placeras före .join();
Argumentet till join() måste vara en iterable av strängar (till exempel en lista eller tuple);
Resultatet är en enda sträng som innehåller alla element, separerade av vald avgränsare.

Sammanfoga regex-träffar till en enda sträng

När du använder funktionen re.findall() returnerar den en lista med alla icke-överlappande träffar. Du kan använda join() för att slå ihop dessa träffar till en enda sträng.

import re

text = 'cat, dog, bat, rat'
animals = re.findall(r'\w{3}', text)
all_animals = ', '.join(animals)
print(all_animals)  # Output: cat, dog, bat, rat

Vanliga användningsområden:

Kombinera alla regex-träffar till en kommaseparerad sträng;
Slå ihop textrader till ett enda block;
Skapa CSV-rader från listor av värden.

Effektiv sammanfogning av strängar hjälper dig att bearbeta, visa och lagra textdata på ett läsbart och strukturerat sätt.


              12345678910111213141516171819202122
            
import re

# Joining a list of strings with a space
words = ["Python", "Regular", "Expressions"]
joined_words = " ".join(words)
print("Joined list:", joined_words)

# Using regex to extract all words starting with a capital letter
text = "Alice and Bob are learning Regular Expressions in Python."
pattern = r"\\b[A-Z][a-z]+\\b"
capitalized_words = re.findall(pattern, text)
print("Capitalized words:", capitalized_words)

# Joining regex match groups with a hyphen
joined_matches = "-".join(capitalized_words)
print("Hyphen-joined matches:", joined_matches)

# Using regex groups and joining them
match = re.match(r"(\\w+) (\\w+)", "Hello World")
if match:
    groups_joined = ", ".join(match.groups())
    print("Groups joined:", groups_joined)

1. Vad är en nästlad funktion i Python och hur kan den vara användbar vid arbete med reguljära uttryck

2. Vilken Python-metod används vanligtvis för att sammanfoga en lista med strängar till en enda sträng, och hur kan den kombineras med regex-matchningar

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 6

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Nästlade Funktioner, Omvändning och Sammanslagning av Strängar

Du kommer att lära dig hur reguljära uttryck kan:

Förbättra funktionaliteten hos nästlade funktioner för att extrahera eller transformera data;
Förenkla processen att vända strängar baserat på specifika mönster;
Möjliggöra dynamisk och anpassningsbar sammanfogning av strängar med hjälp av mönsterbaserade regler.

Använda reguljära uttryck i nästlade funktioner

Definition: Nästlade funktioner

Scope och reguljära uttryck

Den inre funktionen kan använda reguljära uttrycksmönster och kompilerade objekt som definieras i den yttre funktionen;
Du kan skicka reguljära uttrycksmatchningar eller resultat från den yttre till den inre funktionen för vidare bearbetning;
Att kompilera ett regex-mönster i den yttre funktionen förbättrar effektiviteten om den inre funktionen använder samma mönster flera gånger.

Praktiskt exempel: Filtrering och extrahering av data

Anta att du vill bearbeta en lista med e-postadresser, filtrera ut giltiga och extrahera användarnamnet. Du kan använda en nästlad funktion för att kapsla in extraheringslogiken:

import re

def filter_and_extract_usernames(emails):
    pattern = re.compile(r"([\w.-]+)@[\w.-]+\.\w+")
    
    def extract_username(email):
        match = pattern.match(email)
        if match:
            return match.group(1)
        return None
    
    usernames = []
    for email in emails:
        username = extract_username(email)
        if username:
            usernames.append(username)
    return usernames

emails = [
    "alice.smith@example.com",
    "bob99@invalid",
    "carol.jones@domain.org"
]

print(filter_and_extract_usernames(emails))
# Output: ['alice.smith', 'carol.jones']

Viktiga punkter:

pattern kompileras en gång i den yttre funktionen och återanvänds i den nästlade extract_username-funktionen;
Den inre funktionen får tillgång till regex-mönstret från det omslutande scopet;
Denna struktur håller koden organiserad och effektiv, särskilt vid hantering av komplex dataparsering.

Att använda reguljära uttryck i nästlade funktioner är en kraftfull teknik för att bygga modulär, underhållbar kod som bearbetar textdata effektivt.


              123456789101112131415
            
import re

def find_and_replace(text, pattern, replacement):
    def inner_replace():
        # Use re.sub to replace all matches of the pattern in the text
        result = re.sub(pattern, replacement, text)
        return result
    return inner_replace()

sample_text = "The rain in Spain stays mainly in the plain."
pattern = r"ain"
replacement = "###"

result = find_and_replace(sample_text, pattern, replacement)
print(result)

Omvända strängar i Python

Hur man vänder en sträng

Du kan vända vilken sträng som helst i Python med slicing:

text = "Hello, world!"
reversed_text = text[::-1]
print(reversed_text)  # Output: !dlrow ,olleH

Förklaring:

text[::-1] skapar en ny sträng genom att ta alla tecken från text men i omvänd ordning.

Användningsområden

Att vända strängar är användbart i flera situationer:

Kontrollera om en sträng är ett palindrom;
Dölja känslig information genom att visa den baklänges;
Skapa roliga texteffekter för användargränssnitt.

Kombinera regex med strängomvändning

Exempel: Vänd alla ord som börjar med stor bokstav

import re

def reverse_capital_words(text):
    def reverse_match(match):
        return match.group()[::-1]
    # Find all words starting with a capital letter
    pattern = r'\b[A-Z][a-zA-Z]*\b'
    return re.sub(pattern, reverse_match, text)

sentence = "Alice and Bob went to Wonderland."
result = reverse_capital_words(sentence)
print(result)  # Output: "ecilA and boB went to .dnalrednoW"

Så fungerar det:

Regex-mönstret \b[A-Z][a-zA-Z]*\b matchar ord som börjar med stor bokstav.
Funktionen reverse_match vänder varje matchat ord.
re.sub ersätter varje träff med dess omvända version.

Att kombinera reguljära uttryck med strängomvändning gör det möjligt att utföra komplexa texttransformationer på ett koncist och flexibelt sätt.


              123456789101112131415161718
            
import re

# Original string
txt = "Python 3.12 is powerful!"

# Reverse the string
reversed_txt = txt[::-1]
print("Reversed string:", reversed_txt)

# Regex pattern to find all sequences of digits in the reversed string
pattern = r"\\d+"
digits = re.findall(pattern, reversed_txt)
print("Digits found in reversed string:", digits)

# Regex pattern to find all words in the reversed string
word_pattern = r"[A-Za-z]+"
words = re.findall(word_pattern, reversed_txt)
print("Words found in reversed string:", words)

Sammanfoga strängar i Python

Använda `join()` för att kombinera en lista av strängar

Metoden str.join() är standardmetoden för att slå ihop en lista av strängar till en enda sträng. Du anger en avgränsare och anropar join() på den med listan du vill kombinera.

words = ['Python', 'is', 'fun']
sentence = ' '.join(words)
print(sentence)  # Output: Python is fun

Viktiga punkter om join():

Avgränsaren (som ett mellanslag, komma eller radbrytning) placeras före .join();
Argumentet till join() måste vara en iterable av strängar (till exempel en lista eller tuple);
Resultatet är en enda sträng som innehåller alla element, separerade av vald avgränsare.

Sammanfoga regex-träffar till en enda sträng

När du använder funktionen re.findall() returnerar den en lista med alla icke-överlappande träffar. Du kan använda join() för att slå ihop dessa träffar till en enda sträng.

import re

text = 'cat, dog, bat, rat'
animals = re.findall(r'\w{3}', text)
all_animals = ', '.join(animals)
print(all_animals)  # Output: cat, dog, bat, rat

Vanliga användningsområden:

Kombinera alla regex-träffar till en kommaseparerad sträng;
Slå ihop textrader till ett enda block;
Skapa CSV-rader från listor av värden.

Effektiv sammanfogning av strängar hjälper dig att bearbeta, visa och lagra textdata på ett läsbart och strukturerat sätt.


              12345678910111213141516171819202122
            
import re

# Joining a list of strings with a space
words = ["Python", "Regular", "Expressions"]
joined_words = " ".join(words)
print("Joined list:", joined_words)

# Using regex to extract all words starting with a capital letter
text = "Alice and Bob are learning Regular Expressions in Python."
pattern = r"\\b[A-Z][a-z]+\\b"
capitalized_words = re.findall(pattern, text)
print("Capitalized words:", capitalized_words)

# Joining regex match groups with a hyphen
joined_matches = "-".join(capitalized_words)
print("Hyphen-joined matches:", joined_matches)

# Using regex groups and joining them
match = re.match(r"(\\w+) (\\w+)", "Hello World")
if match:
    groups_joined = ", ".join(match.groups())
    print("Groups joined:", groups_joined)

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 6

Nästlade Funktioner, Omvändning och Sammanslagning av Strängar

Använda reguljära uttryck i nästlade funktioner

Definition: Nästlade funktioner

Scope och reguljära uttryck

Praktiskt exempel: Filtrering och extrahering av data

Omvända strängar i Python

Hur man vänder en sträng

Användningsområden

Kombinera regex med strängomvändning

Exempel: Vänd alla ord som börjar med stor bokstav

Sammanfoga strängar i Python

Använda join() för att kombinera en lista av strängar

Sammanfoga regex-träffar till en enda sträng

1. Vad är en nästlad funktion i Python och hur kan den vara användbar vid arbete med reguljära uttryck

2. Vilken Python-metod används vanligtvis för att sammanfoga en lista med strängar till en enda sträng, och hur kan den kombineras med regex-matchningar

Nästlade Funktioner, Omvändning och Sammanslagning av Strängar

Använda reguljära uttryck i nästlade funktioner

Definition: Nästlade funktioner

Scope och reguljära uttryck

Praktiskt exempel: Filtrering och extrahering av data

Omvända strängar i Python

Hur man vänder en sträng

Användningsområden

Kombinera regex med strängomvändning

Exempel: Vänd alla ord som börjar med stor bokstav

Sammanfoga strängar i Python

Använda join() för att kombinera en lista av strängar

Sammanfoga regex-träffar till en enda sträng

Använda `join()` för att kombinera en lista av strängar

Använda `join()` för att kombinera en lista av strängar