Til nå har vi sett måtene å lage en ordbok på på flere måter og forskjellige operasjoner på nøkkelen og verdiene i Python ordbok . La oss nå se forskjellige måter å lage en ordbok med lister på. Merk at begrensningen med nøkler i Python ordbok er bare uforanderlige datatyper kan brukes som nøkler, noe som betyr at vi ikke kan bruke en ordbok med lister som nøkkel.
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.> Problemstilling
Vi fikk generelt feilmeldingen hvis vi prøver å implementere den på normal måte.
Python3
# Creating a dictionary> myDict>=> {[>1>,>2>]:>'Geeks'>}> print>(myDict)> |
>
>
Produksjon:
TypeError: unhashable type: 'list'>
Men det samme kan gjøres veldig klokt med verdier i en ordbok. La oss se alle de forskjellige måtene vi kan lage en ordbok med lister på.
Måter å lage en ordbok med lister
Nedenfor er emnene vi vil dekke i denne artikkelen:
selen opplæring
- Ved hjelp av abonnement
- Bruker append() metode
- Bruker setdefault()-metoden
- Ved hjelp av listeforståelse
- Ved hjelp av defaultdict
- Ved hjelp av Json.dumb() metode
- Ved hjelp av itertools-modul
Opprett en ordbok med lister ved å bruke subscript
Denne koden initialiserer en tom ordbok myDict>. Den legger deretter til to nøkkelverdi-par til ordboken:'key1'>med verdien[1, 2]>, og'key2'>med verdien['Geeks', 'For', 'Geeks']>. Til slutt skriver koden ut innholdet i ordboken.
Python3
# Creating an empty dictionary> myDict>=> {}> # Adding list as value> myDict[>'key1'>]>=> [>1>,>2>]> myDict[>'key2'>]>=> [>'Geeks'>,>'For'>,>'Geeks'>]> print>(myDict)> |
>
>
Produksjon:
{'key2': ['Geeks', 'For', 'Geeks'], 'key1': [1, 2]}> Tidskompleksitet: O(1) for hver ordbokinnsetting og utskrift av ordboken.
Ekstra plass: O(n), hvor n er det totale antallet elementer i ordboken.
Lag en ordbok med lister ved å bruke append()-metoden
Legger til nestet liste som en verdi ved å bruke append() metode. Opprett en ny liste, så kan vi ganske enkelt legge den listen til verdien.
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)> |
>
>
Produksjon:
{'key1': [1, 2, ['Geeks', 'For', 'Geeks']]}> Tidskompleksitet: O(1).
Ekstra plass kompleksitet: På).
Lag en ordbok med lister ved å bruke setdefault()-metoden
Iterer listen og fortsett å legge til elementene til det gitte området ved å bruke setdefault()-metoden.
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)> |
>
>
Produksjon:
{1: ['1'], 2: ['1', '2'], 3: ['2', '3'], 4: ['3']}> Tidskompleksitet: O(n^2)
Plass kompleksitet: På)
Lage ordbok med lister ved hjelp av listeforståelse
I listeforståelse vi itererer over verdiene'1'>,'2'>, og'3'>, og for hver verdi oppretter den et nøkkelverdi-par i ordboken. Nøkkelen er gjeldende verdi, og verdien er et område med heltall som starter fra verdien konvertert til et heltall og slutter på verdien pluss 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)> |
>
>
Produksjon:
{'1': [1, 2], '3': [3, 4], '2': [2, 3]}> Tidskompleksitet: O(1).
Ekstra plass kompleksitet: På).
Lage ordbok over lister ved hjelp av defaultdict
Importer defaultdict klasse fra samlingsmodulen. Definer en liste over tupler først med hver tuppel som inneholder et nøkkelverdi-par. Opprett et defaultdict-objekt kalt orDict som vil ha standardverdier for en tom liste. Iterer over listen over tupler først ved å bruke en for-løkke og pakk ut hver tuppel i nøkkel- og valvariablene. Legg til verdien val til listen knyttet til nøkkelen i ordboken.
Skriv ut den resulterende eller Dict-ordboken.
Merk : Det samme kan også gjøres med en enkel ordbok, men bruk av defaultdict er mer effektivt for slike tilfeller.
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)> |
>
>
Produksjon:
defaultdict(, {'For': [2], 'Geeks': [1, 3]})> Tidskompleksitet: O(n).
Hjelperom: O(n).
Merk at det bare er to nøkkel: verdipar i utdataordboken, men inndatalisten inneholder tre tupler. Det første elementet (dvs. nøkkelen) er det samme for den første og tredje tuppelen, og to nøkler kan aldri være like.
Opprette en ordbok med lister ved hjelp av Json
Ved å importerejson>modul. Den initialiserer en listelst>som inneholder tupler. Så en tom ordbokdict>er initialisert. Koden konverterer listenlst>inn i en JSON-formatert streng ved hjelp avjson.dumps()> , og tilordner denne strengen som en nøkkel i ordbokendict>med verdien omregnet. Til slutt skrives ordboken ut.
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>)> |
>
>
Produksjon:
{'[['Geeks', 1], ['For', 2], ['Geeks', 3]]': 'converted'}> Tidskompleksitet: O(n), hvor n er lengden på listen lst.
Ekstra plass: O(n), hvor n er lengden på listen lst.
Lage ordbok over lister ved hjelp av itertools
En tilnærming er å bruke zip_longest-funksjonen fra itertools-modul. Denne funksjonen lar deg iterere over to eller flere iterables på en parallell måte, og fylle ut eventuelle manglende elementer med en spesifisert fyllverdi.
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']}> |
>
>Produksjon
{1: [10, 'a'], 2: [20, 'b'], 3: [30, 'c'], 0: [40, 'd', 0, 'e']}> Tidskompleksitet: O(n), hvor n er lengden på den lengste listen.
Ekstra plass: På)