Lære Effektive Strengoperationer | Forbedring af Ydeevne med Indbyggede Værktøjer

Effektiv strengsammenkædning

Ved arbejde med mange strenge er det vigtigt at anvende den mest effektive metode til sammenkædning. Gentagen brug af + (+=) operatoren er ineffektiv for store datasæt, da der oprettes en ny streng hver gang. I stedet er brugen af str.join() langt hurtigere og mere hukommelseseffektiv.

Her sammenlignes ydeevnen for to tilgange til at sammenkæde strenge med linjeskift til én enkelt streng. Den første anvender et for-loop med += operatoren, mens den anden benytter den mere effektive str.join() metode.


              1234567891011121314151617181920212223
            
import os
decorators = os.system('wget https://staging-content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null')
from decorators import timeit_decorator

# Simulated lines of a report
lines = [f"Line {i}" for i in range(1, 1000001)]

# Inefficient concatenation
@timeit_decorator(number=50)
def concat_with_plus():
    result = ""
    for line in lines:
        result += line + "\n"
    return result

# Efficient concatenation
@timeit_decorator(number=50)
def concat_with_join():
    return "\n".join(lines) + "\n"  # Add final newline for consistency

result_plus = concat_with_plus()
result_join = concat_with_join()
print(result_plus == result_join)

Forudkompilering af regulære udtryk

Ved arbejde med regulære udtryk kan ydeevnen blive en udfordring, især ved store datasæt eller gentagen mønstergenkendelse. I sådanne tilfælde er forudkompilering af mønstret en nyttig optimeringsteknik.

Forudkompilering sikrer, at regex-motoren ikke genkompilerer mønsteret hver gang det bruges, hvilket kan forbedre ydeevnen markant, når det samme mønster anvendes flere gange på et datasæt. Denne tilgang er særligt fordelagtig i situationer som filtrering, validering eller søgning i store tekstfiler.

Her sammenlignes ydeevnen for to metoder til validering af brugernavne ved hjælp af regulære udtryk. Den første metode anvender funktionen re.match med mønsteret defineret direkte hver gang den kaldes. Den anden, mere effektive metode, forudkompilerer regex-mønsteret ved hjælp af re.compile og genbruger det til alle valideringer.


              1234567891011121314151617181920212223
            
import os
import re
decorators = os.system('wget https://staging-content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null')
from decorators import timeit_decorator

# Simulated usernames
usernames = ["user123", "admin!@#", "test_user", "invalid!"] * 100000

# Naive approach
@timeit_decorator(number=10)
def validate_with_re():
    pattern = r"^\w+$"
    return [bool(re.match(pattern, username)) for username in usernames]

# Optimized approach
@timeit_decorator(number=10)
def validate_with_compiled_re():
    compiled_pattern = re.compile(r"^\w+$")
    return [bool(compiled_pattern.match(username)) for username in usernames]

result_without_precompiling = validate_with_re()
result_with_precompiling = validate_with_compiled_re()
print(result_without_precompiling == result_with_precompiling)

1. Du genererer en rapport med `10000` linjer, hvor hver linje repræsenterer et transaktionsresumé. Hvilken metode er mest effektiv til at kombinere disse linjer til én enkelt streng med `;` imellem?

2. Hvorfor er det ofte hurtigere at forkompilere et regulært udtryk med `re.compile()` end at bruge `re.match()` med et indlejret mønster?

Var alt klart?

Tak for dine kommentarer!

Sektion 3. Kapitel 4

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Awesome!

Completion rate improved to 7.69

Stryg for at vise menuen

Effektiv strengsammenkædning


              1234567891011121314151617181920212223
            
import os
decorators = os.system('wget https://staging-content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null')
from decorators import timeit_decorator

# Simulated lines of a report
lines = [f"Line {i}" for i in range(1, 1000001)]

# Inefficient concatenation
@timeit_decorator(number=50)
def concat_with_plus():
    result = ""
    for line in lines:
        result += line + "\n"
    return result

# Efficient concatenation
@timeit_decorator(number=50)
def concat_with_join():
    return "\n".join(lines) + "\n"  # Add final newline for consistency

result_plus = concat_with_plus()
result_join = concat_with_join()
print(result_plus == result_join)

Forudkompilering af regulære udtryk


              1234567891011121314151617181920212223
            
import os
import re
decorators = os.system('wget https://staging-content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null')
from decorators import timeit_decorator

# Simulated usernames
usernames = ["user123", "admin!@#", "test_user", "invalid!"] * 100000

# Naive approach
@timeit_decorator(number=10)
def validate_with_re():
    pattern = r"^\w+$"
    return [bool(re.match(pattern, username)) for username in usernames]

# Optimized approach
@timeit_decorator(number=10)
def validate_with_compiled_re():
    compiled_pattern = re.compile(r"^\w+$")
    return [bool(compiled_pattern.match(username)) for username in usernames]

result_without_precompiling = validate_with_re()
result_with_precompiling = validate_with_compiled_re()
print(result_without_precompiling == result_with_precompiling)

1. Du genererer en rapport med `10000` linjer, hvor hver linje repræsenterer et transaktionsresumé. Hvilken metode er mest effektiv til at kombinere disse linjer til én enkelt streng med `;` imellem?

2. Hvorfor er det ofte hurtigere at forkompilere et regulært udtryk med `re.compile()` end at bruge `re.match()` med et indlejret mønster?

Var alt klart?

Tak for dine kommentarer!

Sektion 3. Kapitel 4

Effektive Strengoperationer

Effektiv strengsammenkædning

Forudkompilering af regulære udtryk

1. Du genererer en rapport med 10000 linjer, hvor hver linje repræsenterer et transaktionsresumé. Hvilken metode er mest effektiv til at kombinere disse linjer til én enkelt streng med ; imellem?

2. Hvorfor er det ofte hurtigere at forkompilere et regulært udtryk med re.compile() end at bruge re.match() med et indlejret mønster?

Awesome!

Effektive Strengoperationer

Effektiv strengsammenkædning

Forudkompilering af regulære udtryk

1. Du genererer en rapport med 10000 linjer, hvor hver linje repræsenterer et transaktionsresumé. Hvilken metode er mest effektiv til at kombinere disse linjer til én enkelt streng med ; imellem?

2. Hvorfor er det ofte hurtigere at forkompilere et regulært udtryk med re.compile() end at bruge re.match() med et indlejret mønster?

1. Du genererer en rapport med `10000` linjer, hvor hver linje repræsenterer et transaktionsresumé. Hvilken metode er mest effektiv til at kombinere disse linjer til én enkelt streng med `;` imellem?

2. Hvorfor er det ofte hurtigere at forkompilere et regulært udtryk med `re.compile()` end at bruge `re.match()` med et indlejret mønster?

1. Du genererer en rapport med `10000` linjer, hvor hver linje repræsenterer et transaktionsresumé. Hvilken metode er mest effektiv til at kombinere disse linjer til én enkelt streng med `;` imellem?

2. Hvorfor er det ofte hurtigere at forkompilere et regulært udtryk med `re.compile()` end at bruge `re.match()` med et indlejret mønster?