Python: изменение значения в кортеже

Я новичок в python, поэтому этот вопрос может быть немного базовым. У меня есть кортеж, valuesкоторый содержит следующее:

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

Я хочу изменить первое значение (т.е. 275) в этом кортеже, но я понимаю, что кортежи неизменяемы, поэтому values[0] = 200работать не будет. Как я могу этого добиться?

Сначала нужно спросить, зачем вам это нужно?

Но это возможно через:

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

Но если вам нужно что-то изменить, вам, вероятно, лучше оставить это как list

В зависимости от вашей проблемы нарезка может быть действительно отличным решением:

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

Это позволяет вам добавлять несколько элементов или также заменять несколько элементов (особенно, если они являются «соседями». В приведенном выше случае приведение к списку, вероятно, более уместно и читабельно (хотя обозначение срезов намного короче).

Как уже показал Труфа, есть два основных способа заменить элемент кортежа по заданному индексу. Либо преобразуйте кортеж в список, замените элемент и преобразуйте обратно, либо создайте новый кортеж путем конкатенации.

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

Итак, какой метод лучше, то есть быстрее?

Оказывается, для коротких кортежей (в Python 3.3) конкатенация на самом деле быстрее!

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

Тем не менее, если мы посмотрим на более длинные кортежи, преобразование списка - это путь:

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

Для очень длинных кортежей преобразование списков значительно лучше!

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

Кроме того, производительность метода конкатенации зависит от индекса, по которому мы заменяем элемент. Для метода списка индекс не имеет значения.

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

Итак: если ваш кортеж короткий, нарежьте и объедините. Если он длинный, сделайте преобразование списка!

Возможно с одним лайнером:

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

Не то чтобы это лучше, но, если кому-то интересно, это можно сделать в одной строке:

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

Я считаю, что это технически ответ на вопрос, но не делайте этого дома. На данный момент все ответы включают создание нового кортежа, но вы можете использовать его ctypesдля изменения кортежа в памяти. Опираясь на различные детали реализации CPython в 64-битной системе, можно сделать это следующим образом:

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

Как написал в комментариях Хантер Макмиллен, кортежи неизменяемы, для этого вам нужно создать новый кортеж. Например:

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

РЕДАКТИРОВАТЬ: это еще не работает с кортежами с повторяющимися записями !!

По идее Пуйи :

Если вы планируете делать это часто (чего не следует делать, поскольку кортежи по какой-то причине неизменяемы), вам следует сделать что-то вроде этого:

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

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

Или на основе идеи Джона :

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

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

Фрист, спросите себя, почему вы хотите изменить свой tuple. Есть причина, по которой строки и кортеж неизменяемы в Ptyhon , если вы хотите изменить свой, tupleто, вероятно, listвместо этого он должен быть .

Во-вторых, если вы все еще хотите изменить свой кортеж, вы можете преобразовать его tupleв a, listзатем преобразовать его обратно и переназначить новый кортеж той же переменной. Это замечательно, если вы собираетесь изменить кортеж только один раз . В противном случае я лично считаю, что это нелогично. Потому что он по сути создает новый кортеж, и каждый раз, если вы хотите изменить кортеж, вам придется выполнять преобразование. Также, если вы читаете код, было бы непонятно, почему бы просто не создать list? Но это приятно, потому что не требует никакой библиотеки.

Я предлагаю использовать mutabletuple(typename, field_names, default=MtNoDefault)from mutabletuple 0.2 . Я лично считаю, что этот способ более интуитивно понятен и удобочитаем. Личное чтение кода должно знать, что писатель намеревается изменить этот кортеж в будущем. Обратной стороной по сравнению с listописанным выше методом преобразования является то, что вам необходимо импортировать дополнительный файл 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 : Не пытайтесь мутировать tuple. если вы это сделаете, и это будет одноразовая операция, преобразовать tupleв список, изменить его, превратить listв новый tupleи переназначить обратно переменной, содержащей старый tuple. Если вы tupleхотите чего-то избежать listи хотите видоизменить более одного раза, тогда создавайте mutabletuple.

на основе Идеи Джона и дорогой Труфа

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

он изменяет все ваши старые вхождения значений

Вы не можете. Если вы хотите его изменить, вам нужно использовать список вместо кортежа.

Обратите внимание, что вместо этого вы можете создать новый кортеж с новым значением в качестве первого элемента.

Я обнаружил, что лучший способ редактировать кортежи - это воссоздать кортеж, используя предыдущую версию в качестве основы.

Вот пример, который я использовал для создания более светлой версии цвета (у меня он уже был открыт в то время):

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

Что он делает, так это то, что он просматривает «цвет» кортежа и читает каждый элемент, что-то делает с ним и, наконец, добавляет его в новый кортеж.

Так что вам нужно что-то вроде:

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

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

Этот конкретный вариант не работает, но концепция - это то, что вам нужно.

tuple = (0, 1, 2)

tuple = перебирать кортеж, при необходимости изменять каждый элемент

это концепция.

Я опаздываю в игру, но я думаю, что самый простой , экономичный и быстрый способ (в зависимости от ситуации) - это перезаписать сам кортеж. Так как это избавит от необходимости создавать список и переменную и архивируется в одну строку.

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

>>> (1, 2, 24)

Но: это удобно только для довольно небольших кортежей, а также ограничивает вас фиксированным значением кортежа, тем не менее, в любом случае это происходит с кортежами большую часть времени.

В данном конкретном случае это будет выглядеть так:

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; «обходным путем» является создание нового объекта кортежа, а не изменение исходного

Хотя это очень старый вопрос, кто-то рассказал мне об этом безумии изменения кортежей Python. Что я был очень удивлен / заинтригован, и, немного погуглил, я попал сюда (и другие похожие образцы в Интернете)

Я провел тест, чтобы доказать свою теорию

Примечание ==оценивает равенство, в то время isкак ссылочное равенство (obj a тот же экземпляр, что и 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))

Урожайность:

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

Вы не можете изменять элементы в кортеже, но можете изменять свойства изменяемых объектов в кортежах (например, если эти объекты являются списками или фактическими объектами класса)

Например

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

я сделал это:

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

и чтобы изменить, просто сделай

list[0]=6

и вы можете изменить кортеж: D

вот оно в точности скопировано из 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]

Вы можете изменить значение кортежа, используя копию по ссылке

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

>>> tuple2=tuple1

>>> tuple2
    [20, 30, 40]

>>> tuple2[1]=10

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

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