தீர்க்கப்பட்டது: பட்டியல் பைத்தானில் உள்ள நகல்களை மறுபெயரிடவும்

பட்டியலில் உள்ள நகல்களை மறுபெயரிடுவது ஒரு கடினமான சிக்கலாக இருக்கலாம், ஏனெனில் அதற்கு நீங்கள் நகல்களை அடையாளம் கண்டு பின்னர் அவற்றை எவ்வாறு மறுபெயரிடுவது என்பதை முடிவு செய்ய வேண்டும். பட்டியலில் பல கூறுகள் இருந்தால் அல்லது உறுப்புகள் சிக்கலான பொருள்களாக இருந்தால் இது குறிப்பாக சவாலாக இருக்கும். கூடுதலாக, நகல்களை மறுபெயரிடுவதற்கு, உறுப்புகளின் அசல் பெயர்களை நம்பியிருக்கும் உங்கள் குறியீட்டின் பிற பகுதிகளை நீங்கள் மாற்றியமைக்க வேண்டியிருக்கும்.

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

_lst

# இந்த குறியீடு rename_duplicates எனப்படும் செயல்பாட்டை வரையறுக்கிறது, இது ஒரு பட்டியலை ஒரு வாதமாக எடுத்துக்கொள்கிறது.
def rename_duplicates(lst):

# பிறகு பார்த்தது என்ற வெற்று தொகுப்பையும் new_lst எனப்படும் வெற்று பட்டியலையும் உருவாக்குகிறது.
பார்த்தேன் = தொகுப்பு()
new_lst = []

# பின்னர் பட்டியலில் உள்ள உருப்படிகள் மூலம் மீண்டும் மீண்டும் அவை ஏற்கனவே பார்த்த உருப்படிகளின் தொகுப்பில் உள்ளதா எனச் சரிபார்க்கும்.
lst இல் உள்ள உருப்படிக்கு:
உருப்படி காணப்படவில்லை என்றால்: # அது இல்லையென்றால், பார்த்த உருப்படிகளின் தொகுப்பில் அதைச் சேர்த்து புதிய பட்டியலில் சேர்க்கும்.
பார்த்தேன்.சேர் (உருப்படி)
new_lst.append(item) # இருந்தால், அதன் பெயருடன் பின்னொட்டை (எ.கா., '_1') சேர்ப்பதன் மூலம் அந்த உருப்படியின் தனித்துவமான பதிப்பை உருவாக்குகிறது மற்றும் புதிதாக உருவாக்கப்பட்ட உருப்படி ஏற்கனவே பார்த்த உருப்படிகளின் தொகுப்பில் உள்ளதா என்பதைச் சரிபார்க்கிறது.

வேறு: # அப்படியானால், அது அந்த உருப்படியின் பெயரின் பயன்படுத்தப்படாத பதிப்பைக் கண்டுபிடிக்கும் வரை பின்னொட்டை அதிகரிக்கிறது மற்றும் இந்த புதிய பட்டியலை அதன் செயல்பாட்டின் முடிவில் திருப்பித் தரும் முன், பார்த்த உருப்படிகளின் தொகுப்பு மற்றும் புதிய பட்டியல் இரண்டிலும் புதிதாக உருவாக்கப்பட்ட உருப்படியைச் சேர்க்கும்.

new_item = உருப்படி + '_1'

புதிய_உருப்படி பார்க்கும்போது: # தனித்தன்மை வரை அதிகரிப்பு பின்னொட்டு

பின்னொட்டு = int(new_item.split('_')[-1]) + 1 # கடைசி எண்ணைப் பெற்று அதில் ஒன்றைச் சேர்க்கவும்

new_item = '{}_{}'.format('_'.join(new_item.split('_')[:-1]), பின்னொட்டு)

பார்த்தேன்.சேர்(புதியது

பைத்தானில் பட்டியல்கள்

பைத்தானில் உள்ள பட்டியல்கள் பொதுவாகப் பயன்படுத்தப்படும் தரவு கட்டமைப்புகளில் ஒன்றாகும். பிற பட்டியல்கள் உட்பட எந்த வகையிலும் இருக்கும் பொருட்களின் தொகுப்பை சேமிக்க அவை பயன்படுத்தப்படுகின்றன. பட்டியல்கள் மாறக்கூடியவை, அதாவது அவை உருவாக்கப்பட்ட பிறகு மாற்றப்படலாம். அவை அட்டவணைப்படுத்தல், வெட்டுதல் மற்றும் இணைத்தல் போன்ற செயல்பாடுகளையும் ஆதரிக்கின்றன.

பைத்தானில் ஒரு பட்டியலை உருவாக்க, நீங்கள் சதுர அடைப்புக்குறிகளைப் பயன்படுத்தி ஒவ்வொரு உருப்படியையும் கமாவால் பிரிக்கவும்:

my_list = [1, 2, 3]

பட்டியலில் உள்ள தனிப்பட்ட கூறுகளை அவற்றின் குறியீட்டைப் பயன்படுத்தி அணுகலாம்:
my_list[0] # ரிட்டர்ன்ஸ் 1
my_list[1] # ரிட்டர்ன்ஸ் 2
my_list[2] # ரிட்டர்ன்ஸ் 3

பட்டியலின் முடிவில் இருந்து உறுப்புகளை அணுக எதிர்மறை குறியீடுகளையும் பயன்படுத்தலாம்:

my_list[-1] # 3 ஐ வழங்குகிறது (கடைசி உறுப்பு)

append() முறையைப் பயன்படுத்தி பட்டியலில் உருப்படிகளைச் சேர்க்கலாம்:

my_list.append(4) # பட்டியலின் முடிவில் 4ஐ சேர்க்கிறது

நீக்கு() அல்லது பாப்() முறைகளைப் பயன்படுத்தி பட்டியலிலிருந்து உருப்படிகளை நீக்கலாம்:

my_list.remove(3) # பட்டியலில் இருந்து 3ஐ நீக்குகிறது

my_list.pop(2) # பட்டியலிலிருந்து 2ஐ (மூன்றாவது உறுப்பு) நீக்கி, திரும்பப் பெறுகிறது

பைத்தானில் பட்டியலில் உள்ள நகல்களை மறுபெயரிடவும்

பைத்தானில் உள்ள பட்டியலில் உள்ள நகல்களை மறுபெயரிடுவது பட்டியல்களைக் கையாளும் போது ஒரு பொதுவான பணியாகும். பட்டியலில் உள்ள நகல் கூறுகளை தனிப்பட்ட மதிப்புகளுடன் மாற்றுவது இதில் அடங்கும். இது set() செயல்பாட்டைப் பயன்படுத்தி செய்யப்படலாம், இது ஒரு பட்டியலிலிருந்து அனைத்து நகல் கூறுகளையும் நீக்குகிறது மற்றும் தனிப்பட்ட உறுப்புகளுடன் புதிய பட்டியலை வழங்குகிறது. செட்() செயல்பாடு பழைய மதிப்புகளை புதிய மதிப்புகளுக்கு மேப்பிங் செய்வதன் மூலம் நகல்களை மறுபெயரிடவும் பயன்படுத்தப்படலாம். எடுத்துக்காட்டாக, உங்களிடம் எண்களின் பட்டியல் இருந்தால் மற்றும் அனைத்து நகல்களையும் அந்தந்த சதுரங்களுடன் மாற்ற விரும்பினால், பின்வரும் குறியீட்டைப் பயன்படுத்தலாம்:

# வெற்று அகராதியை உருவாக்கவும்
மேப்பிங் = {}

# அசல் பட்டியலை மீண்டும் செய்யவும்
my_list இல் உள்ள உருப்படிக்கு:
# அகராதியில் உருப்படி ஏற்கனவே உள்ளதா எனச் சரிபார்க்கவும்
உருப்படி மேப்பிங்கில் இல்லை என்றால்:
# இல்லையெனில், அதை அகராதியில் சேர்த்து அதன் சதுரத்தை மதிப்பாக ஒதுக்கவும்
மேப்பிங்[உருப்படி] = உருப்படி * உருப்படி

# வெற்று முடிவு பட்டியலை உருவாக்கவும்
முடிவு_பட்டியல் = []

# அசல் பட்டியலை மீண்டும் மீண்டும் செய்யவும் மற்றும் ஒவ்வொரு உறுப்பையும் அதன் சதுரத்தின் மூலம் எனது_பட்டியலில் i க்கு மாற்றவும்: result_list.append(mapping[i])

# முடிவை அச்சிடுக(முடிவு_பட்டியல்)