157

我有一个名为的元组values，其中包含以下内容：

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

我想更改275此元组中的第一个值（即 ），但我知道元组是不可变的，因此values[0] = 200不起作用。我怎样才能做到这一点？

4

17 回答 17

215

可以通过：

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

但是如果你需要改变一些东西，你最好把它保留为list

于 2012-07-12T18:29:29.503 回答
85

根据您的问题，切片可能是一个非常巧妙的解决方案：

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

这允许您添加多个元素或替换一些元素（特别是如果它们是“邻居”。在上述情况下，转换为列表可能更合适和可读（即使切片符号要短得多）。

于 2014-03-27T00:53:59.953 回答
26

好吧，正如 Trufa 已经展示的那样，基本上有两种方法可以在给定索引处替换元组的元素。要么将元组转换为列表，替换元素并转换回来，要么通过连接构造一个新的元组。

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

所以：如果你的元组很短，切片和连接。如果它很长，请进行列表转换！

于 2013-11-23T10:14:10.897 回答
15

一个衬里是可能的：

values = ('275', '54000', '0.0', '5000.0', '0.0')
values = ('300', *values[1:])
于 2018-10-05T03:21:34.263 回答
10

正如 Hunter McMillen 所提到的，元组是不可变的，您需要创建一个新元组才能实现这一点。例如：

>>> 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')
于 2016-06-13T08:36:35.827 回答
9

并不是说这是优越的，但如果有人好奇，可以通过以下方式完成：

tuple = tuple([200 if i == 0 else _ for i, _ in enumerate(tuple)])
于 2016-11-11T19:28:42.140 回答
9

我相信这在技术上回答了这个问题，但不要在家里这样做。目前，所有答案都涉及创建一个新元组，但您可以使用它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
于 2017-08-15T17:33:42.803 回答
4

您不能修改元组中的项目，但可以修改元组中可变对象的属性（例如，如果这些对象是列表或实际的类对象）

例如

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')
于 2020-07-12T07:31:54.837 回答
3

编辑：这不适用于具有重复条目的元组！

基于Pooya 的想法：

如果你打算经常这样做（你不应该这样做，因为元组是不可变的）你应该这样做：

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")
于 2012-07-12T18:58:33.677 回答
3

首先，问问自己为什么要改变你的tuple. 字符串和元组在 Ptyhon 中是不可变的是有原因的，如果你想改变你的，tuple那么它可能应该是 a list。

其次，如果您仍然希望改变您的元组，那么您可以将您的元组转换tuple为 alist然后将其转换回来，并将新元组重新分配给同一个变量。如果你只打算改变你的元组一次，那就太好了。否则，我个人认为这是违反直觉的。因为它本质上是在创建一个新的元组，每次如果你想改变元组，你都必须执行转换。此外，如果您阅读了代码，会令人困惑地认为为什么不创建一个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。

于 2017-08-15T18:54:10.610 回答
2

基于Jon的想法和亲爱的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")

它改变了你所有的旧值出现

于 2012-07-12T18:37:22.873 回答
1

你不能。如果要更改它，则需要使用列表而不是元组。

请注意，您可以改为创建一个新元组，将新值作为其第一个元素。

于 2012-07-12T18:29:58.263 回答
0

我发现编辑元组的最佳方法是使用以前的版本作为基础重新创建元组。

这是我用来制作颜色较浅版本的示例（当时我已经打开了它）： 

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 = 遍历元组，根据需要更改每个项目

这就是概念。

于 2016-03-18T03:48:17.030 回答
0

我迟到了，但我认为最简单、资源最友好和最快的方法（取决于情况）是覆盖元组本身。因为这将消除创建列表和变量的需要，并存档在一行中。 

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')
于 2019-09-01T12:49:34.293 回答
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
于 2020-02-11T05:01:05.150 回答
-2

我这样做了：

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]
于 2014-11-01T21:11:33.917 回答
-5

您可以使用通过引用复制来更改元组的值

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

>>> tuple2=tuple1

>>> tuple2
    [20, 30, 40]

>>> tuple2[1]=10

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

>>> print(tuple1)
    [20, 10, 40]
于 2018-10-02T14:54:52.480 回答