పైథాన్ సెట్ రకంతో కార్యకలాపాలను సెట్ చేయండి (ఉదా., యూనియన్ సెట్‌లు, ఉత్పత్తి సెట్‌లు మరియు ఉపసమితులను నిర్ణయించడం)

వ్యాపారం

పైథాన్ అంతర్నిర్మిత డేటా రకం, సెట్‌లను అందిస్తుంది, ఇది సెట్‌లను నిర్వహిస్తుంది.

టైప్ సెట్ అనేది నాన్-డూప్లికేట్ ఎలిమెంట్స్ (ఒకే విలువ లేని ఎలిమెంట్స్, యూనిక్ ఎలిమెంట్స్) మరియు యూనియన్ సెట్, ప్రొడక్ట్ సెట్ మరియు డిఫరెన్స్ సెట్ వంటి సెట్ ఆపరేషన్‌లను చేయగలదు.

ఈ విభాగంలో, సెట్-టైప్ సెట్ కార్యకలాపాలలో ప్రాథమిక కార్యకలాపాలు నమూనా కోడ్‌తో వివరించబడ్డాయి.

  • సెట్ వస్తువుల సృష్టి:{},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'>

మూలకాలుగా వివిధ రకాలను కలిగి ఉండటం సాధ్యమే. అయితే, జాబితా రకాలు వంటి నవీకరించదగిన వస్తువులు నమోదు చేయబడవు. టుపుల్స్ అనుమతించబడతాయి.

అలాగే, సెట్ రకాలు క్రమం చేయబడవు కాబట్టి, అవి ఉత్పత్తి చేయబడిన క్రమం నిల్వ చేయబడదు.

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

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

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

Int మరియు float వంటి వివిధ రకాలు వాటి విలువలు సమానంగా ఉంటే నకిలీలుగా పరిగణించబడతాయి.

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'>

సెట్()ని ఉపయోగించి జాబితా లేదా టుపుల్ నుండి నకిలీ మూలకాలను తీసివేయవచ్చు, కానీ అసలు జాబితా యొక్క క్రమం భద్రపరచబడదు.

సెట్ రకాన్ని జాబితా లేదా టుపుల్‌గా మార్చడానికి, జాబితా(),టుపుల్()ని ఉపయోగించండి.

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()

ఒక సెట్‌లోని మూలకాల సంఖ్యను అంతర్నిర్మిత ఫంక్షన్ లెన్()తో పొందవచ్చు.

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}

Remove() పద్ధతి ఆర్గ్యుమెంట్‌లో పేర్కొన్న ఎలిమెంట్‌ను కూడా తొలగిస్తుంది, అయితే సెట్‌లో లేని విలువ పేర్కొనబడితే లోపం KeyError చూపబడుతుంది.

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

పాప్() పద్ధతి సెట్ నుండి ఎలిమెంట్‌లను తీసివేస్తుంది మరియు వాటి విలువలను అందిస్తుంది. ఏ విలువలను తీసివేయాలో ఎంచుకోవడం సాధ్యం కాదు. ఖాళీ సెట్ కీఎర్రర్ ఎర్రర్‌కు దారి తీస్తుంది.

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()

^ ఆపరేటర్ లేదా 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
Copied title and URL