ಪರಿಹರಿಸಲಾಗಿದೆ: ಪಟ್ಟಿ ಪೈಥಾನ್‌ನಲ್ಲಿ ನಕಲುಗಳನ್ನು ಮರುಹೆಸರಿಸಿ

ಪಟ್ಟಿಯಲ್ಲಿನ ನಕಲುಗಳನ್ನು ಮರುಹೆಸರಿಸುವುದು ಪರಿಹರಿಸಲು ಕಷ್ಟಕರವಾದ ಸಮಸ್ಯೆಯಾಗಿದೆ ಏಕೆಂದರೆ ನೀವು ನಕಲುಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ಹೇಗೆ ಮರುಹೆಸರಿಸಬೇಕೆಂದು ನಿರ್ಧರಿಸುವ ಅಗತ್ಯವಿದೆ. ಪಟ್ಟಿಯು ಅನೇಕ ಅಂಶಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ಅಥವಾ ಅಂಶಗಳು ಸಂಕೀರ್ಣ ವಸ್ತುಗಳಾಗಿದ್ದರೆ ಇದು ವಿಶೇಷವಾಗಿ ಸವಾಲಾಗಬಹುದು. ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಕಲುಗಳನ್ನು ಮರುಹೆಸರಿಸುವುದು ನಿಮ್ಮ ಕೋಡ್‌ನ ಇತರ ಭಾಗಗಳನ್ನು ಮಾರ್ಪಡಿಸುವ ಅಗತ್ಯವಿರಬಹುದು, ಅದು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ಮುಂದುವರಿಸಲು ಅಂಶಗಳ ಮೂಲ ಹೆಸರುಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ.

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 ಎಂಬ ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ ಅದು ಪಟ್ಟಿಯನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
ಡೆಫ್ rename_duplicates(lst):

# ಇದು ನಂತರ ಸೀನ್ ಎಂಬ ಖಾಲಿ ಸೆಟ್ ಮತ್ತು new_lst ಎಂಬ ಖಾಲಿ ಪಟ್ಟಿಯನ್ನು ರಚಿಸುತ್ತದೆ.
ಕಂಡ = ಸೆಟ್()
new_lst = []

# ನಂತರ ಇದು ಪಟ್ಟಿಯಲ್ಲಿರುವ ಐಟಂಗಳ ಮೂಲಕ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ ಮತ್ತು ಅವುಗಳು ಈಗಾಗಲೇ ನೋಡಿದ ಐಟಂಗಳ ಸೆಟ್‌ನಲ್ಲಿವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
lst ನಲ್ಲಿನ ಐಟಂಗಾಗಿ:
ಐಟಂ ಕಾಣಿಸದಿದ್ದರೆ: # ಅದು ಇಲ್ಲದಿದ್ದರೆ, ಅದು ನೋಡಿದ ಐಟಂಗಳ ಗುಂಪಿಗೆ ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹೊಸ ಪಟ್ಟಿಗೆ ಸೇರಿಸುತ್ತದೆ.
seen.add(ಐಟಂ)
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]

ನೀವು ಅವರ ಸೂಚಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪಟ್ಟಿಯಲ್ಲಿರುವ ಪ್ರತ್ಯೇಕ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು:
ನನ್ನ_ಪಟ್ಟಿ[0] # ಹಿಂತಿರುಗಿಸುತ್ತದೆ 1
ನನ್ನ_ಪಟ್ಟಿ[1] # ಹಿಂತಿರುಗಿಸುತ್ತದೆ 2
ನನ್ನ_ಪಟ್ಟಿ[2] # ಹಿಂತಿರುಗಿಸುತ್ತದೆ 3

ಪಟ್ಟಿಯ ಅಂತ್ಯದಿಂದ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ನೀವು ನಕಾರಾತ್ಮಕ ಸೂಚ್ಯಂಕಗಳನ್ನು ಸಹ ಬಳಸಬಹುದು:

my_list[-1] # ಹಿಂತಿರುಗಿಸುತ್ತದೆ 3 (ಕೊನೆಯ ಅಂಶ)

append() ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಪಟ್ಟಿಗೆ ಐಟಂಗಳನ್ನು ಸೇರಿಸಬಹುದು:

my_list.append(4) # ಪಟ್ಟಿಯ ಅಂತ್ಯಕ್ಕೆ 4 ಅನ್ನು ಸೇರಿಸುತ್ತದೆ

ತೆಗೆದುಹಾಕು() ಅಥವಾ ಪಾಪ್() ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಪಟ್ಟಿಯಿಂದ ಐಟಂಗಳನ್ನು ತೆಗೆದುಹಾಕಬಹುದು:

my_list.remove(3) # ಪಟ್ಟಿಯಿಂದ 3 ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ

my_list.pop(2) # ಪಟ್ಟಿಯಿಂದ 2 (ಮೂರನೇ ಅಂಶ) ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ಹಿಂತಿರುಗಿಸುತ್ತದೆ

ಪೈಥಾನ್‌ನಲ್ಲಿ ಪಟ್ಟಿಯಲ್ಲಿರುವ ನಕಲುಗಳನ್ನು ಮರುಹೆಸರಿಸಿ

ಪಟ್ಟಿಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಪೈಥಾನ್‌ನಲ್ಲಿನ ಪಟ್ಟಿಯಲ್ಲಿನ ನಕಲುಗಳನ್ನು ಮರುಹೆಸರು ಮಾಡುವುದು ಸಾಮಾನ್ಯ ಕಾರ್ಯವಾಗಿದೆ. ಇದು ಅನನ್ಯ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಪಟ್ಟಿಯಲ್ಲಿರುವ ನಕಲಿ ಅಂಶಗಳನ್ನು ಬದಲಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಸೆಟ್() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಮಾಡಬಹುದು, ಇದು ಪಟ್ಟಿಯಿಂದ ಎಲ್ಲಾ ನಕಲಿ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ಅನನ್ಯ ಅಂಶಗಳೊಂದಿಗೆ ಹೊಸ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಹಳೆಯ ಮೌಲ್ಯಗಳ ಮ್ಯಾಪಿಂಗ್ ಅನ್ನು ಹೊಸ ಮೌಲ್ಯಗಳಿಗೆ ಒದಗಿಸುವ ಮೂಲಕ ನಕಲುಗಳನ್ನು ಮರುಹೆಸರಿಸಲು ಸೆಟ್() ಕಾರ್ಯವನ್ನು ಸಹ ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ನೀವು ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದ್ದರೆ ಮತ್ತು ಎಲ್ಲಾ ನಕಲುಗಳನ್ನು ಅವುಗಳ ಆಯಾ ಚೌಕಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸಲು ಬಯಸಿದರೆ, ನೀವು ಈ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಬಳಸಬಹುದು:

# ಖಾಲಿ ನಿಘಂಟನ್ನು ರಚಿಸಿ
ಮ್ಯಾಪಿಂಗ್ = {}

# ಮೂಲ ಪಟ್ಟಿಯ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಿ
ನನ್ನ_ಪಟ್ಟಿಯಲ್ಲಿರುವ ಐಟಂಗಾಗಿ:
# ನಿಘಂಟಿನಲ್ಲಿ ಐಟಂ ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ
ಐಟಂ ಮ್ಯಾಪಿಂಗ್‌ನಲ್ಲಿ ಇಲ್ಲದಿದ್ದರೆ:
# ಇಲ್ಲದಿದ್ದರೆ, ಅದನ್ನು ನಿಘಂಟಿಗೆ ಸೇರಿಸಿ ಮತ್ತು ಅದರ ವರ್ಗವನ್ನು ಮೌಲ್ಯವಾಗಿ ನಿಯೋಜಿಸಿ
ಮ್ಯಾಪಿಂಗ್[ಐಟಂ] = ಐಟಂ * ಐಟಂ

# ಖಾಲಿ ಫಲಿತಾಂಶ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಿ
ಫಲಿತಾಂಶ_ಪಟ್ಟಿ = []

# ಮೂಲ ಪಟ್ಟಿಯನ್ನು ಮತ್ತೊಮ್ಮೆ ಪುನರಾವರ್ತಿಸಿ ಮತ್ತು ನನ್ನ_ಪಟ್ಟಿಯಲ್ಲಿ i ಗಾಗಿ ನಿಘಂಟಿನಿಂದ ಪ್ರತಿ ಅಂಶವನ್ನು ಅದರ ಚೌಕದಿಂದ ಬದಲಾಯಿಸಿ: result_list.append(mapping[i])

# ಪ್ರಿಂಟ್ ಫಲಿತಾಂಶ ಮುದ್ರಣ (ಫಲಿತಾಂಶ_ಪಟ್ಟಿ)