Python Language
शब्दकोश

वाक्य - विन्यास

• mydict = {}
• mydict [k] = मान
• मूल्य = मिथक [के]
• मान = mydict.get (k)
• मान = mydict.get (k, "default_value")

पैरामीटर

टिप्पणियों

एक शब्दकोश के मूल्यों तक पहुँचना

dictionary = {"Hello": 1234, "World": 5678}
print(dictionary["Hello"])

उपरोक्त कोड 1234 प्रिंट करेगा।

इस उदाहरण में स्ट्रिंग "Hello" को एक कुंजी कहा जाता है। यह में एक मूल्य देखने के लिए प्रयोग किया जाता है dict वर्ग कोष्ठक में कुंजी रखकर।

संख्या 1234 में संबंधित कोलन के बाद देखा जाता है dict परिभाषा। इसे इस dict में "Hello" मानचित्रों का मान कहा जाता है।

एक कुंजी के साथ इस तरह के एक मूल्य को KeyError जो अस्तित्व में नहीं है, KeyError अपवाद को बढ़ाएगा, यदि अनकैप्ड निष्पादन को रोक दिया जाए। हम एक जोखिम लिए बिना एक मूल्य पर पहुंचना चाहते हैं KeyError , हम उपयोग कर सकते हैं dictionary.get विधि। डिफ़ॉल्ट रूप से यदि कुंजी मौजूद नहीं है, तो विधि None लौटेगा। हम यह करने के बजाय वापस जाने के लिए एक दूसरा मान पारित कर सकते हैं None एक असफल देखने की स्थिति में।

w = dictionary.get("whatever")
x = dictionary.get("whatever", "nuh-uh")

इस उदाहरण में w को मान None मिलेगा और x को "nuh-uh" मान मिलेगा।

तानाशाह () रचनाकार

dict() कंस्ट्रक्टर का उपयोग कीवर्ड तर्कों से, या कुंजी-मूल्य जोड़े के एक एकल पुनरावृत्ति से, या एक शब्दकोश और कीवर्ड तर्कों से शब्दकोश बनाने के लिए किया जा सकता है।

dict(a=1, b=2, c=3)                   # {'a': 1, 'b': 2, 'c': 3}
dict([('d', 4), ('e', 5), ('f', 6)])  # {'d': 4, 'e': 5, 'f': 6}
dict([('a', 1)], b=2, c=3)            # {'a': 1, 'b': 2, 'c': 3}
dict({'a' : 1, 'b' : 2}, c=3)         # {'a': 1, 'b': 2, 'c': 3}

KeyError अपवाद से बचना

शब्दकोश का उपयोग करते समय एक सामान्य नुकसान एक गैर-मौजूद कुंजी का उपयोग करना है। यह आमतौर पर KeyError अपवाद में होता है

mydict = {}
mydict['not there']

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'not there'

मुख्य त्रुटियों से बचने का एक तरीका यह है कि आप dict.get पद्धति का उपयोग करें, जो आपको अनुपस्थित कुंजी के मामले में लौटने के लिए एक डिफ़ॉल्ट मान निर्दिष्ट करने की अनुमति देता है।

value = mydict.get(key, default_value)

जो मौजूद होने पर mydict[key] लौटाता है, लेकिन अन्यथा default_value लौटाता है। ध्यान दें कि यह mydict key नहीं mydict । इसलिए यदि आप उस प्रमुख मूल्य जोड़ी को बनाए रखना चाहते हैं, तो आपको mydict.setdefault(key, default_value) उपयोग करना चाहिए, जो कुंजी मूल्य जोड़ी को संग्रहीत करता है ।

mydict = {}
print(mydict)
# {}
print(mydict.get("foo", "bar"))
# bar
print(mydict)
# {}
print(mydict.setdefault("foo", "bar"))
# bar
print(mydict)
# {'foo': 'bar'}

समस्या से निपटने का एक वैकल्पिक तरीका अपवाद को पकड़ रहा है

try:
    value = mydict[key]
except KeyError:
    value = default_value

तुम भी यदि कुंजी है जांच कर सकता है in शब्दकोश।

if key in mydict:
    value = mydict[key]
else:
    value = default_value

ध्यान दें, हालांकि, बहु-थ्रेडेड वातावरण में कुंजी के लिए यह संभव है कि आप चेक करने के बाद डिक्शनरी से हटा दें, एक दौड़ की स्थिति बनाएं जहां अपवाद अभी भी फेंका जा सकता है।

एक अन्य विकल्प यह है कि एक उप-वर्ग का उपयोग करें, जिसमें उप-संग्रह, डिक्टल्टलडिक्ट हो, जिसमें एक नई_की दी जाने पर डिफॉल्ट में नई प्रविष्टियां बनाने के लिए एक डिफ़ॉल्ट_फैक्ट्री है।

कुंजियों और मूल्यों तक पहुँचना

जब शब्दकोशों के साथ काम है, यह अक्सर सभी कुंजियों और मानों एक में शब्दकोश में उपयोग करने के लिए, या तो आवश्यक है for पाश, एक सूची समझ, या सिर्फ एक सादे सूची के रूप में।

जैसे एक शब्दकोश दिया:

mydict = {
    'a': '1',
    'b': '2'
}

आप कुंजियों का उपयोग करके कुंजियों की एक सूची प्राप्त कर सकते हैं keys() विधि:

print(mydict.keys())
# Python2: ['a', 'b']
# Python3: dict_keys(['b', 'a'])

यदि आप मानों की सूची चाहते हैं, तो values() विधि का उपयोग करें:

print(mydict.values())
# Python2: ['1', '2']
# Python3: dict_values(['2', '1'])

यदि आप कुंजी और उसके अनुरूप मान दोनों के साथ काम करना चाहते हैं, तो आप items() विधि items() उपयोग कर सकते हैं:

print(mydict.items())
# Python2: [('a', '1'), ('b', '2')]
# Python3: dict_items([('b', '2'), ('a', '1')])

नोट: क्योंकि एक dict है, keys() , values() , और items() में कोई सॉर्ट ऑर्डर नहीं है। यदि आप इन विधियों को वापस करने के आदेश की परवाह करते हैं, तो sorted() sort() , sorted() , या OrderedDict उपयोग करें।

पायथन 2/3 अंतर: पायथन 3 में, ये विधियाँ विशेष चलने योग्य वस्तुओं को लौटाती हैं, सूचियों को नहीं, और पायथन 2 iterkeys() , itervalues() , और iteritems() विधियों के iteritems() । इन वस्तुओं का उपयोग अधिकांश भाग के लिए सूचियों की तरह किया जा सकता है, हालांकि कुछ अंतर हैं। अधिक विवरण के लिए PEP 3106 देखें।

शब्दकोश का परिचय

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

एक तानाशाही बनाना

शब्दकोशों को कई तरीकों से शुरू किया जा सकता है:

शाब्दिक वाक्य रचना

d = {}                        # empty dict
d = {'key': 'value'}          # dict with initial values

# Also unpacking one or multiple dictionaries with the literal syntax is possible

# makes a shallow copy of otherdict
d = {**otherdict}
# also updates the shallow copy with the contents of the yetanotherdict.
d = {**otherdict, **yetanotherdict}

तानाशाही समझ

d = {k:v for k,v in [('key', 'value',)]}

इन्हें भी देखें: समझ

अंतर्निहित वर्ग: dict()

d = dict()                    # emtpy dict
d = dict(key='value')         # explicit keyword arguments
d = dict([('key', 'value')])  # passing in a list of key/value pairs
# make a shallow copy of another dict (only possible if keys are only strings!)
d = dict(**otherdict)         

एक तानाशाही संशोधन

किसी शब्दकोश में आइटम जोड़ने के लिए, बस एक मूल्य के साथ एक नई कुंजी बनाएं:

d['newkey'] = 42

मूल्य के रूप में list और dictionary को जोड़ना भी संभव है:

d['new_list'] = [1, 2, 3]
d['new_dict'] = {'nested_dict': 1}

किसी आइटम को हटाने के लिए, शब्दकोश से कुंजी हटाएं:

del d['newkey']

डिफ़ॉल्ट मूल्यों के साथ शब्दकोश

defaultdict रूप में मानक पुस्तकालय में defaultdict

from collections import defaultdict

d = defaultdict(int)
d['key']                         # 0
d['key'] = 5
d['key']                         # 5

d = defaultdict(lambda: 'empty')
d['key']                         # 'empty'
d['key'] = 'full'
d['key']                         # 'full'

[*] वैकल्पिक रूप से, आप में निर्मित का उपयोग करना चाहिए अगर dict वर्ग, using dict.setdefault() जब भी आप एक महत्वपूर्ण यह है कि पहले अस्तित्व में नहीं था का उपयोग आप एक डिफ़ॉल्ट बनाने के लिए अनुमति देगा:

>>> d = {}
{}
>>> d.setdefault('Another_key', []).append("This worked!")
>>> d
{'Another_key': ['This worked!']}

ध्यान रखें कि यदि आपके पास जोड़ने के लिए कई मान हैं, तो dict.setdefault() प्रारंभिक मूल्य का एक नया उदाहरण बनाएगा (इस उदाहरण में [] a [] ) जिसे हर बार बुलाया जाता है - जो अनावश्यक वर्कलोड पैदा कर सकता है।

[*] पाइथन कुकबुक, तीसरा संस्करण, डेविड बेज़ले और ब्रायन के। जोन्स (ओ'रिली) द्वारा। कॉपीराइट 2013 डेविड बेज़ले और ब्रायन जोन्स, 978-1-449-34037-7।

एक आदेश दिया शब्दकोश बनाना

आप एक आदेशित शब्दकोष बना सकते हैं जो एक निर्धारित क्रम का पालन करेगा जब शब्दकोश में कुंजियों पर पुनरावृत्ति होगी।

collections मॉड्यूल से OrderedDict उपयोग करें। यह हमेशा मूल प्रविष्टि क्रम में शब्दकोश तत्वों को लौटाएगा जब इसे खत्म किया जाता है।

from collections import OrderedDict

d = OrderedDict()
d['first'] = 1
d['second'] = 2
d['third'] = 3
d['last'] = 4

# Outputs "first 1", "second 2", "third 3", "last 4"
for key in d:
    print(key, d[key])

** ऑपरेटर का उपयोग करके शब्दकोशों को खोलना

आप एक फ़ंक्शन के तर्कों में शब्दकोश में कुंजी-मूल्य जोड़े देने के लिए ** कीवर्ड तर्क अनपैकिंग ऑपरेटर का उपयोग कर सकते हैं। आधिकारिक प्रलेखन से एक सरल उदाहरण:

>>>
>>> def parrot(voltage, state, action):
...     print("This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)

This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

अजगर 3.5 के रूप में आप भी की एक मनमाना संख्या मर्ज करने के लिए इस वाक्य रचना का उपयोग कर सकते dict वस्तुओं।

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}
>>> fishdog = {**fish, **dog}
>>> fishdog

{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

जैसा कि यह उदाहरण प्रदर्शित करता है, डुप्लिकेट कीज़ मैप उनके सबसे बाद के मूल्य (उदाहरण के लिए "क्लिफोर्ड" "निमो" को ओवरराइड करता है)।

शब्दकोश विलय

निम्नलिखित शब्दकोशों पर विचार करें:

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}

पायथन 3.5+

>>> fishdog = {**fish, **dog}
>>> fishdog
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

जैसा कि यह उदाहरण प्रदर्शित करता है, डुप्लिकेट कीज़ मैप उनके सबसे बाद के मूल्य (उदाहरण के लिए "क्लिफोर्ड" "निमो" को ओवरराइड करता है)।

अजगर 3.3+

>>> from collections import ChainMap
>>> dict(ChainMap(fish, dog))
{'hands': 'fins', 'color': 'red', 'special': 'gills', 'name': 'Nemo'}

इस तकनीक के साथ सबसे महत्वपूर्ण मान किसी दिए गए कुंजी के बजाय पिछले ("क्लिफोर्ड" "निमो" के पक्ष में बाहर फेंक दिया जाता है) के लिए पूर्वता लेता है।

अजगर 2.x, 3.x

>>> from itertools import chain
>>> dict(chain(fish.items(), dog.items()))
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

यह बाद वाले मूल्य का उपयोग करता है, जैसा कि विलय के लिए ** -आधारित तकनीक के साथ ("क्लिफोर्ड" "निमो" को ओवरराइड करता है)।

>>> fish.update(dog)
>>> fish
{'color': 'red', 'hands': 'paws', 'name': 'Clifford', 'special': 'gills'}

dict.update पिछले वाले को अधिलेखित करने के लिए बाद वाले dict.update का उपयोग करता है।

अनुगामी अल्पविराम

सूचियों और टुपल्स की तरह, आप अपने शब्दकोश में एक अनुगामी अल्पविराम शामिल कर सकते हैं।

role = {"By day": "A typical programmer",
        "By night": "Still a typical programmer", }

PEP 8 तय करता है कि आपको पीछे चल रहे अल्पविराम और समापन ब्रेस के बीच एक स्थान छोड़ना चाहिए।

शब्दकोश मूल्यों के सभी संयोजन

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]
}

एक शब्दकोश जैसे कि ऊपर दिखाया गया है, जहां एक सूची दी गई है जिसमें संबंधित कुंजी का पता लगाने के लिए मूल्यों के एक सेट का प्रतिनिधित्व किया गया है। मान लीजिए कि आप "y"=10 साथ "x"="a" का अन्वेषण करना चाहते हैं, तो "x"="a" साथ "y"=10 , और इसी तरह जब तक आप सभी संभावित संयोजनों का पता नहीं लगा लेते।

आप एक सूची बना सकते हैं जो निम्नलिखित कोड का उपयोग करके मूल्यों के ऐसे सभी संयोजनों को लौटाता है।

import itertools

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]}

keys = options.keys()
values = (options[key] for key in keys)
combinations = [dict(zip(keys, combination)) for combination in itertools.product(*values)]
print combinations

यह हमें चर combinations में निम्नलिखित सूची देता है:

[{'x': 'a', 'y': 10},
 {'x': 'b', 'y': 10},
 {'x': 'a', 'y': 20},
 {'x': 'b', 'y': 20},
 {'x': 'a', 'y': 30},
 {'x': 'b', 'y': 30}]

एक शब्दकोश में Iterating

यदि आप किसी शब्दकोश को इट्रेटर के रूप में उपयोग करते हैं (उदाहरण के for कथन में), तो यह शब्दकोश की कुंजी का पता लगाता है। उदाहरण के लिए:

d = {'a': 1, 'b': 2, 'c':3}
for key in d:
    print(key, d[key])
# c 3
# b 2
# a 1

जब एक समझ में उपयोग किया जाता है तो वही सच होता है

print([key for key in d])
# ['c', 'b', 'a']

for key, value in d.items():
    print(key, value)
# c 3
# b 2
# a 1

for key, value in d.values():
    print(key, value)
    # 3
    # 2
    # 1

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

शब्दकोश बनाने के नियम:

• प्रत्येक कुंजी अद्वितीय होनी चाहिए (अन्यथा इसे ओवरराइड किया जाएगा)
• हर कुंजी हैशेबल होनी चाहिए ( hash फ़ंक्शन का उपयोग इसे हैश करने के लिए कर सकते हैं; नहीं तो TypeError को फेंक दिया जाएगा)
• चाबियों के लिए कोई विशेष आदेश नहीं है।

# Creating and populating it with values
stock = {'eggs': 5, 'milk': 2}

# Or creating an empty dictionary
dictionary = {}

# And populating it after
dictionary['eggs'] = 5
dictionary['milk'] = 2

# Values can also be lists
mydict = {'a': [1, 2, 3], 'b': ['one', 'two', 'three']}

# Use list.append() method to add new elements to the values list
mydict['a'].append(4)   # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three']}
mydict['b'].append('four')  # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three', 'four']}

# We can also create a dictionary using a list of two-items tuples
iterable = [('eggs', 5), ('milk', 2)]
dictionary = dict(iterables)

# Or using keyword argument:
dictionary = dict(eggs=5, milk=2)

# Another way will be to use the dict.fromkeys:
dictionary = dict.fromkeys((milk, eggs))  # => {'milk': None, 'eggs': None}
dictionary = dict.fromkeys((milk, eggs), (2, 5))  # => {'milk': 2, 'eggs': 5}

शब्दकोश उदाहरण

शब्दकोश मूल्यों के लिए शब्दकोशों की चाबियाँ।

car = {}
car["wheels"] = 4
car["color"] = "Red"
car["model"] = "Corvette"

शब्दकोश मूल्यों को उनकी कुंजियों द्वारा पहुँचा जा सकता है।

print "Little " + car["color"] + " " + car["model"] + "!"
# This would print out "Little Red Corvette!"    

शब्दकोश को JSON शैली में भी बनाया जा सकता है:

car = {"wheels": 4, "color": "Red", "model": "Corvette"}

शब्दकोश मूल्यों को इससे अधिक प्रसारित किया जा सकता है:

for key in car:
  print key + ": " + car[key]

# wheels: 4
# color: Red
# model: Corvette