তালিকা থেকে একাধিক উপাদান মোছা হচ্ছে


160

একই সাথে তালিকা থেকে একাধিক উপাদান মুছা সম্ভব? যদি আমি সূচক 0 এবং 2 এ উপাদান মুছুন এবং চেষ্টা ভালো কিছু চান del somelist[0], দ্বারা অনুসরণ del somelist[2], দ্বিতীয় বিবৃতি আসলে মুছে ফেলবে somelist[3]

আমি মনে করি আমি সর্বদা উচ্চতর সংখ্যাযুক্ত উপাদানগুলি প্রথমে মুছে ফেলতে পারি তবে আমি আশা করি এর থেকে আরও ভাল উপায় আছে।

উত্তর:


110

সম্ভবত এই সমস্যার সর্বোত্তম সমাধান নয়:

indices = 0, 2
somelist = [i for j, i in enumerate(somelist) if j not in indices]

2
প্রায়, কেবলমাত্র আপনি সম্পূর্ণ তালিকাটি মুছুন। এটি লেন (সূচকগুলি) * লেন (কোনও তালিকাভুক্ত) হবে। এটি একটি অনুলিপিও তৈরি করে, যা পছন্দসই বা নাও হতে পারে
রিচার্ড লেভাসিউর

আপনি যদি একটি তালিকার কোনও মানটির জন্য যাচাই করেন তবে তা। 'ইন' অপারেটর একটি তালিকার মানগুলিতে কাজ করে, যেখানে এটি ডিকের কীগুলিতে কাজ করে। আমি যদি ভুল হয়ে থাকি তবে দয়া করে আমাকে পিপ / রেফারেন্সে নির্দেশ করুন
রিচার্ড লেভাসিউর

5
আমি সূচকগুলির জন্য টুপলকে বেছে নেওয়ার কারণটি কেবল রেকর্ডের সরলতা ছিল। এটি সেট করার জন্য উপযুক্ত কাজ হবে () ও (এন) দেওয়ার জন্য
সাইলেন্টগোস্ট

18
এটি কোনও কোনও তালিকা থেকে আইটেমগুলি মুছে ফেলা নয়, বরং একেবারে নতুন তালিকা তৈরি করছে। যদি কোনও কিছুতে মূল তালিকার একটি রেফারেন্স থাকে তবে এর মধ্যে এটিতে সমস্ত আইটেম থাকবে।
টম ফিউচার

2
@ সাইলেন্টগোস্ট একটি গণনা করার প্রয়োজন নেই। এই সম্পর্কে somelist = [ lst[i] for i in xrange(len(lst)) if i not in set(indices) ]:?
টুলমেকারস্টেভ

183

কিছু কারণে আমি এখানে উত্তরগুলির কোনও পছন্দ করি না। হ্যাঁ, তারা কাজ করে, তবে কঠোরভাবে বলতে গেলে তাদের বেশিরভাগই তালিকার উপাদানগুলিকে মুছে ফেলছে না, তাই না? (তবে একটি অনুলিপি তৈরি করা এবং তারপরে মূল অনুলিপিটি সম্পাদিত অনুলিপি সহ)।

প্রথমে উচ্চতর সূচকটি মুছবেন না কেন?

এরজন্য কি কোন কারণ আছে? আমি শুধু করতাম:

for i in sorted(indices, reverse=True):
    del somelist[i]

আপনি যদি সত্যিই পিছন দিকে আইটেমগুলি মুছতে না চান তবে আমার ধারণা আমি শেষ সূচকগুলির চেয়ে বেশি সূচকগুলির সূচকগুলির মানগুলি অবশ্যই সুনির্দিষ্ট করে তুলতে হবে (আপনি আলাদা তালিকা তৈরি করার পরে একই সূচকটি ব্যবহার করতে পারবেন না) বা ব্যবহার করুন তালিকার একটি অনুলিপি (যা 'মুছে ফেলা হবে না' তবে সম্পাদিত অনুলিপিটির সাথে মূলটি প্রতিস্থাপন করবে)

আমি কি এখানে কিছু মিস করছি, বিপরীত ক্রমে মোছার কোনও কারণ নেই?


1
কেন জানি এটি গ্রহণযোগ্য উত্তর হিসাবে বেছে নেওয়া হয়নি! এর জন্য ধন্যবাদ.
সোয়াথিস

4
এর দুটি কারণ রয়েছে। (ক) একটি তালিকার জন্য, সময় জটিলতা গড়ে "অনুলিপি তৈরি করুন" পদ্ধতির (সূচকগুলির একটি সেট ব্যবহার করে) গড়ের চেয়ে বেশি হবে (এলোমেলিক সূচকগুলি ধরে নিচ্ছেন) কারণ কিছু উপাদান একাধিকবার এগিয়ে যেতে হবে। (খ) কমপক্ষে আমার পক্ষে এটি পড়া শক্ত, কারণ এখানে একটি সাজানোর কাজ রয়েছে যা কোনও আসল প্রোগ্রামের যুক্তির সাথে সঙ্গতিপূর্ণ নয় এবং কেবল প্রযুক্তিগত কারণে রয়েছে। যদিও এতক্ষণে আমি ইতিমধ্যে যুক্তিটি ভালভাবে বুঝতে পেরেছি, তবুও আমার মনে হয় এটি পড়তে অসুবিধা হবে।
অবর্ণনীয় রাত

1
@ ইম্প্রিশেবলনিয়াইট আপনি কি (ক) বিস্তারিত বর্ণনা করবেন? আমি বুঝতে পারি না "কিছু উপাদান স্থানান্তরিত হওয়া দরকার"। (খ) এর জন্য আপনি কেবল একটি ফাংশন সংজ্ঞায়িত করতে পারেন যদি আপনার স্পষ্টতা পড়ার প্রয়োজন হয়।
tglaria

109

যদি আপনি একাধিক অ-সংলগ্ন আইটেমগুলি মুছছেন, তবে আপনি যা বর্ণনা করছেন তা হ'ল সর্বোত্তম উপায় (এবং হ্যাঁ, সর্বোচ্চ সূচী থেকে শুরু করা নিশ্চিত হন)।

যদি আপনার আইটেমগুলি সংলগ্ন হয় তবে আপনি স্লাইস অ্যাসাইনমেন্ট সিনট্যাক্সটি ব্যবহার করতে পারেন:

a[2:10] = []

95
আপনি del a[2:10]একই প্রভাব সঙ্গে বলতে পারেন ।
হেলায়

8
@ মজার মজার বিষয় হল, ডেল কার্য নির্ধারণের চেয়ে কিছুটা দ্রুত।
thefourtheye

24

আপনি numpy.deleteনিম্নলিখিত হিসাবে ব্যবহার করতে পারেন :

import numpy as np
a = ['a', 'l', 3.14, 42, 'u']
I = [0, 2]
np.delete(a, I).tolist()
# Returns: ['l', '42', 'u']

আপনি যদি শেষে numpyঅ্যারে দিয়ে আপত্তি না করেন তবে আপনি এটি ছেড়ে দিতে পারেন .tolist()। আপনার আরও কিছু বড় গতির উন্নতি দেখতে হবে, এটি আরও একটি স্কেলযোগ্য সমাধান হিসাবে তৈরি করে। আমি এটি বেঞ্চমার্ক করিনি, তবে numpyঅপারেশনগুলি সি বা ফোর্টরান উভয়তেই লিখিত কোডগুলি সংকলিত।


1
সাধারণ সমাধান যখন উপাদানগুলি ধারাবাহিক না হয় +1
নভেম্বর

1
এখানে প্রশ্ন করুন, কীভাবে ['এ', 42] মুছতে হবে।
ইভানহোটোম

গতির জন্য অন্যদের তুলনায় এই সমাধানের জন্য বিশাল বোনাস পয়েন্ট। আমি যা বলতে পারি তা হ'ল খুব বড় ডেটা সেট করার জন্য, কিছুটা অর্জন করতে আমাকে কয়েক মিনিট সময় নিচ্ছিল যা ভাল ওল 'নম্পটি দিয়ে মাত্র কয়েক সেকেন্ড সময় নিয়েছিল।
লেজেল

18

গ্রেগের উত্তরের বিশেষীকরণ হিসাবে আপনি এমনকি বর্ধিত স্লাইস সিনট্যাক্সও ব্যবহার করতে পারেন। যেমন। আপনি যদি 0 এবং 2 আইটেমগুলি মুছতে চান:

>>> a= [0, 1, 2, 3, 4]
>>> del a[0:3:2]
>>> a
[1, 3, 4]

এটি অবশ্যই কোনও স্বেচ্ছাসেবী নির্বাচন কভার করে না, তবে এটি অবশ্যই দুটি আইটেম মোছার জন্য কাজ করতে পারে।


16

একটি ফাংশন হিসাবে:

def multi_delete(list_, *args):
    indexes = sorted(list(args), reverse=True)
    for index in indexes:
        del list_[index]
    return list_

এন লগ (এন) সময়ে চলছে , যা এটি এখনও দ্রুততম সঠিক সমাধান করা উচিত।


1
আরগস.সোর্ট ()। বিপরীত () সহ সংস্করণটি অবশ্যই আরও ভাল। এটি নিক্ষেপের পরিবর্তে নিক্ষেপগুলি বা আরও খারাপভাবে, নীরবে দুর্নীতিগ্রস্থ হয়ে কাজ করার ক্ষেত্রে ঘটে।

সাজানোর () টিউপলের জন্য সংজ্ঞায়িত করা হয়নি, আপনাকে প্রথমে তালিকায় রূপান্তর করতে হবে। বাছাই () কিছুই দেয় না, সুতরাং আপনি এটিতে বিপরীত () ব্যবহার করতে পারবেন না।
সাইলেন্টগোস্ট

@ আর পেট: সেই কারণে আমি প্রথম সংস্করণটি সরিয়েছি। ধন্যবাদ। @ সাইলেন্টগোস্ট: এটি স্থির করে।
নিখিল চেলিয়া

@ নিখিল: না আপনি করেননি;) আরগস = লিস্ট (আরগস) আরগস.সোর্ট () আরগস.রেভারস () তবে আরও ভাল বিকল্পটি হ'ল: আরগস = সাজানো (
অর্গস

2
n log n? সত্যি? আমি del list[index]ও (1) বলে মনে করি না ।
ব্যবহারকারী 202729

12

সুতরাং, আপনি মূলত এক পাসে একাধিক উপাদান মুছতে চান? সেক্ষেত্রে মোছার জন্য পরবর্তী উপাদানটির অবস্থানটি অফসেট হয়ে যাবে তবে অনেকগুলি আগে মুছে ফেলা হয়েছিল।

আমাদের লক্ষ্য হ'ল সমস্ত স্বরবর্ণগুলি মুছে ফেলা, যা সূচকগুলি 1, 4 এবং 7 হিসাবে সূচিত হয় are নোট করুন যে এটির গুরুত্বপূর্ণ টো_ডিলিট সূচকগুলি আরোহী ক্রমে রয়েছে, অন্যথায় এটি কাজ করবে না।

to_delete = [1, 4, 7]
target = list("hello world")
for offset, index in enumerate(to_delete):
  index -= offset
  del target[index]

আপনি যদি কোনও ক্রমে উপাদানগুলি মুছতে চান তবে এটি আরও জটিল হবে। আইএমও, বাছাই to_deleteকরা আপনার পক্ষে কখন বিয়োগ করা উচিত বা করা উচিত নয় তা নির্ধারণের চেয়ে সহজ হতে পারে index


8

আমি পাইথনের মোটামুটি শিক্ষানবিস এবং আমার প্রোগ্রামিংটি এই মুহুর্তে অল্প কথায় কুরুচিপূর্ণ এবং নোংরা, তবে আমার সমাধানটি প্রাথমিক টিউটোরিয়ালে শিখেছি বেসিক কমান্ডগুলির সংমিশ্রণটি ব্যবহার করা ছিল:

some_list = [1,2,3,4,5,6,7,8,10]
rem = [0,5,7]

for i in rem:
    some_list[i] = '!' # mark for deletion

for i in range(0, some_list.count('!')):
    some_list.remove('!') # remove
print some_list

স্পষ্টতই, "মুছে ফেলার জন্য" চিহ্নটি বেছে নেওয়ার কারণে এর এর সীমাবদ্ধতা রয়েছে।

তালিকার আকারের আকারের আকার হিসাবে পারফরম্যান্সের ক্ষেত্রে, আমি নিশ্চিত যে আমার সমাধান সাব-অনুকূল। তবে এটি সহজবোধ্য, যা আমি আশা করি অন্যান্য সূচনাপ্রাপ্তদের কাছে আবেদন করে, এবং some_listএমন একটি সুনির্দিষ্ট ক্ষেত্রে কাজ করবে যেখানে একটি সুপরিচিত ফর্ম্যাট যেমন, সর্বদা সংখ্যাসূচক ...


2
পরিবর্তে 'ব্যবহার!' আপনার বিশেষ চরিত্র হিসাবে, কিছুই ব্যবহার করুন। এটি প্রতিটি চরিত্রকে বৈধ রাখে এবং আপনার
সম্ভাব্যতাগুলি

5

এখানে একটি বিকল্প রয়েছে, যা টিপলস তৈরি করতে গণনা () ব্যবহার করে না (সাইলেন্টঘস্টের মূল উত্তর হিসাবে)।

এটি আমার কাছে আরও পাঠযোগ্য বলে মনে হচ্ছে। (আমি যদি গণনা ব্যবহারের অভ্যাসে থাকি তবে আমি অন্যরকম অনুভব করতাম)) ক্যাভেট: আমি দুটি পদ্ধতির পারফরম্যান্স পরীক্ষা করিনি।

# Returns a new list. "lst" is not modified.
def delete_by_indices(lst, indices):
    indices_as_set = set(indices)
    return [ lst[i] for i in xrange(len(lst)) if i not in indices_as_set ]

দ্রষ্টব্য: পাইথন 2.7 বাক্য গঠন। পাইথন 3, xrange=> এর জন্য range

ব্যবহার:

lst = [ 11*x for x in xrange(10) ]
somelist = delete_by_indices( lst, [0, 4, 5])

somelist:

[11, 22, 33, 66, 77, 88, 99]

--- বোনাস ---

একটি তালিকা থেকে একাধিক মান মুছুন। এটি হ'ল আমাদের যে মানগুলি মুছতে চাই তা রয়েছে:

# Returns a new list. "lst" is not modified.
def delete__by_values(lst, values):
    values_as_set = set(values)
    return [ x for x in lst if x not in values_as_set ]

ব্যবহার:

somelist = delete__by_values( lst, [0, 44, 55] )

somelist:

[11, 22, 33, 66, 77, 88, 99]

এটি আগের মত একই উত্তর, তবে এবার আমরা মুছে ফেলার ভ্যালু সরবরাহ করেছি [0, 44, 55]


আমি সিদ্ধান্ত নিয়েছি @ সাইলেন্টগোস্টের পাঠ করা কেবলমাত্র কঠিন ছিল, কারণ অঙ্কের ফলাফলের জন্য অ-বর্ণনামূলক পরিবর্তনশীল নাম ব্যবহার করা হয়েছিল। এছাড়াও, পেরেনগুলি পড়া সহজ করে দিত। তাই এখানে কিভাবে আমি শব্দ তার সমাধান ( "সেট" পারফরম্যান্সের জন্য, এখনো যোগ করেনি সঙ্গে) would: [ value for (i, value) in enumerate(lst) if i not in set(indices) ]। তবে আমি আমার উত্তরটি এখানে রেখে দেব, কারণ আমি দেখাব যে কীভাবে মানগুলি মুছতে হয়। এটি একটি সহজ ক্ষেত্রে, তবে কারওর পক্ষে সহায়তা করতে পারে।
টুলমেকারস্টেভ

@ ভিড্রাক- আপনাকে ধন্যবাদ; আমি প্রথমে সেটটি তৈরি করতে পুনরায় লিখেছি। আপনি কী ভাবেন - সাইলেন্টঘস্টের চেয়ে দ্রুত সমাধান এখন? (আমি এটা আসলে এটা সময় গুরুত্বপূর্ণ যথেষ্ট বিবেচনা না, শুধু আপনার মতামত জিজ্ঞাসা।) একইভাবে, আমি পুনরায় লেখার SilentGhost এর সংস্করণ would indices_as_set = set(indices), [ value for (i, value) in enumerate(lst) if i not in indices_as_set ]এটা গতি বাড়াতে পর্যন্ত।
নির্মাতা স্টিভ

ডাবল আন্ডারস্কোর ভিতরে কোনও স্টাইল কারণ আছে delete__by_values()?
টম

5

একটি বিকল্প তালিকা অনুধাবন পদ্ধতি যা তালিকার সূচক মানগুলি ব্যবহার করে:

stuff = ['a', 'b', 'c', 'd', 'e', 'f', 'woof']
index = [0, 3, 6]
new = [i for i in stuff if stuff.index(i) not in index]

এটি ফিরে আসে:

['b', 'c', 'e', 'f']

উত্তম উত্তর, তবে সূচকের তালিকার নামকরণ indexবিভ্রান্তিকর কারণ তালিকাতে পুনরাবৃত্তি পদ্ধতিটি ব্যবহার করা হয়index()
জো

4

এখানে অন্য পদ্ধতি যা স্থানের উপাদানগুলি সরিয়ে দেয়। এছাড়াও যদি আপনার তালিকাটি সত্যিই দীর্ঘ হয় তবে এটি আরও দ্রুত।

>>> a = range(10)
>>> remove = [0,4,5]
>>> from collections import deque
>>> deque((list.pop(a, i) for i in sorted(remove, reverse=True)), maxlen=0)

>>> timeit.timeit('[i for j, i in enumerate(a) if j not in remove]', setup='import random;remove=[random.randrange(100000) for i in range(100)]; a = range(100000)', number=1)
0.1704120635986328

>>> timeit.timeit('deque((list.pop(a, i) for i in sorted(remove, reverse=True)), maxlen=0)', setup='from collections import deque;import random;remove=[random.randrange(100000) for i in range(100)]; a = range(100000)', number=1)
0.004853963851928711

+1: একটি "for ..:" ব্লকের প্রয়োজনের চেয়ে অভিব্যক্তির অংশ হিসাবে ক্রিয়াকলাপ সম্পাদন করার জন্য ডিউকের আকর্ষণীয় ব্যবহার। তবে, এই সাধারণ ক্ষেত্রে আমি নিখিলকে ব্লকের জন্য আরও পাঠযোগ্য able
টুলমেকারস্টেভ

4

এটি উল্লেখ করা হয়েছে, তবে কোনওভাবেই এটি সঠিকভাবে পরিচালিত করতে পারেনি।

উপর O(n)সমাধান হতে হবে:

indices = {0, 2}
somelist = [i for j, i in enumerate(somelist) if j not in indices]

এটি সাইলেন্টগোস্টের সংস্করণটির খুব কাছাকাছি হলেও দুটি ধনুর্বন্ধনী যোগ করেছে।


O(n)আপনি যদি log(len(indices))প্রতিটি পুনরাবৃত্তির জন্য গ্রহণ করা লুপগুলি গণনা করেন এটি এটি নয় ।
ম্যাড পদার্থবিদ

@ ম্যাডফিসিসিস্ট j not in indicesহলেন O(1)
Veedrac

আপনি কীভাবে এই নম্বরটি পেয়েছেন তা নিশ্চিত নই। যেহেতু সূচকের গুচ্ছ, j not in indicesএখনও লুকআপ প্রয়োজন, যা O(log(len(indices)))। যদিও আমি একমত যে 2-উপাদানগুলির সেটটিতে একটি অনুসন্ধানের জন্য যোগ্যতা রয়েছে O(1), সাধারণ ক্ষেত্রে এটি হবে O(log(N))। যেভাবেই O(N log(N))এখনও মারধর করে O(N^2)
ম্যাড পদার্থবিদ


এবং দুটি ধনুর্বন্ধনী ঠিক কী করেছিল?
নিউক্লিয়ার03020704

4
l = ['a','b','a','c','a','d']
to_remove = [1, 3]
[l[i] for i in range(0, len(l)) if i not in to_remove])

এটি মূলত শীর্ষ ভোটের জবাব হিসাবে একই, এটি লেখার এক ভিন্ন উপায়। মনে রাখবেন যে l.index () ব্যবহার করা ভাল ধারণা নয়, কারণ এটি তালিকায় নকল উপাদানগুলি পরিচালনা করতে পারে না।


2

সরান পদ্ধতি তালিকার উপাদানগুলির অনেকগুলি স্থানান্তরিত করবে। আমি মনে করি একটি অনুলিপি তৈরি করা ভাল:

...
new_list = []
for el in obj.my_list:
   if condition_is_true(el):
      new_list.append(el)
del obj.my_list
obj.my_list = new_list
...

2

প্রযুক্তিগতভাবে, উত্তরটি হ'ল একই সময়ে দুটি বস্তু মুছা সম্ভব নয়। তবে সুন্দর অজগরটির এক লাইনে দুটি অবজেক্ট মুছে ফেলা সম্ভব।

del (foo['bar'],foo['baz'])

recusrively মুছে ফেলা হবে foo['bar'], তারপরfoo['baz']


এটি কোনও ডিক অবজেক্ট থেকে মুছে ফেলা হয়, একটি তালিকা নয়, তবে আমি এখনও এটির জন্য +1 করছি কারণ এটি খুব সুন্দর হয়ে উঠছে!
উলফ আসলাক

এটি যথাযথ বাক্য গঠন সহ তালিকার ক্ষেত্রেও প্রযোজ্য। তবে দাবিটি একই সাথে দুটি অবজেক্ট মুছে ফেলা সম্ভব নয় এটি মিথ্যা; উত্তরটি @ ববিন্স
পেড্রো গিমেনো

2

আমরা সূচকগুলিকে অবতরণ অনুসারে বাছাইয়ের পরে সূচীগুলিতে লুপের পুনরাবৃত্তির জন্য এটি ব্যবহার করতে পারি

mylist=[66.25, 333, 1, 4, 6, 7, 8, 56, 8769, 65]
indexes = 4,6
indexes = sorted(indexes, reverse=True)
for i in index:
    mylist.pop(i)
print mylist

2

তালিকাএ থেকে 0 এবং 2 সূচকগুলির জন্য:

for x in (2,0): listA.pop(x)

কিছু এলোমেলিক সূচকে তালিকাএ থেকে সরানোর জন্য:

indices=(5,3,2,7,0) 
for x in sorted(indices)[::-1]: listA.pop(x)

2

আমি বিভিন্ন সমাধানের সাথে তুলনা করার একটি উপায় চেয়েছিলাম যা নোবগুলি ঘুরিয়ে দেওয়া সহজ করে তোলে।

প্রথমে আমি আমার ডেটা তৈরি করেছি:

import random

N = 16 * 1024
x = range(N)
random.shuffle(x)
y = random.sample(range(N), N / 10)

তারপরে আমি আমার ফাংশনগুলি সংজ্ঞায়িত করেছি:

def list_set(value_list, index_list):
    index_list = set(index_list)
    result = [value for index, value in enumerate(value_list) if index not in index_list]
    return result

def list_del(value_list, index_list):
    for index in sorted(index_list, reverse=True):
        del(value_list[index])

def list_pop(value_list, index_list):
    for index in sorted(index_list, reverse=True):
        value_list.pop(index)

তারপরে আমি timeitসমাধানগুলি তুলনা করতাম :

import timeit
from collections import OrderedDict

M = 1000
setup = 'from __main__ import x, y, list_set, list_del, list_pop'
statement_dict = OrderedDict([
    ('overhead',  'a = x[:]'),
    ('set', 'a = x[:]; list_set(a, y)'),
    ('del', 'a = x[:]; list_del(a, y)'),
    ('pop', 'a = x[:]; list_pop(a, y)'),
])

overhead = None
result_dict = OrderedDict()
for name, statement in statement_dict.iteritems():
    result = timeit.timeit(statement, number=M, setup=setup)
    if overhead is None:
        overhead = result
    else:
        result = result - overhead
        result_dict[name] = result

for name, result in result_dict.iteritems():
    print "%s = %7.3f" % (name, result)

আউটপুট

set =   1.711
del =   3.450
pop =   3.618

সুতরাং একটিতে সূচকগুলি সহ জেনারেটরটি setবিজয়ী ছিল। এবং delতারপর কিছুটা দ্রুত pop


এই তুলনা করার জন্য আপনাকে ধন্যবাদ, এটি আমার নিজের পরীক্ষাগুলি তৈরি করতে পরিচালিত করেছে (আসলে সবেমাত্র আপনার কোড ধার করা হয়েছে) এবং সামান্য সংখ্যক আইটেম অপসারণের জন্য, একটি এসইটি তৈরির জন্য ওভারহেড এটি সবচেয়ে খারাপ সমাধান করে তোলে (10, 100, 500 এর জন্য ব্যবহার করুন) 'y' এর দৈর্ঘ্য এবং আপনি দেখতে পাবেন)। বেশিরভাগ সময়, এটি প্রয়োগের উপর নির্ভর করে।
tglaria

2

আপনি এই যুক্তি ব্যবহার করতে পারেন:

my_list = ['word','yes','no','nice']

c=[b for i,b in enumerate(my_list) if not i in (0,2,3)]

print c

2

সর্বোচ্চ সূচক থেকে অপসারণের ধারণার আর একটি বাস্তবায়ন।

for i in range(len(yourlist)-1, -1, -1):
    del yourlist(i)

1

আমি এটি করার দুটি উপায় সম্পর্কে ভাবতে পারি:

  1. তালিকায় টুকরো টুকরো করুন (এটি প্রথম, তৃতীয় এবং অষ্টম উপাদানগুলি মুছে ফেলে)

    কিছু তালিকা = কিছু তালিকা [1: 2] + কিছু তালিকা [3: 7] + কিছু তালিকা [8:]

  2. এটি জায়গায় করুন, তবে একবারে একটি:

    somelist.pop (2) somelist.pop (0)


1

আপনি কোনও তালিকাতে নয়, ডিকের মাধ্যমে সেভাবে করতে পারেন। একটি তালিকায় উপাদানগুলি ক্রমানুসারে রয়েছে। একটি আদেশে তারা কেবল সূচকের উপর নির্ভর করে।

সরল কোড শুধু এটা ব্যাখ্যা করার করে :

>>> lst = ['a','b','c']
>>> dct = {0: 'a', 1: 'b', 2:'c'}
>>> lst[0]
'a'
>>> dct[0]
'a'
>>> del lst[0]
>>> del dct[0]
>>> lst[0]
'b'
>>> dct[0]
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    dct[0]
KeyError: 0
>>> dct[1]
'b'
>>> lst[1]
'c'

একটি ডিকের একটি তালিকা "রূপান্তর" করার একটি উপায়:

>>> dct = {}
>>> for i in xrange(0,len(lst)): dct[i] = lst[i]

বিপরীতটি হ'ল:

lst = [dct[i] for i in sorted(dct.keys())] 

যাইহোক আমি মনে করি আপনি যেমন বলেছিলেন তেমন উচ্চ সূচী থেকে মুছে ফেলা ভাল।


পাইথন গ্যারান্টি দেয় [ডিসিটি [i] আইসিটি ইন আইসিএস] কি সর্বদা i এর বর্ধমান মান ব্যবহার করবে? যদি তা হয় তবে তালিকা (dct.values ​​()) অবশ্যই আরও ভাল।

আমি এটা সম্পর্কে চিন্তা ছিল না। তুমি ঠিক বলছো. আমি এখানে [এখানে] [1] পড়ার সাথে গ্যারান্টি নেই যে আইটেমগুলি ক্রমে বা কমপক্ষে প্রত্যাশিত অর্ডারে নেওয়া হবে। আমি সম্পাদনা করেছি। [১]: ডকস.পিথন.আর.আলিবেরি
আম্বু

2
এই উত্তরটি মৌলিকভাবে ভুল উপায়ে অভিধানগুলি সম্পর্কে আলোচনা করে। একটি অভিধানের মূল কী রয়েছে (ইন্ডিকস নয়)। হ্যাঁ, কী / মান জোড় একে অপরের থেকে স্বতন্ত্র। না, আপনি কী প্রবেশদ্বারগুলি মুছে ফেলবেন তা কোনও ব্যাপার নয় just কেবলমাত্র একটি তালিকা থেকে কিছু উপাদান মুছতে একটি অভিধানে রূপান্তর করা ওভারকিল হবে।
টুলমেকারস্টেভ

1

মন্তব্যটি @sth থেকে সাধারণীকরণের জন্য । কোন ক্লাসে আইটেম মুছে ফেলার যে কার্যকরী abc.MutableSequence , এবং listবিশেষ করে, এর মাধ্যমে সম্পন্ন করা হয় __delitem__জাদু পদ্ধতি। এই পদ্ধতিটি এর অনুরূপ কাজ করে __getitem__, এর অর্থ এটি কোনও পূর্ণসংখ্যা বা স্লাইস গ্রহণ করতে পারে। এখানে একটি উদাহরণ:

class MyList(list):
    def __delitem__(self, item):
        if isinstance(item, slice):
            for i in range(*item.indices(len(self))):
                self[i] = 'null'
        else:
            self[item] = 'null'


l = MyList(range(10))
print(l)
del l[5:8]
print(l)

এই আউটপুট হবে

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 'null', 'null', 'null', 8, 9]

1

কেবলমাত্র এ কারণে এটি আমদানি করা অতিমাত্রার চাপ হতে পারে, তবে আপনি যদি pandasযাইহোক এটি ব্যবহার করে থাকেন তবে সমাধানটি সহজ এবং সোজা:

import pandas as pd
stuff = pd.Series(['a','b','a','c','a','d'])
less_stuff = stuff[stuff != 'a']  # define any condition here
# results ['b','c','d']

1
some_list.remove(some_list[max(i, j)])

বাছাইয়ের ব্যয় এবং স্পষ্টভাবে কপির তালিকাগুলি এড়ানো যায় না।


0

কীভাবে এই এক সম্পর্কে (আমি খুব পাইথন নতুন নই, কিন্তু তারা মনে ঠিক):

ocean_basin = ['a', 'Atlantic', 'Pacific', 'Indian', 'a', 'a', 'a']
for i in range(1, (ocean_basin.count('a') + 1)):
    ocean_basin.remove('a')
print(ocean_basin)

['আটলান্টিক', 'প্রশান্ত মহাসাগরীয়', 'ভারতীয়']

ob = ['a', 'b', 4, 5,'Atlantic', 'Pacific', 'Indian', 'a', 'a', 4, 'a']
remove = ('a', 'b', 4, 5)
ob = [i for i in ob if i not in (remove)]
print(ob)

['আটলান্টিক', 'প্রশান্ত মহাসাগরীয়', 'ভারতীয়']


0

এখন অবধি দেওয়া কোনও উত্তরই মুছে ফেলার জন্য নির্ধারিত সংখ্যক সূচকের জন্য তালিকার দৈর্ঘ্যে ও (এন) এর জায়গায় মুছে ফেলার কাজটি করে না , তাই আমার সংস্করণটি এখানে:

def multi_delete(the_list, indices):
    assert type(indices) in {set, frozenset}, "indices must be a set or frozenset"
    offset = 0
    for i in range(len(the_list)):
        if i in indices:
            offset += 1
        elif offset:
            the_list[i - offset] = the_list[i]
    if offset:
        del the_list[-offset:]

# Example:
a = [0, 1, 2, 3, 4, 5, 6, 7]
multi_delete(a, {1, 2, 4, 6, 7})
print(a)  # prints [0, 3, 5]

0

আপনি অপসারণটিও ব্যবহার করতে পারেন।

delete_from_somelist = []
for i in [int(0), int(2)]:
     delete_from_somelist.append(somelist[i])
for j in delete_from_somelist:
     newlist = somelist.remove(j)

0

আমি এগুলি সমস্ত list_diffফাংশনে একসাথে রেখেছি যা প্রথম তালিকার মূল ক্রম সংরক্ষণের সময় কেবল দুটি তালিকা ইনপুট হিসাবে গ্রহণ করে এবং তাদের পার্থক্য ফিরিয়ে দেয় returns

def list_diff(list_a, list_b, verbose=False):

    # returns a difference of list_a and list_b,
    # preserving the original order, unlike set-based solutions

    # get indices of elements to be excluded from list_a
    excl_ind = [i for i, x in enumerate(list_a) if x in list_b]
    if verbose:
        print(excl_ind)

    # filter out the excluded indices, producing a new list 
    new_list = [i for i in list_a if list_a.index(i) not in excl_ind]
    if verbose:
        print(new_list)

    return(new_list)

নমুনা ব্যবহার:

my_list = ['a', 'b', 'c', 'd', 'e', 'f', 'woof']
# index = [0, 3, 6]

# define excluded names list
excl_names_list = ['woof', 'c']

list_diff(my_list, excl_names_list)
>> ['a', 'b', 'd', 'e', 'f']
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.