Der eleganteste Weg, Elemente verschachtelter Listen zu verändern

Ich habe eine 2D-Liste, die wie folgt aussieht:

table = [['donkey', '2', '1', '0'], ['goat', '5', '3', '2']]

Möchte ich ändern Sie die letzten drei Elemente, die zu zahlen, aber den code unten fühlt sich sehr hässlich:

for row in table:
    for i in range(len(row)-1):
        row[i+1] = int(row[i+1])

Aber ich hätte lieber etwas, das aussieht wie:

for row in table:
    for col in row[1:]:
        col = int(col)

Ich denke, es sollte ein Weg gefunden werden, schreiben Sie den code oben, aber die Scheibe erzeugt einen iterator/neue Liste, die getrennt von der ursprünglichen, so dass die Bezüge nicht zum tragen.

Gibt es eine Möglichkeit, um mehr Pythonic Lösung?

InformationsquelleAutor der Frage Conrad.Dean | 2011-04-15

nested-lists python

20
```
for row in table:
    row[1:] = [int(c) for c in row[1:]]
```
Nicht oben schauen, mehr pythonic?

InformationsquelleAutor der Antwort Shekhar
13

Versuchen:
```
>>> for row in table:
...     row[1:]=map(int,row[1:])
... 
>>> table
[['donkey', 2, 1, 0], ['goat', 5, 3, 2]]
```
AFAIK, die Zuordnung zu einer list slice-Kräfte die operation erfolgt statt der Schaffung einer neuen list.

InformationsquelleAutor der Antwort MAK
9

Ich mag Shekhar Antwort eine Menge.

Als Allgemeine Regel gilt, beim schreiben von Python-code, wenn Sie finden, sich selbst schreiben for i in range(len(somelist)) Sie tun es falsch:
- versuchen enumerate wenn Sie eine einzelne Liste
- versuchen zip oder itertools.izip wenn Sie 2 oder mehr Listen, die Sie Durchlaufen parallel
In Ihrem Fall, die erste Spalte ist anders, so dass Sie nicht aus nutzen auflisten:
```
for row in table:
    for i, val in enumerate(row):
        if i == 0: continue
        row[i] = int(val)
```
InformationsquelleAutor der Antwort gurney alex
2

Ihre "hässlichen" code verbessert werden kann, gerade indem Sie range mit zwei Argumenten:
```
for row in table:
    for i in range(1, len(row)):
        row[i] = int(row[i])
```
Dies ist wahrscheinlich das beste, was Sie tun können, wenn Sie darauf bestehen, auf eine änderung der Artikel an Ort und Stelle, ohne Zuweisung von neuen temporären Listen (mit einer Liste Verständnis, map und/oder aufschneiden). Sehen Gibt es ein direktes äquivalent auf 'Karte' in python?

Obwohl ich dies nicht empfehlen, können Sie auch diesen code, allgemeiner, durch die Einführung Ihrer eigenen in-place-map-Funktion:
```
def inplacemap(f, items, start=0, end=None):
    """Applies ``f`` to each item in the iterable ``items`` between the range
    ``start`` and ``end``."""
    # If end was not specified, make it the length of the iterable
    # We avoid setting end in the parameter list to force it to be evaluated on
    # each invocation
    if end is None:
        end = len(items)
    for i in range(start, end):
        items[i] = f(items[i])

for row in table:
    inplacemap(int, row, 1)
```
Persönlich, ich finde diese weniger Pythonic. Es gibt vorzugsweise nur eine offensichtliche Weg, es zu tun, und das ist es nicht.

InformationsquelleAutor der Antwort Wesley

Use-Liste Verstehens:

table = [row[0] + [int(col) for col in row[1:]] for row in table]

InformationsquelleAutor der Antwort Nicholas Mancuso

0

Dies funktionieren wird:
```
table = [[row[0]] + [int(v) for v in row[1:]] for row in table]
```
Allerdings möchten Sie vielleicht denken über das tun der Umwandlung an der Stelle, wo die Liste zum ersten mal erstellt.

InformationsquelleAutor der Antwort Keith

-1

Diese leistet, was Sie suchen. Es ist eine lesbare Lösung. Sie können gehen für eine ähnliche Verwendung listcomp zu.

>>> for row in table:
...     for i, elem in enumerate(row):
...             try:
...                     int(elem)
...             except ValueError:
...                     pass
...             else:
...                     row[i] = int(elem)
...

InformationsquelleAutor der Antwort Senthil Kumaran

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.