你可以从一个空白的元组开始，比如t =()。你可以用+进行加法，但你必须添加另一个元组。如果您想添加单个元素，请将其设置为单例:t = t + (element，)。您可以添加包含多个元素的元组，可以带逗号，也可以不带逗号。

>>> t = ()
>>> t = t + (1,)
>>> t
(1,)
>>> t = t + (2,)
>>> t
(1, 2)
>>> t = t + (3, 4, 5)
>>> t
(1, 2, 3, 4, 5)
>>> t = t + (6, 7, 8,)
>>> t
(1, 2, 3, 4, 5, 6, 7, 8)

另一个没有提到的策略是使用追加到列表，然后在最后将列表转换为元组:

mylist = []
for x in range(5):
    mylist.append(x)
mytuple = tuple(mylist)
print mytuple

返回

(0, 1, 2, 3, 4)

当我必须传递一个元组作为函数参数时，我有时会使用这个，这对于numpy函数来说通常是必要的。

你可以从一个空白的元组开始，比如t =()。你可以用+进行加法，但你必须添加另一个元组。如果您想添加单个元素，请将其设置为单例:t = t + (element，)。您可以添加包含多个元素的元组，可以带逗号，也可以不带逗号。

>>> t = ()
>>> t = t + (1,)
>>> t
(1,)
>>> t = t + (2,)
>>> t
(1, 2)
>>> t = t + (3, 4, 5)
>>> t
(1, 2, 3, 4, 5)
>>> t = t + (6, 7, 8,)
>>> t
(1, 2, 3, 4, 5, 6, 7, 8)

如下所示:

info_1 = "one piece of info"
info_2 = "another piece"
vars = (info_1, info_2)
# 'vars' is now a tuple with the values ("info_1", "info_2")

然而，Python中的元组是不可变的，因此一旦创建了元组，就不能向其添加变量。

在Python 3中，您可以使用*从原始元组和新元素一起创建一个新的元素元组。

>>> tuple1 = ("foo", "bar")
>>> tuple2 = (*tuple1, "baz")
>>> tuple2
('foo', 'bar', 'baz')

字节码几乎与tuple1 + ("baz"，)相同

Python 3.7.5 (default, Oct 22 2019, 10:35:10) 
[Clang 10.0.1 (clang-1001.0.46.4)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def f():
...     tuple1 = ("foo", "bar")
...     tuple2 = (*tuple1, "baz")
...     return tuple2
... 
>>> def g():
...     tuple1 = ("foo", "bar")
...     tuple2 = tuple1 + ("baz",)
...     return tuple2
... 
>>> from dis import dis
>>> dis(f)
  2           0 LOAD_CONST               1 (('foo', 'bar'))
              2 STORE_FAST               0 (tuple1)

  3           4 LOAD_FAST                0 (tuple1)
              6 LOAD_CONST               3 (('baz',))
              8 BUILD_TUPLE_UNPACK       2
             10 STORE_FAST               1 (tuple2)

  4          12 LOAD_FAST                1 (tuple2)
             14 RETURN_VALUE
>>> dis(g)
  2           0 LOAD_CONST               1 (('foo', 'bar'))
              2 STORE_FAST               0 (tuple1)

  3           4 LOAD_FAST                0 (tuple1)
              6 LOAD_CONST               2 (('baz',))
              8 BINARY_ADD
             10 STORE_FAST               1 (tuple2)

  4          12 LOAD_FAST                1 (tuple2)
             14 RETURN_VALUE

唯一的区别是BUILD_TUPLE_UNPACK和BINARY_ADD。确切的性能取决于Python解释器的实现，但是实现BUILD_TUPLE_UNPACK比BINARY_ADD更快是很自然的，因为BINARY_ADD是一个多态运算符，需要额外的类型计算和隐式转换。

元组是不可变的;在构造后不能更改它们所包含的变量。但是，你可以将它们拼接或切片以形成新的元组:

a = (1, 2, 3)
b = a + (4, 5, 6)  # (1, 2, 3, 4, 5, 6)
c = b[1:]  # (2, 3, 4, 5, 6)

当然，要从现有的价值观出发:

name = "Joe"
age = 40
location = "New York"
joe = (name, age, location)