Python: Wert in einem Tupel ändern

Zuerst müssen Sie sich Fragen, warum Sie dies tun wollen?

Aber es ist möglich über:

t = ('275', '54000', '0.0', '5000.0', '0.0')
lst = list(t)
lst[0] = '300'
t = tuple(lst)

Aber wenn Sie gehen zu müssen, um Dinge zu ändern, sind Sie wahrscheinlich besser dran, zu halten, eine list

InformationsquelleAutor der Antwort Jon Clements

Gut, wie Trufa hat bereits gezeigt, gibt es grundsätzlich zwei Möglichkeiten, zu ersetzen, einen Tupel-element an einem bestimmten index. Konvertieren Sie die Tupel in eine Liste, ersetzen Sie das element und wieder zurück konvertieren, oder erstellen Sie ein neues Tupel durch Verkettung.

In [1]: def replace_at_index1(tup, ix, val):
   ...:     lst = list(tup)
   ...:     lst[ix] = val
   ...:     return tuple(lst)
   ...:

In [2]: def replace_at_index2(tup, ix, val):
   ...:     return tup[:ix] + (val,) + tup[ix+1:]
   ...:

Welche Methode ist besser, d.h. schneller?

Es stellt sich heraus, dass für kurze Tupel (auf Python 3.3), die Verkettung ist tatsächlich schneller!

In [3]: d = tuple(range(10))

In [4]: %timeit replace_at_index1(d, 5, 99)
1000000 loops, best of 3: 872 ns per loop

In [5]: %timeit replace_at_index2(d, 5, 99)
1000000 loops, best of 3: 642 ns per loop

Doch wenn wir uns länger Tupel -, Listen-Umwandlung ist der Weg zu gehen:

In [6]: k = tuple(range(1000))

In [7]: %timeit replace_at_index1(k, 500, 99)
100000 loops, best of 3: 9.08 µs per loop

In [8]: %timeit replace_at_index2(k, 500, 99)
100000 loops, best of 3: 10.1 µs per loop

Sehr lange Tupel -, Listen-Konvertierung ist deutlich besser!

In [9]: m = tuple(range(1000000))

In [10]: %timeit replace_at_index1(m, 500000, 99)
10 loops, best of 3: 26.6 ms per loop

In [11]: %timeit replace_at_index2(m, 500000, 99)
10 loops, best of 3: 35.9 ms per loop

Auch, die Leistung der Verkettung Methode hängt von der index, an dem wir ersetzen das element. Für die Liste-Methode, der index ist irrelevant.

In [12]: %timeit replace_at_index1(m, 900000, 99)
10 loops, best of 3: 26.6 ms per loop

In [13]: %timeit replace_at_index2(m, 900000, 99)
10 loops, best of 3: 49.2 ms per loop

So: Wenn Ihr ein Tupel ist kurz, in Scheiben schneiden und zu verketten.
Wenn es lange in der Liste Konvertierung!

InformationsquelleAutor der Antwort sjakobi

Nicht, dass dies die beste ist, aber wenn jemand neugierig ist, es kann getan werden, auf einer Linie mit:

tuple = tuple([200 if i == 0 else _ for i, _ in enumerate(tuple)])

InformationsquelleAutor der Antwort bphi

basierend auf Jon's Idee und Liebe Trufa

def modifyTuple(tup, oldval, newval):
    lst=list(tup)
    for i in range(tup.count(oldval)):
        index = lst.index(oldval)
        lst[index]=newval

    return tuple(lst)

print modTupByIndex((1, 1, 3), 1, "a")

ändert es alle Ihre alten Werte vorkommen

InformationsquelleAutor der Antwort Pooya

Ich habe festgestellt, der beste Weg, um Bearbeiten-Tupeln besteht darin, die Tupel mit der vorherigen version als Basis.

Hier ist ein Beispiel, das ich verwendet für die Herstellung eine leichtere version einer Farbe (ich hatte es schon offen zu der Zeit):

colour = tuple([c+50 for c in colour])

Was es tut, ist es geht durch das Tupel 'Farbe' und liest jeden Artikel, macht etwas, um es, und schließlich fügt es den neuen Tupel.

Also, was Sie wollen, wäre so etwas wie:

values = ('275', '54000', '0.0', '5000.0', '0.0')

values  = (tuple(for i in values: if i = 0: i = 200 else i = values[i])

Dass spezifische nicht funktioniert, aber das Konzept ist das, was Sie brauchen.

tuple = (0, 1, 2)

Tupel = Iteration über Tupel, verändern jedes Element, wie erforderlich,

das ist das Konzept.

InformationsquelleAutor der Antwort Aedus

Ich glaube, dass dies technisch wird die Frage beantwortet, aber nicht dieses zu Hause. Im moment, alle Antworten umfassen das erstellen einer neuen Tupel, sondern Sie können ctypes ändern eines Tupels in-memory. Unter Berufung auf verschiedene details der Implementierung der CPython auf einem 64-bit-system, ein Weg, dies zu tun ist wie folgt:

def modify_tuple(t, idx, new_value):
    # `id` happens to give the memory address in CPython; you may
    # want to use `ctypes.addressof` instead.
    element_ptr = (ctypes.c_longlong).from_address(id(t) + (3 + idx)*8)
    element_ptr.value = id(new_value)
    # Manually increment the reference count to `new_value` to pretend that
    # this is not a terrible idea.
    ref_count = (ctypes.c_longlong).from_address(id(new_value))
    ref_count.value += 1

t = (10, 20, 30)
modify_tuple(t, 1, 50)   # t is now (10, 50, 30)
modify_tuple(t, -1, 50)  # Will probably crash your Python runtime

InformationsquelleAutor der Antwort fuglede