Până acum, am văzut modalități de a crea un dicționar în mai multe moduri și operațiuni diferite asupra cheii și valorilor din Python dicţionar . Acum, să vedem diferite moduri de a crea un dicționar de liste. Rețineți că restricția cu cheile în Piton Dicționarul este doar imuabil. Tipurile de date pot fi folosite ca chei, ceea ce înseamnă că nu putem folosi un dicționar de liste ca cheie.
Exemplu :
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.> Declarație problemă
În general, obținem typrerror dacă încercăm să o implementăm în mod normal.
Python3
# Creating a dictionary> myDict>=> {[>1>,>2>]:>'Geeks'>}> print>(myDict)> |
>
>
Ieșire:
TypeError: unhashable type: 'list'>
Dar același lucru se poate face foarte înțelept cu valorile dintr-un dicționar. Să vedem toate modalitățile diferite prin care putem crea un dicționar de liste.
Modalități de a crea un dicționar de liste
Mai jos sunt subiectele pe care le vom trata în acest articol:
- Folosind indicele
- Folosind metoda append().
- Folosind metoda setdefault().
- Folosind înțelegerea listei
- Folosind defaultdict
- Folosind Json.dumb() metodă
- Folosind modulul iertools
Creați un dicționar de liste folosind indicele
Acest cod inițializează un cod gol dicţionar myDict>. Apoi adaugă două perechi cheie-valoare la dicționar:'key1'>cu valoarea[1, 2]>, și'key2'>cu valoarea['Geeks', 'For', 'Geeks']>. În cele din urmă, codul imprimă conținutul dicționarului.
Python3
din punct de vedere lexicografic
# Creating an empty dictionary> myDict>=> {}> # Adding list as value> myDict[>'key1'>]>=> [>1>,>2>]> myDict[>'key2'>]>=> [>'Geeks'>,>'For'>,>'Geeks'>]> print>(myDict)> |
>
>
Ieșire:
care este 10 din 60
{'key2': ['Geeks', 'For', 'Geeks'], 'key1': [1, 2]}> Complexitatea timpului: O(1) pentru fiecare inserare de dicționar și imprimare a dicționarului.
Spatiu auxiliar: O(n), unde n este numărul total de elemente din dicționar.
Creați un dicționar de liste folosind metoda append().
Adăugarea listei imbricate ca valoare folosind metoda append(). Creați o nouă listă și pur și simplu putem adăuga acea listă la valoare.
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)> |
>
>
Ieșire:
{'key1': [1, 2, ['Geeks', 'For', 'Geeks']]}> Complexitatea timpului: O(1).
Complexitatea spațiului auxiliar: Pe).
Creați un dicționar de liste folosind metoda setdefault().
Repetați lista și continuați să adăugați elementele până la intervalul dat folosind metoda setdefault().
Python3
git status -s
# 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)> |
>
>
Ieșire:
{1: ['1'], 2: ['1', '2'], 3: ['2', '3'], 4: ['3']}> Complexitatea timpului: O(n^2)
Complexitatea spațiului: Pe)
Crearea dicționarului de liste folosind List Comprehension
În înțelegerea listei iterăm peste valori'1'>,'2'>, și'3'>, iar pentru fiecare valoare, creează o pereche cheie-valoare în dicționar. Cheia este valoarea curentă, iar valoarea este un interval de numere întregi care pornesc de la valoarea convertită într-un număr întreg și se termină la valoarea plus 1.
Piton
# 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)> |
>
>
Ieșire:
{'1': [1, 2], '3': [3, 4], '2': [2, 3]}> Complexitatea timpului: O(1).
Complexitatea spațiului auxiliar: Pe).
Crearea dicționarului de liste folosind defaultdict
Importă defaultdict clasa din modulul colecții. Definiți o listă de tupluri lst, fiecare tuplu conținând o pereche cheie-valoare. Creați un obiect defaultdict numit orDict care va avea valorile implicite ale unei liste goale. Repetați lista de tupluri lst folosind o buclă for și despachetați fiecare tuplu în variabilele cheie și val. Adăugați valoarea val la lista asociată cu cheia din dicționarul orDict.
Imprimați dicționarul rezultat sau Dict.
Notă : Același lucru se poate face și cu un dicționar simplu, dar utilizarea defaultdict este mai eficientă pentru astfel de cazuri.
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)> |
sortare cu găleată
>
>
Ieșire:
defaultdict(, {'For': [2], 'Geeks': [1, 3]})> Complexitatea timpului: O(n).
Spațiu auxiliar: O(n).
Rețineți că există doar două perechi cheie: valoare în dicționarul de ieșire, dar lista de intrare conține trei tupluri. Primul element (adică cheia) este același pentru primul și al treilea tuplu și două chei nu pot fi niciodată la fel.
Crearea unui dicționar de liste folosind Json
Prin importuljson>modul. Inițializează o listălst>conţinând tupluri. Apoi, un dicționar goldict>este inițializată. Codul convertește listalst>într-un șir formatat JSON folosindjson.dumps()> , și atribuie acest șir ca o cheie în dicționardict>cu valoarea convertită. În cele din urmă, dicționarul este tipărit.
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>)> |
>
>
Ieșire:
{'[['Geeks', 1], ['For', 2], ['Geeks', 3]]': 'converted'}> Complexitatea timpului: O(n), unde n este lungimea listei lst.
Spatiu auxiliar: O(n), unde n este lungimea listei lst.
Crearea dicționarului de liste folosind iertools
O abordare este să folosiți funcția zip_longest din modulul iertools. Această funcție vă permite să repetați peste două sau mai multe iterabile în paralel, completând orice elemente lipsă cu o valoare de umplere specificată.
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']}> |
>
>
vârsta salman khanIeșire
{1: [10, 'a'], 2: [20, 'b'], 3: [30, 'c'], 0: [40, 'd', 0, 'e']}> Complexitatea timpului: O(n), unde n este lungimea celei mai lungi liste.
Spatiu auxiliar: Pe)