Python: zmiana wartości w krotce

Jestem nowy w Pythonie, więc to pytanie może być trochę podstawowe. Mam zwaną krotkę, valuesktóra zawiera następujące elementy:

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

Chcę zmienić pierwszą wartość (tj. 275) W tej krotce, ale rozumiem, że krotki są niezmienne, więc values[0] = 200nie będą działać. Jak mogę to osiągnąć?

Najpierw musisz zapytać, dlaczego chcesz to zrobić?

Ale jest to możliwe poprzez:

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

Ale jeśli będziesz musiał coś zmienić, prawdopodobnie lepiej zachowaj to jako plik list

W zależności od problemu krojenie może być naprawdę zgrabnym rozwiązaniem:

>>> b = (1, 2, 3, 4, 5)
>>> b[:2] + (8,9) + b[3:]
(1, 2, 8, 9, 4, 5)
>>> b[:2] + (8,) + b[3:]
(1, 2, 8, 4, 5)

Pozwala to na dodanie wielu elementów lub też zastąpienie kilku elementów (szczególnie jeśli są one „sąsiadami”. W powyższym przypadku rzutowanie na listę jest prawdopodobnie bardziej odpowiednie i czytelne (mimo że notacja wycinania jest znacznie krótsza).

Cóż, jak już pokazała Trufa, istnieją zasadniczo dwa sposoby zastąpienia elementu krotki w danym indeksie. Przekonwertuj krotkę na listę, zamień element i przekonwertuj z powrotem lub utwórz nową krotkę przez konkatenację.

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:]
   ...:

Więc która metoda jest lepsza, to znaczy szybsza?

Okazuje się, że w przypadku krótkich krotek (w Pythonie 3.3) konkatenacja jest faktycznie szybsza!

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

Jeśli jednak przyjrzymy się dłuższym krotkom, najlepszą drogą jest konwersja listy:

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

W przypadku bardzo długich krotek konwersja listy jest znacznie lepsza!

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

Również wydajność metody konkatenacji zależy od indeksu, w którym zastępujemy element. W przypadku metody listowej indeks nie ma znaczenia.

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

Więc: jeśli twoja krotka jest krótka, pokrój i połącz. Jeśli jest długi, wykonaj konwersję listy!

Jest to możliwe z jednym wkładem:

values = ('275', '54000', '0.0', '5000.0', '0.0')
values = ('300', *values[1:])

Nie żeby to było lepsze, ale jeśli ktoś jest ciekawy, można to zrobić w jednej linii za pomocą:

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

Wydaje mi się, że to technicznie odpowiada na pytanie, ale nie rób tego w domu. W tej chwili wszystkie odpowiedzi obejmują utworzenie nowej krotki, ale możesz użyć jej ctypesdo zmodyfikowania krotki w pamięci. Opierając się na różnych szczegółach implementacji języka CPython w systemie 64-bitowym, można to zrobić w następujący sposób:

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

Jak napisał Hunter McMillen w komentarzach, krotki są niezmienne, aby to osiągnąć, musisz utworzyć nową krotkę. Na przykład:

>>> tpl = ('275', '54000', '0.0', '5000.0', '0.0')
>>> change_value = 200
>>> tpl = (change_value,) + tpl[1:]
>>> tpl
(200, '54000', '0.0', '5000.0', '0.0')

EDYCJA: To jeszcze nie działa na krotkach ze zduplikowanymi wpisami !!

Na podstawie pomysłu Pooyi :

Jeśli planujesz robić to często (czego nie powinieneś, ponieważ krotki są niezmienne z jakiegoś powodu), powinieneś zrobić coś takiego:

def modTupByIndex(tup, index, ins):
    return tuple(tup[0:index]) + (ins,) + tuple(tup[index+1:])

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

Lub w oparciu o pomysł Jona :

def modTupByIndex(tup, index, ins):
    lst = list(tup)
    lst[index] = ins
    return tuple(lst)

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

Po pierwsze, zadaj sobie pytanie, dlaczego chcesz zmutować swój plik tuple. Istnieje powód, dla którego ciągi znaków i krotka są niezmienne w Ptyhonie , jeśli chcesz zmutować swój tuple, prawdopodobnie powinien to być lista.

Po drugie, jeśli nadal chcesz zmutować swoją krotkę, możesz przekonwertować tupleją na lista, a następnie przekonwertować ją z powrotem i ponownie przypisać nową krotkę do tej samej zmiennej. Jest to świetne rozwiązanie, jeśli zamierzasz zmutować swoją krotkę tylko raz . W przeciwnym razie osobiście uważam, że jest to sprzeczne z intuicją. Ponieważ zasadniczo tworzy nową krotkę i za każdym razem, jeśli chcesz zmutować krotkę, musisz wykonać konwersję. Jeśli przeczytasz kod, zastanowienie się, dlaczego nie po prostu utworzyć pliku list? Ale jest fajny, ponieważ nie wymaga żadnej biblioteki.

Sugeruję użycie mutabletuple(typename, field_names, default=MtNoDefault)z mutabletuple 0.2 . Osobiście uważam, że ten sposób jest bardziej intuicyjny i czytelny. Osobiste odczytanie kodu wiedziałoby, że autor zamierza w przyszłości zmodyfikować tę krotkę. Wadą w porównaniu z listpowyższą metodą konwersji jest to, że wymaga to zaimportowania dodatkowego pliku py.

from mutabletuple import mutabletuple

myTuple = mutabletuple('myTuple', 'v w x y z')
p = myTuple('275', '54000', '0.0', '5000.0', '0.0')
print(p.v) #print 275
p.v = '200' #mutate myTuple
print(p.v) #print 200

TL; DR : Nie próbuj mutować tuple. jeśli to zrobisz i jest to jednorazowa operacja, przekonwertuj ją tuplena listę, zmień ją, zamień listna nową tuplei ponownie przypisz z powrotem do zmiennej przechowującej stare tuple. Jeśli tuplepragniesz i chcesz w jakiś sposób uniknąć listi chcesz mutować więcej niż raz, stwórz mutabletuple.

oparty na Pomyśle Jona i drogiej Trufie

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")

zmienia wszystkie stare wystąpienia wartości

Nie możesz. Jeśli chcesz to zmienić, musisz użyć listy zamiast krotki.

Zauważ, że możesz zamiast tego utworzyć nową krotkę, która będzie miała nową wartość jako pierwszy element.

Odkryłem, że najlepszym sposobem edycji krotek jest odtworzenie krotki przy użyciu poprzedniej wersji jako podstawy.

Oto przykład, którego użyłem do stworzenia jaśniejszej wersji koloru (miałem go już wtedy otwartą):

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

To, co robi, polega na tym, że przechodzi przez krotkę „kolor” i czyta każdy element, robi z nim coś, a na koniec dodaje go do nowej krotki.

Więc chciałbyś coś takiego:

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

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

Ten konkretny nie działa, ale koncepcja jest tym, czego potrzebujesz.

tuple = (0, 1, 2)

tuple = iteracja przez krotkę, zmień każdy element w razie potrzeby

taka jest koncepcja.

Spóźniłem się na grę, ale myślę, że najprostszym , najbardziej przyjaznym dla zasobów i najszybszym sposobem (w zależności od sytuacji) jest nadpisanie samej krotki. Ponieważ wyeliminowałoby to potrzebę tworzenia listy i zmiennych i jest archiwizowane w jednej linii.

new = 24
t = (1, 2, 3)
t = (t[0],t[1],new)

>>> (1, 2, 24)

Ale: Jest to przydatne tylko w przypadku raczej małych krotek, a także ogranicza cię do ustalonej wartości krotki, niemniej jednak tak jest w przypadku krotek przez większość czasu.

Czyli w tym konkretnym przypadku wyglądałoby to tak:

new = '200'
t = ('275', '54000', '0.0', '5000.0', '0.0')
t = (new, t[1], t[2], t[3], t[4])

>>> ('200', '54000', '0.0', '5000.0', '0.0')

tldr; „obejściem” jest utworzenie nowego obiektu krotki, a nie faktyczna modyfikacja oryginału

Chociaż jest to bardzo stare pytanie, ktoś powiedział mi o tym szaleństwie mutacji krotek w Pythonie. Co byłem bardzo zaskoczony / zaintrygowany, i robiąc trochę googlowania, wylądowałem tutaj (i inne podobne próbki online)

Przeprowadziłem test, aby udowodnić swoją teorię

Uwaga ==czy równość wartości, podczas gdy równość isreferencyjna (czy jest to ta sama instancja co obj b)

a = ("apple", "canana", "cherry")
b = tuple(["apple", "canana", "cherry"])
c = a

print("a: " + str(a))
print("b: " + str(b))
print("c: " + str(c))
print("a == b :: %s" % (a==b))
print("b == c :: %s" % (b==c))
print("a == c :: %s" % (a==c))
print("a is b :: %s" % (a is b))
print("b is c :: %s" % (b is c))
print("a is c :: %s" % (a is c))

d = list(a)
d[1] = "kiwi"
a = tuple(d)

print("a: " + str(a))
print("b: " + str(b))
print("c: " + str(c))
print("a == b :: %s" % (a==b))
print("b == c :: %s" % (b==c))
print("a == c :: %s" % (a==c))
print("a is b :: %s" % (a is b))
print("b is c :: %s" % (b is c))
print("a is c :: %s" % (a is c))

Plony:

a: ('apple', 'canana', 'cherry')
b: ('apple', 'canana', 'cherry')
c: ('apple', 'canana', 'cherry')
a == b :: True
b == c :: True
a == c :: True
a is b :: False
b is c :: False
a is c :: True
a: ('apple', 'kiwi', 'cherry')
b: ('apple', 'canana', 'cherry')
c: ('apple', 'canana', 'cherry')
a == b :: False
b == c :: True
a == c :: False
a is b :: False
b is c :: False
a is c :: False

Nie możesz modyfikować elementów w krotce, ale możesz modyfikować właściwości zmiennych obiektów w krotkach (na przykład jeśli te obiekty są listami lub rzeczywistymi obiektami klas)

Na przykład

my_list = [1,2]
tuple_of_lists = (my_list,'hello')
print(tuple_of_lists) # ([1, 2], 'hello')
my_list[0] = 0
print(tuple_of_lists) # ([0, 2], 'hello')

ja to zrobiłem:

list = [1,2,3,4,5]
tuple = (list)

a żeby zmienić, po prostu zrób

list[0]=6

i możesz zmienić krotkę: D

tutaj jest to dokładnie skopiowane z IDLE

>>> list=[1,2,3,4,5,6,7,8,9]

>>> tuple=(list)

>>> print(tuple)

[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list[0]=6

>>> print(tuple)

[6, 2, 3, 4, 5, 6, 7, 8, 9]

Możesz zmienić wartość krotki za pomocą kopiowania przez odniesienie

>>> tuple1=[20,30,40]

>>> tuple2=tuple1

>>> tuple2
    [20, 30, 40]

>>> tuple2[1]=10

>>> print(tuple2)
    [20, 10, 40]

>>> print(tuple1)
    [20, 10, 40]