2016-11-09 16 views
8
निम्नलिखित की जांच एक साधारण सूची में

तुच्छ है:चेक अगर एक आइटम एक नेस्टेड सूची में है

x = [[1, 2, 3], [2, 3, 4]] 

2 in x -> False 

यह कैसे कर सकते हैं:

x = [1, 2, 3] 

2 in x -> True 

लेकिन अगर यह इस तरह के रूप सूची की एक सूची है, True वापस करने के लिए संबोधित किया जाना चाहिए?

उत्तर

8

अंतर्निहित any फ़ंक्शन का उपयोग करके इसे आजमाएं। यह सबसे मुहावरेदार समाधान है, और यह भी कुशल है, क्योंकि any शॉर्ट सर्किट और के रूप में यह पहला मैच पाता है बंद हो जाता है के रूप में जल्द:

x = [[1, 2, 3], [2, 3, 4]] 
any(2 in sl for sl in x) 
=> True 
+0

इस मामले में क्या है? – DenCowboy

+0

बस एक परिवर्तनीय नाम है, यह "उप-सूची" –

+0

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

2

यह काम करेगा:

for arr in x: 
    if 2 in arr: 
     print True 
     break 

मैं ऑस्कर के जवाब की सिफारिश करेंगे any के रूप में यहां सही विकल्प है।

+0

यह तब तक काम नहीं करेगा जब तक कि तत्व अंतिम उपमहाद्वीप में न हो ... और इसके अलावा, तत्व को पहले पाया जाने पर शॉर्ट-सर्किट होना चाहिए। और यही है कि 'किसी भी' की आवश्यकता है, मेरा जवाब देखें। –

+0

बस परीक्षण किया गया और यह तब भी काम करता है, भले ही यह अंतिम उपन्यास में न हो। – KVISH

+0

नहीं, यह नहीं है। इसे 'x = [[3,3], [4,4]] के साथ परीक्षण करें और यह काम करेगा, भले ही इसे नहीं करना चाहिए। –

4

आप set.issubset() और itertools.chain() उपयोग कर सकते हैं:

In [55]: x = [[1, 2, 3], [2, 3, 4]] 

In [56]: {4}.issubset(chain.from_iterable(x)) 
Out[56]: True 

In [57]: {10}.issubset(chain.from_iterable(x)) 
Out[57]: False 

तुम भी कुशलता से कई मदों के लिए सदस्यता chek कर सकते हैं:

In [70]: {2, 4}.issubset(chain.from_iterable(x)) 
Out[70]: True 

In [71]: {2, 4, 10}.issubset(chain.from_iterable(x)) 
Out[71]: False 
7

यहाँ एक पुनरावर्ती संस्करण है कि घोंसले के किसी भी स्तर के लिए काम करता है।

def in_nested_list(my_list, item): 
    """ 
    Determines if an item is in my_list, even if nested in a lower-level list. 
    """ 
    if item in my_list: 
     return True 
    else: 
     return any(in_nested_list(sublist, item) for sublist in my_list if isinstance(sublist, list)) 

यहाँ कुछ परीक्षण कर रहे हैं:

x = [1, 3, [1, 2, 3], [2, 3, 4], [3, 4, [], [2, 3, 'a']]] 
print in_nested_list(x, 2) 
print in_nested_list(x, 5) 
print in_nested_list(x, 'a') 
print in_nested_list(x, 'b') 
print in_nested_list(x, []) 
print in_nested_list(x, [1, 2]) 
print in_nested_list(x, [1, 2, 3]) 

True 
False 
True 
False 
True 
False 
True 
1

टी एल; डॉ

x = [0, [1, 2, 3], [2, 3, [4, 5, [6], []], [7, 8]]] 
def find_n(input_list, n): 
    for el in input_list: 
     if el == n or (isinstance(el, list) and find_n(el, n)): 
      return True 
    return False 
print(find_n(x, 6)) 

ध्यान दें कि, कुछ हद तक दिलचस्प है:

def find_n(input_list, n): 
    return any([el == n or (isinstance(el, list) and find_n(el, n)) for el in input_list]) 
return (find_n(x, 6)) 

50% से अधिक धीमी हैनिष्पादन हेतु।

मूल उत्तर (रों)

क्या आप 2 से अधिक गहराई है तो क्या होगा? यहाँ सामान्य मामले के लिए एक दृष्टिकोण है: हालांकि

x = [0, [1, 2, 3], [2, 3, [4, 5, [6], []], [7, 8]]] 

def flatten(input_list): 
    flat_list = [] 
    for sublist_or_el in input_list: 
     if isinstance(sublist_or_el, list): 
      for sublist_or_el2 in flatten(sublist_or_el): 
       flat_list.append(sublist_or_el2) 
     else: 
      flat_list.append(sublist_or_el) 
    return flat_list 

print(6 in flatten(x)) 

गति के बारे में सुनिश्चित नहीं हैं, लेकिन जैसा कि मैंने कहा, यह एक दृष्टिकोण है कि किसी के लिए उपयोगी हो सकता है है!

संपादित करें - बेहतर (तेज) उत्तर:

यह (यदि n पाया जाता है, वास्तव में, भले ही यह नहीं पाया जाता है, के बारे में आधे समय वास्तव में ...) जल्दी वापस लौट कर लिया गया समय कम कर देता है। यह @ कर्ट एफ के उत्तर से थोड़ा तेज़ है, और एक ऐसा फ़ंक्शन बनाने से धीमा है जो अधिकतम गहराई (स्वीकार्य उत्तर) मानता है।

x = [0, [1, 2, 3], [2, 3, [4, 5, [6], []], [7, 8]]] 
def find_n(input_list, n): 
    flat_list = [] 
    for sublist_or_el in input_list: 
     if isinstance(sublist_or_el, list): 
      if find_n(sublist_or_el, n) == True: 
       return True 
     elif sublist_or_el == n: 
      return True 
    return False 
print(find_n(x, 6)) 

त्वरित समय (बहुत hacky, माफ करना, आज व्यस्त!):

import time 

x = [0, [1, 2, 3], [2, 3, [4, 5, [6], []], [7, 8]]] 

def a(): 
    def flatten(input_list): 
     flat_list = [] 
     for sublist_or_el in input_list: 
      if isinstance(sublist_or_el, list): 
       for sublist_or_el2 in flatten(sublist_or_el): 
        flat_list.append(sublist_or_el2) 
      else: 
       flat_list.append(sublist_or_el) 
     return flat_list 
    return (6 in flatten(x)) 

def b(): 
    def find_n(input_list, n): 
     flat_list = [] 
     for sublist_or_el in input_list: 
      if isinstance(sublist_or_el, list): 
       if find_n(sublist_or_el, n) == True: 
        return True 
      elif sublist_or_el == n: 
       return True 
     return False 
    return (find_n(x, 6)) 


zz = 0 
for i in range(100000): 
    start_time = time.clock() 
    res = a() 
    zz += time.clock() - start_time 
print(a()) 
print((zz)/100, "seconds") 

zz = 0 
for i in range(100000): 
    start_time = time.clock() 
    res = b() 
    zz += time.clock() - start_time 
print(b()) 
print((zz)/100, "seconds") 
0

कोशिश

2 in [i for sublist in x for i in sublist] 
0

मेरे कोड Oscar Lopez के समाधान पर आधारित है। उनका समाधान बिल्कुल मेरी समस्या के लिए जरूरी नहीं था, लेकिन मेरी समस्या का पता लगाने के लिए उसने पर्याप्त जानकारी दी। तो यदि आपके पास एक सूची में तत्वों को घोंसला है और यह देखने की आवश्यकता है कि वे किसी अन्य नेस्टेड सूची में हैं, तो यह काम करेगा।

#!python2 

lst1 = [['a', '1'], ['b', '2'], ['c', '3'], ['d', '4'], ['e', '5']] 
lst2 = [['b', '2'], ['d', '4'], ['f', '6'], ['h', '8'], ['j', '10'], ['l', '12'], ['n', '14']] 

# prints lst1[0] items that aren't in lst2 
for i in lst1: 
    if not any(i[0] in sublst for sublst in lst2): 
     print i 
''' 
['a', '1'] 
['c', '3'] 
['e', '5'] 
''' 

print 

# prints lst2[0] items that aren't in lst1 
for i in lst2: 
    if not any(i[0] in sublst for sublst in lst1): 
     print i 
''' 
['f', '6'] 
['h', '8'] 
['j', '10'] 
['l', '12'] 
['n', '14'] 
''' 
संबंधित मुद्दे