పైథాన్‌లో జాబితా (శ్రేణి)లో నకిలీ మూలకాలు (అన్ని మూలకాలు ప్రత్యేకమైనవి/ప్రత్యేకమైనవి) ఉందో లేదో నిర్ణయించడం ఎలా అనే దాని వివరణ క్రింది విధంగా ఉంది.
- మూలకంలో జాబితా లేని జాబితా కోసం
- మూలకాల జాబితాలతో జాబితాల కోసం (రెండు డైమెన్షనల్ శ్రేణులు, జాబితాల జాబితాలు మొదలైనవి)
జాబితా నుండి డూప్లికేట్ ఎలిమెంట్‌లను ఎలా తీసివేయాలి లేదా సంగ్రహించాలి అనే దాని గురించి క్రింది కథనాన్ని చూడండి.
జాబితాలు వివిధ రకాల డేటాను నిల్వ చేయగలవని మరియు శ్రేణుల నుండి ఖచ్చితంగా భిన్నంగా ఉంటాయని గమనించండి. మీరు మెమరీ పరిమాణం మరియు మెమరీ చిరునామాలు లేదా పెద్ద డేటా యొక్క సంఖ్యాపరమైన ప్రాసెసింగ్ అవసరమయ్యే ప్రక్రియలలో శ్రేణులను నిర్వహించాలనుకుంటే, శ్రేణి (ప్రామాణిక లైబ్రరీ) లేదా 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
ఉదాహరణ ఒక జాబితా, కానీ అదే ఫంక్షన్‌ను టుపుల్స్‌తో ఉపయోగించవచ్చు.
జాబితాల వంటి మార్చదగిన (అప్‌డేట్ చేయగల) వస్తువులు టైప్ సెట్ యొక్క మూలకాలు కాకూడదు. కాబట్టి, మూలకాలుగా జాబితాలతో జాబితాలు (రెండు-డైమెన్షనల్ శ్రేణులు, జాబితాల జాబితాలు మొదలైనవి) 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
సెట్()కి బదులుగా, జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం ఒక జాబితాను ఉత్పత్తి చేస్తుంది, దీని మూలకాలు ప్రత్యేక విలువలు మాత్రమే ఉంటాయి మరియు మూలకాల సంఖ్య సరిపోల్చబడుతుంది. వివరాల కోసం క్రింది కథనాన్ని చూడండి.
మూలకాల జాబితా లేని జాబితాలకు కూడా ఈ ఫంక్షన్ చెల్లుతుంది.
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() కూడా ఉపయోగించవచ్చు. అదనంగా, మూడు లేదా అంతకంటే ఎక్కువ పరిమాణాల జాబితాను చదును చేసినప్పుడు, కొత్త ఫంక్షన్‌ను నిర్వచించడం అవసరం.
