પાયથોનમાં ટાઈપ લિસ્ટની યાદી (એરે) માંથી તત્વને દૂર કરવા માટે, યાદી પદ્ધતિઓ 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()
સૂચિની મેથડ 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
નોંધ કરો કે pop(0), જે પ્રથમ ઘટકને દૂર કરે છે, તેને નીચેની કિંમતની જરૂર છે અને તે કાર્યક્ષમ કામગીરી નથી. યાદીઓ પરની વિવિધ કામગીરીની કોમ્પ્યુટેશનલ જટિલતા માટે સત્તાવાર વિકિ પર નીચેનું પૃષ્ઠ જુઓ.O(n)
O(1)ડેક પ્રકાર પ્રમાણભૂત પુસ્તકાલય સંગ્રહ મોડ્યુલમાં એક પ્રકાર તરીકે પ્રદાન કરવામાં આવે છે જે આ કિંમતે ટોચ પરના તત્વોને કાઢી નાખે છે. ઉદાહરણ તરીકે, જો તમે ડેટાને કતાર (FIFO) તરીકે ગણવા માંગતા હોવ, તો ડેકનો ઉપયોગ કરવો વધુ કાર્યક્ષમ છે.
ઉલ્લેખિત મૂલ્ય સાથે ઘટકો માટે શોધે છે અને પ્રથમ ઘટક દૂર કરે છે.: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
આ 2 વડે ભાગ્યા i નો શેષ ભાગ છે.
સૂચિ સમજણ સંકેતમાં, એક નવી સૂચિ બનાવવામાં આવે છે. અત્યાર સુધી રજૂ કરાયેલી સૂચિ પ્રકારની પદ્ધતિઓથી વિપરીત, મૂળ સૂચિ યથાવત છે.
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']