Gibt es einen besseren Weg, um eine Liste mit einem Wörterbuch in Python mit Tasten, aber keine Werte zu konvertieren?

Question

ich sicher war, dass es wäre ein Motto, eine Liste zu einem Wörterbuch zu konvertieren, wo die Elemente in der Liste waren Schlüssel und das Wörterbuch und keine Werte.

Die einzige Art, wie ich es wurde argumentiert, gegen tun finden.

„Verwenden Listenkomprehensionen, wenn das Ergebnis ignoriert wird, ist irreführend und ineffizient. Eine for Schleife ist besser“

myList = ['a','b','c','d']
myDict = {}
x=[myDict.update({item:None}) for item in myList]

>>> myDict
{'a': None, 'c': None, 'b': None, 'd': None}

Es funktioniert, aber es gibt einen besseren Weg, dies zu tun?

Answer 1

Verwenden dict.fromkeys:

>>> my_list = [1, 2, 3]
>>> dict.fromkeys(my_list)
{1: None, 2: None, 3: None}

Werte Standard None, aber man kann sich als optionales Argument angeben:

>>> my_list = [1, 2, 3]
>>> dict.fromkeys(my_list, 0)
{1: 0, 2: 0, 3: 0}

Aus der Dokumentation:

  

a.fromkeys (f [, Wert]) Erstellt eine neue   Wörterbuch mit Schlüsseln aus Seq und   Werte eingestellt Wert.

     

dict.fromkeys ist eine Klasse, Methode,   gibt ein neues Wörterbuch. Wert   Standardwerte Keine. Neu in der Version 2.3.

Answer 2

Sie könnten einen anstelle eines dict:

>>> myList=['a','b','c','d']
>>> set(myList)
set(['a', 'c', 'b', 'd'])

Das ist besser, wenn Sie nie Werte speichern müssen, und sind nur eine ungeordnete Sammlung von Unikaten zu speichern.

Answer 3

Um die ursprüngliche Fragestellers Performance Sorgen (für Lookups in dict vs set) zu beantworten, etwas überraschend, dict Lookups können minutiös schneller werden (in Python 2.5.1 auf meinem eher langsamen Laptop) unter der Annahme, zum Beispiel dass die Hälfte der Lookups scheitern und die Hälfte erfolgreich zu sein. Hier ist, wie man geht darum, herauszufinden:

$ python -mtimeit -s'k=dict.fromkeys(range(99))' '5 in k and 112 in k'
1000000 loops, best of 3: 0.236 usec per loop
$ python -mtimeit -s'k=set(range(99))' '5 in k and 112 in k'
1000000 loops, best of 3: 0.265 usec per loop

jede Prüfung mehrmals tun, um zu überprüfen, sie wiederholbar sind. Also, wenn diese 30 ns oder weniger auf einem langsamen Laptop in einem ganz entscheidenden Engpass sind, kann es sich lohnen, gehen für die dunkle dict.fromkeys Lösung eher als die einfache, klar, lesbar und eindeutig richtig set (ungewöhnlich - fast immer in Python die einfache und direkte Lösung hat zu Leistungsvorteil).

Natürlich muss man mit dem eigenen Python-Version, Maschine, Daten, und das Verhältnis von erfolgreichen zu überprüfen Tests vs Fehlern, und bestätigt mit extrem genauer Profilierung, dass Rasieren 30 ns (oder was auch immer) aus diese Suche wird einen wichtigen Unterschied machen.

Zum Glück, in der überwiegenden Mehrzahl der Fälle wird dies völlig unnötig erweisen ... aber da Programmierer obsess über sinnlose Mikro-Optimierungen sowieso , egal wie viele Zeiten, die sie über ihre Irrelevanz gesagt sind, dann ist das timeit Modul direkt in der Standardbibliothek jene meist-bedeutungslos Mikro-Benchmarks leicht sowieso zu machen! -)

Answer 4

Und hier ist ein ziemlich falsch und ineffizienter Weg, es mit der Karte zu tun:

>>> d = dict()
>>> map (lambda x: d.__setitem__(x, None), [1,2,3])
[None, None, None]
>>> d
{1: None, 2: None, 3: None}

Answer 5

Sie können eine Liste Verständnis verwenden:

my_list = ['a','b','c','d']
my_dict = dict([(ele, None) for ele in my_list])

Answer 6

Vielleicht können Sie itertools verwenden:

>>>import itertools
>>>my_list = ['a','b','c','d']
>>>d = {}
>>>for x in itertools.imap(d.setdefault, my_list): pass
>>>print d
{'a': None, 'c': None, 'b': None, 'd': None}

Für riesige Listen, vielleicht ist dies sehr gut: P