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

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

பின்வரும் விவரங்கள் இங்கே விவரிக்கப்பட்டுள்ளன.

• நகல் கூறுகளை அகற்றி புதிய பட்டியல்களை உருவாக்கவும்
  • அசல் பட்டியலின் வரிசையைப் பாதுகாக்க வேண்டாம்:set()
  • அசல் பட்டியலின் வரிசையைப் பாதுகாக்கிறது:dict.fromkeys(),sorted()
  • இரு பரிமாண வரிசை (பட்டியல் பட்டியல்)
• நகல் கூறுகளை பிரித்தெடுத்து புதிய பட்டியலை உருவாக்கவும்
  • அசல் பட்டியலின் வரிசையைப் பாதுகாக்க வேண்டாம்
  • அசல் பட்டியலின் வரிசையைப் பாதுகாக்கிறது
  • இரு பரிமாண வரிசை (பட்டியல் பட்டியல்)

இதே கருத்தை பட்டியல்களுக்கு பதிலாக டூப்பிள்களுக்கும் பயன்படுத்தலாம்.

பின்வரும் கட்டுரையைப் பார்க்கவும்

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

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

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

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

அசல் பட்டியலின் வரிசையைப் பாதுகாக்க வேண்டாம்:set()

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

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

நீங்கள் அதை tuple ஆக்க விரும்பினால், tuple() ஐப் பயன்படுத்தவும்.

l = [3, 3, 2, 1, 5, 1, 4, 2, 3]

print(set(l))
# {1, 2, 3, 4, 5}

print(list(set(l)))
# [1, 2, 3, 4, 5]

நிச்சயமாக, அதையும் அமைக்கலாம். தொகுப்பு வகை தொகுப்பு பற்றிய கூடுதல் தகவலுக்கு பின்வரும் கட்டுரையைப் பார்க்கவும்.

• தொடர்புடையது:பைத்தானின் செட் வகையுடன் செயல்பாடுகளை அமைக்கவும் (எ.கா., யூனியன் செட், தயாரிப்பு தொகுப்புகள் மற்றும் துணைக்குழுக்களை தீர்மானித்தல்)

அசல் பட்டியலின் வரிசையைப் பாதுகாக்கிறது:dict.fromkeys(),sorted()

அசல் பட்டியலின் வரிசையை நீங்கள் பாதுகாக்க விரும்பினால், அகராதி வகையின் class method fromkeys() அல்லது உள்ளமைக்கப்பட்ட செயல்பாடு வரிசைப்படுத்தப்பட்ட() ஐப் பயன்படுத்தவும்.

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

• classmethod fromkeys(iterable[, value]) — Built-in Types — Python 3.10.4 Documentation

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

print(dict.fromkeys(l))
# {3: None, 2: None, 1: None, 5: None, 4: None}

print(list(dict.fromkeys(l)))
# [3, 2, 1, 5, 4]

பைதான் 3.7 (CPython is 3.6) என்பதிலிருந்து dict.fromkeys() வாத வரிசையின் வரிசையைப் பாதுகாக்கிறது என்று உத்தரவாதம் அளிக்கப்பட்டுள்ளது. முந்தைய பதிப்புகள் பின்வருமாறு உள்ளமைக்கப்பட்ட செயல்பாட்டைப் பயன்படுத்துகின்றன()

வரிசைப்படுத்தப்பட்ட வாத விசைக்கான பட்டியல் tuple முறை குறியீட்டை() குறிப்பிடவும், இது உறுப்புகளின் வரிசைப்படுத்தப்பட்ட பட்டியலை வழங்கும்.

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

print(sorted(set(l), key=l.index))
# [3, 2, 1, 5, 4]

இரு பரிமாண வரிசை (பட்டியல் பட்டியல்)

இரு பரிமாண வரிசைகளுக்கு (பட்டியல் பட்டியல்கள்), set() அல்லது dict.fromkeys() ஐப் பயன்படுத்தும் முறை TypeError இல் விளைகிறது.

l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]

# l_2d_unique = list(set(l_2d))
# TypeError: unhashable type: 'list'

# l_2d_unique_order = dict.fromkeys(l_2d)
# TypeError: unhashable type: 'list'

ஏனென்றால், பட்டியல்கள் போன்ற ஹேஷபிள் அல்லாத பொருள்கள் வகை தொகுப்பின் கூறுகளாகவோ அல்லது டைப் டிக்டின் விசைகளாகவோ இருக்க முடியாது.

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

• python – How do you remove duplicates from a list whilst preserving order? – Stack Overflow

def get_unique_list(seq):
    seen = []
    return [x for x in seq if x not in seen and not seen.append(x)]

print(get_unique_list(l_2d))
# [[1, 1], [0, 1], [0, 0], [1, 0]]

print(get_unique_list(l))
# [3, 2, 1, 5, 4]

பட்டியல் புரிதல் குறியீடு பயன்படுத்தப்படுகிறது.

• தொடர்புடையது:பைதான் பட்டியல் புரிதல்களை எவ்வாறு பயன்படுத்துவது

இங்கே நாம் பின்வருவனவற்றைப் பயன்படுத்துகிறோம்

• “எக்ஸ் மற்றும் ஒய்” இல் உள்ள எக்ஸ் மற்றும் ஆபரேட்டரின் ஷார்ட் சர்க்யூட் மதிப்பீட்டில் தவறானது எனில், Y மதிப்பிடப்படாது (செயல்படுத்தப்படவில்லை).
• append() முறை எதுவும் இல்லை என்று வழங்குகிறது.

அசல் பட்டியல் seq இன் கூறுகள் பார்த்ததில் இல்லை என்றால், பின்னர் மற்றும் பின் மதிப்பீடு செய்யப்படும்.
seen.append(x) செயல்படுத்தப்பட்டு, உறுப்பு பார்த்ததில் சேர்க்கப்படுகிறது.
ஏனெனில் append() முறை None மற்றும் None is False என்பதைத் தருகிறது, காணப்படவில்லை. append(x) ஆனது True என மதிப்பிடுகிறது.
பட்டியல் புரிதல் குறியீட்டில் உள்ள நிபந்தனை வெளிப்பாடு உண்மையாகி, இறுதியாக உருவாக்கப்பட்ட பட்டியலின் ஒரு அங்கமாக சேர்க்கப்படும்.

அசல் பட்டியல் seq இன் உறுப்புகள் பார்த்ததில் இருந்தால், x not in seen என்பது False, மற்றும் பட்டியல் புரிதல் வெளிப்பாட்டிற்கான நிபந்தனை வெளிப்பாடு False.
எனவே, அவை இறுதி உருவாக்கப்பட்ட பட்டியலின் கூறுகளாக சேர்க்கப்படவில்லை.

மற்றொரு முறை, NumPy இன் செயல்பாட்டின் np.unique() இல் வாத அச்சை அமைப்பது, இருப்பினும் முடிவு வரிசைப்படுத்தப்படும்.

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

அசல் பட்டியலின் வரிசையைப் பாதுகாக்க வேண்டாம்

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

• தொடர்புடையது:பைதான் கவுண்டர் மூலம் பட்டியலில் உள்ள ஒவ்வொரு தனிமத்தின் நிகழ்வுகளின் எண்ணிக்கையைக் கணக்கிடுகிறது

import collections

l = [3, 3, 2, 1, 5, 1, 4, 2, 3]

print(collections.Counter(l))
# Counter({3: 3, 2: 2, 1: 2, 5: 1, 4: 1})

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

• தொடர்புடையது:லூப் செயலாக்கத்திற்கான பைதான் அகராதி (டிக்ட்) (விசைகள், மதிப்புகள், உருப்படிகள்)

print([k for k, v in collections.Counter(l).items() if v > 1])
# [3, 2, 1]

அசல் பட்டியலின் வரிசையைப் பாதுகாக்கிறது

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

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

print(sorted([k for k, v in collections.Counter(l).items() if v > 1], key=l.index))
# [3, 2, 1]

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

cc = collections.Counter(l)
print([x for x in l if cc[x] > 1])
# [3, 3, 2, 1, 1, 2, 3]

இரு பரிமாண வரிசை (பட்டியல் பட்டியல்)

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

l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]

def get_duplicate_list(seq):
    seen = []
    return [x for x in seq if not seen.append(x) and seen.count(x) == 2]

def get_duplicate_list_order(seq):
    seen = []
    return [x for x in seq if seq.count(x) > 1 and not seen.append(x) and seen.count(x) == 1]

print(get_duplicate_list(l_2d))
# [[0, 1], [1, 1]]

print(get_duplicate_list_order(l_2d))
# [[1, 1], [0, 1]]

print(get_duplicate_list(l))
# [3, 1, 2]

print(get_duplicate_list_order(l))
# [3, 2, 1]

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

print([x for x in l_2d if l_2d.count(x) > 1])
# [[1, 1], [0, 1], [0, 1], [1, 1], [1, 1]]

எண்ணின்() கணக்கீட்டு சிக்கலானது O(n) என்பதால், மீண்டும் மீண்டும் Count()ஐ இயக்கும் செயல்பாடு மிகவும் திறமையற்றது என்பதை நினைவில் கொள்ளவும். புத்திசாலித்தனமான வழி இருக்கலாம்.

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

# print(collections.Counter(l_2d))
# TypeError: unhashable type: 'list'