Indtil nu har vi set måder at oprette en ordbog på på flere måder og forskellige operationer på nøglen og værdierne i Python ordbog . Lad os nu se forskellige måder at oprette en ordbog over lister på. Bemærk, at begrænsningen med nøgler i Python ordbog er kun uforanderlige datatyper kan bruges som nøgler, hvilket betyder at vi ikke kan bruge en ordbog over lister som nøgle.
Eksempel :
Input: myDict = {} myDict['key1'] = [1, 2] # Adding list as value myDict['key2'] = ['Geeks', 'For', 'Geeks'] Output: {'key2': ['Geeks', 'For', 'Geeks'], 'key1': [1, 2]} Explanation: In the output, we have a dictionary of lists.> Problemformulering
Vi fik generelt typrorfejlen, hvis vi forsøger at implementere den på normal vis.
Python3
# Creating a dictionary> myDict>=> {[>1>,>2>]:>'Geeks'>}> print>(myDict)> |
>
>
Produktion:
TypeError: unhashable type: 'list'>
Men det samme kan gøres meget klogt med værdier i en ordbog. Lad os se alle de forskellige måder, vi kan oprette en ordbog over lister på.
Måder at oprette en ordbog over lister
Nedenfor er de emner, som vi vil dække i denne artikel:
typer netværk
- Ved brug af abonnent
- Bruger append() metode
- Bruger setdefault() metode
- Ved brug af listeforståelse
- Ved brug af defaultdict
- Ved brug af Json.dumb() metode
- Ved brug af itertools modul
Opret en ordbog over lister ved hjælp af subscript
Denne kode initialiserer en tom ordbog myDict>. Det tilføjer derefter to nøgleværdi-par til ordbogen:'key1'>med værdien[1, 2]>, og'key2'>med værdien['Geeks', 'For', 'Geeks']>. Til sidst udskriver koden indholdet af ordbogen.
Python3
# Creating an empty dictionary> myDict>=> {}> # Adding list as value> myDict[>'key1'>]>=> [>1>,>2>]> myDict[>'key2'>]>=> [>'Geeks'>,>'For'>,>'Geeks'>]> print>(myDict)> |
>
>
Produktion:
{'key2': ['Geeks', 'For', 'Geeks'], 'key1': [1, 2]}> Tidskompleksitet: O(1) for hver ordbogsindsættelse og udskrivning af ordbogen.
Hjælpeplads: O(n), hvor n er det samlede antal elementer i ordbogen.
Opret en ordbog over lister ved hjælp af append()-metoden
Tilføjelse af indlejret liste som en værdi ved hjælp af append() metode. Opret en ny liste, og vi kan blot tilføje den liste til værdien.
Python3
# Creating an empty dictionary> myDict>=> {}> # Adding list as value> myDict[>'key1'>]>=> [>1>,>2>]> # creating a list> lst>=> [>'Geeks'>,>'For'>,>'Geeks'>]> # Adding this list as sublist in myDict> myDict[>'key1'>].append(lst)> print>(myDict)> |
>
>
Produktion:
{'key1': [1, 2, ['Geeks', 'For', 'Geeks']]}> Tidskompleksitet: O(1).
Hjælperums kompleksitet: På).
Opret en ordbog over lister ved hjælp af setdefault()-metoden
Gentag listen og fortsæt med at tilføje elementerne indtil det givne område ved hjælp af setdefault() metode.
Python3
# Creating an empty dict> myDict>=> dict>()> # Creating a list> valList>=> [>'1'>,>'2'>,>'3'>]> # Iterating the elements in list> for> val>in> valList:> >for> ele>in> range>(>int>(val),>int>(val)>+> 2>):> >myDict.setdefault(ele, []).append(val)> print>(myDict)> |
>
>
Produktion:
{1: ['1'], 2: ['1', '2'], 3: ['2', '3'], 4: ['3']}> Tidskompleksitet: O(n^2)
Rumkompleksitet: På)
Oprettelse af ordbog over lister ved hjælp af listeforståelse
I listeforståelse vi itererer over værdierne'1'>,'2'>, og'3'>, og for hver værdi opretter den et nøgle-værdi-par i ordbogen. Nøglen er den aktuelle værdi, og værdien er et område af heltal, der starter fra værdien konverteret til et heltal og slutter ved værdien plus 1.
Python
# Creating a dictionary of lists using list comprehension> d>=> dict>((val,>range>(>int>(val),>int>(val)>+> 2>))> >for> val>in> [>'1'>,>'2'>,>'3'>])> print>(d)> |
>
>
Produktion:
{'1': [1, 2], '3': [3, 4], '2': [2, 3]}> Tidskompleksitet: O(1).
Hjælperums kompleksitet: På).
Oprettelse af ordbog over lister ved hjælp af defaultdict
Importer defaultdict klasse fra samlingsmodulet. Definer en liste over tupler først, hvor hver tupel indeholder et nøgleværdi-par. Opret et defaultdict-objekt kaldet orDict, der vil have standardværdier for en tom liste. Gentag listen over tupler først ved at bruge en for-løkke, og pak hver tuple ud i nøgle- og valvariablerne. Tilføj værdien val til den liste, der er knyttet til nøglen i ordbogen.
Udskriv den resulterende eller Dict-ordbog.
Bemærk : Det samme kan også gøres med en simpel ordbog, men at bruge defaultdict er mere effektivt i sådanne tilfælde.
Python3
from> collections>import> defaultdict> lst>=> [(>'Geeks'>,>1>), (>'For'>,>2>), (>'Geeks'>,>3>)]> orDict>=> defaultdict(>list>)> # iterating over list of tuples> for> key, val>in> lst:> >orDict[key].append(val)> print>(orDict)> |
>
>
Produktion:
defaultdict(, {'For': [2], 'Geeks': [1, 3]})> Tidskompleksitet: O(n).
Hjælperum: O(n).
Bemærk, at der kun er to nøgle: værdipar i outputordbogen, men inputlisten indeholder tre tupler. Det første element (dvs. nøgle) er det samme for den første og tredje tuple, og to nøgler kan aldrig være ens.
Oprettelse af en ordbog over lister ved hjælp af Json
Ved at importerejson>modul. Det initialiserer en listelst>indeholdende tupler. Så en tom ordbogdict>er initialiseret. Koden konverterer listenlst>ind i en JSON-formateret streng ved brug afjson.dumps()> , og tildeler denne streng som en nøgle i ordbogendict>med værdien omregnet. Til sidst trykkes ordbogen.
Python3
#importing json> import> json> #Initialisation of list> lst>=> [(>'Geeks'>,>1>), (>'For'>,>2>), (>'Geeks'>,>3>)]> #Initialisation of dictionary> dict> => {}> #using json.dump()> hash> => json.dumps(lst)> #creating a hash> dict>[>hash>]>=> 'converted'> #Printing dictionary> print>(>dict>)> |
>
>
Produktion:
{'[['Geeks', 1], ['For', 2], ['Geeks', 3]]': 'converted'}> Tidskompleksitet: O(n), hvor n er længden af listen lst.
Hjælpeplads: O(n), hvor n er længden af listen lst.
Oprettelse af ordbog over lister ved hjælp af itertools
En tilgang er at bruge zip_longest-funktionen fra itertools modul. Denne funktion giver dig mulighed for at iterere over to eller flere iterables på en parallel måde og udfylde eventuelle manglende elementer med en specificeret udfyldningsværdi.
Python3
from> itertools>import> zip_longest> # Initialize the lists> list1>=> [>1>,>2>,>3>]> list2>=> [>10>,>20>,>30>,>40>]> list3>=> [>'a'>,>'b'>,>'c'>,>'d'>,>'e'>]> # Use zip_longest to iterate over the lists in parallel> d>=> {}> for> elem1, elem2, elem3>in> zip_longest(list1, list2, list3, fillvalue>=>0>):> >d.setdefault(elem1, []).append(elem2)> >d.setdefault(elem1, []).append(elem3)> print>(d)> # Output: {1: [10, 'a'], 2: [20, 'b'], 3: [30, 'c'], 0: [40, 'd']}> |
>
>Produktion
{1: [10, 'a'], 2: [20, 'b'], 3: [30, 'c'], 0: [40, 'd', 0, 'e']}> Tidskompleksitet: O(n), hvor n er længden af den længste liste.
Hjælpeplads: På)