Zugriff auf nicht aufeinanderfolgende Elemente in einer Liste oder einem string in python

Soweit ich kann sagen, dies ist nicht offiziell nicht möglich, aber gibt es einen "trick", um Zugriff auf beliebige nicht-sequentielle Elemente einer Liste durch aufschneiden?

Beispiel:

>>> L = range(0,101,10)
>>> L
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

Nun möchte ich in der Lage sein zu tun

a,b = L[2,5]

so, dass a == 20 und b == 50

Einen Weg neben den beiden Aussagen wäre etwas dummes wie:

a,b = L[2:6:3][:2]

Aber, dass nicht skaliert werden, bei der alle unregelmäßigen Abständen.

Vielleicht mit list comprehension mit den Indizes, die ich will?

[L[x] for x in [2,5]]

Ich würde gerne wissen, was es wird empfohlen, für dieses gemeinsame problem.

a,b = L[2],L[5]?
Das macht es einfach Aussehen, aber ich wollte wenden diese direkt an den Ausgang einer Funktion, die eine Liste zurückgibt, ohne einen Aufruf der Funktion zweimal oder re-Zuweisung, die eine variable und dann packte.
Ich bin geneigt zu sagen, dass Ihre Liste Einsicht ist das beste, was Sie tun können. Oder, wenn Sie nicht brauchen, eine aktuelle Liste, verwenden Sie einen generator-Ausdruck, wie in Shashank Gupta Antwort (obwohl, wenn Sie nur brauchen Sie es einmal, Sie könnten einfach die genexp inline, anstatt eine Funktion zurück).

InformationsquelleAutor beroe | 2013-10-02

8

Sowas?
```
def select(lst, *indices):
    return (lst[i] for i in indices)
```
Verwendung:
```
>>> def select(lst, *indices):
...     return (lst[i] for i in indices)
...
>>> L = range(0,101,10)
>>> a, b = select(L, 2, 5)
>>> a, b
(20, 50)
```
Die Art und Weise der Funktion ist durch Rücksendung eine generator-Objekt, die Durchlaufen werden können über ähnlich zu irgendeiner Art von Python-Sequenz.

Als @justhalf angemerkt in den Kommentaren, die Aufrufsyntax kann geändert werden, indem die Art und Weise definieren Sie die Parameter für die Funktion.
```
def select(lst, indices):
    return (lst[i] for i in indices)
```
Und dann könnte man die Funktion aufrufen mit:
```
select(L, [2, 5])
```
oder eine Liste Ihrer Wahl.

Update: ich jetzt empfehlen die Verwendung operator.itemgetter statt, es sei denn, Sie wirklich brauchen, die lazy evaluation Funktion von Generatoren. Sehen John Y s Antwort.
- Denken Sie, definieren der Funktion als select(lst, indices) und nannte es als select(L, [2,5]) besser wäre?
- Ja das ist möglich, ich mache eine Notiz.
- kurze Frage. die "*die Indizes" argument ist einfach nur "*args" Recht? aber mit einem anderen Namen?
- Ja, genau. 🙂 Das ist eine ganz alte Antwort aber, und ich würde empfehlen, mit operator.itemgetter statt, es sei denn, die lazy-evaluation-Funktion von Generatoren erforderlich ist.
InformationsquelleAutor Shashank
25

Wohl am nächsten, was du suchst, ist itemgetter (oder hier für Python 2 docs):
```
>>> L = list(range(0, 101, 10))  # works in Python 2 or 3
>>> L
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
>>> from operator import itemgetter
>>> itemgetter(2, 5)(L)
(20, 50)
```
- Gut, itemgetter ist sehr ähnlich zu Shashank Antwort, außer die, die sich schon in der Python-standard-Bibliothek.
- Es ist eine schöne Lösung toto, aber ich denke, die extra bis die Stimmen sind da, Sie kam etwas früher..., das ich letztlich wählte, die nicht erfordern eine import obwohl es hauptsächlich wickelte die OP in die definition einer Funktion.
- Es ist immer noch mehr neuen Stimmen auch nachdem Sie akzeptiert die andere Antwort, also der früheren Zeit hat nichts damit zu tun. Ich glaube, der Grund meiner Antwort ist immer mehr Stimmen, die erfahrene Python-Programmierer wird in der Regel lieber verwenden itemgetter als um eine neue Funktion definieren. Ein import ist kürzer und einfacher als eine definition einer Funktion.
- Macht Sinn. Ich mag es als eine Lösung. (Ich habe für es zu ;^)
- Für Python 3, die erste Zeile würde sich ändern >>> L = list(range(0, 101, 10)) zum ausführen der "identischen" Betrieb.
- true genug, aber ich war einfach zu bewahren, was war die ursprüngliche Frage. Ich denke, es könnte nicht Schaden, zu Bearbeiten, meine Antwort trotzdem.
InformationsquelleAutor John Y
11

Wenn Sie verwenden können numpy können Sie genau das tun:
```
>>> import numpy
>>> the_list = numpy.array(range(0,101,10))
>>> the_indices = [2,5,7]
>>> the_subset = the_list[the_indices]
>>> print the_subset, type(the_subset)
[20 50 70] <type 'numpy.ndarray'>
>>> print list(the_subset)
[20, 50, 70]
```
numpy.array ist sehr ähnlich zu list nur, dass es unterstützt mehr Betrieb, wie z.B. mathematische Operationen und auch beliebige index-Auswahl wie wir hier sehen.
- Dies sollte die akzeptierte Antwort, die ich fühle.
- Ich denke, der Grund, es ist nicht die akzeptierte Antwort ist, weil (a) es hat mehr aufblasen, und (b) es wird weniger verallgemeinert. (a): numpy ist eine große - Bibliothek, und diese Antwort zieht die ganze Sache in. (Vielleicht from numpy import array?) (b): numpy ist konkret für mathematische Operationen, so ist das weniger bekannte Leute, die den Fokus auf beispielsweise back-end-web-Entwicklung. itemgetter ist näher an "blanken" Python, erreicht ein breiteres Publikum.
- from numpy import array noch laden die ganze numpy-Paket, glaube ich. Aber du hast Recht, das wäre des guten zuviel, wenn die Liste nicht für mathematische Operationen verwendet.
InformationsquelleAutor justhalf
3

Nur der Vollständigkeit halber, die Methode von der ursprünglichen Frage ist ziemlich einfach. Würden Sie wollen, wickeln Sie es in eine Funktion, wenn L ist eine Funktion selbst, oder weisen Sie das Ergebnis der Funktion an eine variable vorher, damit es nicht immer wieder aufgerufen:
```
[L[x] for x in [2,5]]
```
Natürlich würde es auch für einen string...
```
["ABCDEF"[x] for x in [2,0,1]]
['C', 'A', 'B']
```
InformationsquelleAutor beroe

Keiner der anderen Antworten wird für die Arbeit mehrdimensionales Objekt schneiden. IMHO ist dies die Allgemeine Lösung (verwendet numpy):

numpy.ix_ ermöglicht Ihnen die Auswahl beliebiger Indizes in allen Dimensionen eines Arrays gleichzeitig.

z.B.:

>>> a = np.arange(10).reshape(2, 5) # create an array
>>> a
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
>>> ixgrid = np.ix_([0, 1], [2, 4]) # create the slice-like grid
>>> ixgrid
(array([[0],
       [1]]), array([[2, 4]]))
>>> a[ixgrid]                       # use the grid to slice a
array([[2, 4],
       [7, 9]])

Ja, es ist schade, python nicht besser grundlegende Unterstützung von array-Typ-Daten, ohne dass numpy

InformationsquelleAutor Jesse Knight

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.