दिलचस्प पोस्ट
जब बंदर एक विधि को पैचिंग करते हैं, तो क्या आप नए कार्यान्वयन से ओवरराइड विधि को कॉल कर सकते हैं? केवल एक तत्व का उपयोग करके बढ़ाया षट्कोण आकार का बटन लोग base128 का उपयोग क्यों नहीं करते हैं? मैं जावास्क्रिप्ट में एक स्ट्रिंग में अक्षर कैसे फेर सकता हूँ? जावा में ब्रेसिज़ की एक अनिवार्य जोड़ी के साथ एक लाइन-लूप DIV को 100% शरीर की ऊँचाई, शून्य से तय-ऊँचाई शीर्षलेख और पादलेख लेना अजगर: सिंटेक्स त्रुटि: स्ट्रिंग स्कैनिंग करते समय ईओएल ':' वर्ण, हेक्साडेसिमल मान 0x3 ए, एक नाम में शामिल नहीं किया जा सकता दो उपयोगकर्ताओं के बीच सामाजिक दूरी की गणना करें मानक Guid पर अनुक्रमिक मार्गदर्शिका में प्रदर्शन में सुधार क्या है? Google क्रोम एक्सटेंशन: प्रोग्रामेटिक इंजेक्शन सामग्री स्क्रिप्ट में jQuery को कैसे शामिल करें? एक enum के भीतर इन # परिभाषा का उद्देश्य क्या है? फ़ंक्शन पैरामीटर के लिए 'const' का उपयोग करें जावास्क्रिप्ट में एक नया स्थान ऑब्जेक्ट बनाना आईओएस में वर्तमान डिवाइस भाषा प्राप्त करना?

नेस्टेड पायथन डिक्शनरी, कम्प्रसेशन कुंजियां समतल करें

मान लें कि आपके पास एक शब्दकोश है:

{'a': 1, 'c': {'a': 2, 'b': {'x': 5, 'y' : 10}}, 'd': [1, 2, 3]} 

आप इस तरह से कुछ के बारे में कैसे चपटे होंगे:

 {'a': 1, 'c_a': 2, 'c_b_x': 5, 'c_b_y': 10, 'd': [1, 2, 3]} 

Solutions Collecting From Web of "नेस्टेड पायथन डिक्शनरी, कम्प्रसेशन कुंजियां समतल करें"

मूल रूप से उसी तरह से आप नेस्टेड सूची को समतल कर देंगे, आपको कुंजी / मूल्य के अनुसार डिक्टेट करने के लिए अतिरिक्त कार्य करना होगा, अपने नए शब्दकोश के लिए नई कुंजी बनाने और अंतिम चरण पर शब्दकोश बनाना होगा।

 import collections def flatten(d, parent_key='', sep='_'): items = [] for k, v in d.items(): new_key = parent_key + sep + k if parent_key else k if isinstance(v, collections.MutableMapping): items.extend(flatten(v, new_key, sep=sep).items()) else: items.append((new_key, v)) return dict(items) >>> flatten({'a': 1, 'c': {'a': 2, 'b': {'x': 5, 'y' : 10}}, 'd': [1, 2, 3]}) {'a': 1, 'c_a': 2, 'c_b_x': 5, 'd': [1, 2, 3], 'c_b_y': 10} 

दो बड़े विचार हैं जो मूल पोस्टर पर विचार करने की आवश्यकता है:

  1. क्या कोई चाबियाँ स्थापित करने वाली समस्याएं हैं? उदाहरण के लिए, {'a_b':{'c':1}, 'a':{'b_c':2}} का परिणाम {'a_b_c':???} । नीचे दिए गए समाधान युग्म के चलने के द्वारा समस्या को समाप्त करते हैं।
  2. यदि प्रदर्शन एक समस्या है, तो कुंजी-रिड्यूसर फ़ंक्शन (जो मैं इसके द्वारा 'शामिल होने' के रूप में संदर्भित करता है) को पूरे कुंजी-पथ तक पहुंच की आवश्यकता है, या क्या यह ओ (1) काम पेड़ में हर नोड पर कर सकता है? अगर आप joinedKey = '_'.join(*keys) सक्षम होना चाहते हैं joinedKey = '_'.join(*keys) , जो आपको ओ (एन ^ 2) चलने का समय देगी। हालांकि यदि आप nextKey = previousKey+'_'+thisKey कहने के लिए तैयार हैं कि nextKey = previousKey+'_'+thisKey यह कि, जो आपको ओ (एन) समय मिलता है नीचे का समाधान आपको दोनों करने देता है (क्योंकि आप केवल सभी चाबियाँ जोड़ सकते हैं, फिर उन्हें पोस्ट कर सकते हैं)।

(प्रदर्शन की संभावना एक मुद्दा नहीं है, लेकिन मैं दूसरे बिंदु पर विस्तारित हूं क्योंकि किसी और की परवाह है: इसे लागू करने में, कई खतरनाक विकल्प हैं। यदि आप इसे पुनरावर्तित करते हैं और उपज और फिर से उपज देते हैं, या कुछ समान जो स्पर्श करते हैं नोड्स एक बार से अधिक (जो गलती से करना बहुत आसान है), आप संभावित रूप से ओ (एन) के बजाय ओ (एन ^ 2) काम कर रहे हैं। ऐसा इसलिए है क्योंकि शायद आप एक कुंजी की गणना कर रहे हैं a_1 फिर a_1_i …, और फिर a a_1 तो a_1_ii … की गणना, लेकिन वास्तव में आपको a_1 फिर से गणना करने की a_1 नहीं है। भले ही आप इसे पुन: पेश नहीं कर रहे हैं, फिर से उपज (एक 'स्तर-दर-स्तर' दृष्टिकोण) एक अच्छा उदाहरण {1:{1:{1:{1:...(N times)...{1:SOME_LARGE_DICTIONARY_OF_SIZE_N}...}}}} पर प्रदर्शन के बारे में सोचना है {1:{1:{1:{1:...(N times)...{1:SOME_LARGE_DICTIONARY_OF_SIZE_N}...}}}} )

नीचे एक फ़ंक्शन है जिसका मैंने flattenDict(d, join=..., lift=...) लिखा है 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 लिए अपरिचित लोगों के लिए एक आरेख है, अन्यथा "गुना बाएं" के रूप में जाना जाता है कभी-कभी यह k0 के स्थान पर प्रारंभिक मान के साथ खींचा जाता है (फ़ंक्शन में पारित सूची का हिस्सा नहीं)। यहां, 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 

… आह, मुझे नहीं लगता कि ये मेरी गलती है …


[मॉडरेशन मुद्दों के कारण महत्वहीन ऐतिहासिक नोट]

पायथन में सूचियों के शब्दकोशों (2 स्तरों के गहरे) के एक शब्दकोश की कथित डुप्लिकेट के बारे में:

उस सवाल का समाधान हल करके इस एक के sorted( sum(flatten(...),[]) ) कार्यान्वित किया जा सकता है sorted( sum(flatten(...),[]) ) । रिवर्स संभव नहीं है: जबकि यह सत्य है कि flatten(...) के मान कथित डुप्लिकेट से एक उच्च-ऑर्डर संचयक के मानचित्रण के द्वारा पुनर्प्राप्त किया जा सकता है, कोई भी चाबियाँ पुनर्प्राप्त नहीं कर सकता है (संपादित करें: इसके अलावा यह पता चला है कि कथित डुप्लिकेट मालिक का प्रश्न पूरी तरह से अलग है, इसमें केवल 2-स्तर की गहराई के शब्दकोश के साथ ही संबंधित है, हालांकि उस पृष्ठ पर दिए उत्तरों में से कोई एक सामान्य समाधान देता है।)

यहां एक तरह का "कार्यात्मक", "एक-लाइनर" कार्यान्वयन है यह पुनरावर्ती है, और एक सशर्त अभिव्यक्ति और एक डिक्की समझ के आधार पर।

 def flatten_dict(dd, separator='_', prefix=''): return { prefix + separator + k if prefix else k : v for kk, vv in dd.items() for k, v in flatten_dict(vv, separator, kk).items() } if isinstance(dd, dict) else { prefix : dd } 

परीक्षा:

 In [2]: flatten_dict({'abc':123, 'hgf':{'gh':432, 'yu':433}, 'gfd':902, 'xzxzxz':{"432":{'0b0b0b':231}, "43234":1321}}, '.') Out[2]: {'abc': 123, 'gfd': 902, 'hgf.gh': 432, 'hgf.yu': 433, 'xzxzxz.432.0b0b0b': 231, 'xzxzxz.43234': 1321} 

कोड:

 test = {'a': 1, 'c': {'a': 2, 'b': {'x': 5, 'y' : 10}}, 'd': [1, 2, 3]} def parse_dict(init, lkey=''): ret = {} for rkey,val in init.items(): key = lkey+rkey if isinstance(val, dict): ret.update(parse_dict(val, key+'_')) else: ret[key] = val return ret print(parse_dict(test,'')) 

परिणाम:

 $ python test.py {'a': 1, 'c_a': 2, 'c_b_x': 5, 'd': [1, 2, 3], 'c_b_y': 10} 

मैं Python3.2 का उपयोग कर रहा हूं, अजगर के आपके संस्करण के लिए अपडेट।

यह शब्दकोशों के लिए प्रतिबंधित नहीं है, लेकिन हर मानचित्रण प्रकार। इसके अलावा आईटीटी तेजी से क्योंकि यह एक हालत खराब करता है। फिर भी क्रेडिट इमरान के पास जाते हैं:

 def flatten(d, parent_key=''): items = [] for k, v in d.items(): try: items.extend(flatten(v, '%s%s_' % (parent_key, k)).items()) except AttributeError: items.append(('%s%s' % (parent_key, k), v)) return dict(items) 

यह दोनों इमरान और रालु के उत्तर के समान है। यह एक जनरेटर का उपयोग नहीं करता है, लेकिन इसके बजाय एक बंद के साथ recursion को रोजगार:

 def flatten_dict(d, separator='_'): final = {} def _flatten_dict(obj, parent_keys=[]): for k, v in obj.iteritems(): if isinstance(v, dict): _flatten_dict(v, parent_keys + [k]) else: key = separator.join(parent_keys + [k]) final[key] = v _flatten_dict(d) return final >>> print flatten_dict({'a': 1, 'c': {'a': 2, 'b': {'x': 5, 'y' : 10}}, 'd': [1, 2, 3]}) {'a': 1, 'c_a': 2, 'c_b_x': 5, 'd': [1, 2, 3], 'c_b_y': 10} 

या यदि आप पहले से ही पंडों का उपयोग कर रहे हैं, तो आप इसे json_normalize() साथ कर सकते हैं:

 import pandas as pd df = pd.io.json.json_normalize({'a': 1, 'c': {'a': 2, 'b': {'x': 5, 'y' : 10}}, 'd': [1, 2, 3]}) print(df.to_dict(orient='records')[0]) 

आउटपुट:

 {'a': 1, 'c.a': 2, 'cbx': 5, 'cby': 10, 'd': [1, 2, 3]} 

अगर आप नहीं चाहते हैं विभाजक, आप इसे इतना पसंद कर सकते हैं:

 d = df.to_dict(orient='records')[0] print dict(zip([x.replace('.', '_') for x in d.keys()], d.values())) 

आउटपुट:

 {'a': 1, 'c_a': 2, 'c_b_x': 5, 'c_b_y': 10, 'd': [1, 2, 3]} 

मेरे पायथन 3.3 जनरेटर का उपयोग कर समाधान:

 def flattenit(pyobj, keystring=''): if type(pyobj) is dict: if (type(pyobj) is dict): keystring = keystring + "_" if keystring else keystring for k in pyobj: yield from flattenit(pyobj[k], keystring + k) elif (type(pyobj) is list): for lelm in pyobj: yield from flatten(lelm, keystring) else: yield keystring, pyobj #your flattened dictionary object flattened={k:v for k,v in flattenit(person)} 

डावोड का समाधान बहुत अच्छा है, लेकिन नेस्टेड डिक्ट में डिकट की सूची शामिल होने पर संतोषजनक परिणाम नहीं दिए जाते हैं, लेकिन उनके कोड को उस मामले के लिए अनुकूलित किया जा सकता है:

 def flatten_dict(d): items = [] for k, v in d.items(): try: if (type(v)==type([])): for l in v: items.extend(flatten_dict(l).items()) else: items.extend(flatten_dict(v).items()) except AttributeError: items.append((k, v)) return dict(items) 

सुरुचिपूर्ण, इन-प्लेस प्रतिस्थापन के लिए यहां एक एल्गोरिथ्म है। पायथन 2.7 और पायथन 3.5 के साथ परीक्षण किया गया। एक विभाजक के रूप में डॉट वर्ण का उपयोग करना

 def flatten_json(json): if type(json) == dict: for k, v in list(json.items()): if type(v) == dict: flatten_json(v) json.pop(k) for k2, v2 in v.items(): json[k+"."+k2] = v2 

उदाहरण:

 d = {'a': {'b': 'c'}} flatten_json(d) print(d) unflatten_json(d) print(d) 

आउटपुट:

 {'a.b': 'c'} {'a': {'b': 'c'}} 

मैंने इस कोड को यहां मिलान के साथ unflatten_json फ़ंक्शन के साथ प्रकाशित किया है।

Python3.5 में कार्यात्मक और निष्पादक समाधान के बारे में कैसे?

 from functools import reduce def _flatten_reducer(dict_, key, val, prefix): if isinstance(val, dict): return {**flatten(val, prefix + key), **dict_} else: return {prefix + key: val, **dict_} def flatten(dict_, prefix=''): return reduce( lambda new_dict, cur_kv: _flatten_reducer(new_dict, *cur_kv, prefix), dict_.items(), {} ) 

उपयोग में:

 my_obj = {'a': 1, 'c': {'a': 2, 'b': {'x': 5, 'y': 10}}, 'd': [1, 2, 3]} print(flatten(my_obj)) # {'d': [1, 2, 3], 'cby': 10, 'cbx': 5, 'ca': 2, 'a': 1} 

जनरेटर का उपयोग करना:

 def flat_dic_helper(prepand,d): if len(prepand) > 0: prepand = prepand + "_" for k in d: i=d[k] if type(i).__name__=='dict': r = flat_dic_helper(prepand+k,i) for j in r: yield j else: yield (prepand+k,i) def flat_dic(d): return dict(flat_dic_helper("",d)) d={'a': 1, 'c': {'a': 2, 'b': {'x': 5, 'y' : 10}}, 'd': [1, 2, 3]} print(flat_dic(d)) >> {'a': 1, 'c_a': 2, 'c_b_x': 5, 'd': [1, 2, 3], 'c_b_y': 10} 

काम के ऊपर जवाब वास्तव में अच्छी तरह से बस सोचा था कि मैं उस फलक समारोह को जोड़ूंगा जिसे मैंने लिखा था:

 def unflatten(d): ud = {} for k, v in d.items(): context = ud for sub_key in k.split('_')[:-1]: if sub_key not in context: context[sub_key] = {} context = context[sub_key] context[k.split('_')[-1]] = v return ud 

नोट: यह चाबियाँ में पहले से मौजूद '_' के लिए खाता नहीं है, बहुत समतल समतलों की तरह।

मैंने निम्नलिखित जेएसएन को समतल करने की कोशिश की:

 { "blkio_stats": { "io_merged_recursive": [], "io_queue_recursive": [], "io_service_bytes_recursive": [], "io_service_time_recursive": [], "io_serviced_recursive": [], "io_time_recursive": [], "io_wait_time_recursive": [], "sectors_recursive": [] }, "cpu_stats": { "cpu_usage": { "percpu_usage": [56477793484, 53845065668], "total_usage": 110322859152, "usage_in_kernelmode": 74310000000, "usage_in_usermode": 24760000000 }, "system_cpu_usage": 11583455420000000, "throttling_data": { "periods": 0, "throttled_periods": 0, "throttled_time": 0 } }, "memory_stats": { "failcnt": 0, "limit": 4074237952, "max_usage": 485281792, "stats": { "active_anon": 7823360, "active_file": 8192, "cache": 8192, "dirty": 0, "hierarchical_memory_limit": 9223372036854771712, "inactive_anon": 0, "inactive_file": 0, "mapped_file": 0, "pgfault": 5602509, "pgmajfault": 0, "pgpgin": 5421031, "pgpgout": 5429850, "rss": 7823360, "rss_huge": 6291456, "total_active_anon": 7823360, "total_active_file": 8192, "total_cache": 8192, "total_dirty": 0, "total_inactive_anon": 0, "total_inactive_file": 0, "total_mapped_file": 0, "total_pgfault": 5602509, "total_pgmajfault": 0, "total_pgpgin": 5421031, "total_pgpgout": 5429850, "total_rss": 7823360, "total_rss_huge": 6291456, "total_unevictable": 0, "total_writeback": 0, "unevictable": 0, "writeback": 0 }, "usage": 7831552 }, "networks": { "eth0": { "rx_bytes": 1512143070, "rx_dropped": 0, "rx_errors": 0, "rx_packets": 2605267, "tx_bytes": 1450105558, "tx_dropped": 0, "tx_errors": 0, "tx_packets": 2326940 } }, "pids_stats": {}, "precpu_stats": { "cpu_usage": { "percpu_usage": null, "total_usage": 0, "usage_in_kernelmode": 0, "usage_in_usermode": 0 }, "system_cpu_usage": 0, "throttling_data": { "periods": 0, "throttled_periods": 0, "throttled_time": 0 } }, "read": "2017-02-17T10:22:07.278903338Z" } 

उस फाइल को समतल करने का सबसे अच्छा विकल्प के रूप में पृथक्करण चिह्न यह था: https://stackoverflow.com/a/41840603/5730361 यह केवल "pids_stats" को छोड़ दिया है: {}, विकल्प:

 { "blkio_stats.io_merged_recursive": [], "blkio_stats.io_queue_recursive": [], "blkio_stats.io_service_bytes_recursive": [], "blkio_stats.io_service_time_recursive": [], "blkio_stats.io_serviced_recursive": [], "blkio_stats.io_time_recursive": [], "blkio_stats.io_wait_time_recursive": [], "blkio_stats.sectors_recursive": [], "cpu_stats.cpu_usage.percpu_usage": [56477793484, 53845065668], "cpu_stats.cpu_usage.total_usage": 110322859152, "cpu_stats.cpu_usage.usage_in_kernelmode": 74310000000, "cpu_stats.cpu_usage.usage_in_usermode": 24760000000, "cpu_stats.system_cpu_usage": 11583455420000000, "cpu_stats.throttling_data.periods": 0, "cpu_stats.throttling_data.throttled_periods": 0, "cpu_stats.throttling_data.throttled_time": 0, "memory_stats.failcnt": 0, "memory_stats.limit": 4074237952, "memory_stats.max_usage": 485281792, "memory_stats.stats.active_anon": 7823360, "memory_stats.stats.active_file": 8192, "memory_stats.stats.cache": 8192, "memory_stats.stats.dirty": 0, "memory_stats.stats.hierarchical_memory_limit": 9223372036854771712, "memory_stats.stats.inactive_anon": 0, "memory_stats.stats.inactive_file": 0, "memory_stats.stats.mapped_file": 0, "memory_stats.stats.pgfault": 5602509, "memory_stats.stats.pgmajfault": 0, "memory_stats.stats.pgpgin": 5421031, "memory_stats.stats.pgpgout": 5429850, "memory_stats.stats.rss": 7823360, "memory_stats.stats.rss_huge": 6291456, "memory_stats.stats.total_active_anon": 7823360, "memory_stats.stats.total_active_file": 8192, "memory_stats.stats.total_cache": 8192, "memory_stats.stats.total_dirty": 0, "memory_stats.stats.total_inactive_anon": 0, "memory_stats.stats.total_inactive_file": 0, "memory_stats.stats.total_mapped_file": 0, "memory_stats.stats.total_pgfault": 5602509, "memory_stats.stats.total_pgmajfault": 0, "memory_stats.stats.total_pgpgin": 5421031, "memory_stats.stats.total_pgpgout": 5429850, "memory_stats.stats.total_rss": 7823360, "memory_stats.stats.total_rss_huge": 6291456, "memory_stats.stats.total_unevictable": 0, "memory_stats.stats.total_writeback": 0, "memory_stats.stats.unevictable": 0, "memory_stats.stats.writeback": 0, "memory_stats.usage": 7831552, "networks.eth0.rx_bytes": 1512143070, "networks.eth0.rx_dropped": 0, "networks.eth0.rx_errors": 0, "networks.eth0.rx_packets": 2605267, "networks.eth0.tx_bytes": 1450105558, "networks.eth0.tx_dropped": 0, "networks.eth0.tx_errors": 0, "networks.eth0.tx_packets": 2326940, "precpu_stats.cpu_usage.percpu_usage": null, "precpu_stats.cpu_usage.total_usage": 0, "precpu_stats.cpu_usage.usage_in_kernelmode": 0, "precpu_stats.cpu_usage.usage_in_usermode": 0, "precpu_stats.system_cpu_usage": 0, "precpu_stats.throttling_data.periods": 0, "precpu_stats.throttling_data.throttled_periods": 0, "precpu_stats.throttling_data.throttled_time": 0, "read": "2017-02-17T10:22:07.278903338Z" } 

फ़ाइल को बिना किसी समस्या के संदर्भ में, साथ में विकल्प के रूप में, मैं नेस्टेड पायथन डिक्शनरीज़, कम्प्रसेशन कुंजियों का चयन करता हूं – क्योंकि यह रिकर्सिव और पूरी तरह से काम करता है। ध्यान दें कि "pids_stats": {} वह पिछले चरण में खो गया था के रूप में गायब है।

 { "blkio_stats": { "io_merged_recursive": [], "io_queue_recursive": [], "io_service_bytes_recursive": [], "io_service_time_recursive": [], "io_serviced_recursive": [], "io_time_recursive": [], "io_wait_time_recursive": [], "sectors_recursive": [] }, "cpu_stats": { "cpu_usage": { "percpu_usage": [56477793484, 53845065668], "total_usage": 110322859152, "usage_in_kernelmode": 74310000000, "usage_in_usermode": 24760000000 }, "system_cpu_usage": 11583455420000000, "throttling_data": { "periods": 0, "throttled_periods": 0, "throttled_time": 0 } }, "memory_stats": { "failcnt": 0, "limit": 4074237952, "max_usage": 485281792, "stats": { "active_anon": 7823360, "active_file": 8192, "cache": 8192, "dirty": 0, "hierarchical_memory_limit": 9223372036854771712, "inactive_anon": 0, "inactive_file": 0, "mapped_file": 0, "pgfault": 5602509, "pgmajfault": 0, "pgpgin": 5421031, "pgpgout": 5429850, "rss": 7823360, "rss_huge": 6291456, "total_active_anon": 7823360, "total_active_file": 8192, "total_cache": 8192, "total_dirty": 0, "total_inactive_anon": 0, "total_inactive_file": 0, "total_mapped_file": 0, "total_pgfault": 5602509, "total_pgmajfault": 0, "total_pgpgin": 5421031, "total_pgpgout": 5429850, "total_rss": 7823360, "total_rss_huge": 6291456, "total_unevictable": 0, "total_writeback": 0, "unevictable": 0, "writeback": 0 }, "usage": 7831552 }, "networks": { "eth0": { "rx_bytes": 1512143070, "rx_dropped": 0, "rx_errors": 0, "rx_packets": 2605267, "tx_bytes": 1450105558, "tx_dropped": 0, "tx_errors": 0, "tx_packets": 2326940 } }, "precpu_stats": { "cpu_usage": { "percpu_usage": null, "total_usage": 0, "usage_in_kernelmode": 0, "usage_in_usermode": 0 }, "system_cpu_usage": 0, "throttling_data": { "periods": 0, "throttled_periods": 0, "throttled_time": 0 } }, "read": "2017-02-17T10:22:07.278903338Z" } 

नेस्टेड शब्दकोशों को समतल करने के लिए सरल कार्य:

 def flatten_dict(init_dict): res_dict = {} if type(init_dict) is not dict: return res_dict for k, v in init_dict.iteritems(): if type(v) == dict: res_dict.update(flatten_dict(v)) else: res_dict[k] = v return res_dict 

विचार / आवश्यकता थी: पैरेंट कुंजी को रखने के बिना फ्लैट शब्द प्राप्त करें

उपयोग का उदाहरण:

 dd = {'a': 3, 'b': {'c': 4, 'd': 5}, 'e': {'f': {'g': 1, 'h': 2} }, 'i': 9, } flatten_dict(dd) >> {'a': 3, 'c': 4, 'd': 5, 'g': 1, 'h': 2, 'i': 9} 

माता-पिता की चाबियाँ पूरी तरह से सरल रहें