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

வணிக

பைதான் ஒரு உள்ளமைக்கப்பட்ட தரவு வகையை வழங்குகிறது, இது செட்களைக் கையாளுகிறது.

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

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

  • தொகுப்பு பொருட்களை உருவாக்குதல்:{},set()
  • சேர்ப்பு குறிப்பை அமைக்கவும்
  • தொகுப்பில் உள்ள உறுப்புகளின் எண்ணிக்கை:len()
  • ஒரு தொகுப்பில் ஒரு உறுப்பு சேர்த்தல்:add()
  • தொகுப்பிலிருந்து ஒரு உறுப்பை அகற்றவும்:discard(),remove(),pop(),clear()
  • வாசெட் (இணைப்பு, ஒன்றியம்):|ஆபரேட்டர்,union()
  • தயாரிப்பு தொகுப்புகள் (பொதுவான பாகங்கள், குறுக்குவெட்டுகள், குறுக்குவெட்டுகள்):& இயக்குபவர்,intersection()
  • உறவினர் நிரப்பு:– ஆபரேட்டர்,difference()
  • சமச்சீர் வேறுபாடு தொகுப்பு:^ ஆபரேட்டர்,symmetric_difference()
  • துணைக்குழு அல்லது இல்லை:<= ஆபரேட்டர்,issubset()
  • மேல் தொகுப்பு அல்லது இல்லை:>= ஆபரேட்டர்,issuperset()
  • அவை பரஸ்பரம் முதன்மையானதா இல்லையா என்பதை தீர்மானித்தல்:isdisjoint()

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

தொகுப்பு பொருளின் உருவாக்கம்::{},set()

அலை அடைப்புக்குறிகளால் உருவாக்கப்பட்டது {}

பிரேஸ்களில் உள்ள கூறுகளை இணைத்து வகை தொகுப்பின் பொருள்களை உருவாக்கலாம் {}.

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

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

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

மேலும், தொகுப்பு வகைகள் வரிசைப்படுத்தப்படாததால், அவை உருவாக்கப்படும் வரிசை சேமிக்கப்படவில்லை.

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

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

s = {100, 100.0}

print(s)
# {100}

வெற்று பிரேஸ் {} ஒரு அகராதி வகையாகக் கருதப்படுவதால், அடுத்து விவரிக்கப்பட்டுள்ள கன்ஸ்ட்ரக்டரைப் பயன்படுத்தி வெற்று தொகுப்பு வகைப் பொருளை (வெற்று தொகுப்பு) உருவாக்கலாம்.

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

கட்டமைப்பாளர் தொகுப்பால் உருவாக்கப்பட்டது()

வகை தொகுப்பின் பொருள்களை கன்ஸ்ட்ரக்டர் செட்() மூலம் உருவாக்கலாம்.

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

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

print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>

s_l = set(l)

print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>

கன்ஸ்ட்ரக்டர் ஃப்ரோசென்செட்() மூலம் மாறாத உறைநிலை வகைகள் உருவாக்கப்படுகின்றன.

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

வாதம் தவிர்க்கப்பட்டால், ஒரு வெற்று தொகுப்பு வகை பொருள் (வெற்று தொகுப்பு) உருவாக்கப்பட்டது.

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

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

ஒரு தொகுப்பு வகையை பட்டியல் அல்லது டூப்பிளாக மாற்ற, list(),tuple() ஐப் பயன்படுத்தவும்.

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

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

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

சேர்ப்பு குறிப்பை அமைக்கவும்

அத்துடன் பட்டியல் புரிதல்கள், தொகுப்பு புரிதல்கள் உள்ளன. பட்டியல் புரிதல்களில் சதுர அடைப்புக்குறிகளை [] பிரேஸ்களுடன் {} மாற்றவும்.

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

பட்டியல் புரிதல் குறிப்பீடு பற்றிய கூடுதல் தகவலுக்கு பின்வரும் கட்டுரையைப் பார்க்கவும்.

தொகுப்பில் உள்ள உறுப்புகளின் எண்ணிக்கை:len()

ஒரு தொகுப்பில் உள்ள உறுப்புகளின் எண்ணிக்கையை உள்ளமைக்கப்பட்ட செயல்பாடு len() மூலம் பெறலாம்.

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

ஒவ்வொரு பட்டியலிலும் உள்ள தனிமங்களின் எண்ணிக்கையைக் கணக்கிட விரும்பினால், நகல் மதிப்புகள் போன்றவற்றைக் கொண்ட உறுப்புகள், பின்வரும் கட்டுரையைப் பார்க்கவும்.

ஒரு தொகுப்பில் ஒரு உறுப்பு சேர்த்தல்:add()

ஒரு தொகுப்பில் ஒரு உறுப்பைச் சேர்க்க, add() முறையைப் பயன்படுத்தவும்.

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

தொகுப்பிலிருந்து ஒரு உறுப்பை அகற்றவும்:discard(),remove(),pop(),clear()

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

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

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

அகற்று() முறையானது வாதத்தில் குறிப்பிடப்பட்ட உறுப்பை நீக்குகிறது, ஆனால் தொகுப்பில் இல்லாத மதிப்பு குறிப்பிடப்பட்டால் பிழை KeyError வழங்கப்படும்.

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

பாப்() முறையானது ஒரு தொகுப்பிலிருந்து கூறுகளை நீக்கி அவற்றின் மதிப்புகளை வழங்குகிறது. எந்த மதிப்புகளை அகற்ற வேண்டும் என்பதைத் தேர்ந்தெடுக்க முடியாது. ஒரு வெற்று தொகுப்பு ஒரு KeyError பிழையை ஏற்படுத்தும்.

s = {2, 1, 0}

v = s.pop()

print(s)
print(v)
# {1, 2}
# 0

s = {2, 1, 0}

print(s.pop())
# 0

print(s.pop())
# 1

print(s.pop())
# 2

# print(s.pop())
# KeyError: 'pop from an empty set'

தெளிவான() முறையானது அனைத்து கூறுகளையும் நீக்கி, தொகுப்பை காலியாக்குகிறது.

s = {0, 1, 2}

s.clear()
print(s)
# set()

வாசெட் (இணைப்பு, ஒன்றியம்):|ஆபரேட்டர்,union()

யூனியன் தொகுப்பு (இணைப்பு, ஒன்றியம்) உடன் பெறலாம் | ஆபரேட்டர் அல்லது யூனியன்() முறை.

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}

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

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}

தயாரிப்பு தொகுப்புகள் (பொதுவான பாகங்கள், குறுக்குவெட்டுகள், குறுக்குவெட்டுகள்):& இயக்குபவர்,intersection()

தயாரிப்பு தொகுப்பு (பொதுவான பகுதி, குறுக்குவெட்டு மற்றும் குறுக்குவெட்டு) உடன் & ஆபரேட்டர் அல்லது குறுக்குவெட்டு() முறை.

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}

உறவினர் நிரப்பு:– ஆபரேட்டர்,difference()

வேறுபாடு தொகுப்பை – ஆபரேட்டர் அல்லது வேறுபாடு() முறை மூலம் பெறலாம்.

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}

சமச்சீர் வேறுபாடு தொகுப்பு:^ ஆபரேட்டர்,symmetric_difference()

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

தருக்க செயல்பாடுகளில் பிரத்தியேக டிஸ்ஜங்க்ஷன் (XOR) க்கு சமம்.

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

துணைக்குழு அல்லது இல்லை:<= ஆபரேட்டர்,issubset()

ஒரு தொகுப்பு மற்றொரு தொகுப்பின் துணைக்குழு என்பதைத் தீர்மானிக்க, <= ஆபரேட்டர் அல்லது issubset() முறையைப் பயன்படுத்தவும்.

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

<= ஆபரேட்டர் மற்றும் issubset() முறை இரண்டும் சமமான தொகுப்புகளுக்கு உண்மை என்று திரும்பும்.

இது உண்மையான துணைக்குழு என்பதைத் தீர்மானிக்க, <= ஆபரேட்டரைப் பயன்படுத்தவும், இது சமமான தொகுப்புகளுக்கு தவறானது என்பதை வழங்குகிறது.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

மேல் தொகுப்பு அல்லது இல்லை:>= ஆபரேட்டர்,issuperset()

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

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

>= ஆபரேட்டர் மற்றும் இசுப்பர்செட்() முறை இரண்டும் சமமான செட்களுக்கு உண்மை என்று திரும்பும்.

இது உண்மையான சூப்பர்செட்தானா என்பதைத் தீர்மானிக்க, >= ஆபரேட்டரைப் பயன்படுத்தவும், இது சமமான தொகுப்புகளுக்கு தவறானது.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

அவை பரஸ்பரம் முதன்மையானதா இல்லையா என்பதை தீர்மானித்தல்:isdisjoint()

இரண்டு தொகுப்புகள் ஒன்றுக்கொன்று முதன்மையானதா என்பதைத் தீர்மானிக்க, isdisjoint() முறையைப் பயன்படுத்தவும்.

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True