向元组添加变量

Question

我正在学习 Python 并创建数据库连接。 在尝试添加到数据库时，我正在考虑根据信息创建元组，然后将它们添加到数据库中。

我在做什么： 我从用户那里获取信息并将其存储在变量中。 我可以将这些变量添加到元组中吗？你能帮我看看语法吗？

另外，如果有有效的方法，请分享...

编辑 让我稍微编辑一下这个问题......我只需要元组将信息输入数据库。将信息添加到数据库后，我应该删除元组吗？我的意思是我不再需要元组了。

Answer 1

就这么简单：

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 中的元组是不可变的，因此一旦创建元组，就不能将变量附加到元组。

Answer 2

我很确定这在 python 中的语法是：

user_input1 = raw_input("Enter Name: ")
user_input2 = raw_input("Enter Value: ")
info = (user_input1, user_input2)

一旦设置，元组就无法更改。

Answer 3

元组是不可变的；您无法在构造后更改它们包含的变量。但是，您可以将它们连接或切片以形成新的元组：

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)

Answer 4

正如其他答案所指出的，您无法更改现有元组，但您始终可以创建一个新元组（可能从现有元组和/或其他来源获取部分或全部项目）。

例如，如果所有感兴趣的项目都在标量变量中，并且您知道这些变量的名称：

def maketuple(variables, names):
  return tuple(variables[n] for n in names)

要使用，例如，如本例所示：

def example():
  x = 23
  y = 45
  z = 67
  return maketuple(vars(), 'x y z'.split())

当然，这一种情况可以更简单地表示为(x, y, z)（或者甚至将名称完全放在前面，(23, 45, 67)），但是maketuple 方法可能在一些更复杂的情况下有用（例如使用也是动态确定的，并在计算期间附加到列表中）。

Answer 5

" 将信息添加到数据库后，我应该删除元组吗？我的意思是我不再需要元组了。"

没有。

一般来说，没有理由删除任何内容。有一些删除的特殊情况，但它们非常非常罕见。

只需定义一个窄范围（即类中的函数定义或方法函数），对象将在范围结束时被垃圾回收。

不用担心删除任何东西。

[注意。我和一个人一起工作——除了试图删除对象之外——总是编写“重置”方法来清除它们。就像他要保存它们并重新使用它们一样。也是一种愚蠢的自负。只需忽略您不再使用的对象。如果你在足够小的代码块中定义你的函数，你就没有什么可考虑的了。]

Answer 6

您可以从带有 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)

Answer 7

另一种尚未提及的策略是使用附加到列表，然后将列表转换为最后的元组：

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

返回

(0, 1, 2, 3, 4)

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

Answer 8

在 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 是一个多态运算符，需要额外的类型计算和隐式转换。