deepcopy() ist extrem langsam

Habe ich ein Spiel state in Python mit über 1000 Objekten (planetarische Systeme + Sterne + Planeten), und ich brauche, um es zu kopieren und anwenden einer Reihe von Transformationen, wenn gewünscht. Aber bei über 1 request/Sekunde, das ist nehmen 24.63% meiner Spielzeit. Wie kann ich es machen das schnell gehen? Beachten Sie, dass das kopieren weniger ist keine option, da die Transformationen berühren Sie einfach über alles.

BEARBEITEN: habe es bis zu 8% mit klugen Umsetzung von __deepcopy__ auf die Dinge. Noch, nicht gut genug. (Gut genug ist 1% oder weniger, ich habe vor, werfen viele weitere Dinge an.) timeit sagt 41.8 ms pro deepcopy().

Alternativ zu dem kopieren der Staat, könnten Sie eine Aktion erstellen, queue: Verwenden Sie den aktuellen Zustand zu bestimmen, die nächsten Aktionen und Effekte für alle Objekte, ohne Sie gleich an, dann gelten all diese Aktionen in eine batch -, dann berechnen Sie die Aktionen für den nächsten 'turn', etc.
Das ist eigentlich genau das, was mein Haufen verwandelt tut, aber ich muss es tun, um wieder ganz oft, also das kopieren.
Dann verstehe ich nicht die Frage: bewerben Sie sich verschiedene Gruppen von Maßnahmen, um den gleichen Zustand. vielleicht um zu sehen, welche kommen am besten an?
Yup. Gut, nicht, um zu sehen, welche kommen am besten, aber das ist, was ich Tue.
Andere Idee: Vielleicht kann man eine Art "diff-state", also wie "dieses ist x und y und alles andere ist das gleiche wie im übergeordneten Zustand z".
Ja, aber Zugriff auf die Ausgabe-ohne änderung an den ursprünglichen Zustand, ich brauche immer noch eine Kopie.
Aber würden Sie nicht brauchen, um zu kopieren Sie den gesamten Staat, wenn diese Aktionen ändern sich nur, sagen wir, 10% von ihm. Legen Sie fest, was diese 10% werden in die "Kopie" des Staates und halten einen Verweis zurück auf den ursprünglichen Zustand, für die restlichen 90%.
Warum nicht 'kopieren ()', die eine flache Kopie ? Ich sehe nicht den Punkt, wo Sie brauchen eine deepcopy().
Das funktioniert vielleicht, aber es wäre eine Menge Arbeit zu pflegen die internen Verweise.
Ich muss eine Tiefe Kopie, da der Staat Objekt hat Objekte, die ich brauche Kopien.

InformationsquelleAutor Electro | 2014-07-15

Eigentlich deepcopy ist sehr langsam. Aber wir können die json verwenden, ujson, oder cPickle.
wir verwenden json/cPickle dump ein Objekt und laden Sie es später.
Das ist mein test:

Total time: 3.46068 s
File: test_deepcopy.py
Function: test at line 15
Line #   Hits          Time Per Hit   % Time  Line Contents
==============================================================
15                                             @profile
16                                             def test():
17       100       957585   9575.9     27.7        b = deepcopy(a)
18       100          862      8.6      0.0        c = copy(a)
19       100        42295    422.9      1.2        d = ujson.loads(ujson.dumps(a))
20       100        85040    850.4      2.5        e = json.loads(json.dumps(a))
21       100      2323465  23234.7     67.1        f = pickle.loads(pickle.dumps(a, -1))
22       100        51434    514.3      1.5        g = cPickle.loads(cPickle.dumps(a, -1))

als das, was wir sehen können, json/ujson/cPickle ist schneller als deepcopy, aber Gurke...

Das ist beängstigend. Was bedeutet deepcopy tun, dass cPickle nicht?
Ich weiß nicht... Sie können etwas finden, nützlich, hier 🙂
Ich habe einige Tests und festgestellt, dass deepcopy besser als json-auf den Listen der Wörterbücher während der json übertroffen deepcopy auf großen verschachtelten dictionaries.

InformationsquelleAutor cherish

3

Wenn Sie erstellen Sie Ihre eigenen Klasse zu halten, diese Objekte kann man erstellen Sie Ihre eigenen Methoden, die Arbeit mit Kopie und Tiefe Kopie. ~~http://www.rafekettler.com/magicmethods.html#copying~~ (Broken Link)

Neues Link für ein github-repository https://github.com/RafeKettler/magicmethods
```
class MyClass():
    def __copy__(self):
        copy_object = MyClass()
        return copy_object

    def __deepcopy__(self, memodict={}):
        copy_object = MyClass()
        copy_object.value = self.value
        return copy_object

if __name__ == "__main__":
    my_inst = MyClass()
    print(copy.deepcopy(my_inst))
```
Hier ist eine ähnliche Beschreibung aus dem vorherigen Defekten link.

Kopieren

Manchmal, besonders wenn es um veränderliche Objekte, die Sie möchten in der Lage sein, um ein Objekt zu kopieren und die änderungen nicht auf das, was Sie kopiert. Dies ist, wo die Python-Kopie ins Spiel kommt. Allerdings (zum Glück), Python-Module, die nicht fühlenden, so dass wir nicht haben, um sorgen über eine Linux-basierte Roboter-Aufstand, aber wir müssen sagen, Python, wie effizient kopieren die Dinge.

__copy__(self)

Definiert Verhalten für die Kopie.copy() für Instanzen der Klasse. kopieren.copy() liefert eine flache Kopie des Objekts-das bedeutet, dass, während die Instanz selbst ist eine neue Instanz, alle seine Daten auf die verwiesen wird, D. H., das Objekt selbst kopiert wird, sondern seine Daten noch referenzierten (und damit änderungen der Daten in eine flache Kopie kann dazu führen, dass Veränderungen im original).

__deepcopy__(self, memodict={})

Definiert Verhalten für die Kopie.deepcopy() für Instanzen der Klasse. kopieren.deepcopy() liefert eine Tiefe Kopie des Objekts -- das Objekt und seine Daten werden beide kopiert. memodict ist ein cache, der vorher kopierten Objekte-diese optimiert das kopieren und verhindert eine unendliche Rekursion beim kopieren von rekursiven Datenstrukturen. Wenn Sie wollen, um Tiefe Kopie ein individuelles Attribut, rufen Sie dann kopieren.deepcopy() auf das Attribut mit memodict wie das erste argument.
Was sind einige Anwendungsfälle für diese Magische Methoden? Wie immer, in jedem Fall, wo Sie brauchen, mehr feinkörnige Kontrolle über das, was dem default-Verhalten gibt. Zum Beispiel, wenn Sie versuchen, um ein Objekt zu kopieren, speichert ein cache in einem Wörterbuch (die große), ist es möglicherweise nicht sinnvoll, Sie zu kopieren Sie den cache sowie -- wenn der cache freigegeben werden können im Speicher zwischen Instanzen, dann sollte es sein.
- Das ist eigentlich, was ich gerade verfolgt. Allerdings habe ich nur es bis zu 8% meiner Spielzeit. Dinge gelernt: deepcopying eine sortedcontainers.SortedListWithKey langsam ist, listify Sie es zuerst. Auch das kopieren itertools.count() ist langsam, was wahrscheinlich für Generatoren im Allgemeinen.
- Ich fand eine ähnliche Beschreibung für das kopieren und fügte ihn unten meine Antwort. Ich fand auch, dass es ein github-repository für diesen link.
InformationsquelleAutor justengel

Habe ich eine schnelle experiment vergleicht man beide deepcopy/json/ujson für mehrere Fälle und meine Ergebnisse widerspricht @hegen diejenigen, die auf bestimmte Fälle, die Entsendung der kleine experiment hier:

import ujson
import timeit
import json
import random
import string
import copy
import ujson
import sys


def random_string(N):
    return ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(N))


def random_json(width=5, height=5, levels=1):
    dct = {}
    lst = [random_string(4) for i in range(width)]
    lst2 = [random.randint(0, 10000) for i in range(width)]
    lst3 = [bool(random.randint(0, 1)) for i in range(width)]
    for j in range(height):
        dct[str(j)] = lst
        dct[str(width+j)] = lst2
        dct[str(2*width+j)] = lst3

    for i in range(levels):
        new_dct = {}
        for j in range(height):
            new_dct[str(j)] = dct
        dct = json.loads(json.dumps(new_dct))

    return new_dct

if __name__ == "__main__":
    print(sys.version)
    levels = 3
    for i in range(15):
        dataset = random_json(i, i, levels)
        print("Comparing deepcopy/ujson/json using random dataset({},{},{}), length {}".format(i,i,levels, len(json.dumps(dataset))))
        print(timeit.timeit('copy.deepcopy(dataset)',
                            setup='from __main__ import copy, dataset', number=10))
        print(timeit.timeit('ujson.loads(ujson.dumps(dataset))',
                            setup='from __main__ import ujson, dataset', number=10))
        print(timeit.timeit('json.loads(json.dumps(dataset))',
                            setup='from __main__ import json, dataset', number=10))
        print()

Und das Ergebnis wäre:

3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:04:45) [MSC v.1900 32 bit (Intel)]
Comparing deepcopy/ujson/json using random dataset(0,0,3), length 2
2.6842977659931844e-05
0.00012039864979822371
7.776568527950847e-05

Comparing deepcopy/ujson/json using random dataset(1,1,3), length 63
0.0002731667726569534
3.552747043226263e-05
0.00012987264191349377

Comparing deepcopy/ujson/json using random dataset(2,2,3), length 1106
0.0011858280130946362
0.00034974820892205325
0.0007093651596308467

Comparing deepcopy/ujson/json using random dataset(3,3,3), length 6834
0.0042218477363672215
0.0021178319874343293
0.003378267688436718

Comparing deepcopy/ujson/json using random dataset(4,4,3), length 26572
0.011379054029782284
0.006288757016181971
0.009920059244030693

Comparing deepcopy/ujson/json using random dataset(5,5,3), length 79210
0.028879491215043435
0.027906433274870912
0.029595961868760734

Comparing deepcopy/ujson/json using random dataset(6,6,3), length 183678
0.047142979515255284
0.04682125853300759
0.06791747047568517

Comparing deepcopy/ujson/json using random dataset(7,7,3), length 395528
0.08239215142913198
0.09871347134571351
0.15347433002098887

Comparing deepcopy/ujson/json using random dataset(8,8,3), length 764920
0.1351954464835896
0.19448842613700734
0.3020533693660834

Comparing deepcopy/ujson/json using random dataset(9,9,3), length 1356570
0.24560258734724671
0.44074906118659407
0.5705849913806413

Comparing deepcopy/ujson/json using random dataset(10,10,3), length 2287770
0.3237815755327835
0.61104051671153
0.8698565598118777

Comparing deepcopy/ujson/json using random dataset(11,11,3), length 3598750
0.4958284828467452
0.9472223636741877
1.2514314609961668

Comparing deepcopy/ujson/json using random dataset(12,12,3), length 5636414
0.6261448233909714
1.4066722957969802
1.8636325417418167

Comparing deepcopy/ujson/json using random dataset(13,13,3), length 8220800
0.8396582099444547
2.061675688670409
2.755659427352441

Comparing deepcopy/ujson/json using random dataset(14,14,3), length 12018290
1.0951926990258762
2.96703050743886
4.088875914783021

Fazit aus diesem kleinen experiment ist:

Wenn Wörterbücher sind kleine time(ujson)<time(json)<time(deepcopy)
Wenn Wörterbücher sind grosse time(deepcopy)<time(ujson)<time(json)

Also es hängt von der Anzahl der Kopien, die Sie machen pro Sekunde und welche Art von Wörterbuch Sie zu tun haben, werden Sie lieber Umschalten zwischen deepcopy oder ujson.

InformationsquelleAutor BPL

0

Sie können Ihre eigene Kopie von Funktionen zu den Objekten, so dass Sie nicht brauchen, Tiefe Kopie. Tiefe Kopie prüft jedes Objekt zu überprüfen, was kopiert werden muss. Dies ist ein teurer Vorgang.
- Ich muss eine Tiefe Kopie von allem. Die bits, die sind verwandelt, sind auch die zahlreichen, und sind damit zu deepcopy() mehr Arbeit zu tun.
- Ich denke was er meinte ist, schreiben Sie Ihre eigenen tiefen Kopie Methode, die kopieren alles, nur ohne die reclection/Introspektion Teil.
- Ich kann das nicht Lesen und verstehen. Oops. Hmm, aber ist die Introspektion, die wirklich die teure operation des deepcopy()?
- Ja, deepcopy() hat, um sicherzustellen, dass kein Referenz-loops wird angezeigt, etc... Es gibt auch eine Menge von Buchhaltung beteiligt. Siehe here here - und hier.
InformationsquelleAutor Bort

Basis auf @BPL-test-Programm und fügen Marschall auf meinem ARMv6-kompatibler Prozessor

print(timeit.timeit('marshal.loads(marshal.dumps(dataset))',
       setup='from __main__ import marshal, dataset', number=1))

Marschall ist schnell als ujson und support-set-und Tupel

2.7.14 (default, Mar  6 2019, 13:27:55)
[GCC 7.3.0]
Comparing deepcopy/marshal/ujson/json using random dataset(0,0,1), length 2
0.000588178634644
0.000134944915771
0.000258922576904
0.00113606452942
()
Comparing deepcopy/marshal/ujson/json using random dataset(0,0,3), length 2
0.000546932220459
0.000134944915771
0.000180006027222
0.00120401382446
()
Comparing deepcopy/marshal/ujson/json using random dataset(0,0,5), length 2
0.000545978546143
0.000128984451294
0.000185966491699
0.00106000900269
()
Comparing deepcopy/marshal/ujson/json using random dataset(0,2,1), length 50
0.00154900550842
0.000281810760498
0.000414848327637
0.00174903869629
()
Comparing deepcopy/marshal/ujson/json using random dataset(0,2,3), length 242
0.00655102729797
0.000789880752563
0.00133085250854
0.00432300567627
()
Comparing deepcopy/marshal/ujson/json using random dataset(0,2,5), length 1010
0.0514280796051
0.0015549659729
0.00413513183594
0.0148711204529
()
Comparing deepcopy/marshal/ujson/json using random dataset(0,4,1), length 172
0.00250005722046
0.000365018844604
0.000761985778809
0.00263404846191
()
Comparing deepcopy/marshal/ujson/json using random dataset(0,4,3), length 2892
0.0329101085663
0.00363397598267
0.0110101699829
0.0262169837952
()
Comparing deepcopy/marshal/ujson/json using random dataset(0,4,5), length 46412
0.616458892822
0.0826110839844
0.189103841782
0.504135131836
()
Comparing deepcopy/marshal/ujson/json using random dataset(2,0,1), length 2
0.000693082809448
0.000132083892822
0.000182867050171
0.00107002258301
()
Comparing deepcopy/marshal/ujson/json using random dataset(2,0,3), length 2
0.000566005706787
0.000132083892822
0.000180959701538
0.00107598304749
()
Comparing deepcopy/marshal/ujson/json using random dataset(2,0,5), length 2
0.000562906265259
0.000128984451294
0.000184059143066
0.00118517875671
()
Comparing deepcopy/marshal/ujson/json using random dataset(2,2,1), length 258
0.00405406951904
0.000534057617188
0.00124287605286
0.00309610366821
()
Comparing deepcopy/marshal/ujson/json using random dataset(2,2,3), length 1058
0.026270866394
0.00180387496948
0.00363302230835
0.0096640586853
()
Comparing deepcopy/marshal/ujson/json using random dataset(2,2,5), length 4338
0.0778729915619
0.00682806968689
0.0151469707489
0.0468928813934
()
Comparing deepcopy/marshal/ujson/json using random dataset(2,4,1), length 716
0.00720596313477
0.00100684165955
0.0215280056
0.0062358379364
()
Comparing deepcopy/marshal/ujson/json using random dataset(2,4,3), length 11468
0.112984895706
0.0238728523254
0.0448131561279
0.0874760150909
()
Comparing deepcopy/marshal/ujson/json using random dataset(2,4,5), length 183628
1.83552503586
0.407335042953
0.617804050446
1.65498495102
()
Comparing deepcopy/marshal/ujson/json using random dataset(4,0,1), length 2
0.000571012496948
0.000132083892822
0.000189781188965
0.00121593475342
()
Comparing deepcopy/marshal/ujson/json using random dataset(4,0,3), length 2
0.000757932662964
0.000131130218506
0.000180959701538
0.00144195556641
()
Comparing deepcopy/marshal/ujson/json using random dataset(4,0,5), length 2
0.00056791305542
0.000132083892822
0.000184059143066
0.00107407569885
()
Comparing deepcopy/marshal/ujson/json using random dataset(4,2,1), length 430
0.00451302528381
0.00053596496582
0.00142502784729
0.00343203544617
()
Comparing deepcopy/marshal/ujson/json using random dataset(4,2,3), length 1730
0.0259549617767
0.00232696533203
0.00387692451477
0.0187470912933
()
Comparing deepcopy/marshal/ujson/json using random dataset(4,2,5), length 7026
0.112207174301
0.0119769573212
0.0211799144745
0.0547370910645
()
Comparing deepcopy/marshal/ujson/json using random dataset(4,4,1), length 1684
0.00609397888184
0.00121903419495
0.00452899932861
0.00959086418152
()
Comparing deepcopy/marshal/ujson/json using random dataset(4,4,3), length 26828
0.19367814064
0.0293428897858
0.0688338279724
0.140627145767
()
Comparing deepcopy/marshal/ujson/json using random dataset(4,4,5), length 433484
3.54843020439
0.590909004211
1.09412097931
2.72070598602

InformationsquelleAutor Ritzen Yang

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.