ஒரு பட்டியல் (வரிசை) பைத்தானில் நகல் கூறுகளைக் கொண்டிருக்கிறதா என்பதைத் தீர்மானித்தல்

வணிக

பின்வரும் ஒவ்வொரு நிகழ்வுக்கும் பைத்தானில் ஒரு பட்டியலில் (வரிசை) நகல் கூறுகள் (அனைத்து உறுப்புகளும் தனிப்பட்டவை/தனித்துவமானவை) உள்ளதா என்பதை எவ்வாறு தீர்மானிப்பது என்பது பற்றிய விளக்கமாகும்.

  • உறுப்பில் பட்டியல் இல்லாத பட்டியலுக்கு
  • உறுப்புகளின் பட்டியல்களைக் கொண்ட பட்டியல்களுக்கு (இரு பரிமாண வரிசைகள், பட்டியல்களின் பட்டியல்கள் போன்றவை)

பட்டியலிலிருந்து நகல் கூறுகளை எவ்வாறு அகற்றுவது அல்லது பிரித்தெடுப்பது என்பதைப் பற்றிய பின்வரும் கட்டுரையைப் பார்க்கவும்.

பட்டியல்கள் வெவ்வேறு வகையான தரவைச் சேமிக்கலாம் மற்றும் வரிசைகளிலிருந்து கண்டிப்பாக வேறுபட்டவை என்பதை நினைவில் கொள்ளவும். நினைவக அளவு மற்றும் நினைவக முகவரிகள் அல்லது பெரிய தரவுகளின் எண்ணியல் செயலாக்கம் தேவைப்படும் செயல்முறைகளில் அணிவரிசைகளைக் கையாள விரும்பினால், வரிசை (நிலையான நூலகம்) அல்லது NumPy ஐப் பயன்படுத்தவும்.

பட்டியலில் நகல் கூறுகள் உள்ளதா என்பதைத் தீர்மானிக்கவும் (உறுப்புக்கு பட்டியல் இல்லை என்றால்)

உறுப்பில் பட்டியல் போன்ற புதுப்பிக்கத்தக்க பொருள் இல்லை என்றால், செட் செட் வகையின் கன்ஸ்ட்ரக்டர் செட்() ஐப் பயன்படுத்தவும்.

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

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

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

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

def has_duplicates(seq):
    return len(seq) != len(set(seq))

l = [0, 1, 2]
print(has_duplicates(l))
# False

l = [0, 1, 1, 2]
print(has_duplicates(l))
# True

உதாரணம் ஒரு பட்டியல், ஆனால் அதே செயல்பாட்டை tuples உடன் பயன்படுத்தலாம்.

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

l_2d = [[0, 1], [1, 1], [0, 1], [1, 0]]
# print(has_duplicates(l_2d))
# TypeError: unhashable type: 'list'

பட்டியலில் நகல் கூறுகள் உள்ளதா என்பதைத் தீர்மானிக்கவும் (உறுப்பு பட்டியல் இருந்தால்)

உறுப்புகளின் பட்டியலைக் கொண்ட பட்டியலின் விஷயத்தில் (பட்டியல்களின் பட்டியல் போன்றவை), நகல் கூறுகள் உள்ளதா என்பதைத் தீர்மானிக்க பின்வரும் செயல்பாடுகளைப் பயன்படுத்தலாம்.

def has_duplicates2(seq):
    seen = []
    unique_list = [x for x in seq if x not in seen and not seen.append(x)]
    return len(seq) != len(unique_list)

l_2d = [[0, 0], [0, 1], [1, 1], [1, 0]]
print(has_duplicates2(l_2d))
# False

l_2d = [[0, 0], [0, 1], [1, 1], [1, 1]]
print(has_duplicates2(l_2d))
# True

set()க்குப் பதிலாக, பட்டியல் புரிதல் குறியீடானது ஒரு பட்டியலை உருவாக்குகிறது, அதன் உறுப்புகள் தனித்துவமான மதிப்புகள் மட்டுமே, மற்றும் உறுப்புகளின் எண்ணிக்கை ஒப்பிடப்படுகிறது. விவரங்களுக்கு பின்வரும் கட்டுரையைப் பார்க்கவும்.

உறுப்புகளின் பட்டியல் இல்லாத பட்டியல்களுக்கும் இந்தச் செயல்பாடு செல்லுபடியாகும்.

l = [0, 1, 2]
print(has_duplicates2(l))
# False

l = [0, 1, 1, 2]
print(has_duplicates2(l))
# True

இதுவரையான உதாரணம், தனிமங்களின் பட்டியல் நகல் எடுக்கப்பட்டுள்ளதா (அதே பட்டியலைக் கொண்டுள்ளது) என்பதை தீர்மானிப்பதாகும்.

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

l_2d = [[0, 1], [2, 3]]
print(sum(l_2d, []))
# [0, 1, 2, 3]

print(has_duplicates(sum(l_2d, [])))
# False

l_2d = [[0, 1], [2, 0]]
print(has_duplicates(sum(l_2d, [])))
# True

இங்கே, sum() பட்டியலை சமன் செய்ய பயன்படுத்தப்படுகிறது, ஆனால் itertools.chain.from_iterable() ஐயும் பயன்படுத்தலாம். கூடுதலாக, மூன்று அல்லது அதற்கு மேற்பட்ட பரிமாணங்களின் பட்டியலை சமன் செய்யும் போது, ​​ஒரு புதிய செயல்பாட்டை வரையறுக்க வேண்டியது அவசியம்.