Tuples are immutable; you can't change which variables they contain after construction. However, you can concatenate or slice them to form new tuples:

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

And, of course, build them from existing values:

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

You can start with a blank tuple with something like `t = ()`. You can add with `+`, but you have to add another tuple. If you want to add a single element, make it a singleton: `t = t + (element,)`. You can add a tuple of multiple elements with or without that trailing comma.

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

In Python 3, you can use `*` to create a new tuple of elements from the original tuple along with the new element.

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

The byte code is almost the same as `tuple1 + ("baz",)`

``Python 3.7.5 (default, Oct 22 2019, 10:35:10) [Clang 10.0.1 (clang-1001.0.46.4)] on darwinType "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``

The only difference is `BUILD_TUPLE_UNPACK` vs `BINARY_ADD`. The exact performance depends on the Python interpreter implementation, but it's natural to implement `BUILD_TUPLE_UNPACK` faster than `BINARY_ADD` because `BINARY_ADD` is a polymorphic operator, requiring additional type calculation and implicit conversion.