मैं एक शब्दकोश में नई कुंजी कैसे जोड़ सकता हूं?

Question

क्या इसे बनाने के बाद एक पायथन शब्दकोश में एक कुंजी जोड़ना संभव है?

यह एक .add()विधि है प्रतीत नहीं होता है ।

Comments

यदि आप यहां यह जानने की कोशिश कर रहे हैं कि कुंजी कैसे जोड़ें और एक नया शब्दकोश वापस करें , तो आप इसे python3.5 +: पर कर सकते हैं {**mydict, 'new_key': new_val}।

— cs95

या तो स्वीकृत उत्तर का उपयोग करें: d ['mynewkey'] = 'mynewvalue' या आप val = d.setdefault ('mynewkey', 'mynewvalue') का उपयोग कर सकते हैं

— Ol '

Answer 1

d = {'key': 'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'key': 'value', 'mynewkey': 'mynewvalue'}

Comments

स्पष्टीकरण यह है: आप उस कुंजी के लिए मान निर्दिष्ट करके शब्दकोश पर एक नया कुंजी \ value युग्म बनाते हैं। यदि कुंजी मौजूद नहीं है, तो इसे जोड़ा जाता है और उस मान को इंगित करता है। यदि यह मौजूद है, तो यह वर्तमान मान को अधिलेखित कर दिया जाता है।

— आर। नवेगा

इस और .update()विधि के बीच अंतर क्या है ? कौन सा बेहतर है कब?

— शाम

@ सिगैक्स d[key]=valको छोटा होने के कारण और किसी भी ऑब्जेक्ट को कुंजी के रूप में संभाल सकते हैं (जब तक कि यह हैज़बल है), और केवल एक मान सेट करता है, जबकि .update(key1=val1, key2=val2)नाइसर है यदि आप एक ही समय में कई मान सेट करना चाहते हैं, जब तक कि कुंजी। तार होते हैं (चूंकि कंवर स्ट्रिंग्स में परिवर्तित हो जाते हैं)। dict.updateएक अन्य शब्दकोश भी ले सकता है, लेकिन मैं व्यक्तिगत रूप से एक और शब्दकोश को अपडेट करने के लिए स्पष्ट रूप से एक नया शब्दकोश बनाना पसंद नहीं करता।

— bgusach

इसे आज़माएँ, यहाँ एक उदाहरण है: repl.it/@SmaMa/Add-key-to-dict

— Sma Ma

मैं एक नेस्टेड तानाशाह में एक तत्व कैसे जोड़ सकता हूं। जैसे php$foo[ ] = [ . . . . ]

— जुआन-कबाली

Answer 2

एक साथ कई कुंजियाँ जोड़ने के लिए, उपयोग करें dict.update():

>>> x = {1:2}
>>> print(x)
{1: 2}

>>> d = {3:4, 5:6, 7:8}
>>> x.update(d)
>>> print(x)
{1: 2, 3: 4, 5: 6, 7: 8}

एकल कुंजी जोड़ने के लिए, स्वीकृत उत्तर में कम कम्प्यूटेशनल ओवरहेड है।

Comments

यह केवल एक कुंजी को अद्यतन करने के लिए एक शब्दकोश बनाने के लिए अक्षम है। आप अधिक से अधिक 1 कुंजी (एक सीमा जिसके ऊपर यह एक dict बनाने के लिए बेहतर है हो सकता है) केवल तभी ऐसा करें

— जीन फ़्राँस्वा Fabre

@ जीन-फ्रांस्वा फाबरे यह उदाहरण कोड है। आपको वास्तव में सभी मामलों को कवर करने के रूप में उत्तरों का इलाज नहीं करना चाहिए।

— रॉबर्ट ब्रिसिटा

यह गलत धारणा देता है कि यह एक कुंजी जोड़ने का पसंदीदा तरीका है।

— जीन फ़्राँस्वा Fabre

@ जीन-फ्रांस्वा फाबरे चूंकि पाइथन 3.7+ में तानाशाही आदेश की गारंटी है (और 3.6+ में प्रदान की गई है) , यह अच्छी तरह से एकल कुंजी जोड़ने का पसंदीदा तरीका हो सकता है जब ऑर्डर महत्वपूर्ण हो ।

— ingyhere

यदि आप एक और कुंजी बनाते हैं x[-1] = 44तो -1मूल्य भी अंत में है। वैसे भी जवाब संपादित किया गया है और अब बहुत बेहतर है। शब्दकोश के साथ अपडेट करना अच्छा है जब यह संभावना है कि इसमें कई आइटम शामिल हैं।

— जीन फ़्राँस्वा Fabre

Answer 3

मुझे लगता है कि पायथन शब्दकोशों के बारे में जानकारी को समेकित करना:

एक खाली शब्दकोश बनाना

data = {}
# OR
data = dict()

प्रारंभिक मूल्यों के साथ एक शब्दकोश बनाना

data = {'a': 1, 'b': 2, 'c': 3}
# OR
data = dict(a=1, b=2, c=3)
# OR
data = {k: v for k, v in (('a', 1), ('b',2), ('c',3))}

किसी एकल मान को सम्मिलित / अद्यतन करना

data['a'] = 1  # Updates if 'a' exists, else adds 'a'
# OR
data.update({'a': 1})
# OR
data.update(dict(a=1))
# OR
data.update(a=1)

कई मानों को सम्मिलित / अद्यतन करना

data.update({'c':3,'d':4})  # Updates 'c' and adds 'd'

मूल को संशोधित किए बिना एक विलय शब्दकोश बनाना

data3 = {}
data3.update(data)  # Modifies data3, not data
data3.update(data2)  # Modifies data3, not data2

शब्दकोश में आइटम हटाना

del data[key]  # Removes specific element in a dictionary
data.pop(key)  # Removes the key & returns the value
data.clear()  # Clears entire dictionary

जांचें कि क्या कोई कुंजी पहले से ही शब्दकोश में है

key in data

एक शब्दकोश में जोड़े के माध्यम से Iterate

for key in data: # Iterates just through the keys, ignoring the values
for key, value in d.items(): # Iterates through the pairs
for key in d.keys(): # Iterates just through key, ignoring the values
for value in d.values(): # Iterates just through value, ignoring the keys

दो सूचियों से एक शब्दकोश बनाएं

data = dict(zip(list_with_keys, list_with_values))

---

पायथन 3.5 पर नया

मूल को संशोधित किए बिना एक विलय शब्दकोश बनाना:

यह एक नया करतब का उपयोग करता है जिसे शब्दकोश अनपैकिंग कहा जाता है ।

data = {**data1, **data2, **data3}

---

पायथन 3.9 में नया

किसी मौजूदा शब्दकोश के लिए मान अपडेट करें या जोड़ें

अद्यतन ऑपरेटर |= अब शब्दकोशों के लिए काम करता है:

data |= {'c':3,'d':4}

मूल को संशोधित किए बिना एक विलय शब्दकोश बनाना

मर्ज ऑपरेटर | अब शब्दकोशों के लिए काम करता है:

data = data1 | {'c':3,'d':4}

---

अधिक जोड़ने के लिए स्वतंत्र महसूस करें!

Answer 4

"क्या पायथन डिक्शनरी को बनाने के बाद इसे जोड़ना संभव है? यह एक .ad () विधि नहीं लगता है।"

हां यह संभव है, और इसमें एक विधि है जो इसे लागू करती है, लेकिन आप इसे सीधे उपयोग नहीं करना चाहते हैं।

यह प्रदर्शित करने के लिए कि कैसे और कैसे उपयोग नहीं करना है, आइए हम तानाशाही के साथ खाली जगह बनाएं {}:

my_dict = {}

सर्वश्रेष्ठ अभ्यास 1: सदस्यता संकेतन

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

my_dict['new key'] = 'new value'

my_dict अब है:

{'new key': 'new value'}

सर्वोत्तम अभ्यास 2: updateविधि - 2 तरीके

हम विधि का उपयोग करने केupdate साथ-साथ कुशलता से कई मूल्यों के साथ तानाशाह को भी अपडेट कर सकते हैं । हम अनावश्यक रूप से dictयहां एक अतिरिक्त निर्माण कर सकते हैं, इसलिए हमें उम्मीद है कि हमारा dictनिर्माण पहले ही हो चुका है और किसी अन्य उद्देश्य के लिए इस्तेमाल किया गया है:

my_dict.update({'key 2': 'value 2', 'key 3': 'value 3'})

my_dict अब है:

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value'}

अपडेट विधि के साथ ऐसा करने का एक और कुशल तरीका कीवर्ड तर्क के साथ है, लेकिन चूंकि उनके पास वैध अजगर शब्द हैं, आपके पास स्थान या विशेष प्रतीक नहीं हो सकते हैं या एक नंबर के साथ नाम शुरू कर सकते हैं, लेकिन कई इसे अधिक पठनीय तरीका मानते हैं एक तानाशाही के लिए कुंजी बनाने के लिए, और यहाँ हम निश्चित रूप से एक अतिरिक्त अनावश्यक बनाने से बचते हैं dict:

my_dict.update(foo='bar', foo2='baz')

और my_dictअब है:

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value', 
 'foo': 'bar', 'foo2': 'baz'}

तो अब हमने अपडेट करने के तीन पायथनिक तरीकों को कवर किया है dict।

---

जादू की विधि, __setitem__और क्यों इसे टाला जाना चाहिए

अपडेट का एक और तरीका है dictजिसे आपको उपयोग नहीं करना चाहिए, जो __setitem__विधि का उपयोग करता है । यहाँ एक उदाहरण दिया गया है कि कैसे कोई __setitem__एक कुंजी-मूल्य जोड़ी को जोड़ने के लिए विधि का उपयोग कर सकता है dict, और इसका उपयोग करने के खराब प्रदर्शन का एक प्रदर्शन:

>>> d = {}
>>> d.__setitem__('foo', 'bar')
>>> d
{'foo': 'bar'}


>>> def f():
...     d = {}
...     for i in xrange(100):
...         d['foo'] = i
... 
>>> def g():
...     d = {}
...     for i in xrange(100):
...         d.__setitem__('foo', i)
... 
>>> import timeit
>>> number = 100
>>> min(timeit.repeat(f, number=number))
0.0020880699157714844
>>> min(timeit.repeat(g, number=number))
0.005071878433227539

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

Comments

यह अंतर 2020 में कम चिह्नित है (मेरी मशीन पर, 1.35 एमएस सबस्क्रिप्टिंग बनाम 2ms के लिए d.__setitem__), हालांकि निष्कर्ष (और विशेष रूप से अंतिम वाक्य) ध्वनि बना हुआ है। लूप से निकलने वाली विधि नाम लुकिंग को लगभग 1.65 एमएस तक कम कर दिया; शेष अंतर काफी हद तक अपरिहार्य पायथन कॉल तंत्र ओवरहेड के कारण है।

— होल्डनवेब

Answer 5

dictionary[key] = value

Answer 6

यदि आप एक शब्दकोश के भीतर एक शब्दकोश जोड़ना चाहते हैं तो आप इसे इस तरह से कर सकते हैं।

उदाहरण: अपने शब्दकोश और उप शब्दकोश में एक नई प्रविष्टि जोड़ें

dictionary = {}
dictionary["new key"] = "some new entry" # add new dictionary entry
dictionary["dictionary_within_a_dictionary"] = {} # this is required by python
dictionary["dictionary_within_a_dictionary"]["sub_dict"] = {"other" : "dictionary"}
print (dictionary)

आउटपुट:

{'new key': 'some new entry', 'dictionary_within_a_dictionary': {'sub_dict': {'other': 'dictionarly'}}}

नोट: पायथन की आवश्यकता है कि आप पहले एक उप जोड़ें

dictionary["dictionary_within_a_dictionary"] = {}

प्रविष्टियों को जोड़ने से पहले।

Comments

यह php.net मैनुअल पेजों में अधिकांश टिप्पणियों के रूप में पूछे गए सवाल के लिए अप्रासंगिक है ...

— एरिक कपलुन

एक पंक्ति पर आपको ऐसा करने से रोकने के लिए कुछ भी नहीं: dictionary = {"dictionary_within_a_dictionary": {"sub_dict": {"other" : "dictionary"}}}(या यदि dictionaryपहले से ही एक तानाशाही है, dictionary["dictionary_within_a_dictionary"] = {"sub_dict": {"other" : "dictionary"}})

— क्रिस

Answer 7

रूढ़िवादी वाक्यविन्यास है d[key] = value, लेकिन यदि आपका कीबोर्ड चौकोर ब्रैकेट कीज़ को याद कर रहा है, तो आप कर सकते हैं:

d.__setitem__(key, value)

वास्तव में, परिभाषित करना __getitem__और __setitem__विधियां हैं कि आप वर्ग ब्रैकेट सिंटैक्स का अपना वर्ग समर्थन कैसे कर सकते हैं। Https://python.developpez.com/cours/DiveIntoPython/php/endiveintopython/object_oriented_framework/special_class_methods.php देखें

Comments

मुझे अपने कीबोर्ड पर ब्रैकेट कीज़ के बिना अजगर के साथ प्रोग्राम करना बेहद मुश्किल होगा।

— बोबोर्ट

यह एकमात्र तरीका था जो मुझे एक सूची समझ के भीतर शब्दकोश मूल्यों को निर्धारित करने के लिए मिल सकता था। धन्यवाद

— क्रिस स्टीवंस

@chrisstevens अगर आप एक मूल्य को एक हैक सेट करना चाहते हैं जो मैंने उपयोग किया है हैक है [a for a in my_dict if my_dict.update({'a': 1}) is None]।

— जेरेमी लोगन

जिज्ञासु ... क्या यह (यानी- गायब चौकोर कोष्ठक) आम है?

— अलेस्टर तानेक जवास माज

@chrisstevens @JeremyLogan जब आप एक व्यापक समझ का उपयोग कर सकते हैं तो सूची समझ का उपयोग क्यों करें? {v: k for k, v in my_dict.items() if <some_conditional_check>}

— ingyhere

Answer 8

आप एक बना सकते हैं:

class myDict(dict):

    def __init__(self):
        self = dict()

    def add(self, key, value):
        self[key] = value

## example

myd = myDict()
myd.add('apples',6)
myd.add('bananas',3)
print(myd)

देता है:

>>> 
{'apples': 6, 'bananas': 3}

Answer 9

यह लोकप्रिय सवाल विलय के कार्यात्मक तरीकों को संबोधित करता हैa और b।

यहाँ कुछ और अधिक सरल तरीके (पायथन 3 में परीक्षण किए गए) दिए गए हैं ...

c = dict( a, **b ) ## see also https://stackoverflow.com/q/2255878
c = dict( list(a.items()) + list(b.items()) )
c = dict( i for d in [a,b] for i in d.items() )

नोट: ऊपर की पहली विधि केवल तभी काम करती है जब चाबियाँ bस्ट्रिंग्स हैं।

किसी एक तत्व को जोड़ने या संशोधित करने के लिए , bशब्दकोश में केवल एक तत्व होगा ...

c = dict( a, **{'d':'dog'} ) ## returns a dictionary based on 'a'

यह इसके बराबर है ...

def functional_dict_add( dictionary, key, value ):
   temp = dictionary.copy()
   temp[key] = value
   return temp

c = functional_dict_add( a, 'd', 'dog' )

Comments

पायथन के BDFL ( यहां ) से पहली विधि के बारे में दिलचस्प टिप्पणी ।

— नोबार

c = dict( a, **{'d':'dog'} )तब तक बेहतर लिखा जाएगा c = dict(a, d='dog'), जब तक कि चाबियों को जाना जाता है और गणना नहीं की जाती।

— होल्डनवेब

Answer 10

चलो दिखावा करते हैं कि आप अपरिवर्तनीय दुनिया में रहना चाहते हैं और मूल को संशोधित नहीं करना चाहते हैं लेकिन एक नया बनाना चाहते हैं जो मूल में dictएक नई कुंजी जोड़ने का परिणाम है।

पायथन 3.5+ में आप यह कर सकते हैं:

params = {'a': 1, 'b': 2}
new_params = {**params, **{'c': 3}}

पायथन 2 समतुल्य है:

params = {'a': 1, 'b': 2}
new_params = dict(params, **{'c': 3})

इनमें से किसी के बाद:

params अभी भी बराबर है {'a': 1, 'b': 2}

तथा

new_params के बराबर है {'a': 1, 'b': 2, 'c': 3}

ऐसे समय होंगे जब आप मूल को संशोधित नहीं करना चाहते हैं (आप केवल मूल को जोड़ना चाहते हैं)। मुझे यह निम्नलिखित के लिए एक ताज़ा विकल्प लगता है:

params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params['c'] = 3

या

params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params.update({'c': 3})

संदर्भ: https://stackoverflow.com/a/2255892/514866

Comments

एक प्रो-फंक्शनल प्रोग्रामिंग सहयोगी के साथ एक लंबी बातचीत में मेरा एक अच्छा बिंदु सामने आया। उपरोक्त दृष्टिकोण से एक नकारात्मक पक्ष यह है कि यदि कोड पढ़ने वाला कोई व्यक्ति **पायथन से परिचित नहीं है (कई नहीं हैं) तो यह स्पष्ट नहीं होगा कि क्या चल रहा है। ऐसे समय होते हैं जब आप बेहतर पठनीयता के लिए कम कार्यात्मक दृष्टिकोण का पक्ष लेंगे।

— शिविरार्थी

हम यह नहीं जान सकते कि हमारे पाठकों को पाइथन भाषा का कौन सा हिस्सा पता है, इसलिए यह मान लेना उचित है कि वे पूरी भाषा जानते हैं इसलिए वे उन भागों के लिए डॉक्स पर खोज करते हैं जो वे नहीं करते हैं।

— गैब्रियल

Answer 11

इतने सारे जवाब और अभी भी हर कोई अजीब नाम के बारे में भूल गया, अजीब तरह से व्यवहार किया, और फिर भी अभी भी काम कर रहा है dict.setdefault()

इस

value = my_dict.setdefault(key, default)

मूल रूप से बस यही करता है:

try:
    value = my_dict[key]
except KeyError: # key not found
    value = my_dict[key] = default

जैसे

>>> mydict = {'a':1, 'b':2, 'c':3}
>>> mydict.setdefault('d', 4)
4 # returns new value at mydict['d']
>>> print(mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # a new key/value pair was indeed added
# but see what happens when trying it on an existing key...
>>> mydict.setdefault('a', 111)
1 # old value was returned
>>> print(mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # existing key was ignored

Answer 12

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

import timeit

timeit.timeit('dictionary = {"karga": 1, "darga": 2}; dictionary.update({"aaa": 123123, "asd": 233})')
>> 0.49582505226135254

timeit.timeit('dictionary = {"karga": 1, "darga": 2}; dictionary["aaa"] = 123123; dictionary["asd"] = 233;')
>> 0.20782899856567383

हालाँकि, यदि आप जोड़ना चाहते हैं, उदाहरण के लिए, हजारों नए कुंजी-मूल्य जोड़े, आपको update()विधि का उपयोग करने पर विचार करना चाहिए ।

Answer 13

मुझे लगता है कि पायथन के collectionsमॉड्यूल को इंगित करना भी उपयोगी होगा जिसमें कई उपयोगी शब्दकोश उपवर्ग और आवरण शामिल हैं जो विशेष रूप से एक शब्दकोश में डेटा प्रकारों के जोड़ और संशोधन को सरल बनाते हैं defaultdict:

तानाशाह उपवर्ग जो लापता मूल्यों की आपूर्ति करने के लिए एक फैक्ट्री फ़ंक्शन को कॉल करता है

यह विशेष रूप से उपयोगी है यदि आप ऐसे शब्दकोशों के साथ काम कर रहे हैं जिनमें हमेशा समान डेटा प्रकार या संरचनाएं होती हैं, उदाहरण के लिए सूचियों का शब्दकोश।

>>> from collections import defaultdict
>>> example = defaultdict(int)
>>> example['key'] += 1
>>> example['key']
defaultdict(<class 'int'>, {'key': 1})

यदि कुंजी अभी तक मौजूद नहीं है, तो शब्दकोश में प्रारंभिक मान के रूप defaultdictमें दिए गए मूल्य (हमारे मामले में 10) को असाइन करें (अक्सर लूप के अंदर उपयोग किया जाता है)। यह ऑपरेशन इसलिए दो चीजें करता है: यह एक शब्दकोश में एक नई कुंजी जोड़ता है (प्रश्न के अनुसार), और मान प्रदान करता है यदि कुंजी अभी तक मौजूद नहीं है। मानक शब्दकोश के साथ, इससे एक त्रुटि उत्पन्न होती है क्योंकि +=ऑपरेशन उस मान तक पहुंचने का प्रयास कर रहा है जो अभी तक मौजूद नहीं है:

>>> example = dict()
>>> example['key'] += 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'key'

उपयोग के बिना defaultdict, एक नए तत्व को जोड़ने के लिए कोड की मात्रा बहुत अधिक होगी और शायद कुछ इस तरह दिखे:

# This type of code would often be inside a loop
if 'key' not in example:
    example['key'] = 0  # add key and initial value to dict; could also be a list
example['key'] += 1  # this is implementing a counter

defaultdictजटिल डेटा प्रकारों के साथ भी इस्तेमाल किया जा सकता है जैसे listऔर set:

>>> example = defaultdict(list)
>>> example['key'].append(1)
>>> example
defaultdict(<class 'list'>, {'key': [1]})

एक तत्व जोड़ना स्वचालित रूप से सूची को आरंभ करता है।

Answer 14

यहाँ एक और तरीका है जो मैंने यहाँ नहीं देखा:

>>> foo = dict(a=1,b=2)
>>> foo
{'a': 1, 'b': 2}
>>> goo = dict(c=3,**foo)
>>> goo
{'c': 3, 'a': 1, 'b': 2}

शब्दकोश का पुनर्निर्माण करने के लिए आप शब्दकोश कंस्ट्रक्टर और निहित विस्तार का उपयोग कर सकते हैं। इसके अलावा, दिलचस्प रूप से, इस पद्धति का उपयोग शब्दकोश निर्माण ( पोस्ट पायथन 3.6 ) के दौरान स्थितीय आदेश को नियंत्रित करने के लिए किया जा सकता है । वास्तव में, पायथन 3.7 और इसके बाद के संस्करण के लिए प्रविष्टि आदेश की गारंटी है!

>>> foo = dict(a=1,b=2,c=3,d=4)
>>> new_dict = {k: v for k, v in list(foo.items())[:2]}
>>> new_dict
{'a': 1, 'b': 2}
>>> new_dict.update(newvalue=99)
>>> new_dict
{'a': 1, 'b': 2, 'newvalue': 99}
>>> new_dict.update({k: v for k, v in list(foo.items())[2:]})
>>> new_dict
{'a': 1, 'b': 2, 'newvalue': 99, 'c': 3, 'd': 4}
>>> 

ऊपर शब्दकोश समझ का उपयोग कर रहा है।

Answer 15

पहले यह जांचने के लिए कि क्या कुंजी पहले से मौजूद है

a={1:2,3:4}
a.get(1)
2
a.get(5)
None

फिर आप नई कुंजी और मूल्य जोड़ सकते हैं

Answer 16

शब्दकोश कुंजी, मूल्य वर्ग जोड़ें।

class myDict(dict):

    def __init__(self):
        self = dict()

    def add(self, key, value):
        #self[key] = value # add new key and value overwriting any exiting same key
        if self.get(key)!=None:
            print('key', key, 'already used') # report if key already used
        self.setdefault(key, value) # if key exit do nothing


## example

myd = myDict()
name = "fred"

myd.add('apples',6)
print('\n', myd)
myd.add('bananas',3)
print('\n', myd)
myd.add('jack', 7)
print('\n', myd)
myd.add(name, myd)
print('\n', myd)
myd.add('apples', 23)
print('\n', myd)
myd.add(name, 2)
print(myd)