निम्नलिखित तर्क लागू करने के लिए पाइथोनिक तरीका क्या होना चाहिए?

Question

मैं एक सूची लूप करना चाहता हूं और यदि आवश्यकता को पूरा करता है तो तत्व को हटा देना चाहता हूं। साथ ही, मैं हटाए गए तत्व को बदल दूंगा और रूपांतरण परिणाम को दूसरी सूची में जोड़ूंगा।

delete_set = set([]) 

for item in my_list: 
    if meet_requirement(item): 
     another_list.append = transform(item) 
     delete_set.add(item) 

my_list = filter(lambda x:x not in delete_set, my_list) 

कोड है, तो सीधी-सपाट नहीं है वहाँ तर्क लागू करने के लिए एक बेहतर तरीका है:

अभी, मैं निम्नलिखित कोड से तर्क ऊपर लागू कर दिया है?

Answer 1

आप केवल समझ के साथ ऐसा कर सकते हैं।

delete_set = set(I for I in my_list if meet_requirement(I)) 
another_list.extend(transform(I) for I in delete_set) 
# or extend(transform(I) for I in my_list if I in delete_set), if duplicates/order matter 
my_list = [I for I in my_list if I not in delete_set] 

Answer 2

आप सेट से बचने के लिए ऐसा कर सकता है:

def part(items, others): 
    for item in items: 
     if meet_requirement(item): 
      others.append(item) 
     else: 
      yield item 

mylist[:] = part(mylist, another_list) 

Answer 3

>>> another_list = [] 
>>> new_list = [] 
>>> 
>>> for item in my_list: 
...  (another_list if meet_requirement(item) else new_list).append(item) 
... 
>>> another_list = map(transform, another_list) 
>>> my_list = new_list 

Answer 4

के बारे में सुनिश्चित नहीं हैं कि pythonic, लेकिन अगर अजगर एक partition समारोह हास्केल के समान था (या आप एक साधारण एक अपने आप को लिख सकता है), कोड को मूल सूची में दो बार फिर से शुरू करने की आवश्यकता नहीं होगी (जैसे कि बिल्ली प्लस 'समाधान में)।

मैं की तरह कुछ का प्रयोग करेंगे निम्नलिखित:

new_my_list, deleted_list = partition(my_list, meet_requirement) 
deleted_list = [transform(e) for e in deleted_list] 

Answer 5

आप इस

for i in reversed(xrange(len(my_list))): 
    if meet_requirement(my_list[i]): 
     another_list.append(transform(my_list.pop(i))) 

कर सकता है तो आप या another_list उल्टा करने के लिए नहीं चाहते हो सकता है हो सकता है (या आप एक deque और appendleft उपयोग कर सकते हैं)

Answer 6

zipped = zip(*[(item, transform(item)) for item in my_list \ 
               if meet_requirement(item)]) 
another_list = zipped[1] 
my_list = [item for item in my_list if item not in zipped[0]] 

Answer 7

मुझे कुछ अन्य डी की तरह कुछ चाहिए ay:

def partition(pred, iterable): 
    result = ([], []) 
    for each in iterable: 
     result[pred(each)].append(each) 
    return result 

xs = some_list  
ys, xs[:] = partition(meet_some_requirement, xs) 
ys = map(do_some_transformation, ys) 

या यह एक-पास भिन्नता:

def partition_and_transform(pred, iterable, *transform): 
    result = ([], []) 
    for each in iterable: 
     v = pred(each) 
     result[v].append(transform[v](each)) 
    return result 

ys, xs[:] = partition_and_transform(meet_some_reqirement, xs, do_some_transformation, lambda x:x)