Python: Elegante und effiziente Wege zur Maske eine Liste

Beispiel:

from __future__ import division
import numpy as np

n = 8
"""masking lists"""
lst = range(n)
print lst

# the mask (filter)
msk = [(el>3) and (el<=6) for el in lst]
print msk

# use of the mask
print [lst[i] for i in xrange(len(lst)) if msk[i]]

"""masking arrays"""
ary = np.arange(n)
print ary

# the mask (filter)
msk = (ary>3)&(ary<=6)
print msk

# use of the mask
print ary[msk]                          # very elegant

und die Ergebnisse sind:

>>> 
[0, 1, 2, 3, 4, 5, 6, 7]
[False, False, False, False, True, True, True, False]
[4, 5, 6]
[0 1 2 3 4 5 6 7]
[False False False False  True  True  True False]
[4 5 6]

Als Sie sehen, die Bedienung der Maskierung auf array ist eleganter im Vergleich zur Liste. Wenn Sie versuchen, verwenden Sie die array-Maskierung Schema auf der Liste werden Sie einen Fehler erhalten:

>>> lst[msk]
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
TypeError: only integer arrays with one element can be converted to an index

Die Frage zu finden, ist eine elegante Maskierung für lists.

Updates:

Die Antwort von jamylak angenommen wurde, für die Einführung compress jedoch die Punkte erwähnt, die von Joel Cornett aus der Lösung abgeschlossen, um eine gewünschte form, die mich interessieren.

>>> mlist = MaskableList
>>> mlist(lst)[msk]
>>> [4, 5, 6]

InformationsquelleAutor Developer | 2012-04-23

Du suchst itertools.compress

Beispiel aus den docs

Entspricht:

def compress(data, selectors):
    # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
    return (d for d, s in izip(data, selectors) if s)

InformationsquelleAutor jamylak

7

Seit jamylak die Frage bereits beantwortet, eine praktische Antwort, hier ist mein Beispiel für eine Liste mit eingebauter Maskierung support (völlig unnötig, btw):
```
from itertools import compress
class MaskableList(list):
    def __getitem__(self, index):
        try: return super(MaskableList, self).__getitem__(index)
        except TypeError: return MaskableList(compress(self, index))
```
Verwendung:
```
>>> myList = MaskableList(range(10))
>>> myList
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> mask = [0, 1, 1, 0]
>>> myList[mask]
[1, 2]
```
Beachten Sie, dass compress beendet, wenn entweder die Daten oder die Maske läuft. Wenn Sie möchten, halten Sie den Teil der Liste, die erstreckt sich über die Länge der Maske, die Sie könnten versuchen, so etwas wie:
```
from itertools import izip_longest

[i[0] for i in izip_longest(myList, mask[:len(myList)], fillvalue=True) if i[1]]
```
- +1 Danke, dass Sie für die Adressierung die gleiche Verwendung der Maskierung auf den Listen als arrays, indem Sie vorschlägt MaskableList. Es sieht sehr interessant und funktioniert sehr gut als mein Wunsch. Eine kurze Notiz ist, dass diese sind ein bisschen langsamer im Vergleich zu array-Maskierung. Hinzugefügt habe ich Ihre Punkte wie updates.
- Ich habe versucht, Ihre Lösung von einem MaskableList, aber ich habe einige Probleme re-instanziieren. Für jedes element in einer Schleife möchte ich diese Maske, indem Sie eine neue Liste: for i in arange(0,n): fts = MaskableList(F) sorter = argsort(A) result[i] = zip(fts[sorter],A[sorter]) aber jede iteration, fts[Sortierer] enthält die gleichen Werte, während sorter ist jedes mal anders. Ich normalerweise verwenden python eher als eine script-Sprache und somit bin ich nicht so vertraut mit Objekten.
- Ich habe es noch nicht getestet, die speziell, aber ein Grund, dass MaskableList könnte erheblich langsamer ist, weil der etwas teuer, exception handling, das geht. Versuchen Sie, die Umstellung der try...except um, so dass es versucht, standardmäßig Maske.
- Ich bin nicht vertraut mit argsort. Auch, was ist A, und was sind die Inhalte der F?
- argsort sortiert ein array und gibt die Liste der Indizes der ursprünglichen. A=[3.5,2.0,1.1,4.0]; argsort(A) zurückkehren würde [2,1,0,3]. F ist nur ein un-maskierbare Liste, lassen Sie uns sagen, ["A","B","C","D"], so zip(fts[sorter],A[sorter]) sollte Ausgabe: {"A":1.1,"B":2.0,"C":3.5,"D":4.0}
- Ah, gut das erste problem ist, dass MaskableList tun nicht, was Sie denken, es tut. Es liefert als Ergebnis eine binäre Maske (1, 0, oder True/False) auf eine Liste. Es wird nicht die Reihenfolge der Elemente gemäß Liste der Indizes. Zweitens zip(fts[sorter], A[sorter]) würde die Ausgabe eine Liste von Tupeln, aber Sie haben ein dict.
- Wenn ich eine Liste myList und eine Liste von Indizes b = argsort(A) - ich würde Sie newList = [myList[i] for i in b] das gewünschte Ergebnis zu erzielen.
- Zunächst muss ich korrigieren, mein Beispiel, das gewünschte Ergebnis ist natürlich {"C":1.1,"B":2.0,"A":3.5,"D":4.0}. Und Zweitens: ich hab ja eigentlich eine Schleife verwenden, um dies zu erreichen, wurde aber neugierig, warum gibt es keinen Weg, um 1-d array Indizierung. Dies würde sehen viel schlauer, da würde ich nicht verwenden, eine weitere for-Schleife
- Hmmm... Naja, technisch gesehen selbst die schnellsten array-Indizierung würde verlangen, dass Sie eine Schleife verwenden, die auf einer bestimmten Ebene der operation (ob das in Python oder in der zugrunde liegenden C-code ist abhängig von Ihrer Verwendung von map(), itertools und andere optimierte Werkzeuge). Da scheint es einen sehr langen Kommentar-thread, würde ich vorschlagen, du postest die Frage in Bezug auf unser Gespräch? Ich bin nicht super vertraut mit numpy und die Lösung, die Sie suchen, vielleicht schon gibt.
- Ich habe eine Frage hier: stackoverflow.com/questions/14664333/... nochmals vielen Dank für Ihre Ideen.
InformationsquelleAutor Joel Cornett

Wenn Sie mit Numpy, können Sie es leicht tun mit Numpy-array ohne die Installation einer anderen Bibliothek:

>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>> msk = [ True, False, False,  True,  True,  True,  True, False, False, False]
>> a = np.array(a) # convert list to numpy array
>> result = a[msk] # mask a
>> result.tolist()
[0, 3, 4, 5, 6]

InformationsquelleAutor biendltb

3

ich denke nicht, dass es elegant. Es ist kompakt, aber eher verwirrend, als das Konstrukt ist sehr anders als die meisten Sprachen.

Als Rossum hat gesagt, über design-Sprache, verbringen wir mehr Zeit mit Lesen als schreiben. Die obskuren Bau der Linie der code, desto unübersichtlicher wird es für andere, die möglicherweise nicht vertraut sind mit Python, obwohl Sie haben die volle Kompetenz in einer beliebigen Anzahl von anderen Sprachen.

Lesbarkeit Trumpf Kurzform Notationen Alltag in der realen Welt der Service-code. Ebenso wie die Festsetzung Ihr Auto. Große Zeichnungen mit vielen Informationen machen die Fehlersuche viel einfacher.

Für mich, ich würde viel lieber beheben jemand den code verwendet, die die lange form
```
print [lst[i] for i in xrange(len(lst)) if msk[i]]
```
als die numpy kurze Schreibweise Maske. Ich muss nicht irgendwelche speziellen Kenntnisse in einem bestimmten Python-Paket zu interpretieren sind.

InformationsquelleAutor Jim

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.