सूचकांक द्वारा पायथन शब्दकोश के तत्वों तक पहुँचना

Question

एक तानाशाह की तरह विचार करें

mydict = {
  'Apple': {'American':'16', 'Mexican':10, 'Chinese':5},
  'Grapes':{'Arabian':'25','Indian':'20'} }

उदाहरण के लिए मैं इस शब्दकोश के किसी विशेष तत्व तक कैसे पहुँच सकता हूँ? उदाहरण के लिए, मैं Apple के पहले तत्व को प्रारूपित करने के बाद पहले तत्व को प्रिंट करना चाहूंगा जो हमारे मामले में केवल 'अमेरिकन' है?

अतिरिक्त जानकारी उपरोक्त डेटा संरचना एक अजगर फ़ाइल में एक इनपुट फ़ाइल पार्स करके बनाई गई थी। एक बार बनाया गया है, लेकिन यह उस रन के लिए समान है।

मैं अपने फ़ंक्शन में इस डेटा संरचना का उपयोग कर रहा हूं।

इसलिए यदि फ़ाइल बदल जाती है, तो अगली बार जब यह एप्लिकेशन चलेगा तो फ़ाइल की सामग्री अलग-अलग होगी और इसलिए इस डेटा संरचना की सामग्री अलग-अलग होगी लेकिन प्रारूप समान होगा। इसलिए आप मुझे अपने कार्य में देख रहे हैं, मुझे नहीं पता है कि Apple में पहला तत्व 'अमेरिकन' है या कुछ और इसलिए मैं सीधे कुंजी के रूप में 'अमेरिकन' का उपयोग नहीं कर सकता।

Comments

क्या आप कृपया अपने द्वारा अपेक्षित आउटपुट का उदाहरण दे सकते हैं?

— ब्योर्न पोलेक्स

आप वास्तव में इस संरचना के साथ क्या करना चाहते हैं? और क्या आप अपने उदाहरण में तानाशाह ('सेब' और 'अंगूर') की चाबी जानते हैं? या आप केवल यह जानते हैं कि आपको डिक्टेट का एक ताना मिलेगा?

— जुआनकोपनज़ा

अपने शब्दकोश को कॉल न करें dict। शब्द 'तानाशाह' पहले से ही पायथन में एक कीवर्ड है। कुछ और उपयोग करें, जैसे mydict।

— रिक

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

— अरन-फे

@ अरान-फे: अनियंत्रित चीजों का आंतरिक क्रम होता है। अनियंत्रित! = कोई आदेश नहीं।

— जेमी मार्शल

Answer 1

यह देखते हुए कि यह एक शब्दकोष है जिसे आप कुंजियों का उपयोग करके एक्सेस करते हैं। "Apple" के तहत संग्रहीत शब्दकोश प्राप्त करना, निम्नलिखित करें:

>>> mydict["Apple"]
{'American': '16', 'Mexican': 10, 'Chinese': 5}

और उनमें से कितने अमेरिकी हैं (16), इस तरह से करें:

>>> mydict["Apple"]["American"]
'16'

Comments

तत्वों की गहराई को जाने बिना कोई इसे गतिशील रूप से कैसे कर सकता है?

— एथन बीरेलिन

आप वास्तव में क्या जानना चाहेंगे? आप एक शब्दकोश की कुंजी प्राप्त कर सकते हैं .keys()जिससे आप उन्हें गतिशील रूप से एक्सेस कर सकते हैं।

— मोर्टेन क्रिस्टेंसन

उदाहरण के लिए, यदि आपके पास अज्ञात गहराई का शब्दकोश है, उदाहरण के लिए, एक नेस्टेड शब्दकोश है, और आपके पास "n"एक अज्ञात गहराई पर तत्व है , जो एक अज्ञात तत्व में संग्रहीत है।

— एथन बाइरेलिन

यह एक बहुत व्यापक प्रश्न है। आपकी डेटा संरचना को देखते हुए आप इसे उचित रूप से संभालने के लिए एक फ़ंक्शन या वर्ग लिखेंगे। शायद आप कुंजी खोजने के लिए एक कुंजी और रणनीति की आपूर्ति कर सकते हैं।

— मोर्टेन क्रिस्टेंसन

@ ईथनबेलरिन का उपयोग: 'कुंजी के लिए, शब्दकोश में मूल्य। मानदंड ()' दोनों की पहुंच और मूल्य

— danius

Answer 2

यदि प्रश्न है, अगर मुझे पता है कि मेरे पास एक विशिष्ट प्रकार के सेब के रूप में 'सेब' है और सेब के एक प्रकार के रूप में 'अमेरिकन' है, तो मैं उपयोग करूंगा:

myDict = {'Apple': {'American':'16', 'Mexican':10, 'Chinese':5},
          'Grapes':{'Arabian':'25','Indian':'20'} }


print myDict['Apple']['American']

जैसा कि दूसरों ने सुझाव दिया। यदि इसके बजाय सवाल है, तो आप नहीं जानते कि क्या 'Apple' एक फल के रूप में और 'अमेरिकी' एक प्रकार के 'Apple' के रूप में मौजूद है जब आप अपने मनमाने ढंग से फ़ाइल को तानाशाही डेटा संरचना में पढ़ते हैं, तो आप कुछ ऐसा कर सकते हैं:

print [ftype['American'] for f,ftype in myDict.iteritems() if f == 'Apple' and 'American' in ftype]

या बेहतर अभी तक तो आप अनावश्यक रूप से पूरे डिक्ट्स के बारे में नहीं जानते हैं अगर आपको पता है कि केवल Apple में ही अमेरिकी है:

if 'Apple' in myDict:
    if 'American' in myDict['Apple']:
        print myDict['Apple']['American']

इन सभी मामलों में यह मायने नहीं रखता है कि डिक्शनरी वास्तव में प्रविष्टियों को किस क्रम में संग्रहीत करती है। यदि आप वास्तव में आदेश के बारे में चिंतित हैं, तो आप एक का उपयोग करने पर विचार कर सकते हैंOrderedDict :

http://docs.python.org/dev/library/collections.html#collections.OrderedDict

Answer 3

जैसा कि मैंने आपके विवरण पर ध्यान दिया है, आप सिर्फ इतना जानते हैं कि आपका पार्सर आपको एक शब्दकोश देगा कि इसके मूल्य इस तरह से भी हैं:

sampleDict = {
              "key1": {"key10": "value10", "key11": "value11"},
              "key2": {"key20": "value20", "key21": "value21"}
              }

इसलिए आपको अपने पैरेंट डिक्शनरी पर चलना होगा। यदि आप sampleDict.values()सूची में सभी पहली शब्दकोश कुंजियों का प्रिंट आउट या एक्सेस करना चाहते हैं , तो आप इस तरह से कुछ का उपयोग कर सकते हैं:

for key, value in sampleDict.items():
    print value.keys()[0]

यदि आप पहले आइटम की पहली कुंजी का उपयोग करना चाहते हैं sampleDict.values(), तो यह उपयोगी हो सकता है:

print sampleDict.values()[0].keys()[0]

यदि आप प्रश्न में दिए गए उदाहरण का उपयोग करते हैं, तो मेरा मतलब है:

sampleDict = {
              'Apple': {'American':'16', 'Mexican':10, 'Chinese':5},
              'Grapes':{'Arabian':'25','Indian':'20'}
              }

पहले कोड के लिए आउटपुट है:

American
Indian

और दूसरे कोड के लिए आउटपुट है:

American

Answer 4

एक बोनस के रूप में, मैं आपके मुद्दे पर एक अलग तरह के समाधान की पेशकश करना चाहूंगा। आप नेस्टेड शब्दकोशों के साथ काम करते हैं, जो आमतौर पर थकाऊ होता है, खासकर जब आपको एक आंतरिक कुंजी के अस्तित्व की जांच करनी होती है।

पिपी पर इस बारे में कुछ दिलचस्प पुस्तकालय हैं, यहां आपके लिए एक त्वरित खोज है।

आपके विशिष्ट मामले में, dict_digger अनुकूल लगता है।

>>> import dict_digger
>>> d = {
  'Apple': {'American':'16', 'Mexican':10, 'Chinese':5},
  'Grapes':{'Arabian':'25','Indian':'20'} 
}

>>> print(dict_digger.dig(d, 'Apple','American'))
16
>>> print(dict_digger.dig(d, 'Grapes','American'))
None

Answer 5

आप शब्दकोश dict['Apple'].keys()[0]में पहली कुंजी प्राप्त करने के लिए उपयोग कर सकते हैं Apple, लेकिन इसकी कोई गारंटी नहीं है कि यह होगा American। शब्दकोश में कुंजियों का क्रम शब्दकोष की सामग्री के आधार पर बदल सकता है और कुंजियाँ जोड़ दी गई हैं।

Comments

जब तक आप लाइब्रेरी OrderedDictमें उपयोग नहीं करतेcollections

— Escachator

Answer 6

मुझे पता है कि यह 8 साल पुराना है, लेकिन कोई भी वास्तव में इस सवाल का जवाब देने और जवाब देने के लिए नहीं लगता है।

आप आंतरिक dicts की एक सूची प्राप्त करने के लिए एक। पर .values ​​() कॉल कर सकते हैं और इस प्रकार उन्हें सूचकांक द्वारा एक्सेस कर सकते हैं।

>>> mydict = {
...  'Apple': {'American':'16', 'Mexican':10, 'Chinese':5},
...  'Grapes':{'Arabian':'25','Indian':'20'} }

>>>mylist = list(mydict.values())
>>>mylist[0]
{'American':'16', 'Mexican':10, 'Chinese':5},
>>>mylist[1]
{'Arabian':'25','Indian':'20'}

>>>myInnerList1 = list(mylist[0].values())
>>>myInnerList1
['16', 10, 5]
>>>myInnerList2 = list(mylist[1].values())
>>>myInnerList2
['25', '20']

Comments

दिलचस्प है, मैंने यह कोशिश की और मिल गया 'dict_values' object does not support indexing । लगता है कि इस उत्तर को अद्यतन करने की आवश्यकता है क्योंकि आपको सूची को पुनर्प्राप्त करने के लिए तानाशाही को लपेटने की आवश्यकता है

— युका

@ युका - आप सही थे, मैंने अपने कोड का परीक्षण नहीं किया। जवाब अद्यतन किया गया है

— जेमी मार्शल

Answer 7

आप शब्दकोशों पर आदेश पर भरोसा नहीं कर सकते। लेकिन आप यह कोशिश कर सकते हैं:

dict['Apple'].items()[0][0]

यदि आप चाहते हैं कि आप संरक्षित किए जाने वाले आदेश का उपयोग करना चाहते हैं: http://www.python.org/dev/peps/pep-0372/#ordered-dict-api

Answer 8

शब्दकोश में तत्वों का उपयोग करने के तरीके को समझने के लिए सरल उदाहरण: -

एक शब्दकोश बनाएँ

d = {'dog' : 'bark', 'cat' : 'meow' } 
print(d.get('cat'))
print(d.get('lion'))
print(d.get('lion', 'Not in the dictionary'))
print(d.get('lion', 'NA'))
print(d.get('dog', 'NA'))

अजगर के बारे में अधिक जानकारी प्राप्त करें

Answer 9

कुछ लोग इस प्रश्न के कई उत्तरों के बावजूद प्रकट होते हैं, उन्होंने कहा कि शब्दकोशों अन-ऑर्डर किए गए मैपिंग हैं, और इसलिए (पायथन 3.7 के साथ सम्मिलन आदेश का आशीर्वाद तक) एक शब्दकोश में "पहले" प्रविष्टि का विचार शाब्दिक रूप से बनाया गया है। कोई मतलब नहीं। और यहां तक ​​कि OrderedDictकेवल संख्यात्मक सूचकांक द्वारा इस तरह के कुरूपता के रूप में उपयोग किया जा सकता है mydict[mydict.keys()[0]](केवल पायथन 2 के रूप में, क्योंकि पायथन 3 keys()एक गैर-उपप्रकार इट्रेटर है।)

3.7 से आगे practice और ३,६ अभ्यास में - तब भी नया व्यवहार पेश किया गया था, लेकिन ३.९ तक भाषा विनिर्देश के हिस्से के रूप में शामिल नहीं किया गया था - एक तानाशाही की कुंजियों, मूल्यों या वस्तुओं पर पुनरावृत्ति (और, मेरा मानना ​​है, सेट भी) सबसे कम-हाल ही में सम्मिलित वस्तुओं को पहले प्राप्त करेगा। सम्मिलन के संख्यात्मक सूचकांक द्वारा उन्हें एक्सेस करने का कोई सरल तरीका अभी भी नहीं है।

आइटम के चयन और "स्वरूपण" के प्रश्न के रूप में, यदि आप उस कुंजी को जानते हैं जिसे आप शब्दकोश में प्राप्त करना चाहते हैं तो आप सामान्य रूप से इसे पुनः प्राप्त करने के लिए एक सबस्क्रिप्ट के रूप में कुंजी का उपयोग करेंगे ( my_var = mydict['Apple'])।

यदि आप वास्तव में एंट्री नंबर द्वारा वस्तुओं को अनुक्रमित करने में सक्षम होना चाहते हैं (इस तथ्य को अनदेखा करते हुए कि प्रविष्टि के रूप में एक विशेष प्रविष्टि का नंबर बदल जाएगा) तो उपयुक्त संरचना संभवतः दो-तत्व ट्यूपल्स की सूची होगी। के बजाय

mydict = {
  'Apple': {'American':'16', 'Mexican':10, 'Chinese':5},
  'Grapes':{'Arabian':'25','Indian':'20'} }

आप उपयोग कर सकते हैं:

mylist = [
    ('Apple', {'American':'16', 'Mexican':10, 'Chinese':5}),
    ('Grapes', {'Arabian': '25', 'Indian': '20'}
]

इस शासन के तहत पहली प्रविष्टि mylist[0]क्लासिक सूची-एंडेक्सेड रूप में है, और इसका मूल्य है ('Apple', {'American':'16', 'Mexican':10, 'Chinese':5})। आप पूरी सूची पर निम्नानुसार पुनरावृति कर सकते हैं:

for (key, value) in mylist:  # unpacks to avoid tuple indexing
    if key == 'Apple':
        if 'American' in value:
            print(value['American'])

लेकिन अगर आपको पता है कि आप "Apple" कुंजी की तलाश कर रहे हैं, तो आप इसके बजाय सिर्फ एक तानाशाही का उपयोग क्यों नहीं करेंगे?

आप चाबियों की सूची को कैश करके अप्रत्यक्ष स्तर का एक अतिरिक्त स्तर पेश कर सकते हैं, लेकिन दो डेटा संरचनाओं को सिंक्रोनाइज़ेशन में रखने की जटिलता अनिवार्य रूप से आपके कोड की जटिलता को जोड़ देगी।

Answer 10

निम्नलिखित छोटे कार्य के साथ, पेड़ के आकार के शब्दकोश में खुदाई करना काफी आसान हो जाता है:

def dig(tree, path):
    for key in path.split("."):
        if isinstance(tree, dict) and tree.get(key):
            tree = tree[key]
        else:
            return None
    return tree

अब, dig(mydict, "Apple.Mexican")रिटर्न 10, जबकि dig(mydict, "Grape")उपज उपज {'Arabian':'25','Indian':'20'}। यदि एक कुंजी शब्दकोश में निहित नहीं है, तो digरिटर्नNone ।

ध्यान दें कि आप विभाजक चार को आसानी से बदल सकते हैं (या पैरामीटर भी कर सकते हैं) '।' से '/', '|' आदि।