Wie überprüft man, ob ein Wert in einer geschachtelten Liste ist

Question

Ich möchte prüfen, ob ein bestimmter Wert in einer geschachtelten Liste ist. Ich habe eine Hauptliste bekam, die mehrere Listen enthält, die mehrere Listen enthalten kann und so weiter .. Genau wie folgt aus:

[['Hey', 1], 0, 0, 0, ['Heyyy', 1], [[['Hi', 1], ['Hiii', 1]], 
['Hola', 1]], ['Hollaa', 2], ['Hallo', 1], 0, ['Hallooo', 1]] 

Jetzt habe ich zum Beispiel prüfen möchten, ob es ‚Hiii‘ in einer der Listen und wenn das True ist, möchte ich den zweiten Wert der Liste ändern.

Ich habe es bisher mit Rekursion und einem Generator versucht, aber ich weiß eigentlich nicht, wie das funktionieren soll .. Und ich weiß nicht, wie ich den zweiten Wert der Listen ändern könnte ...

def search(nested_list): 
    for value in nested_list: 
     for subvalue in search(value): 
      yield subvalue 

Vielen Dank für Ihre Hilfe im Voraus!

Answer 1

Gegeben:

LoL=[['Hey', 1], 0, 0, 0, ['Heyyy', 1], [[['Hi', 1], ['Hiii', 1]], 
['Hola', 1]], ['Hollaa', 2], ['Hallo', 1], 0, ['Hallooo', 1]] 

Um Prüfung wenn ein Wert in einer Liste von Listen ist, hat zunächst einen Generator eine beliebige Liste von Listen zu glätten:

def flatten(it): 
    for x in it: 
     if (isinstance(x, collections.Iterable) and 
      not isinstance(x, str)): 
      yield from flatten(x) 
     else: 
      yield x 

Dann nutzen any:

>>> any(x=="Hiii" for x in flatten(LoL)) 
True 
>>> any(x=="BooHoo" for x in flatten(LoL)) 
False 

---

Um Änderung eine Liste von Listen an Ort und Stelle:

def LoLedit(li, tgt, nv): 
    if isinstance(li, list): 
     if li[0]==tgt: 
      li[1]=nv 
     else: 
      for next_item in li: 
       LoLedit(next_item, tgt, nv) 
    return li 

>>> LoLedit(LoL,"Hiii", "Changed") 
[['Hey', 1], 0, 0, 0, ['Heyyy', 1], [[['Hi', 1], ['Hiii', 'Changed']], ['Hola', 1]], ['Hollaa', 2], ['Hallo', 1], 0, ['Hallooo', 1]] 

Answer 2

Eine sehr einfache rekursive Funktion zu finden und den Wert zu aktualisieren.

def search(n_list): 
    for i in n_list: 
     if isinstance(i, list): 
      search(i) 
     elif i == 'Hiii': 
      try: 
       n_list[1] = # your value here 
      except: 
       pass 

Answer 3

Sie sind auf einem guten Weg, aber Sie nicht über eine Generatorfunktion hier brauchen - einfache Rekursion w/finden & Änderung ausreichen würde:

def search(source, find, new_value): 
    if isinstance(source, list): # no point searching in non-lists 
     if find in source: 
      source[1] = new_value 
     else: 
      for item in source: 
       search(item, find, new_value) 


data = [['Hey', 1], 0, 0, 0, ['Heyyy', 1], [[['Hi', 1], ['Hiii', 1]], ['Hola', 1]], 
     ['Hollaa', 2], ['Hallo', 1], 0, ['Hallooo', 1]] 

search(data, "Hiii", 5) 

print(data) 
# prints: 
# [['Hey', 1], 0, 0, 0, ['Heyyy', 1], [[['Hi', 1], ['Hiii', 5]], ['Hola', 1]], 
# ['Hollaa', 2], ['Hallo', 1], 0, ['Hallooo', 1]] 

Das setzt voraus, dass Sie don‘ Ich möchte tiefer suchen, sobald Sie Ihren Artikel gefunden haben.

Answer 4

Ein anderer Weg, wenn ein bestimmte Wert in einer verschachtelten Liste (eine Liste von Listen) ist zu überprüfen recursion Verwendung erfolgen:

# Flatten the list of lists into a simple list 
def flatten_list(my_list, final=None):          
    if final is None:            
     final = [] 

    for i in my_list: 
     if isinstance(i, list): 
      flatten_list(i, my_list) 
     else: 
      final.append(i) 

    return final 

a = [['Hey', 1], 0, 0, 0, ['Heyyy', 1], [[['Hi', 1], ['Hiii', 1]], 
['Hola', 1]], ['Hollaa', 2], ['Hallo', 1], 0, ['Hallooo', 1]] 

check_element = lambda x, y: x in flatten_list(y) 

# Some tests: 
print(check_element('hey', a)) 
print(check_element('Hey', a)) 
print(check_element('Heyyy', a)) 
print(check_element('Hiii', a)) 
print(check_element(1, a)) 
print(check_element('foo', a)) 

Ausgang:

False 
True 
True 
True 
True 
False