Überprüfen Element-Mitgliedschaft in set in Python

Hallo, ich habe schon die Codierung für ein paar Monate jetzt und kennen die Grundlagen, aber ich bin mit einem Satz membership-problem für das ich keine Lösung finden.

Habe ich eine Liste von Listen von Paaren von Integer-zahlen, und ich möchte, um die Liste zu löschen, die die "ein" integer in Ihnen. Ich dachte, mit Sätzen war der einfachste Weg. Balg ist der code:

## This is the item to test against. 
a = set([3]) 
## This is the list to test.      
groups = [[3, 2], [3, 4], [1, 2], [5, 4], [4, 3]]     

## This is a list that will contain the lists present
## in groups which do not contain "a"
groups_no_a = []        

for group in groups:
    group = set(group)
    if a in group:
        groups_no_a.append(group)
    ## I thought the problem had something to do with
    ## clearing the variable so I put this in,   
    ## but to no remedy. 
    group.clear()  


print groups_no_a

Hatte ich auch versucht, mit Hilfe s.issubset(t), bis ich erkannte, dass dies geprüft, wenn jeder element in s in t.

Danke!

InformationsquelleAutor grasshopper | 2013-08-18

python set

7

Den Sie testen möchten, wenn es keine Kreuzung:
```
if not a & group:
```
oder
```
if not a.intersection(group):
```
oder, Umgekehrt, dass die sets sind getrennten:
```
if a.isdisjoint(group):
```
Die Methode Formen nehmen alle iterierbar, Sie haben nicht einmal zu drehen group in eine Reihe für die. Der folgende Einzeiler würde auch funktionieren:
```
groups_no_a = [group for group in groups if a.isdisjoint(group)]
```
Demo:
```
>>> a = set([3]) 
>>> groups = [[3, 2], [3, 4], [1, 2], [5, 4], [4, 3]]     
>>> [group for group in groups if a.isdisjoint(group)]
[[1, 2], [5, 4]]
```
Wenn alle, die Sie testen, ist eine element, dann könnte es sein, dass das erstellen von sets kostet mehr Leistung als das, was Sie gewinnen in der Prüfung für die Mitgliedschaft, und nur tun:
```
3 not in group
```
wo group ist eine kurze Liste.

Können Sie die timeit - Modul zu vergleichen Stücke von Python-code, um zu sehen, was funktioniert am besten für Ihre spezifische typische Liste Größen.
- Es sei denn, ich habe falsch verstanden, die Frage, was er tun will, er braucht sich nicht setzt. Wie es aussieht, will er nur zu finden, wenn ein element in einer Liste, und beschlossen, die sets waren der Weg, dies zu tun, obwohl Sie es nicht sind.
- Und die Sätze sind schneller für die Aufgabe; one_element in somelist hat das Scannen der Liste.
- Ich war mir gar nicht bewusst, der disjunkt-option, es ist ein bisschen versteckt im link.
- das ist das veraltete Modul aus, bevor set wurde Hinzugefügt, als eine Art der Sprache.
- Optimierung ist die Wurzel allen übels". Ich bezweifle, dass die Verwendung von sets gewesen wäre, vorgeschlagen, falls die Frage sei nur gewesen, "wie um zu überprüfen, ob ein element in einer Liste". Auf jeden Fall habe ich Zweifel, wie groß jede Erhöhung der Leistung, wie Sie nur die Prüfung für die Mitgliedschaft in einer Liste mit 2 Elementen.
- Und vielleicht ist die OP gerade vereinfacht die Fälle hinunter zu sehr kleinen Teilmengen. Ohne das OP-feedback, die wir nicht kennen.
- Die Anwesenheit der Kommentare schon sagt, ist dieses eigentliche code. In jedem Fall würde, die Sie erwähnt haben, legt fest, ob die Frage sei nur gewesen, "zu prüfen, Wie das Vorhandensein eines Elements in einer Liste?"
- ja, je nach Kontext. Wenn der test wird wiederholt für verschiedene Werte (sagen wir, Zeilen in einer Datei), dann eine Reihe wäre eine viel bessere Wahl.
- wie für die Kommentare, diese klären die Frage. Sie don T Schlag mich als Teil der Erzeugung von code. Ich habe gesehen, lädt der Frage askers tun.
- Der häufigste Fall der Prüfung für die Mitgliedschaft ist für kleine Listen, wo in und not in geeignet sind. Also, ich würde sagen, dass sollte der Schwerpunkt einer Antwort, mit Sätzen erwähnt kürzer, was auf die Verwendung beider Methoden. Jedoch, deine Antwort ist das Gegenteil.
- Gut für diejenigen, die neugierig, was ich tun möchte ist; ich habe eine Liste wie die folgende: [ [Fehler, [ [group_item_1, group_item_2], [...], [...], [...] ] ], [mehr wie das Vorherige], [...] ], und ich möchte das Element mit der geringsten Fehler-und das nicht mit "a" in group_item_1 oder group_item_2. Die Listen bereits sortiert sind, indem Sie Fehler. Ich sorta fast es gehen 😀
InformationsquelleAutor Martijn Pieters

Vielleicht könnten Sie List Comprehension:

a = 3
groups = [[3, 2], [3, 4], [1, 2], [5, 4], [4, 3]]
print [x for x in groups if a not in x]

Bearbeiten, basierend auf einem Kommentar:

Gut für diejenigen, die neugierig, was ich tun möchte ist; ich habe eine Liste wie die
Folgendes ein: [ [Fehler, [ [group_item_1, group_item_2], [...], [...],
[...] ] ], [eher wie das Vorherige], [...] ], und ich will den
Element mit der geringsten Fehler-und das nicht mit "a" in group_item_1 oder
group_item_2. Die Listen bereits sortiert sind, indem Sie Fehler. Ich sorta fast gehen
es 😀

Dies sollte den trick tun:

from itertools import chain, iterfilter

def flatten(listOfLists):
    "Flatten one level of nesting"
    return chain.from_iterable(listOfLists)


errors_list =  [ ['error0', [ [30, 2], [3, 4], [1, 2], [5, 4], [4, 3] ] ], ['error1', [ [31, 2], [3, 4], [1, 2], [5, 4], [4, 3] ] ] ]

a = 30
result = next(ifilter(lambda err: a not in flatten(err[1]), reversed(errors_list)), None)

print result #finds error1 as it has no 30 on its list

Funktioniert Super, danke! Liste Verstehens eine Weile dauern, zu meistern...

InformationsquelleAutor lpiepiora

Anstatt a = set([3]), warum dann nicht Folgendes tun?

a = 3
groups = [[3, 2], [3, 4], [1, 2], [5, 4], [4, 3]]
groups_no_a = [group for group in groups if a not in group]

InformationsquelleAutor qaphla

-1

Brauchen Sie nicht zu verwenden, legt hier können Sie testen, für die Mitgliedschaft von Elementen in Listen. Sie scheinen auch zu haben in, wo ich denke, du solltest not in.

Dieser code ist ähnlich wie bei Ihnen, und sollte funktionieren:
```
## This is the item to test against. 
a = 3
## This is the list to test.      
groups = [[3, 2], [3, 4], [1, 2], [5, 4], [4, 3]]     

## This is a list that will contain the lists present
## in groups which do not contain a
groups_no_a = []        

for group in groups:
    if a not in group:
        groups_no_a.append(group)

print groups_no_a
```
Jedoch eine kürzere, mehr Pythonic way verwendet Liste Verstehens:
```
groups_no_a = [i for i in groups if a not in i]
```
Wenn Sie testen, ob ein Element in einer viel längeren Liste, die Sie verwenden sollten, setzt sich stattdessen für die Leistung.
- Oh Mann, wie konnte ich das übersehen... (peinlich)
InformationsquelleAutor rlms

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.