মূল পোস্টারটি বিবেচনা করার জন্য দুটি বড় বিবেচ্য বিষয় রয়েছে:
- কী স্পেস ক্লোবার্বিংয়ের সমস্যা আছে? উদাহরণস্বরূপ,
{'a_b':{'c':1}, 'a':{'b_c':2}}ফলাফল হবে {'a_b_c':???}। নীচের সমাধানটি জোড়ের পুনরাবৃত্তিযোগ্য ফিরিয়ে সমস্যাটি থেকে মুক্তি দেয়।
- কর্মক্ষমতা যদি কোনও সমস্যা হয় তবে কী-রিডুসার ফাংশনটি (যার দ্বারা আমি 'যোগ' হিসাবে উল্লেখ করেছি) পুরো কী-পাথটিতে অ্যাক্সেসের প্রয়োজন আছে, বা এটি কেবল গাছের প্রতিটি নোডে ও (1) কাজ করতে পারে? যদি আপনি বলতে সক্ষম হন
joinedKey = '_'.join(*keys)তবে এটির জন্য আপনার ও (N ^ 2) ব্যয় করতে হবে। তবে আপনি যদি বলতে ইচ্ছুক হন তবে nextKey = previousKey+'_'+thisKeyএটি আপনাকে ও (এন) সময় দেয়। নীচের সমাধানটি আপনাকে উভয়ই করতে দেয় (যেহেতু আপনি কেবল সমস্ত কীগুলি একত্রিত করতে পারেন, তারপরে সেগুলি পোস্টপ্রসেস করুন)।
(পারফরম্যান্স সম্ভবত কোনও সমস্যা নয়, তবে অন্য কেউ যত্ন নেওয়ার ক্ষেত্রে আমি দ্বিতীয় পয়েন্টটি বিস্তারিতভাবে বর্ণনা করব: এটি বাস্তবায়নের ক্ষেত্রে, অনেক বিপজ্জনক পছন্দ রয়েছে you আপনি যদি এটি পুনরাবৃত্তভাবে করেন এবং ফলন এবং পুনরায় ফলন দেন, বা সমান কিছু যা স্পর্শ করে একাধিকবার নোড (যা ঘটনাক্রমে করতে বেশ সহজ), আপনি সম্ভাব্য 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 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(বাম) সাথে অপরিচিতদের জন্য একটি চিত্র রয়েছে যা অন্যথায় "ভাঁজ বাম" নামে পরিচিত। কখনও কখনও এটি কে 0 এর জায়গায় প্রাথমিক মান দিয়ে আঁকা হয় (তালিকার অংশ নয়, ফাংশনটিতে স্থান পেয়েছে)। এখানে,J আমাদের joinফাংশন। আমরা প্রতিটি কে এন সাথে প্রিপ্রোসেস করি 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)
বিক্ষোভ (যা আমি অন্যথায় ডকাস্ট্রিংয়ে রেখেছি):
>>> 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
... দীর্ঘশ্বাস ফেলো, একথা আমার দোষ বলে মনে করো না ...
[সংযোজন সংক্রান্ত সমস্যার কারণে গুরুত্বহীন historicalতিহাসিক নোট]
পাইথনের তালিকাগুলির অভিধানের অভিধান (২ স্তরের গভীর) একটি ফ্ল্যাটনের কথিত সদৃশ সম্পর্কে :
এই প্রশ্নের সমাধানটি এর মাধ্যমে কার্যকর করা যেতে পারে sorted( sum(flatten(...),[]) )। বিপরীত সম্ভব নয়: যখন এটি সত্যি যে মান এর flatten(...)একটি উচ্চ-অর্ডার সঁচায়ক ম্যাপিং দ্বারা কথিত ডুপ্লিকেট থেকে উদ্ধার করা সম্ভব, এক চাবি পুনরুদ্ধার করতে পারবেন না। (সম্পাদনা করুন: এছাড়াও এটি প্রমাণিত হয়েছে যে কথিত সদৃশ মালিকের প্রশ্নটি সম্পূর্ণ আলাদা, কারণ এটি কেবলমাত্র 2-স্তর গভীর অভিধানে ডিল করে, যদিও এই পৃষ্ঠার উত্তরগুলির মধ্যে একটি সাধারণ সমাধান দেয়))