Python-ordbogsforståelsesvejledning

Python-programmeringssproget tilbyder et unikt sæt værktøjer, der gør kodning ikke kun sjovt, men også accelererer dine fremskridt som programmør. På grund af dets brugervenlighed er Python blevet det foretrukne sprog for en række brancher, lige fra webudvikling og datavidenskab til finansiering og videre.

Python- ordbogsforståelse er et vigtigt værktøj, der giver dig mulighed for at generere ordbøger dynamisk ved at iterere over eksisterende iterable datastrukturer eller ordbøger for at oprette nye. Du kan tænke på ordbogsforståelse som lig med listeforståelse, men med en lidt anden brugssituation.

Når du bliver fortrolig med forståelser, vil du opdage, at de kan forbedre kode markant ved at fremme klarhed og eliminere behovet for lange, gentagne loops.

Hvis du er ny i , er du muligvis ikke stødt på forståelse eller brugt den i din kode. Før vi dykker ned i syntaksen, lad os tage fat på det primære spørgsmål: Hvad er Python-ordbogsforståelse?

Indholdsfortegnelse

• Hvad er Python Dictionary Comprehension?
• Forstå syntaksen af ​​ordbogsforståelse
• Eksempler på ordbogsforståelse
  • Kortlægning af tal til deres firkanter
  • Omvendt nøgler og værdier
• 3 store fordele ved ordbogsforståelse
  • 1. Oprettelse af en klar og enkel kode
  • 2. Bedre ydeevne med stil
  • 3. Nem filtrering og datatransformation
• 3 eksempler på, hvornår man skal bruge ordbogsforståelse
  • 1. Når du opretter en ordbog fra to lister
  • 2. Ved filtrering af en ordbog baseret på værdi
  • 3. Når du transformerer nøgler eller værdier
• Faldgruber ved ordbogsforståelse
  • Afbalancering af kompleksitet og læsbarhed
  • Ydeevne med store datasæt
• Sammenligning med andre metoder
  • Til Loop
  • Lambda funktioner
• Bedste praksis for ordbogsforståelse
• Vores sidste ord

Hvad er Python Dictionary Comprehension?

Python Dictionary Comprehension er en kortfattet måde at oprette ordbøger ved hjælp af simple udtryk. Det giver dig mulighed for at generere nye ordbøger uden at skulle bruge for-loops.e

Lad os tage et kig på et eksempel på forståelse. Antag, at du har to lister, den ene indeholder nøgler og den anden indeholder værdier:

keys = ['a', 'b', 'c']
values = [1, 2, 3]

Ved at bruge ordbogsforståelse kan du oprette en ny ordbog ved at iterere over de to lister og kombinere de tilsvarende nøgleværdi-par:

my_dict = {k: v for k, v in zip(keys, values)}
print(my_dict)

Outputtet vil være:

{'a': 1, 'b': 2, 'c': 3}

Ovenstående eksempel skulle give en idé om, hvilke forståelser der er i . For yderligere at hjælpe dig med at styrke konceptet, lad os forstå syntaksen for ordbogsforståelser i Python.

Forstå syntaksen af ​​ordbogsforståelse

Syntaksen til ordbogsforståelse er enkel, men kraftfuld. De tilbyder en kortfattet. De følger også en lignende syntaks til listeforståelse, men bruger krøllede klammeparenteser {} og et nøgle-værdi-par adskilt af et kolon.

Den grundlæggende struktur er som følger:

{key: value for (key, value) in iterable}

I denne syntaks repræsenterer nøglen og værdien de udtryk, der bruges til at generere nøglerne og værdierne i den resulterende ordbog. Iterablen giver kilden til data, der bruges til at skabe nøgleværdi-parrene.

Denne syntaks blev introduceret i Python 3 og backporteret så langt som Python 2.7, hvilket sikrer bred kompatibilitet på tværs af Python-versioner.

For at oprette en ordbog, der kortlægger tal fra 0 til 4 til deres kvadrater ved hjælp af ordbogsforståelse, kan du bruge følgende Python-kode:

square_dict = {x: x**2 for x in range(5)}

Dette vil resultere i følgende ordbog:

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Hvad hvis du gerne vil iterere over to variable på samme tid? Du kan opnå dette ved at bruge ordbogsforståelse med funktionen zip() til at oprette en ordbog ud fra to iterables, hvor den ene repræsenterer tasterne og den anden repræsenterer værdierne. Her er et eksempel:

keys = ['a', 'b', 'c', 'd', 'e']
values = [1, 2, 3, 4, 5]
my_dict = {k: v for k, v in zip(keys, values)}

Den resulterende ordbog bliver:

{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

Ordbogsforståelse giver dig også mulighed for at tilføje en valgfri if-sætning i slutningen af ​​forståelsen for at anvende et betinget filter på de inkluderede elementer.

For eksempel kan du oprette en ordbog med kun lige tal og deres kvadrater ved hjælp af ordbogsforståelse:

even_square_dict = {x: x**2 for x in range(10) if x % 2 == 0}

Dette resulterer i:

{0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

Nu hvor du har et vist kendskab til syntaksen for forståelse, lad os tage et kig på nogle eksempler på forståelse.

Eksempler på ordbogsforståelse

Ordbogsforståelse finder en række anvendelsestilfælde på grund af dens kraftfulde og elegante syntaks. De kan spare dig tid og gøre din kode mere læsbar.

Kortlægning af tal til deres firkanter

Overvej et simpelt eksempel, hvor du vil oprette en ordbog, der kortlægger tal til deres firkanter ved hjælp af Python-ordbogsforståelser:

squares = {x: x**2 for x in range(1, 6)}
print(squares)

Dette vil udsende:

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Ovenstående kode gør det samme job som at køre en løkke seks gange og kvadrere hvert tal. Koden nedenfor demonstrerer at køre en løkke for at tage kvadraterne af tal:

squares = {}
for x in range(1, 6):
    squares[x] = x ** 2

print(squares)

På dette tidspunkt undrer du dig måske over, hvorfor du skal bruge forståelse, når du kan bruge loops. I programmering er en tommelfingerregel at skrive kompakt og effektiv kode.

Du kan også anvende betingelser for din forståelse. For eksempel vil du måske oprette en ordbog, der kun indeholder lige tal og deres kvadrater:

even_squares = {x: x**2 for x in range(1, 6) if x % 2 == 0}
print(even_squares)

Kørsel af denne kode produceres en ny ordbog som følgende:

{2: 4, 4: 16}

Omvendt nøgler og værdier

Du kan også vende ordbogselementer med lethed med ordbogsforståelse i Python.

Følgende kode demonstrerer, hvordan man vender nøgler og værdier i en eksisterende ordbog om ved hjælp af ordbogsforståelse:

original_dict = {"one": 1, "two": 2, "three": 3, "four": 4}
reversed_dict = {v: k for k, v in original_dict.items()}
print(reversed_dict)

Ovenstående ordbogsforståelse (eller diktatforståelse) vil udskrive følgende:

{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

For at få en god forståelse af, hvad ordbøger er, og hvordan du kan bruge dem til forskellige sager, se venligst videoen nedenfor:

De angivne eksempler tjener som et solidt grundlag for at bruge ordbogsforståelse i dine Python-projekter.

Ordbogsforståelsen kan også optimeres yderligere, så en enkelt linje kode kan udføre komplekse opgaver, der kan forbruge mere tid og hukommelse med loops.

3 store fordele ved ordbogsforståelse

Du har oplevet elegancen ved ordbogsforståelse gennem de angivne eksempler. Udover læsbarhed tilbyder forståelser adskillige fordele, herunder effektivitet, når du arbejder med Pythons effektive nøgle/værdi-hash-tabelstruktur, kaldet dict- forståelse.

1. Oprettelse af en klar og enkel kode

Forståelser giver dig mulighed for at oprette nye ordbøger ubesværet og på en læsbar måde. De får din kode til at se og føles mere Pythonic sammenlignet med traditionelle loops.

2. Bedre ydeevne med stil

Forståelser er ikke kun elegante, men også effektive. De virker ofte hurtigere end for loops, da de bruger et enkelt udtryk. Python optimerer denne type kode og eliminerer behovet for gentagne gange at kalde ordbogskonstruktøren eller bruge update()-metoden.

3. Nem filtrering og datatransformation

En anden fordel ved ordbogsforståelse er dens enkelhed ved filtrering og transformation af data. For eksempel kan du oprette en ny ordbog fra en eksisterende ved at anvende en betingelse eller ændre nøglerne eller værdierne.

Det er afgørende at forstå, hvornår man skal bruge ordbogsforståelse i Python, da de hurtigt kan blive komplekse og sværere at læse og skrive. Lad os nu udforske nogle use cases for ordbogsforståelse i Python.

3 eksempler på, hvornår man skal bruge ordbogsforståelse

Forståelser er nyttige i følgende 3 scenarier:

1. Når du opretter en ordbog fra to lister

{key:value for key, value in zip(list1, list2)}

2. Ved filtrering af en ordbog baseret på værdi

{k: v for k, v in original_dict.items() if v > threshold}

3. Når du transformerer nøgler eller værdier

{k.upper(): v * 2 for k, v in original_dict.items()}

Det er vigtigt at huske, at selvom forståelser kan gøre din kode mere elegant og effektiv, kan de også blive svære at læse, hvis de er alt for komplekse.

Lad os se på nogle af de mest almindelige faldgruber, når du bruger ordbogsforståelse.

Faldgruber ved ordbogsforståelse

Ordbogsforståelse bringer elegance og effektivitet, men kommer også med udfordringer. Vi vil diskutere almindelige faldgruber relateret til læsbarhed, kompleksitet og ydeevne med store datasæt.

Afbalancering af kompleksitet og læsbarhed

Komplekse ordbogsforståelser kan være svære at læse. Prioriter kodelæsbarhed, især når du arbejder sammen med andre. I nogle tilfælde kan traditionelle sløjfer være enklere og mere vedligeholdelsesvenlige.

Ydeevne med store datasæt

For store datasæt er ordbogsforståelsen måske ikke altid optimal. Ifølge Stack Overflow kan en indbygget dict()-konstruktør overgå ordbogsforståelser med adskillige nøgleværdi-par på grund af looping i C.

Sammenligning med andre metoder

I dette afsnit vil vi sammenligne ordbogsforståelser med to alternative metoder til at oprette ordbøger i Python: for sløjfer og lambda-funktioner.

Til Loop

Brug af en for-løkke til at oprette en ordbog involverer initialisering af en tom ordbog og derefter iteration gennem det ønskede gyldige nøgleværdipar, tilføjelse af hvert par til ordbogen. Dette er en mere udførlig metode sammenlignet med ordbogsforståelse.

Følgende er et eksempel på oprettelse af ordbog ved hjælp af for loops:

dictionary = {}
for key, value in zip(keys, values):
    dictionary[key] = value

Omvendt giver en ordbogsforståelse dig mulighed for at opnå det samme resultat på en enkelt linje:

dictionary = {key: value for key, value in zip(keys, values)}

Som du kan se, giver forståelser en kortfattet og mere læsbar måde at oprette ordbøger på i Python.

Lambda funktioner

Vi kan også bruge Lambda-funktioner til at lave ordbøger. Lambda-funktioner er en måde at skabe små, anonyme funktioner i Python. De kan bruges sammen med map()-funktionen til at oprette en ordbog.

Lad os se på et eksempel på Lambda-funktioner til at oprette ordbøger:

keys = ['a', 'b', 'c']
values = [1, 2, 3]

key_value_pairs = map(lambda key, value: (key, value), keys, values)
dictionary = dict(key_value_pairs)

Til sammenligning kan du se her, hvordan den samme ordbog kan oprettes ved hjælp af forståelse:

dictionary = {key: value for key, value in zip(keys, values)}

Igen giver ordbogsforståelse et kortfattet og mere læsbart alternativ til at oprette ordbøger ved hjælp af lambda-funktioner og map()-funktionen.

Bedste praksis for ordbogsforståelse

Når du bruger forståelser i Python, er det vigtigt at følge bedste praksis for at forbedre læsbarheden, vedligeholdelsen og effektiviteten. Her er nogle bedste fremgangsmåder at overveje:

1. Hold ordbogsforståelsen enkel

Ordbogsforståelse er kraftfuld, men den skal være klar og kortfattet. Hvis din forståelse bliver for kompleks eller spænder over flere linjer, kan du overveje at bruge en traditionel for-løkke i stedet. Dette hjælper med at forstå kode, især for andre, eller når du ser dit arbejde igen senere.

2. Udnyt indbyggede funktioner

Python tilbyder indbyggede funktioner som zip() og enumerate(), der hjælper med at skabe forståelser. Brug disse funktioner til at strømline din kode og gøre den mere læsbar.

For eksempel, at bruge zip() til at kombinere to lister og oprette en ordbog resulterer i kortfattet og ren kode som denne:

{key: value for key, value in zip(keys, values)}

3. Brug betingede udsagn med omtanke

Inkorporer betingede udsagn i dine forståelser, når det er nødvendigt, men overbrug dem ikke. De kan hjælpe med at filtrere eller ændre den resulterende ordbog, men for mange indlejrede betingelser kan gøre koden svær at læse. Et simpelt eksempel, der involverer en betinget erklæring, er:

{x: x**2 for x in range(10) if x % 2 == 0}

4. Vær opmærksom på indlejret ordbogsforståelse

Indlejret ordbogsforståelse kan generere ordbøger med indlejrede strukturer. Men ligesom betingede udsagn kan et overskud af indlejret ordbog gøre koden sværere at dechifrere. Undgå at gå ud over to niveauer af indlejring i din indlejrede ordbogsforståelse.

Nogle gange skal du måske bruge indlejret ordbogsforståelse inde i sløjfer for at opnå den ønskede effektivitet.

Vores sidste ord

Nu har du mestret ordbogsforståelse i Python. Denne elegante, effektive teknik hjælper med at skabe ordbøger ved at iterere over iterables eller bruge betingelser. Forståelser strømliner din kode, hvilket øger læsbarheden og vedligeholdelsen.

Det er nemt at oprette nye ordbøger med forståelse, hvilket sparer tid og kræfter sammenlignet med traditionelle for-loops. De er nyttige i virkelige applikationer som databehandling, kortlægning og transformation.

Hvis du gerne vil videreudvikle din Python-viden og blive en rigtig professionel, til vores Python-kursus og se, hvordan vi skaber verdens bedste Python-brugere.