Die überprüfung für die Unterliste in der Liste

Die Frage ist: Sie schreiben eine Funktion, genannt isSublist(), die zwei Argumente nimmt (list, sublist) und zurück 1 wenn Teilliste ist eine Teilliste der Liste, und sonst 0.

Also ich habe meinen code, jedoch bekomme ich True wenn die Unterliste ist nicht in der Liste. Irgendwelche Vorschläge, dies zu beheben, bitte?

 def isSublist(list, sublist):
    for i in range(len(list)-(len(sublist))+1):
        return True
    if sublist==list[i:i+(len(sublist))]:
        return False

Beispiel für die Eingabe:

list= (0,1,2,3,4,5,6,7,8,9)
isSublist(list, [1,2,3])
output:
True

Können Sie Beispiel für die Eingabe und erwartete Ausgabe? Wenn Sie sagen, Teilliste, meinst du wie in [1,2,3] in [[1,2,3], [5,6,7]] oder meinst du [1,2,3] in [1,2,3,4,5,6]?
Bitte definieren Sie kurz, was meinst du mit eine Unterliste einer Liste
Und nicht, um zu zählen? Möchten Sie den gleichen Ausgang für die beiden Teillisten [1, 2, 3] und [2, 3, 1]?
durch die Unterliste ich meine in der Liste [1,2,3,4] ist die Teilliste von [1,2] in der Liste. Wenn also print True, wenn nicht False
Was sublist = [2, 1]? Und was ist, wenn list = [1, 1, 2, 2, 3] und sublist = [1, 2, 3]?
die Teilliste nicht in umgekehrter Richtung. die Unterliste muss in der Liste erscheinen, genau wie die Liste

InformationsquelleAutor user2898221 | 2013-11-14

python sublist

Brechen Sie dies, indem Sie immer alle Scheiben die Größe der Teilliste und der Vergleich der Geschlechter:

def n_slices(n, list_):
    for i in xrange(len(list_) + 1 - n):
        yield list_[i:i+n]

def isSublist(list_, sub_list):
    for slice_ in n_slices(len(sub_list), list_):
        if slice_ == sub_list:
            return True
    return False

Zur Deckung der Ausgabe der Bestellung. Eine Liste ist, per definition, bestellt. Wenn wir wollen, zu ignorieren, die Bestellung, die Sie tun können, setzt:

def isSubset(list_, sub_list):
    return set(sub_list) <= set(list_)

Wenn wir abdecken müssen wiederholte Elemente und ignorieren Bestellung, du bist jetzt im Reich der multimengen:

def isSubset(list_, sub_list):
    for item in sub_list:
        if sub_list.count(item) > list_.count(item):
            return False
    return True

Dies ist die einzige Antwort, dass funktioniert so weit.
Sätze haben eine <= operator, keine union. return set(sub_list) <= set(list_)

InformationsquelleAutor John Spong

0
```
>>> def isSublist(originallist,sublist,biglist):
    if not sublist:
        return True
    if not biglist:
        return False
    if sublist[0]==biglist[0]:
        return isSublist(originallist,sublist[1:],biglist[1:]) or isSublist(originallist,sublist,biglist[1:])
    return isSublist(originallist,originallist,biglist[1:])
```
test Ausgabe:
```
>>> isSublist([1,2,4],[1,2,4],[1,2,3,4])
False
>>> isSublist([1,2,3],[1,2,3],[1,2,3,4])
True
>>> 
```
Bearbeitet für unterlisten, die nicht Teilmenge. Hässlicher, aber arbeitet. Hinzufügen könnte ein wrapper um Verwirrung zu vermeiden der Parameter.
```
def sublist(a,b):
    isSublist(a,a,b)
```
- isSublist([1, 2, 4], [1, 2, 3, 4]) zurück True falsch.
- OP hat nicht angegeben, wenn die Reihenfolge von Bedeutung ist, so dass Sie coulnd möglicherweise nicht so sicher sein.
- Unterliste, die nicht Teilmenge. Teilmenge wäre eine einfache return set(sublist) <= set(list)
- Ich vermute, dass der OP den Unterschied nicht kennen zwischen den beiden..
- seine eine Unterliste nicht Teilmenge
InformationsquelleAutor C.B.
0

Teil des Problems ist, dass in Python(0,1,2,3,4,5,6,7,8,9)ist nicht technisch einlist, es ist eintuple - das ist im wesentlichen ein immutable (unveränderlich)list. Auch sollten Sie es vermeiden, benennen Dinge, die in Ihrem Programm die gleichen wie built-in-Funktionen und-Typen, denn Sie müssen gelegentlich auf Sie verweisen und Ihre eigene definition verbergen würde diejenigen, die vom system bereitgestellt werden.

Eine einfache Möglichkeit, dies zu umgehen, ist, einfach Anhängen einer_an das Ende des namens, wie in der folgenden, die versucht zu drehen, konvertiert das argument in einelistwenn es nicht eine zunächst. Es testet nicht die Art dersublist argument, aber eine ähnliche überprüfung kann sinnvoll sein für Sie, zu.
```
def isSublist(list_, sublist):
    if not isinstance(list_, list):
        list_ = list(list_)
    sublen = len(sublist)
    for i in xrange(len(list_)-sublen+1):
        if list_[i:i+sublen] == sublist:
            return True
    return False

list_ = (0,1,2,3,4,5,6,7,8,9)
print subfunc(list_, [0,1])  # --> True
print subfunc(list_, [1,2,3])  # --> True
print subfunc(list_, [4,6,7])  # --> False
print subfunc(list_, [4,5])  # --> True
```
InformationsquelleAutor martineau

def isSublist(x, y):
  occ = [i for i, a in enumerate(x) if a == y[0]]
  for b in occ:
      if x[b:b+len(y)] == y:
           print 'YES-- SUBLIST at : ', b
           return True
      else:
           pass
      if len(occ)-1 ==  occ.index(b):
           print 'NO SUBLIST'
           return False

list1 = [1,0,1,1,1,0,0]
list2 = [1,0,1,0,1,0,1]

#should return True
isSublist(list1, [1,1,1])

#Should return False
isSublist(list2, [1,1,1])

InformationsquelleAutor SuperNova

Ich habe nur geschrieben ein Rezept für das dieses (dies funktioniert für zusammenhängende Teilliste):

def is_sublist(sublist, superlist):  
    ''''' 
    Checks whether 'sublist' is a sublist of 'superlist'. 
    Both arguments must be typed list or tuple. 
    '''  
    if not isinstance(sublist, (list, tuple)) or not isinstance(sublist, (list,tuple)):  
        raise TypeError("Both 'sublist' and 'superlist' must be lists or tuples.")  
    # Return early if candidate sublist is longer than superlist  
    if len(sublist) > len(superlist):  
        return False  
    else:  
        for chunk in (superlist[i:i+len(sublist)] for i in range(0, len(superlist)-len(sublist)+1)):   
            if chunk == sublist:  
                return True  
        return False

Die Idee ist, eine Verlagerung Fenster (mit der gleichen Breite wie der Kandidat Teilliste) Scannen Sie die superlist und prüfen Sie die Gleichheit zwischen den chunk und die Teilliste, die bei jedem Durchlauf.

Dass ein brute-force-Methode.

Sorry, ich hatte nicht gesehen, dass die original post date und alle vorhandenen Antworten. Ich lasse meine Antwort als syntax-und Typ-überprüfung sind ein bisschen anders als die anderen Antworten.

InformationsquelleAutor Olivier H

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.