मूल पोस्टर पर विचार करने के लिए दो बड़े विचार हैं:
- वहाँ keyspace clobbering मुद्दे हैं? उदाहरण के लिए, इसमें
{'a_b':{'c':1}, 'a':{'b_c':2}}परिणाम होगा {'a_b_c':???}। नीचे दिए गए समाधान जोड़े की पुनरावृत्ति को वापस करके समस्या को हल करते हैं।
- यदि प्रदर्शन एक मुद्दा है, तो की-रिड्यूसर फ़ंक्शन (जिसे मैं 'जॉइन' के रूप में संदर्भित करता हूं) को पूरे की-पाथ तक पहुंच की आवश्यकता होती है, या क्या यह पेड़ में प्रत्येक नोड पर O (1) काम कर सकता है? यदि आप कहना चाहते हैं
joinedKey = '_'.join(*keys), तो आपको O (N ^ 2) को चलाने में समय लगेगा। हालाँकि यदि आप यह कहना चाहते हैं nextKey = previousKey+'_'+thisKeyकि आपको O (N) समय मिलता है। नीचे दिए गए समाधान से आप दोनों कर सकते हैं (चूंकि आप सभी कुंजियों को केवल संक्षिप्त कर सकते हैं, फिर उन्हें पोस्टप्रोसेस कर सकते हैं)।
(प्रदर्शन की संभावना नहीं है कि कोई समस्या हो, लेकिन मैं दूसरे बिंदु पर विस्तार से बताऊंगा कि कोई और परवाह करता है: इसे लागू करने में, कई खतरनाक विकल्प हैं। यदि आप इसे पुनरावर्ती करते हैं और उपज और पुन: उपज, या कुछ भी जो छूता है के बराबर है। एक बार से अधिक नोड्स (जो गलती से ऐसा करने के लिए काफी आसान है), तो आप संभवतः हे (एन ^ 2) बल्कि हे (एन) की तुलना में काम कर रहे हैं। इसका कारण यह है हो सकता है आप एक महत्वपूर्ण गणना कर रहे हैं aतो a_1फिर a_1_i..., और फिर की गणना aतो a_1फिर a_1_ii..., लेकिन वास्तव में आपको a_1फिर से गणना नहीं करनी चाहिए । यहां तक कि अगर आप इसे पुनर्गणना नहीं कर रहे हैं, तो इसे फिर से उपजाना ('स्तर-दर-स्तर' दृष्टिकोण) उतना ही बुरा है। एक अच्छा उदाहरण। पर प्रदर्शन के बारे में सोचने के लिए {1:{1:{1:{1:...(N times)...{1:SOME_LARGE_DICTIONARY_OF_SIZE_N}...}}}})
नीचे एक फ़ंक्शन है flattenDict(d, join=..., lift=...)जो मैंने लिखा था जिसे कई उद्देश्यों के लिए अनुकूलित किया जा सकता है और आप जो चाहते हैं वह कर सकते हैं। अफसोस की बात है कि उपरोक्त प्रदर्शन का दंड दिए बिना इस समारोह का एक आलसी संस्करण बनाना काफी कठिन है (कई अजगर बिल्डरों जैसे कि चेन ।from_iterable वास्तव में कुशल नहीं हैं, जो मुझे केवल इस कोड के तीन अलग-अलग संस्करणों के व्यापक परीक्षण के बाद पता चला है यह वाला)।
from collections import Mapping
from itertools import chain
from operator import add
_FLAG_FIRST = object()
def flattenDict(d, join=add, lift=lambda x:x):
results = []
def visit(subdict, results, partialKey):
for k,v in subdict.items():
newKey = lift(k) if partialKey==_FLAG_FIRST else join(partialKey,lift(k))
if isinstance(v,Mapping):
visit(v, results, newKey)
else:
results.append((newKey,v))
visit(d, results, _FLAG_FIRST)
return results
यह समझने के लिए कि क्या चल रहा है, नीचे reduce(बाएं) से अपरिचित लोगों के लिए एक आरेख है , अन्यथा "तह बाएं" के रूप में जाना जाता है। कभी-कभी इसे k0 के स्थान पर प्रारंभिक मान के साथ खींचा जाता है (सूची का हिस्सा नहीं, फ़ंक्शन में पारित)। यहाँ, Jहमारा joinकार्य है। हम प्रत्येक k n के साथ प्रीप्रोसेस करते हैं lift(k)।
[k0,k1,...,kN].foldleft(J)
/ \
... kN
/
J(k0,J(k1,J(k2,k3)))
/ \
/ \
J(J(k0,k1),k2) k3
/ \
/ \
J(k0,k1) k2
/ \
/ \
k0 k1
यह वास्तव में वैसा ही है functools.reduce, लेकिन जहां हमारा कार्य पेड़ के सभी प्रमुख रास्तों पर होता है।
>>> reduce(lambda a,b:(a,b), range(5))
((((0, 1), 2), 3), 4)
प्रदर्शन (जो मैं अन्यथा docstring में डालूंगा):
>>> testData = {
'a':1,
'b':2,
'c':{
'aa':11,
'bb':22,
'cc':{
'aaa':111
}
}
}
from pprint import pprint as pp
>>> pp(dict( flattenDict(testData, lift=lambda x:(x,)) ))
{('a',): 1,
('b',): 2,
('c', 'aa'): 11,
('c', 'bb'): 22,
('c', 'cc', 'aaa'): 111}
>>> pp(dict( flattenDict(testData, join=lambda a,b:a+'_'+b) ))
{'a': 1, 'b': 2, 'c_aa': 11, 'c_bb': 22, 'c_cc_aaa': 111}
>>> pp(dict( (v,k) for k,v in flattenDict(testData, lift=hash, join=lambda a,b:hash((a,b))) ))
{1: 12416037344,
2: 12544037731,
11: 5470935132935744593,
22: 4885734186131977315,
111: 3461911260025554326}
प्रदर्शन:
from functools import reduce
def makeEvilDict(n):
return reduce(lambda acc,x:{x:acc}, [{i:0 for i in range(n)}]+range(n))
import timeit
def time(runnable):
t0 = timeit.default_timer()
_ = runnable()
t1 = timeit.default_timer()
print('took {:.2f} seconds'.format(t1-t0))
>>> pp(makeEvilDict(8))
{7: {6: {5: {4: {3: {2: {1: {0: {0: 0,
1: 0,
2: 0,
3: 0,
4: 0,
5: 0,
6: 0,
7: 0}}}}}}}}}
import sys
sys.setrecursionlimit(1000000)
forget = lambda a,b:''
>>> time(lambda: dict(flattenDict(makeEvilDict(10000), join=forget)) )
took 0.10 seconds
>>> time(lambda: dict(flattenDict(makeEvilDict(100000), join=forget)) )
[1] 12569 segmentation fault python
... आह, यह मत सोचो कि एक मेरी गलती है ...
[मॉडरेशन मुद्दों के कारण महत्वहीन ऐतिहासिक नोट]
पायथन में सूचियों के एक शब्दकोश (2 स्तरों गहरे) के शब्दकोश के कथित नकल के बारे में :
इस प्रश्न का समाधान इस एक के संदर्भ में कार्यान्वित किया जा सकता है sorted( sum(flatten(...),[]) )। रिवर्स संभव नहीं है: जबकि यह सच है कि मूल्यों की flatten(...)एक उच्च क्रम संचायक मानचित्रण द्वारा कथित डुप्लिकेट से बरामद किया जा सकता है, एक कुंजी को ठीक नहीं कर सकते। (संपादित करें: यह भी पता चलता है कि कथित डुप्लिकेट स्वामी का प्रश्न पूरी तरह से अलग है, इसमें वह केवल 2-स्तरीय गहन शब्दकोशों के साथ ही व्यवहार करता है, हालांकि उस पृष्ठ का एक उत्तर सामान्य समाधान देता है।)