हल: सूची अजगर में डुप्लिकेट का नाम बदलें

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

def rename_duplicates(lst): 
    seen = set() 
    new_lst = [] 

    for item in lst: 
        if item not in seen: 
            seen.add(item) 
            new_lst.append(item) 
        else: 
            new_item = item + '_1'   # append a suffix to make it unique  

            while new_item in seen:   # increment the suffix until it's unique  
                suffix = int(new_item.split('_')[-1]) + 1   # get the last number and add one to it  
                new_item = '{}_{}'.format('_'.join(new_item.split('_')[:-1]), suffix)

            seen.add(new_item)     # add the newly created item to the set of seen items  
            new_lst.append(new_item)     # append the newly created item to the list

    return new

_पहला

# यह कोड rename_duplicates नामक एक फ़ंक्शन को परिभाषित करता है जो एक सूची में एक तर्क के रूप में लेता है।
def rename_duplicates (पहला):

# फिर यह एक खाली सेट बनाता है जिसे देखा जाता है और एक खाली सूची जिसे new_lst कहा जाता है।
देखा = सेट()
new_lst = []

# यह तब सूची में वस्तुओं के माध्यम से पुनरावृति करता है और जांचता है कि क्या वे पहले से ही देखी गई वस्तुओं के सेट में हैं।
सूची में आइटम के लिए:
यदि आइटम नहीं देखा गया है: # यदि यह नहीं है, तो यह इसे देखे गए आइटमों के सेट में जोड़ता है और इसे नई सूची में जोड़ता है।
देखा.जोड़ (आइटम)
new_lst.append(item) # यदि यह है, तो यह उस आइटम के नाम में एक प्रत्यय (जैसे, '_1') जोड़कर उस आइटम का एक अनूठा संस्करण बनाता है और यह जांचता है कि क्या यह नया बनाया गया आइटम पहले से ही देखी गई वस्तुओं के सेट में है।

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

new_item = आइटम + '_1'

जबकि new_item देखा गया: # अद्वितीय होने तक प्रत्यय बढ़ाएँ

प्रत्यय = int(new_item.split('_')[-1]) + 1 # अंतिम संख्या प्राप्त करें और इसमें एक जोड़ें

new_item = '{}_{}'.format('_'.join(new_item.split('_')[:-1]), प्रत्यय)

देखा। जोड़ें (नया

पायथन में सूची

पायथन में सूचियाँ सबसे अधिक उपयोग की जाने वाली डेटा संरचनाओं में से एक हैं। उनका उपयोग वस्तुओं के संग्रह को संग्रहीत करने के लिए किया जाता है, जो अन्य सूचियों सहित किसी भी प्रकार का हो सकता है। सूचियाँ परिवर्तनशील हैं, जिसका अर्थ है कि उन्हें बनाए जाने के बाद बदला जा सकता है। वे इंडेक्सिंग, स्लाइसिंग और कॉन्टेनेशन जैसे ऑपरेशंस का भी समर्थन करते हैं।

पायथन में एक सूची बनाने के लिए, आप वर्ग कोष्ठक का उपयोग करते हैं और प्रत्येक आइटम को अल्पविराम से अलग करते हैं:

मेरी_सूची = [1, 2, 3]

आप सूची में अलग-अलग तत्वों को उनके सूचकांक का उपयोग करके एक्सेस कर सकते हैं:
my_list [0] # रिटर्न 1
my_list [1] # रिटर्न 2
my_list [2] # रिटर्न 3

आप सूची के अंत से तत्वों तक पहुँचने के लिए नकारात्मक सूचकांकों का भी उपयोग कर सकते हैं:

my_list[-1] # रिटर्न 3 (अंतिम तत्व)

आप सूची में आइटम जोड़ने के लिए एपेंड () विधि का उपयोग कर सकते हैं:

my_list.append(4) # सूची के अंत में 4 जोड़ता है

आप निकालें () या पॉप () विधियों का उपयोग करके किसी सूची से आइटम निकाल सकते हैं:

my_list.remove(3) # सूची से 3 हटाता है

my_list.pop(2) # सूची से 2 (तीसरा तत्व) हटाता है और लौटाता है

पायथन में सूची में डुप्लिकेट का नाम बदलें

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

# एक खाली शब्दकोश बनाएँ
मैपिंग = {}

# मूल सूची पर पुनरावृति करें
my_list में आइटम के लिए:
# जांचें कि क्या आइटम पहले से ही शब्दकोश में मौजूद है
यदि आइटम मैपिंग में नहीं है:
# यदि नहीं, तो इसे डिक्शनरी में जोड़ें और इसके वर्ग को मान के रूप में असाइन करें
मैपिंग [आइटम] = आइटम * आइटम

# एक खाली परिणाम सूची बनाएँ
परिणाम_सूची = []

# मूल सूची पर दोबारा दोहराएं और my_list में i के लिए शब्दकोश से प्रत्येक तत्व को उसके वर्ग से बदलें: result_list.append(mapping[i])

# प्रिंट परिणाम प्रिंट (परिणाम_सूची)