एक अनुमानित

Question

के आधार पर किसी सूची से किसी तत्व को निकालना, मैं सूची से तत्व को हटाना चाहता हूं, जैसे कि तत्व 'X' या 'N' है। मुझे एक बड़े जीनोम के लिए आवेदन करना है। यहाँ एक उदाहरण है:

इनपुट:

codon=['AAT','XAC','ANT','TTA'] 

उम्मीद उत्पादन:

codon=['AAT','TTA'] 

Answer 1

वहाँ भी फिल्टर

list = filter(lambda x: 'X' not in x and 'N' not in x, list) 

Answer 2

का उपयोग कर आधार उद्देश्य

के लिए यह करने की विधि है

>>> [x for x in ['AAT','XAC','ANT','TTA'] if "X" not in x and "N" not in x] 
['AAT', 'TTA'] 

लेकिन अगर आप डेटा की बड़ी राशि है, मैं सुझाव है कि आप dict का उपयोग करें या

स्थापित करने के लिए और आप कई एक्स और एन से अन्य पात्रों की, तो आप इस

>>> [x for x in ['AAT','XAC','ANT','TTA'] if not any(ch for ch in list(x) if ch in ["X","N","Y","Z","K","J"])] 
['AAT', 'TTA'] 

नोट की तरह कर सकते हैं: list(x) सिर्फ x हो सकता है, और ["X","N","Y","Z","K","J"] केवल "XNYZKJ" हो सकता है, और gnibbler उत्तर देखें, उसने सबसे अच्छा किया।

Answer 3

1. filter(lambda x: 'N' not in x or 'X' not in x, your_list)
2. your_list = [x for x in your_list if 'N' not in x or 'X' not in x]

Answer 4

एक और नहीं सबसे तेज़ तरीका है, लेकिन मैं यह अच्छी तरह

>>> [x for x in ['AAT','XAC','ANT','TTA'] if not any(y in x for y in "XN")] 
['AAT', 'TTA'] 

>>> [x for x in ['AAT','XAC','ANT','TTA'] if not set("XN")&set(x)] 
['AAT', 'TTA'] 

पढ़ता है इस तरह से लंबे समय तक कोडोन के लिए तेजी से हो जाएगा (यह मानते हुए कुछ पुनरावृत्ति होती है) लगता है

codon = ['AAT','XAC','ANT','TTA'] 
def pred(s,memo={}): 
    if s not in memo: 
     memo[s]=not any(y in s for y in "XN") 
    return memo[s] 

print filter(pred,codon) 

यहाँ विधि जेम्स ब्रूक्स ने सुझाव दिया है, आप अपने डेटा

codon = ['AAT','XAC','ANT','TTA'] 
def pred(s,memo={}): 
    if s not in memo: 
     memo[s]= not set("XN")&set(s) 
    return memo[s] 

print filter(pred,codon) 

इस नमूने कोडोन के लिए के लिए है जो देखने के लिए तेजी से परीक्षण करने के लिए होगा, सेट का उपयोग कर संस्करण के बारे में 10% धीमी है

Answer 5

एस। मार्क ने यहां अनुरोध किया है कि मेरा संस्करण है। यह शायद धीमा है लेकिन जो भी हटाया जाता है उसे बदलने में आसान बनाता है।

def filter_genome(genome, killlist = set("X N".split()): 
    return [codon for codon in genome if 0 == len(set(codon) | killlist)] 

Answer 6

संपूर्ण सूची को डुप्लिकेट करने का कोई कारण? कैसे के बारे में:

>>> def pred(item, haystack="XN"): 
...  return any(needle in item for needle in haystack) 
... 
>>> lst = ['AAT', 'XAC', 'ANT', 'TTA'] 
>>> idx = 0 
>>> while idx < len(lst): 
...  if pred(lst[idx]): 
...   del lst[idx] 
...  else: 
...   idx = idx + 1 
... 
>>> lst 
['AAT', 'TTA'] 

मुझे पता है कि सूची comprehensions हैं सब क्रोध इन दिनों, लेकिन हम सही बिना किसी कारण के यह नकल नहीं करना चाहती है, तो सूची लंबी है? आप अगले चरण के लिए इस लेने के लिए और एक अच्छा उपयोगिता समारोह बना सकते हैं:

>>> def remove_if(coll, predicate): 
...  idx = len(coll) - 1 
...  while idx >= 0: 
...   if predicate(coll[idx]): 
...    del coll[idx] 
...   idx = idx - 1 
...  return coll 
... 
>>> lst = ['AAT', 'XAC', 'ANT', 'TTA'] 
>>> remove_if(lst, pred) 
['AAT', 'TTA'] 
>>> lst 
['AAT', 'TTA'] 

Answer 7

मैं के gnibbler Memoization तरह एक बहुत दृष्टिकोण। बड़े डेटा सेट पर बड़ी तस्वीर में ज्ञापन का उपयोग करने वाली विधि को समान रूप से तेज़ होना चाहिए, क्योंकि ज्ञापन शब्दकोश को जल्दी से भरना चाहिए और वास्तविक परीक्षण शायद ही कभी किया जाना चाहिए।इस बात को ध्यान में रखते हुए, हम बड़े डेटा सेट के लिए प्रदर्शन को और भी बेहतर बनाने में सक्षम होना चाहिए। (यह बहुत कम कीमतों के लिए कुछ कीमतों पर आता है, लेकिन उन लोगों की परवाह कौन करता है?) निम्नलिखित कोड को केवल दो बार की बजाय ज्ञापन के दौरान एक आइटम को देखना होगा (एक बार सदस्यता निर्धारित करने के लिए, निकालने के लिए दूसरा महत्व)।

codon = ['AAT', 'XAC', 'ANT', 'TTA'] 
def pred(s,memo={}): 
    try: 
     return memo[s] 
    except KeyError: 
     memo[s] = not any(y in s for y in "XN") 
    return memo[s] 

filtered = filter(pred, codon) 

जैसा कि मैंने कहा था, जीनोम बड़ा होने पर यह काफी तेज़ होना चाहिए (या कम से कम बहुत छोटा नहीं)।

आप सूची नकल करने, लेकिन सिर्फ फ़िल्टर की गई सूची से अधिक पुनरावृति, की तरह कुछ करना नहीं चाहते हैं:

for item in (item for item in codon if pred): 
    do_something(item) 

Answer 8

यह (asympotically) तेजी से एक रेगुलर एक्सप्रेशन में कई बार खोज से उपयोग करने के लिए है एक निश्चित चरित्र के लिए एक ही स्ट्रिंग: असल में, एक नियमित अभिव्यक्ति के साथ अनुक्रम केवल एक बार पढ़ा जाता है (उदाहरण के लिए, जब अक्षरों को नहीं मिलता है, तो अक्षरों को नहीं मिलता है)। gnibbler के Memoization के साथ, नियमित अभिव्यक्ति दृष्टिकोण पढ़ता है:

import re 
remove = re.compile('[XN]').search 

codon = ['AAT','XAC','ANT','TTA'] 
def pred(s,memo={}): 
    if s not in memo: 
     memo[s]= not remove(s) 
    return memo[s] 

print filter(pred,codon) 

यह होना चाहिए (asymptotically) "में" का उपयोग या "सेट" जाँच करता है की तुलना में तेजी (यानी, इसके बाद के संस्करण कोड काफी देर तक तार के लिए तेजी से होना चाहिए s)।

मैं मूल रूप से सोचा था कि gnibbler के जवाब dict.setdefault() के साथ एक तेजी से और अधिक कॉम्पैक्ट तरह से लिखा जा सकता है:

codon = ['AAT','XAC','ANT','TTA'] 
def pred(s,memo={}): 
    return memo.setdefault(s, not any(y in s for y in "XN")) 

print filter(pred,codon) 

लेकिन, जैसा कि gnibbler बताया गया है, SetDefault में मान हमेशा मूल्यांकन किया जाता है (भले ही सिद्धांत रूप में, इसका मूल्यांकन तब किया जा सकता है जब शब्दकोश कुंजी नहीं मिलती)।

Answer 9

यदि आप अत्यधिक बड़ी सूचियों से निपट रहे हैं, तो आप उन विधियों का उपयोग करना चाहते हैं जिनमें पूरी सूची को पूरी तरह से करने की आवश्यकता नहीं है।

आपका सबसे अच्छा शर्त होने की संभावना एक फिल्टर समारोह बनाने के लिए किया जाएगा, और itertools.ifilter का उपयोग कर, उदा .:

new_seq = itertools.ifilter(lambda x: 'X' in x or 'N' in x, seq) 

यह वास्तव में सूची में प्रत्येक तत्व का परीक्षण defers जब तक आप वास्तव में इस पर पुनरावृति है। नोट यदि आपको फ़िल्टर अनुक्रम फ़िल्टर कर सकते हैं कि बस के रूप में आप कर सकते हैं मूल अनुक्रम:

new_seq1 = itertools.ifilter(some_other_predicate, new_seq) 

संपादित करें:

इसके अलावा, एक छोटे से परीक्षण से पता चलता है कि memoizing एक सेट में प्रविष्टि नहीं मिली के लिए पर्याप्त मिलने की संभावना है

seq = ['AAT','XAC','ANT','TTA'] 
>>> p = re.compile('[X|N]') 
>>> timeit.timeit('[x for x in seq if not p.search(x)]', 'from __main__ import p, seq') 
3.4722548536196314 
>>> timeit.timeit('[x for x in seq if "X" not in x and "N" not in x]', 'from __main__ import seq') 
1.0560532134670666 
>>> s = set(('XAC', 'ANT')) 
>>> timeit.timeit('[x for x in seq if x not in s]', 'from __main__ import s, seq') 
0.87923730529996647