జాబితా (శ్రేణి) నుండి డూప్లికేట్ ఎలిమెంట్‌లను తీసివేయడం లేదా సంగ్రహించడం ద్వారా పైథాన్‌లో కొత్త జాబితాను ఎలా రూపొందించాలో ఈ విభాగం వివరిస్తుంది.
కింది వివరాలు ఇక్కడ వివరించబడ్డాయి.
- నకిలీ మూలకాలను తీసివేసి, కొత్త జాబితాలను రూపొందించండి
- అసలు జాబితా యొక్క క్రమాన్ని భద్రపరచవద్దు:
set() - అసలైన జాబితా క్రమాన్ని భద్రపరుస్తుంది:
dict.fromkeys(),sorted() - ద్విమితీయ శ్రేణి (జాబితాల జాబితా)
- అసలు జాబితా యొక్క క్రమాన్ని భద్రపరచవద్దు:
- నకిలీ మూలకాలను సంగ్రహించి, కొత్త జాబితాను రూపొందించండి
- అసలు జాబితా యొక్క క్రమాన్ని భద్రపరచవద్దు
- అసలైన జాబితా క్రమాన్ని భద్రపరుస్తుంది
- ద్విమితీయ శ్రేణి (జాబితాల జాబితా)
అదే భావనను జాబితాలకు బదులుగా టుపుల్స్‌కు అన్వయించవచ్చు.
కోసం క్రింది కథనాన్ని చూడండి
- మీరు జాబితా లేదా టుపుల్‌లో డూప్లికేట్ ఎలిమెంట్స్ ఉన్నాయో లేదో గుర్తించాలనుకుంటే
- మీరు ఒకే జాబితాకు బదులుగా బహుళ జాబితాలలో సాధారణమైన లేదా సాధారణం కాని అంశాలను సంగ్రహించాలనుకుంటే
జాబితాలు వివిధ రకాల డేటాను నిల్వ చేయగలవని మరియు శ్రేణుల నుండి ఖచ్చితంగా భిన్నంగా ఉంటాయని గమనించండి. మీరు మెమరీ పరిమాణం మరియు మెమరీ చిరునామాలు లేదా పెద్ద డేటా యొక్క సంఖ్యాపరమైన ప్రాసెసింగ్ అవసరమయ్యే ప్రక్రియలలో శ్రేణులను నిర్వహించాలనుకుంటే, శ్రేణి (ప్రామాణిక లైబ్రరీ) లేదా NumPyని ఉపయోగించండి.
నకిలీ మూలకాలను తీసివేసి, కొత్త జాబితాలను రూపొందించండి
అసలు జాబితా యొక్క క్రమాన్ని భద్రపరచవద్దు:set()
అసలు జాబితా యొక్క క్రమాన్ని భద్రపరచాల్సిన అవసరం లేకుంటే, సెట్ టైప్ సెట్‌ను రూపొందించే సెట్()ని ఉపయోగించండి.
సెట్ రకం అనేది నకిలీ మూలకాలు లేని డేటా రకం. జాబితా లేదా ఇతర డేటా రకాన్ని సెట్()కి పంపినప్పుడు, నకిలీ విలువలు విస్మరించబడతాయి మరియు టైప్ సెట్‌లోని వస్తువు తిరిగి ఇవ్వబడుతుంది, దీనిలో ఏకైక విలువలు మూలకాలు మాత్రమే.
మీరు దీన్ని టుపుల్‌గా చేయాలనుకుంటే, టుపుల్()ని ఉపయోగించండి.
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()
మీరు అసలైన జాబితా క్రమాన్ని భద్రపరచాలనుకుంటే, డిక్షనరీ రకానికి చెందిన క్లాస్ పద్ధతి fromkeys()ని లేదా అంతర్నిర్మిత ఫంక్షన్ క్రమబద్ధీకరించబడిన()ని ఉపయోగించండి.
dict.fromkeys() ఆర్గ్యుమెంట్‌లలో పేర్కొన్న జాబితాలు, టుపుల్స్ మొదలైన వాటి కీలు కొత్త నిఘంటువు వస్తువును సృష్టిస్తుంది. రెండవ వాదన విస్మరించబడితే, విలువ ఏదీ కాదు.
నిఘంటువు కీలు నకిలీ మూలకాలను కలిగి ఉండవు కాబట్టి, సెట్()లో వలె నకిలీ విలువలు విస్మరించబడతాయి. అదనంగా, డిక్షనరీ కీలు ఉన్న మూలకాల జాబితాను పొందేందుకు డిక్షనరీ ఆబ్జెక్ట్‌ను జాబితా()కి ఆర్గ్యుమెంట్‌గా పంపవచ్చు.
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 3.6) నుండి dict.fromkeys() ఆర్గ్యుమెంట్ సీక్వెన్స్ క్రమాన్ని భద్రపరుస్తుందని హామీ ఇవ్వబడింది. మునుపటి సంస్కరణలు ఈ క్రింది విధంగా క్రమబద్ధీకరించబడిన () అంతర్నిర్మిత ఫంక్షన్‌ను ఉపయోగిస్తాయి.
క్రమబద్ధీకరించబడిన ఆర్గ్యుమెంట్ కీ కోసం జాబితా టుపుల్ పద్ధతి సూచిక()ని పేర్కొనండి, ఇది మూలకాల యొక్క క్రమబద్ధీకరించబడిన జాబితాను అందిస్తుంది.
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'
ఎందుకంటే జాబితాల వంటి హ్యాషబుల్ కాని వస్తువులు టైప్ సెట్ యొక్క మూలకాలు లేదా టైప్ డిక్ట్ యొక్క కీలు కాకూడదు.
కింది విధులను నిర్వచించండి అసలు జాబితా యొక్క క్రమం భద్రపరచబడింది మరియు ఒక డైమెన్షనల్ జాబితాలు మరియు టుపుల్స్ కోసం పని చేస్తుంది.
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]
జాబితా గ్రహణ సంజ్ఞామానం ఉపయోగించబడుతుంది.
ఇక్కడ, మేము ఈ క్రింది వాటిని ఉపయోగిస్తాము
- మరియు ఆపరేటర్ యొక్క షార్ట్-సర్క్యూట్ మూల్యాంకనంలో “X మరియు Y”లోని X తప్పు అయితే, Y మూల్యాంకనం చేయబడదు (అమలుపరచబడలేదు).
- append() మెథడ్ ఏదీ లేదు అని అందిస్తుంది.
అసలైన జాబితా సీక్ యొక్క మూలకాలు చూసిన వాటిలో ఉనికిలో లేకుంటే, ఆపై మరియు తర్వాత మూల్యాంకనం చేయబడతాయి.
seen.append(x) అమలు చేయబడుతుంది మరియు సీన్‌కి మూలకం జోడించబడుతుంది.
ఎందుకంటే append() పద్ధతి ఏదీ లేదు మరియు ఏదీ తప్పు కాదు, చూడలేదు.
జాబితా కాంప్రహెన్షన్ సంజ్ఞామానంలోని షరతులతో కూడిన వ్యక్తీకరణ నిజం అవుతుంది మరియు తుది రూపొందించబడిన జాబితా యొక్క మూలకం వలె జోడించబడుతుంది.
అసలైన జాబితా seq యొక్క మూలకాలు చూసినవిలో ఉన్నట్లయితే, x కనిపించనిది తప్పు, మరియు జాబితా గ్రహణ వ్యక్తీకరణ కోసం షరతులతో కూడిన వ్యక్తీకరణ తప్పు.
అందువల్ల, అవి తుది రూపొందించిన జాబితా యొక్క మూలకాలుగా జోడించబడవు.
NumPy ఫంక్షన్ np.unique()లో ఆర్గ్యుమెంట్ అక్షాన్ని సెట్ చేయడం మరొక పద్ధతి, అయినప్పటికీ ఫలితం క్రమబద్ధీకరించబడుతుంది.
నకిలీ మూలకాలను సంగ్రహించి, కొత్త జాబితాను రూపొందించండి
అసలు జాబితా యొక్క క్రమాన్ని భద్రపరచవద్దు
అసలు జాబితా నుండి నకిలీ మూలకాలను మాత్రమే సంగ్రహించడానికి, collections.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) అయినందున, కౌంట్()ని పదే పదే అమలు చేసే పైన చూపిన ఫంక్షన్ చాలా అసమర్థంగా ఉందని గమనించండి. తెలివైన మార్గం ఉండవచ్చు.
కౌంటర్ అనేది నిఘంటువు యొక్క ఉపవర్గం, కాబట్టి మీరు జాబితాలు లేదా టుపుల్‌ల మూలకాలు లేదా ఇతర హ్యాషబుల్ కాని వస్తువులు సేకరణలకు పాస్ చేస్తే, ఒక లోపం ఏర్పడుతుంది మరియు మీరు దానిని ఉపయోగించలేరు.
# print(collections.Counter(l_2d))
# TypeError: unhashable type: 'list'
