একটি তালিকা থেকে একটি মান এর সমস্ত উপস্থিতি সরান?
উত্তর:
কার্যকরী পদ্ধতির:
পাইথন 3.x
>>> x = [1,2,3,2,2,2,3,4]
>>> list(filter((2).__ne__, x))
[1, 3, 3, 4]অথবা
>>> x = [1,2,3,2,2,2,3,4]
>>> list(filter(lambda a: a != 2, x))
[1, 3, 3, 4]পাইথন 2.x
>>> x = [1,2,3,2,2,2,3,4]
>>> filter(lambda a: a != 2, x)
[1, 3, 3, 4][y for y in x if y != 2]
__ne__। দুটি মানের তুলনা করা কেবল কল করা __eq__বা __ne__তার মধ্যে একটির চেয়ে অনেক জটিল প্রক্রিয়া । এটি এখানে সঠিকভাবে কাজ করতে পারে কারণ আপনি কেবল সংখ্যার তুলনা করছেন, তবে সাধারণ ক্ষেত্রে এটি ভুল এবং একটি বাগ।
আপনি একটি তালিকা বোধগম্যতা ব্যবহার করতে পারেন:
def remove_values_from_list(the_list, val):
return [value for value in the_list if value != val]
x = [1, 2, 3, 4, 2, 2, 3]
x = remove_values_from_list(x, 2)
print x
# [1, 3, 4, 3]inঅপারেটর এবং removeপদ্ধতি উভয়ই পুরো তালিকাকে স্ক্যান করে (তারা কোনও মিল খুঁজে না পাওয়া পর্যন্ত) যাতে আপনি সেই তালিকাটিকে একাধিকবার স্ক্যান করে শেষ করেন।
আপনি যদি এখনও একটি দক্ষ তালিকা উপলব্ধি (বা জেনারেটর এক্সপ্রেশন) ব্যবহার করে মূল তালিকাটি পরিবর্তন করতে হয় তবে আপনি স্লাইস অ্যাসাইনমেন্টটি ব্যবহার করতে পারেন।
>>> x = [1, 2, 3, 4, 2, 2, 3]
>>> x[:] = (value for value in x if value != 2)
>>> x
[1, 3, 4, 3]x = [ v for v in x if x != 2 ]প্রস্তাবগুলির বিপরীতে , যেগুলি একটি নতুন তালিকা তৈরি করে এবং এটি উল্লেখ করার জন্য এক্স পরিবর্তন করে, মূল তালিকাটি ছোঁয়া ছাড়বে।
আরও বিমূর্ত পদ্ধতিতে প্রথম পোস্টটির সমাধানটি পুনরাবৃত্তি করা:
>>> x = [1, 2, 3, 4, 2, 2, 3]
>>> while 2 in x: x.remove(2)
>>> x
[1, 3, 4, 3]x = [1] * 10000 + [2] * 1000। লুপ বডিটি 1000 বার কার্যকর করে এবং .remove () প্রতিবার এটি প্রয়োগ করার সময় 10000 উপাদান এড়িয়ে যেতে হয়। এটি আমার কাছে ও (এন * এন) এর মতো গন্ধযুক্ত তবে এটি কোনও প্রমাণ নয়। আমি মনে করি যে প্রমাণটি হ'ল তালিকার 2s সংখ্যাটি তার দৈর্ঘ্যের সাথে আনুপাতিক। সেই অনুপাতের ফ্যাক্টরটি তখন বিগ-ও স্বরলিপিটিতে অদৃশ্য হয়ে যায়। যদিও তালিকার কেবল ধ্রুবক 2s সংখ্যার মধ্যে সর্বোত্তম ক্ষেত্রে ও (এন ^ 2) নয়, কেবল ও (2 এন) যা ও (এন)।
উপরের সমস্ত উত্তর (মার্টিন অ্যান্ডারসন বাদে) মূল তালিকা থেকে আইটেমগুলি সরিয়ে না দিয়ে পছন্দসই আইটেমগুলি ছাড়াই একটি নতুন তালিকা তৈরি করে।
>>> import random, timeit
>>> a = list(range(5)) * 1000
>>> random.shuffle(a)
>>> b = a
>>> print(b is a)
True
>>> b = [x for x in b if x != 0]
>>> print(b is a)
False
>>> b.count(0)
0
>>> a.count(0)
1000
>>> b = a
>>> b = filter(lambda a: a != 2, x)
>>> print(b is a)
Falseযদি আপনার চারপাশে ঝুলন্ত তালিকার অন্যান্য উল্লেখ থাকে তবে এটি গুরুত্বপূর্ণ হতে পারে।
তালিকায় স্থান পরিবর্তন করতে এই জাতীয় পদ্ধতি ব্যবহার করুন
>>> def removeall_inplace(x, l):
... for _ in xrange(l.count(x)):
... l.remove(x)
...
>>> removeall_inplace(0, b)
>>> b is a
True
>>> a.count(0)
0যতদূর গতি সম্পর্কিত, আমার ল্যাপটপে ফলাফলগুলি রয়েছে (সবগুলি 5000 এন্ট্রি তালিকাতে 1000 এন্ট্রি সরানো আছে)
- তালিকা উপলব্ধি - us 400us
- ফিল্টার - 900 ডলার
- .রেমো () লুপ - 50 মিমি
সুতরাং। রেমোভ লুপটি প্রায় 100x ধীর ........ হুম, সম্ভবত একটি ভিন্ন পদ্ধতির প্রয়োজন। আমি সবচেয়ে দ্রুত খুঁজে পেয়েছি তালিকাটি বোঝার ব্যবহার করে তবে তারপরে মূল তালিকার বিষয়বস্তুগুলি প্রতিস্থাপন করুন the
>>> def removeall_replace(x, l):
.... t = [y for y in l if y != x]
.... del l[:]
.... l.extend(t)- মুছে ফেলা_প্লেস () - 450us
def remove_all(x, l): return [y for y in l if y != x]তারপরেl = remove_all(3,l)
তুমি এটি করতে পারো
while 2 in x:
x.remove(2)পঠনযোগ্যতার ব্যয়ে, আমি মনে করি এই সংস্করণটি কিছুটা দ্রুততর হয়েছে কারণ এটি তালিকাটিকে পুনরায় পরীক্ষা করতে বাধ্য করে না, সুতরাং ঠিক একই কাজটি মুছে ফেললে যেভাবেই করতে হবে:
x = [1, 2, 3, 4, 2, 2, 3]
def remove_values_from_list(the_list, val):
for i in range(the_list.count(val)):
the_list.remove(val)
remove_values_from_list(x, 2)
print(x)1.000.000 উপাদান সহ একটি তালিকা / অ্যারের বিরুদ্ধে নম্পী পদ্ধতির এবং সময়গুলি:
সময়:
In [10]: a.shape
Out[10]: (1000000,)
In [13]: len(lst)
Out[13]: 1000000
In [18]: %timeit a[a != 2]
100 loops, best of 3: 2.94 ms per loop
In [19]: %timeit [x for x in lst if x != 2]
10 loops, best of 3: 79.7 ms per loopউপসংহার: তালিকা বোঝার পদ্ধতির তুলনায় নম্পি 27 গুণ (আমার নোটবুকটিতে) দ্রুত)
পিএস যদি আপনি আপনার নিয়মিত পাইথন তালিকাকে lstনমপি অ্যারে রূপান্তর করতে চান :
arr = np.array(lst)সেটআপ:
import numpy as np
a = np.random.randint(0, 1000, 10**6)
In [10]: a.shape
Out[10]: (1000000,)
In [12]: lst = a.tolist()
In [13]: len(lst)
Out[13]: 1000000পরীক্ষা করে দেখুন:
In [14]: a[a != 2].shape
Out[14]: (998949,)
In [15]: len([x for x in lst if x != 2])
Out[15]: 998949a = [1, 2, 2, 3, 1]
to_remove = 1
a = [i for i in a if i != to_remove]
print(a)সম্ভবত সবচেয়ে পাইথোনিক না তবে এখনও আমার পক্ষে সবচেয়ে সহজ হা হা
সমস্ত সদৃশ ঘটনাগুলি সরাতে এবং তালিকায় একটি রেখে দিন:
test = [1, 1, 2, 3]
newlist = list(set(test))
print newlist
[1, 2, 3]আমি প্রকল্প ইউলারের জন্য যে ফাংশনটি ব্যবহার করেছি তা এখানে:
def removeOccurrences(e):
return list(set(e))আমি বিশ্বাস করি এটি সম্ভবত অন্য যে কোনও উপায়ে দ্রুত হয় যদি আপনি তালিকাগুলির ক্রমটির বিষয়ে চিন্তা না করেন, আপনি যদি চূড়ান্ত অর্ডারটি সূচকগুলি মূল এবং এর মাধ্যমে রিসর্ট থেকে সঞ্চয় করে থাকেন।
category_ids.sort()
ones_last_index = category_ids.count('1')
del category_ids[0:ones_last_index]for i in range(a.count(' ')):
a.remove(' ')আমি অনেক সহজ বিশ্বাস করি।
দিন
>>> x = [1, 2, 3, 4, 2, 2, 3]ইতোমধ্যে পোস্ট করার মতো সহজ এবং দক্ষ সমাধান
>>> x[:] = [v for v in x if v != 2]
>>> x
[1, 3, 4, 3]আরেকটি সম্ভাবনা যা কম স্মৃতি ব্যবহার করতে হবে তবে ধীর হওয়া উচিত
>>> for i in range(len(x) - 1, -1, -1):
if x[i] == 2:
x.pop(i) # takes time ~ len(x) - i
>>> x
[1, 3, 4, 3]10% মেলানো এন্ট্রি সহ 1000 এবং 100000 দৈর্ঘ্যের তালিকার সময়সীমার ফলাফল: 0.16 বনাম 0.25 এমএস, এবং 23 বনাম 123 এমএস।
পাইথন তালিকা থেকে একটি মানের সমস্ত ঘটনা সরিয়ে ফেলুন
lists = [6.9,7,8.9,3,5,4.9,1,2.9,7,9,12.9,10.9,11,7]
def remove_values_from_list():
for list in lists:
if(list!=7):
print(list)
remove_values_from_list()ফলাফল: 6.9 8.9 3 5 4.9 1 2.9 9 12.9 10.9 11
অন্যথা,
lists = [6.9,7,8.9,3,5,4.9,1,2.9,7,9,12.9,10.9,11,7]
def remove_values_from_list(remove):
for list in lists:
if(list!=remove):
print(list)
remove_values_from_list(7)ফলাফল: 6.9 8.9 3 5 4.9 1 2.9 9 12.9 10.9 11
যদি আপনি অন্তর্নির্মিত না থাকেন filterবা অতিরিক্ত স্থান ব্যবহার করতে না চান এবং আপনার একটি রৈখিক সমাধান প্রয়োজন ...
def remove_all(A, v):
k = 0
n = len(A)
for i in range(n):
if A[i] != v:
A[k] = A[i]
k += 1
A = A[:k]hello = ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
#chech every item for a match
for item in range(len(hello)-1):
if hello[item] == ' ':
#if there is a match, rebuild the list with the list before the item + the list after the item
hello = hello[:item] + hello [item + 1:]
print hello['ওহে বিশ্ব']
আমরা ইন-জায়গা সব ব্যবহার হয় অপসারণ করতে পারি না delবা pop:
import random
def remove_values_from_list(lst, target):
if type(lst) != list:
return lst
i = 0
while i < len(lst):
if lst[i] == target:
lst.pop(i) # length decreased by 1 already
else:
i += 1
return lst
remove_values_from_list(None, 2)
remove_values_from_list([], 2)
remove_values_from_list([1, 2, 3, 4, 2, 2, 3], 2)
lst = remove_values_from_list([random.randrange(0, 10) for x in range(1000000)], 2)
print(len(lst))
দক্ষতার জন্য এখন:
In [21]: %timeit -n1 -r1 x = random.randrange(0,10)
1 loop, best of 1: 43.5 us per loop
In [22]: %timeit -n1 -r1 lst = [random.randrange(0, 10) for x in range(1000000)]
g1 loop, best of 1: 660 ms per loop
In [23]: %timeit -n1 -r1 lst = remove_values_from_list([random.randrange(0, 10) for x in range(1000000)]
...: , random.randrange(0,10))
1 loop, best of 1: 11.5 s per loop
In [27]: %timeit -n1 -r1 x = random.randrange(0,10); lst = [a for a in [random.randrange(0, 10) for x in
...: range(1000000)] if x != a]
1 loop, best of 1: 710 ms per loop
যেমনটি আমরা দেখতে পাই যে স্থানটিতে সংস্করণে remove_values_from_list()কোনও অতিরিক্ত মেমরির প্রয়োজন হয় না, তবে এটি চালাতে আরও অনেক বেশি সময় লাগে:
- ইনপ্লেস মানগুলি সরানোর জন্য 11 সেকেন্ড
- তালিকা বোধগম্যতার জন্য 710 মিলি সেকেন্ড , যা মেমরিতে নতুন তালিকা বরাদ্দ করে
সময় এবং স্থান জটিলতার জন্য কেউই সর্বোত্তম উত্তর পোস্ট করেনি, তাই আমি ভেবেছিলাম আমি এটিকে একটি শট দেব। এখানে একটি সমাধান যা একটি নতুন অ্যারে তৈরি না করে এবং একটি কার্যকর সময়ের জটিলতায় নির্দিষ্ট মানটির সমস্ত উপস্থিতি সরিয়ে দেয়। অপূর্ণতা হ'ল উপাদানগুলি শৃঙ্খলা বজায় রাখে না ।
সময়ের জটিলতা: ও (এন)
অতিরিক্ত স্থান জটিলতা: ও (1)
def main():
test_case([1, 2, 3, 4, 2, 2, 3], 2) # [1, 3, 3, 4]
test_case([3, 3, 3], 3) # []
test_case([1, 1, 1], 3) # [1, 1, 1]
def test_case(test_val, remove_val):
remove_element_in_place(test_val, remove_val)
print(test_val)
def remove_element_in_place(my_list, remove_value):
length_my_list = len(my_list)
swap_idx = length_my_list - 1
for idx in range(length_my_list - 1, -1, -1):
if my_list[idx] == remove_value:
my_list[idx], my_list[swap_idx] = my_list[swap_idx], my_list[idx]
swap_idx -= 1
for pop_idx in range(length_my_list - swap_idx - 1):
my_list.pop() # O(1) operation
if __name__ == '__main__':
main()গতি সম্পর্কে!
import time
s_time = time.time()
print 'start'
a = range(100000000)
del a[:]
print 'finished in %0.2f' % (time.time() - s_time)
# start
# finished in 3.25
s_time = time.time()
print 'start'
a = range(100000000)
a = []
print 'finished in %0.2f' % (time.time() - s_time)
# start
# finished in 2.11কি সমস্যা:
Motor=['1','2','2']
For i in Motor:
If i != '2':
Print(i)
Print(motor)অ্যানাকোন্ডা ব্যবহার করা হচ্ছে