OrderedDict vs defaultdict vs dict

In python-Bibliothek, jetzt haben wir zwei Python-Implementierung von Wörterbüchern, die Unterklassen dict über die native dict geben.

Python-Befürworter haben es immer vorgezogen defaultdict über die Verwendung dict.setdefault wo es möglich ist. Auch die doc Zitate, die This technique is simpler and faster than an equivalent technique using dict.setdefault():

In ähnlicher Weise, wie die Wörterbücher nicht die Aufrechterhaltung der Ordnung, mit OrderedDict über die Verwendung dict gefolgt vom Sortieren der Elemente ist bevorzugt, wenn immer möglich, für die alternative Nutzung.

In der obige Fall, der code ist definitiv sauberer, aber auf Kosten von Einbußen bei der Leistung.

Während der Beantwortung und Kommentierung auf eine Frage python eindeutige Liste basiert auf Elementich stolperte über die performance-Einbußen über die native dict bei der Verwendung defaultdict und OrderedDict. Es scheint auch die Größe der Daten ist auch nicht unerheblich für die performance-Vorteil dict Lösung hat gegenüber anderen.

Ich glaube There should be one-- and preferably only one --obvious way to do it.so was ist der bevorzugte Weg?

InformationsquelleAutor der Frage Abhijit | 2013-10-28

  1. 48

    Es gibt nicht eine einzige Antwort und nicht eine, wahre und einzige dict. Zu viele Variablen, es hängt davon ab:

    1. Größe des Datensatzes;
    2. Anzahl eindeutiger Schlüssel;
    3. Geschwindigkeit der zugrunde liegenden Fabrik für defaultdict;
    4. Geschwindigkeit von OrderDict vs etwas später Bestell-Schritt;
    5. Version von Python.

    Ich bin verabscheuen zu verallgemeinern, aber hier sind einige Allgemeine Hinweise:

    1. Die Aussage This technique is simpler and faster than an equivalent technique using dict.setdefault() ist nur flach falsch. Es kommt auf die Daten;
    2. setdefault ist schneller und einfacher mit kleinen Datensätzen;
    3. defaultdict ist schneller für größere Datenmengen mit homogener key-sets;
    4. setdefault einen Vorteil mit mehr heterogenen-key-sets;
    5. diese Ergebnisse unterscheiden sich für Python 3 vs. Python 2;
    6. OrderedDict ist langsamer in allen anderen Fällen als ein Algorithmus, der hängt auf Bestellung und ist nicht leicht zu rekonstruieren oder zu Sortieren;
    7. Python 3 ist in der Regel schneller für die meisten dict Operationen;
    8. Python 3.6 s dict ist nun bestellt durch insertion um.

    Die einzige Wahrheit: Es Hängt! Alle drei Verfahren sind nützlich.

    Hier ist etwas timing-code zu zeigen:

    from __future__ import print_function
from collections import defaultdict
from collections import OrderedDict

try:
    t=unichr(100)
except NameError:
    unichr=chr

def f1(li):
    '''defaultdict'''
    d = defaultdict(list)
    for k, v in li:
        d[k].append(v)
    return d.items()

def f2(li):
    '''setdefault'''
    d={}
    for k, v in li:
        d.setdefault(k, []).append(v)
    return d.items()

def f3(li):
    '''OrderedDict'''
    d=OrderedDict()
    for k, v in li:
        d.setdefault(k, []).append(v)
    return d.items()      


if __name__ == '__main__':
    import timeit
    import sys
    print(sys.version)
    few=[('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
    fmt='{:>12}: {:10.2f} micro sec/call ({:,} elements, {:,} keys)'
    for tag, m, n in [('small',5,10000), ('medium',20,1000), ('bigger',1000,100), ('large',5000,10)]:
        for f in [f1,f2,f3]:
            s = few*m
            res=timeit.timeit("{}(s)".format(f.__name__), setup="from __main__ import {}, s".format(f.__name__), number=n)
            st=fmt.format(f.__doc__, res/n*1000000, len(s), len(f(s)))
            print(st)
            s = [(unichr(i%0x10000),i) for i in range(1,len(s)+1)]
            res=timeit.timeit("{}(s)".format(f.__name__), setup="from __main__ import {}, s".format(f.__name__), number=n)
            st=fmt.format(f.__doc__, res/n*1000000, len(s), len(f(s)))
            print(st)            
        print()

    Python 2.7 Ergebnis:

    2.7.5 (default, Aug 25 2013, 00:04:04) 
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)]
 defaultdict:      10.20 micro sec/call (25 elements, 3 keys)
 defaultdict:      21.08 micro sec/call (25 elements, 25 keys)
  setdefault:      13.41 micro sec/call (25 elements, 3 keys)
  setdefault:      18.24 micro sec/call (25 elements, 25 keys)
 OrderedDict:      49.47 micro sec/call (25 elements, 3 keys)
 OrderedDict:     102.16 micro sec/call (25 elements, 25 keys)

 defaultdict:      28.28 micro sec/call (100 elements, 3 keys)
 defaultdict:      79.78 micro sec/call (100 elements, 100 keys)
  setdefault:      45.68 micro sec/call (100 elements, 3 keys)
  setdefault:      68.66 micro sec/call (100 elements, 100 keys)
 OrderedDict:     117.78 micro sec/call (100 elements, 3 keys)
 OrderedDict:     343.17 micro sec/call (100 elements, 100 keys)

 defaultdict:    1123.60 micro sec/call (5,000 elements, 3 keys)
 defaultdict:    4250.44 micro sec/call (5,000 elements, 5,000 keys)
  setdefault:    2089.86 micro sec/call (5,000 elements, 3 keys)
  setdefault:    3803.03 micro sec/call (5,000 elements, 5,000 keys)
 OrderedDict:    4399.16 micro sec/call (5,000 elements, 3 keys)
 OrderedDict:   16279.14 micro sec/call (5,000 elements, 5,000 keys)

 defaultdict:    5609.39 micro sec/call (25,000 elements, 3 keys)
 defaultdict:   25351.60 micro sec/call (25,000 elements, 25,000 keys)
  setdefault:   10267.00 micro sec/call (25,000 elements, 3 keys)
  setdefault:   24091.51 micro sec/call (25,000 elements, 25,000 keys)
 OrderedDict:   22091.98 micro sec/call (25,000 elements, 3 keys)
 OrderedDict:   94028.00 micro sec/call (25,000 elements, 25,000 keys)

    Python 3.3 Ergebnis:

    3.3.2 (default, May 21 2013, 11:50:47) 
[GCC 4.2.1 Compatible Apple Clang 4.1 ((tags/Apple/clang-421.11.66))]
 defaultdict:       8.58 micro sec/call (25 elements, 3 keys)
 defaultdict:      21.18 micro sec/call (25 elements, 25 keys)
  setdefault:      10.42 micro sec/call (25 elements, 3 keys)
  setdefault:      14.58 micro sec/call (25 elements, 25 keys)
 OrderedDict:      45.43 micro sec/call (25 elements, 3 keys)
 OrderedDict:      92.69 micro sec/call (25 elements, 25 keys)

 defaultdict:      20.47 micro sec/call (100 elements, 3 keys)
 defaultdict:      77.48 micro sec/call (100 elements, 100 keys)
  setdefault:      34.22 micro sec/call (100 elements, 3 keys)
  setdefault:      54.86 micro sec/call (100 elements, 100 keys)
 OrderedDict:     107.37 micro sec/call (100 elements, 3 keys)
 OrderedDict:     318.98 micro sec/call (100 elements, 100 keys)

 defaultdict:     714.70 micro sec/call (5,000 elements, 3 keys)
 defaultdict:    3892.92 micro sec/call (5,000 elements, 5,000 keys)
  setdefault:    1502.91 micro sec/call (5,000 elements, 3 keys)
  setdefault:    2888.08 micro sec/call (5,000 elements, 5,000 keys)
 OrderedDict:    3912.95 micro sec/call (5,000 elements, 3 keys)
 OrderedDict:   14863.02 micro sec/call (5,000 elements, 5,000 keys)

 defaultdict:    3649.02 micro sec/call (25,000 elements, 3 keys)
 defaultdict:   22313.17 micro sec/call (25,000 elements, 25,000 keys)
  setdefault:    7447.28 micro sec/call (25,000 elements, 3 keys)
  setdefault:   18426.88 micro sec/call (25,000 elements, 25,000 keys)
 OrderedDict:   19202.17 micro sec/call (25,000 elements, 3 keys)
 OrderedDict:   85946.45 micro sec/call (25,000 elements, 25,000 keys)

    InformationsquelleAutor der Antwort dawg

  2. 7

    Ich das Gefühl, dass Ihre Annahme - nur eine bevorzugte Art und Weise - nicht halten. Ich sehe mindestens zwei Fällen mit unterschiedlichen Anforderungen:

    In wartungsintensiv code (z.B. eine option-parser für eine sich entwickelnde utility-Klasse) würde ich immer sauberer codeso dass die anderen und ich kann die Umsetzung der neuen features leichter. Die Leistung ist nicht kritisch, da nur kleine Mengen (z.B. ein dict-Benutzer-Einstellungen) bearbeitet werden.

    während in

    die Umsetzung einer performance-kritische Algorithmus in a data processing task, ich würde nicht dagegen schreiben ein bisschen mehr verbose code für die viel schnellere Ausführung. Wenn die alorithm ist unwahrscheinlich zu ändern, die etwas weniger lesbaren code wird nicht zu einem Problem werden.

    InformationsquelleAutor der Antwort ojdo

Schreibe einen Kommentar