Hittills har vi sett sätten att skapa en ordbok på flera sätt och olika operationer på nyckeln och värdena i Python lexikon . Låt oss nu se olika sätt att skapa en ordlista med listor. Observera att begränsningen med nycklar i Pytonorm ordbok är endast oföränderliga datatyper som kan användas som nycklar, vilket innebär att vi inte kan använda en ordlista med listor som nyckel.
Exempel :
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.> Problembeskrivning
Vi får vanligtvis typrorfelet om vi försöker implementera det på normalt sätt.
Python3
# Creating a dictionary> myDict>=> {[>1>,>2>]:>'Geeks'>}> print>(myDict)> |
>
>
Produktion:
TypeError: unhashable type: 'list'>
Men detsamma kan göras mycket klokt med värden i en ordbok. Låt oss se alla olika sätt vi kan skapa en ordlista med listor.
Sätt att skapa en ordbok med listor
Nedan är de ämnen som vi kommer att ta upp i den här artikeln:
- Använder sig av index
- Använda append() metod
- Använda setdefault() metod
- Använder sig av listförståelse
- Använder sig av defaultdict
- Använder sig av Json.dumb() metod
- Använder sig av itertools modul
Skapa en ordbok med listor med hjälp av subscript
Denna kod initierar en tom lexikon myDict>. Den lägger sedan till två nyckel-värdepar till ordboken:'key1'>med värdet[1, 2]>, och'key2'>med värdet['Geeks', 'For', 'Geeks']>. Slutligen skriver koden ut innehållet i ordboken.
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]}> Tidskomplexitet: O(1) för varje ordboksinsättning och utskrift av ordboken.
Extra utrymme: O(n), där n är det totala antalet element i ordboken.
Skapa en ordlista med listor med metoden append().
Lägga till kapslad lista som ett värde med hjälp av append() metod. Skapa en ny lista så kan vi helt enkelt lägga till den listan till värdet.
string.replaceall i java
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)> |
typ variabler java
>
>
Produktion:
{'key1': [1, 2, ['Geeks', 'For', 'Geeks']]}> Tidskomplexitet: O(1).
Hjälputrymmes komplexitet: På).
Skapa en ordlista med listor med metoden setdefault().
Iterera listan och fortsätt att lägga till elementen till det givna intervallet med hjälp av setdefault() metod.
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']}> Tidskomplexitet: O(n^2)
Utrymmes komplexitet: På)
Skapa ordlista med listor med hjälp av listförståelse
I listförståelse vi itererar över värdena'1'>,'2'>, och'3'>, och för varje värde skapas ett nyckel-värdepar i ordboken. Nyckeln är det aktuella värdet och värdet är ett intervall av heltal som börjar från värdet omvandlat till ett heltal och slutar på värdet plus 1.
Pytonorm
# 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]}> Tidskomplexitet: O(1).
Hjälputrymmes komplexitet: På).
Skapa ordbok över listor med standarddict
Importera defaultdict klass från samlingsmodulen. Definiera en lista med tupler först med varje tupel som innehåller ett nyckel-värdepar. Skapa ett defaultdict-objekt som heter orDict som kommer att ha standardvärden för en tom lista. Iterera över listan med tupler först med en for-loop och packa upp varje tupel i nyckel- och valvariablerna. Lägg till värdet val till listan som är associerad med nyckeln i ordboken.
Skriv ut den resulterande eller Diktordboken.
Notera : Samma sak kan också göras med en enkel ordbok men att använda defaultdict är mer effektivt för sådana fall.
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]})> Tidskomplexitet: O(n).
Hjälputrymme: O(n).
Observera att det bara finns två nyckel: värdepar i utdataordboken men inmatningslistan innehåller tre tupler. Det första elementet (d.v.s. nyckeln) är detsamma för den första och tredje tuppeln och två nycklar kan aldrig vara samma.
Skapa en ordlista med listor med Json
Genom att importerajson>modul. Den initierar en listalst>innehållande tupler. Sedan en tom ordbokdict>initieras. Koden konverterar listanlst>till en JSON-formaterad sträng använder sig avjson.dumps()> , och tilldelar denna sträng som en nyckel i ordbokendict>med värdet omräknat. Slutligen skrivs 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>)> |
>
>
Produktion:
{'[['Geeks', 1], ['For', 2], ['Geeks', 3]]': 'converted'}> Tidskomplexitet: O(n), där n är längden på listan lst.
Extra utrymme: O(n), där n är längden på listan lst.
Skapa ordbok över listor med hjälp av itertools
Ett tillvägagångssätt är att använda zip_longest-funktionen från itertools modul. Denna funktion låter dig iterera över två eller flera iterables på ett parallellt sätt, och fylla i alla saknade element med ett specificerat fyllvärde.
Python3
namn på usa stad
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']}> Tidskomplexitet: O(n), där n är längden på den längsta listan.
Extra utrymme: På)