Lære Udnyttelse af Map() og Listeforståelser | Forbedring af Ydeevne med Indbyggede Værktøjer

Når det er muligt, er det bedre at benytte indbyggede funktioner, metoder eller biblioteksfunktioner fremfor at udvikle algoritmer fra bunden. Indbyggede og biblioteksfunktioner er typisk optimeret for ydeevne, kører mere effektivt og er designet til at håndtere en bred vifte af edge cases effektivt.

Lad os starte med kraftfulde værktøjer som map()-funktionen og listeforståelser, der kan øge hastigheden på din kode betydeligt. Da listeforståelser er mere optimerede for ydeevne og map() er implementeret i C, udføres de generelt hurtigere end manuelt skrevne løkker.

Listeforståelser

Listeforståelser tilbyder en mere kortfattet og ofte hurtigere måde at oprette lister på sammenlignet med traditionelle for-løkker. Derudover kan de gøre din kode lettere at læse og forstå.

Lad os sammenligne ydeevnen af en for-løkke og en listeforståelse ved at generere en liste, hvor hvert tal fra 1 til 10000000 ganges med 2:


              123456789101112131415161718192021
            
import os
os.system('wget https://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)

Brug af map()

Funktionen map anvender en angivet funktion på hver enkelt element i et iterabelt objekt (f.eks. en liste).

Ud over at være mere kortfattet end at skrive løkker, kører den ofte hurtigere på grund af C-niveau optimeringer i dens implementering, hvilket reducerer overhead ved gentagne funktionskald.

Selvom map kan give visse ydelsesfordele, især ved brug af indbyggede funktioner, er hastighedsforskellen sammenlignet med listeforståelser ofte ubetydelig. Begge er stærkt optimerede, og for simple operationer er ydelsesfordelen ved map næsten ikke mærkbar. I praksis bør valget mellem de to i højere grad baseres på læsbarhed og specifikke anvendelsestilfælde, såsom hukommelseseffektivitet med map.

Lad os sammenligne ydeevnen for map, for-løkker og listeforståelser, når vi formaterer 1000000 kundenavne til titelcase (f.eks. 'john doe' -> 'John Doe'):


              1234567891011121314151617181920212223242526
            
import os
os.system('wget https://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økken den langsomste metode af de tre. I dette eksempel viste map sig at være hurtigere end listeforståelse, selvom ydeevnen i praksis kan variere afhængigt af den specifikke anvendelse. Nogle gange kan listeforståelser endda overgå map, især ved enklere udtryk.

Var alt klart?

Tak for dine kommentarer!

Sektion 3. Kapitel 1

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