Lære Utnyttelse av map() og listeforståelser | Forbedre Ytelsen med Innebygde Verktøy

Når det er mulig, er det bedre å bruke innebygde funksjoner, metoder eller biblioteksfunksjoner i stedet for å lage algoritmer fra bunnen av. Innebygde og biblioteksfunksjoner er vanligvis optimalisert for ytelse, kjører mer effektivt, og er designet for å håndtere et bredt spekter av spesialtilfeller på en god måte.

La oss starte med kraftige verktøy som map()-funksjonen og listeforståelser, som kan øke hastigheten på koden din betydelig. Siden listeforståelser er mer optimalisert for ytelse og map() er implementert i C, kjører de generelt raskere enn manuelt skrevne løkker.

Listeforståelser

Listeforståelser gir en mer konsis og ofte raskere måte å lage lister på sammenlignet med tradisjonelle for-løkker. I tillegg kan de gjøre koden din lettere å lese og forstå.

La oss sammenligne ytelsen til en for-løkke og en listeforståelse ved å generere en liste der hvert tall fra 1 til 10000000 multipliseres med 2:


              123456789101112131415161718192021
            
import os
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

numbers = list(range(1, 10000001))

@timeit_decorator(number=3)
def list_comprehension():
    return [x * 2 for x in numbers]

@timeit_decorator(number=3)
def for_loop():
    result = []
    for x in numbers:
        result.append(x * 2)
    return result

list_1 = list_comprehension()
list_2 = for_loop()

print(list_1 == list_2)

Bruk av map()

Funksjonen map anvender en spesifisert funksjon på hvert element i en itererbar (for eksempel en liste).

I tillegg til å være mer konsis enn å skrive løkker, kjører den ofte raskere på grunn av C-nivå optimaliseringer i implementasjonen, som reduserer overhead ved gjentatte funksjonskall.

Selv om map kan gi noen ytelsesfordeler, spesielt når man arbeider med innebygde funksjoner, er fartsforskjellen sammenlignet med listeforståelser ofte ubetydelig. Begge er svært optimaliserte, og for enkle operasjoner er ytelsesfordelen til map knapt merkbar. I praksis bør valget mellom de to baseres mer på lesbarhet og spesifikke brukstilfeller, som for eksempel minneeffektivitet med map.

La oss sammenligne ytelsen til map, for-løkker og listeforståelser når vi formaterer 1000000 kundenavn til tittelbokstaver (for eksempel 'john doe' -> 'John Doe'):


              1234567891011121314151617181920212223242526
            
import os
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

customer_names = ['john doe', 'jane smith', 'alex johnson', 'ivan smith'] * 250000

@timeit_decorator(number=10)
def map_function():
    return list(map(str.title, customer_names))

@timeit_decorator(number=10)
def list_comprehension():
    return [name.title() for name in customer_names]

@timeit_decorator(number=10)
def for_loop():
    result = []
    for name in customer_names:
        result.append(name.title())
    return result

formatted_with_map = map_function()
formatted_with_comprehension = list_comprehension()
formatted_with_for_loop = for_loop()

print(formatted_with_map == formatted_with_comprehension == formatted_with_for_loop)

Som forventet er for-løkka den tregeste metoden av de tre. I dette eksempelet viste det seg at map var raskere enn listeforståelse, selv om ytelsen i praksis kan variere avhengig av det spesifikke bruksområdet. Noen ganger kan listeforståelser til og med være raskere enn map, spesielt for enklere uttrykk.

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 3. Kapittel 1

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Awesome!

Completion rate improved to 7.69

Sveip for å vise menyen