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

Question 1

मान लें कि हमारे पास पायथन शब्दकोश है d, और हम इसे इस तरह से देख रहे हैं:

for k,v in d.iteritems():
    del d[f(k)] # remove some item
    d[g(k)] = v # add a new item

( fऔर gसिर्फ कुछ ब्लैक-बॉक्स रूपांतरण हैं।)

दूसरे शब्दों में, हम dउपयोग करते समय पुनरावृति करते हुए वस्तुओं को जोड़ने / हटाने का प्रयास करते हैं iteritems।

क्या यह अच्छी तरह से परिभाषित है? क्या आप अपने उत्तर का समर्थन करने के लिए कुछ संदर्भ प्रदान कर सकते हैं?

(यह बहुत स्पष्ट है कि इसे कैसे ठीक किया जाए अगर यह टूट गया है, तो यह वह कोण नहीं है जिसके बाद मैं हूं।)

Question 2

यह स्पष्ट रूप से पायथन डॉक पेज ( पायथन 2.7 के लिए ) पर उल्लिखित है

iteritems()शब्दकोश में प्रविष्टियों को जोड़ने या हटाने का उपयोग करते समय RuntimeErrorसभी प्रविष्टियों पर पुनरावृति करने या विफल करने के लिए उठा सकते हैं।

इसी तरह पायथन 3 के लिए ।

वही धारण करता है iter(d), d.iterkeys()और d.itervalues(), मैं यह कहूँगा कि जहाँ तक यह होता है for k, v in d.items():(मुझे ठीक से याद नहीं है कि क्या forकरता है, लेकिन अगर कार्यान्वयन कहा जाता है तो मुझे आश्चर्य नहीं होगा iter(d))।

Question 3

इस पर एलेक्स मार्टेली का वजन है ।

कंटेनर पर लूप करते समय कंटेनर (जैसे तानाशाह) को बदलना सुरक्षित नहीं हो सकता है। तो del d[f(k)]सुरक्षित नहीं हो सकता। जैसा कि आप जानते हैं, वर्कअराउंड का उपयोग करना है d.items()(कंटेनर की एक स्वतंत्र प्रतिलिपि पर लूप करना) d.iteritems()( बजाय उसी अंतर्निहित कंटेनर का उपयोग करता है)।

मान को किसी मौजूदा इंडेक्स पर संशोधित करना ठीक है , लेकिन नए सूचकांकों (जैसे d[g(k)]=v) में मान डालने से काम नहीं हो सकता है।

Question 4

आप ऐसा नहीं कर सकते, कम से कम के साथ d.iteritems()। मैंने इसे आजमाया, और पायथन के साथ विफल हो गया

RuntimeError: dictionary changed size during iteration

यदि आप इसके बजाय उपयोग करते हैं d.items(), तो यह काम करता है।

Python 3 d.items()में, शब्दकोश में एक दृश्य है, जैसे d.iteritems()Python 2 में। Python 3 में ऐसा करने के लिए, बजाय उपयोग के d.copy().items()। यह उसी तरह हमें शब्दकोश की एक प्रति पर पुनरावृति करने की अनुमति देगा ताकि हम उस डेटा संरचना को संशोधित करने से बच सकें, जिस पर हम पुनरावृत्ति कर रहे हैं।

Question 5

मेरे पास Numpy सरणियों वाला एक बड़ा शब्दकोश है, इसलिए तानाशाह। ()। चाबियाँ () @ murgatroid99 द्वारा सुझाई गई बात व्यवहार्य नहीं थी (हालांकि यह काम किया)। इसके बजाय, मैंने बस keys_view को एक सूची में बदल दिया और यह ठीक काम किया (पायथन 3.4 में):

for item in list(dict_d.keys()):
    temp = dict_d.pop(item)
    dict_d['some_key'] = 1  # Some value

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

Question 6

निम्न कोड दिखाता है कि यह अच्छी तरह से परिभाषित नहीं है:

def f(x):
    return x

def g(x):
    return x+1

def h(x):
    return x+10

try:
    d = {1:"a", 2:"b", 3:"c"}
    for k, v in d.iteritems():
        del d[f(k)]
        d[g(k)] = v+"x"
    print d
except Exception as e:
    print "Exception:", e

try:
    d = {1:"a", 2:"b", 3:"c"}
    for k, v in d.iteritems():
        del d[f(k)]
        d[h(k)] = v+"x"
    print d
except Exception as e:
    print "Exception:", e

पहला उदाहरण जी (के) को कॉल करता है, और एक अपवाद को फेंक देता है (पुनरावृति के दौरान इसका बदला हुआ आकार)।

दूसरा उदाहरण h (k) कहता है और कोई अपवाद नहीं फेंकता है, लेकिन आउटपुट:

{21: 'axx', 22: 'bxx', 23: 'cxx'}

जो, कोड को देखकर गलत लगता है - मुझे कुछ इस तरह की उम्मीद होगी:

{11: 'ax', 12: 'bx', 13: 'cx'}

Question 7

मुझे वही समस्या मिली और मैंने इस समस्या को हल करने के लिए निम्नलिखित प्रक्रिया का उपयोग किया।

यदि आप इस पर पुनरावृत्ति के दौरान संशोधित करते हैं तो भी पायथन सूची पुनरावृत्त हो सकती है। तो निम्नलिखित कोड के लिए यह 1 का अनंत प्रिंट करेगा।

for i in list:
   list.append(1)
   print 1

तो सूची और तानाशाही का उपयोग करके आप इस समस्या को हल कर सकते हैं।

d_list=[]
 d_dict = {} 
 for k in d_list:
    if d_dict[k] is not -1:
       d_dict[f(k)] = -1 # rather than deleting it mark it with -1 or other value to specify that it will be not considered further(deleted)
       d_dict[g(k)] = v # add a new item 
       d_list.append(g(k))

Question 8

अजगर 3 आपको बस चाहिए:

prefix = 'item_'
t = {'f1': 'ffw', 'f2': 'fca'}
t2 = dict() 
for k,v in t.items():
    t2[k] = prefix + v

या उपयोग:

t2 = t1.copy()

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

Question 9

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

मैंने निम्नलिखित दिनचर्या का निर्माण किया, जिसे jaraco.itertools में भी पाया जा सकता है :

def _mutable_iter(dict):
    """
    Iterate over items in the dict, yielding the first one, but allowing
    it to be mutated during the process.
    >>> d = dict(a=1)
    >>> it = _mutable_iter(d)
    >>> next(it)
    ('a', 1)
    >>> d
    {}
    >>> d.update(b=2)
    >>> list(it)
    [('b', 2)]
    """
    while dict:
        prev_key = next(iter(dict))
        yield prev_key, dict.pop(prev_key)

डॉकस्ट्रिंग उपयोग को दर्शाता है। यह फ़ंक्शन d.iteritems()वांछित प्रभाव के लिए ऊपर की जगह इस्तेमाल किया जा सकता है।