పైథాన్‌లోని టైప్ జాబితా జాబితా (శ్రేణి) నుండి మూలకాన్ని తీసివేయడానికి, జాబితా పద్ధతులను ఉపయోగించండి clear(), pop() మరియు remove(). మీరు ఇండెక్స్ లేదా స్లైస్‌ని ఉపయోగించి జాబితా యొక్క స్థానం మరియు పరిధిని కూడా పేర్కొనవచ్చు మరియు డెల్ స్టేట్‌మెంట్‌ని ఉపయోగించి దాన్ని తొలగించవచ్చు.
కింది సమాచారం ఇక్కడ అందించబడింది.
- అన్ని అంశాలను తీసివేయండి:
clear() - పేర్కొన్న స్థానం వద్ద మూలకాన్ని తొలగించి, దాని విలువను పొందండి.:
pop() - పేర్కొన్న విలువతో మూలకాల కోసం శోధిస్తుంది మరియు మొదటి మూలకాన్ని తీసివేస్తుంది.:
remove() - ఇండెక్స్ స్లైస్‌లో స్థానం మరియు పరిధిని పేర్కొనడం ద్వారా తొలగిస్తోంది:
del - బ్యాచ్ ప్రమాణాలకు అనుగుణంగా ఉండే బహుళ అంశాలను తొలగిస్తుంది.:జాబితా చేరిక సూచన
జాబితాలు వివిధ రకాల డేటాను నిల్వ చేయగలవని మరియు శ్రేణుల నుండి ఖచ్చితంగా భిన్నంగా ఉంటాయని గమనించండి. మెమరీ పరిమాణం లేదా మెమరీ చిరునామా అవసరమయ్యే ప్రక్రియల కోసం లేదా పెద్ద-స్థాయి డేటా యొక్క సంఖ్యా గణన కోసం మీరు శ్రేణులను నిర్వహించాలనుకున్నప్పుడు శ్రేణి (ప్రామాణిక లైబ్రరీ) లేదా NumPyని ఉపయోగించండి.
- అన్ని అంశాలను తీసివేయండి:clear()
- పేర్కొన్న స్థానం వద్ద మూలకాన్ని తొలగించి, దాని విలువను పొందండి.:pop()
- పేర్కొన్న విలువతో మూలకాల కోసం శోధిస్తుంది మరియు మొదటి మూలకాన్ని తీసివేస్తుంది.:remove()
- ఇండెక్స్ స్లైస్‌లో స్థానం మరియు పరిధిని పేర్కొనడం ద్వారా తొలగిస్తోంది:del
- బ్యాచ్ ప్రమాణాలకు అనుగుణంగా ఉండే బహుళ అంశాలను తొలగిస్తుంది.:జాబితా చేరిక సూచన
అన్ని అంశాలను తీసివేయండి:clear()
జాబితా పద్ధతిలో clear(), అన్ని మూలకాలు తీసివేయబడతాయి, ఫలితంగా ఖాళీ జాబితా వస్తుంది.
l = list(range(10))
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l.clear()
print(l)
# []
పేర్కొన్న స్థానం వద్ద మూలకాన్ని తొలగించి, దాని విలువను పొందండి.:pop()
జాబితా యొక్క పాప్() పద్ధతిని పేర్కొన్న స్థానంలో ఒక మూలకాన్ని తొలగించడానికి మరియు ఆ మూలకం యొక్క విలువను పొందడానికి ఉపయోగించవచ్చు.
మొదటి (ప్రారంభ) సంఖ్య 0.
l = list(range(10))
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l.pop(0))
# 0
print(l)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l.pop(3))
# 4
print(l)
# [1, 2, 3, 5, 6, 7, 8, 9]
ముగింపు (చివరి) నుండి స్థానాన్ని పేర్కొనడానికి ప్రతికూల విలువను కూడా ఉపయోగించవచ్చు. ముగింపు (చివరిది) -1.
print(l.pop(-2))
# 8
print(l)
# [1, 2, 3, 5, 6, 7, 9]
వాదన విస్మరించబడి, ఎటువంటి స్థానం పేర్కొనబడనట్లయితే, చివర (చివరి) మూలకం తొలగించబడుతుంది.
print(l.pop())
# 9
print(l)
# [1, 2, 3, 5, 6, 7]
ఉనికిలో లేని స్థానాన్ని పేర్కొనడం వలన లోపం ఏర్పడుతుంది.
# print(l.pop(100))
# IndexError: pop index out of range
మొదటి మూలకాన్ని తీసివేసే పాప్(0)కి క్రింది ఖర్చు అవసరమని మరియు సమర్థవంతమైన ఆపరేషన్ కాదని గమనించండి. జాబితాలలోని వివిధ కార్యకలాపాల యొక్క గణన సంక్లిష్టత కోసం అధికారిక వికీలో క్రింది పేజీని చూడండి.O(n)
O(1)డిక్యూ రకం ప్రామాణిక లైబ్రరీ సేకరణల మాడ్యూల్‌లో ఈ ధరతో ఎగువకు ఎలిమెంట్‌లను తొలగించే రకంగా అందించబడింది. ఉదాహరణకు, మీరు డేటాను క్యూ (FIFO)గా పరిగణించాలనుకుంటే, dequeని ఉపయోగించడం మరింత సమర్థవంతమైనది.
పేర్కొన్న విలువతో మూలకాల కోసం శోధిస్తుంది మరియు మొదటి మూలకాన్ని తీసివేస్తుంది.:remove()
జాబితా పద్ధతి తొలగించు() పేర్కొన్న విలువతో కూడిన మూలకాల కోసం శోధించడానికి మరియు మొదటి మూలకాన్ని తీసివేయడానికి ఉపయోగించవచ్చు.
l = ['Alice', 'Bob', 'Charlie', 'Bob', 'Dave']
print(l)
# ['Alice', 'Bob', 'Charlie', 'Bob', 'Dave']
l.remove('Alice')
print(l)
# ['Bob', 'Charlie', 'Bob', 'Dave']
జాబితాలో పేర్కొన్న విలువకు సరిపోలే ఒకటి కంటే ఎక్కువ మూలకాలు ఉంటే, మొదటిది మాత్రమే తీసివేయబడుతుంది.
l.remove('Bob')
print(l)
# ['Charlie', 'Bob', 'Dave']
ఉనికిలో లేని విలువ పేర్కొనబడితే, లోపం ఏర్పడుతుంది.
# l.remove('xxx')
# ValueError: list.remove(x): x not in list
ఇండెక్స్ స్లైస్‌లో స్థానం మరియు పరిధిని పేర్కొనడం ద్వారా తొలగిస్తోంది:del
మీరు జాబితా నుండి మూలకాలను తీసివేయడానికి డెల్ స్టేట్‌మెంట్‌ను కూడా ఉపయోగించవచ్చు.
దాని సూచిక ద్వారా తొలగించాల్సిన మూలకాన్ని పేర్కొనండి. మొదటి (ప్రారంభ) సూచిక 0, మరియు చివరి (చివరి) సూచిక -1.
l = list(range(10))
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
del l[0]
print(l)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
del l[-1]
print(l)
# [1, 2, 3, 4, 5, 6, 7, 8]
del l[6]
print(l)
# [1, 2, 3, 4, 5, 6, 8]
మీరు స్లైస్‌లతో పరిధిని పేర్కొంటే, మీరు ఒకేసారి బహుళ మూలకాలను తొలగించవచ్చు.
l = list(range(10))
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
del l[2:5]
print(l)
# [0, 1, 5, 6, 7, 8, 9]
l = list(range(10))
del l[:3]
print(l)
# [3, 4, 5, 6, 7, 8, 9]
l = list(range(10))
del l[4:]
print(l)
# [0, 1, 2, 3]
l = list(range(10))
del l[-3:]
print(l)
# [0, 1, 2, 3, 4, 5, 6]
మొత్తం పరిధిని పేర్కొనడం మరియు అన్ని మూలకాలను తొలగించడం కూడా సాధ్యమే.
l = list(range(10))
del l[:]
print(l)
# []
[start:stop:step]మీరు ఈ విధంగా స్లైస్‌లో పరిధిని పేర్కొంటే మరియు పెరుగుతున్న దశను పేర్కొంటే, మీరు ఒకేసారి బహుళ జంపింగ్ ఎలిమెంట్‌లను తొలగించవచ్చు.
l = list(range(10))
del l[2:8:2]
print(l)
# [0, 1, 3, 5, 7, 8, 9]
l = list(range(10))
del l[::3]
print(l)
# [1, 2, 4, 5, 7, 8]
ముక్కలు చేయడం గురించి మరింత సమాచారం కోసం, క్రింది కథనాన్ని చూడండి.
బ్యాచ్ ప్రమాణాలకు అనుగుణంగా ఉండే బహుళ అంశాలను తొలగిస్తుంది.:జాబితా చేరిక సూచన
పరిస్థితులను సంతృప్తిపరిచే మూలకాలను తొలగించే ప్రక్రియ షరతులను సంతృప్తిపరచని మూలకాలను విడిచిపెట్టే (సంగ్రహించే) ప్రక్రియకు సమానం. ఈ రకమైన ప్రాసెసింగ్ కోసం జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం ఉపయోగించబడుతుంది.
- సంబంధిత కథనాలు:పైథాన్ జాబితా కాంప్రహెన్షన్స్ సంజ్ఞామానాన్ని ఉపయోగించడం
బేసి లేదా సరి మూలకాలను తొలగించే ఉదాహరణ (= సరి లేదా బేసి మూలకాలను వదిలివేయడం) క్రింద చూపబడింది.%ఇది మిగిలిన ఆపరేటర్.i % 2
ఇది i యొక్క శేషం 2తో భాగించబడింది.
జాబితా కాంప్రహెన్షన్ సంజ్ఞామానంలో, కొత్త జాబితా సృష్టించబడుతుంది. ఇప్పటివరకు ప్రవేశపెట్టిన జాబితా రకం పద్ధతుల వలె కాకుండా, అసలు జాబితా మారదు.
l = list(range(10))
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print([i for i in l if i % 2 == 0])
# [0, 2, 4, 6, 8]
print([i for i in l if i % 2 != 0])
# [1, 3, 5, 7, 9]
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
ఇతర ఉదాహరణలు. షరతులతో కూడిన వ్యక్తీకరణపై ఆధారపడి వివిధ రకాల ప్రాసెసింగ్ సాధ్యమవుతుంది.
l = ['Alice', 'Bob', 'Charlie', 'Bob', 'David']
print(l)
# ['Alice', 'Bob', 'Charlie', 'Bob', 'David']
print([s for s in l if s != 'Bob'])
# ['Alice', 'Charlie', 'David']
print([s for s in l if s.endswith('e')])
# ['Alice', 'Charlie']
మీరు నకిలీ మూలకాలను తీసివేయాలనుకుంటే, సెట్ సెట్ రకాన్ని ఉపయోగించండి.
print(list(set(l)))
# ['David', 'Alice', 'Charlie', 'Bob']
