Как я могу сделать копию кортежа, содержащего вложенные кортежи в Python?

Вы должны использовать модуль копирования.

Этот модуль имеет две функции, которые соответствуют вашим потребностям: копирование и глубокое копирование. copy делает то же самое, что и copy_tree.

Например, если вы это сделаете:

import copy
l = [[0],[0]]
l2 = copy.copy(l)
l[0] = [1]
l[1][0] = [1]

Тогда l2 будет [[0], [1]] Первый элемент l2 не изменился, потому что вы заменили l первым элементом. Однако второй элемент изменился, потому что вы изменили второй элемент l, который является ссылкой на элемент l2.

Если вы используете deepcopy:

 import copy
 l = [[0],[0]]
 l2 = copy.deepcopy(l)
 l[0] = [1]
 l[1][0] = [1]

Тогда l2 будет [[0], [0]], потому что l и l2 больше не имеют ничего общего.

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

def copy_tuple(t):
    output = []
    for i in t:
        if isinstance(i, tuple):
            output.append(copy_tuple(i))
        else:
            output.append(i)
    return tuple(output)

так что:

a = ((3, 2), 1, (4,), 5)
b = copy_tuple(a)
print(a)
print(b)
print(a[0] is b[0])

выведет:

((3, 2), (4,), 5)
((3, 2), (4,), 5)
False

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

def copy_tree(tree):
    if isinstance(tree, tuple):
        return tuple(map(copy_tree, tree))
        # or, maybe more readable
        # return tuple(copy_tree(x) for x in tree)
    return tree

Рекурсия - определенно самый элегантный подход, если вы не знаете заранее уровни вложенности.

В вашем коде отсутствует рекурсивный шаг - вы копируете только кортеж верхнего уровня.

def copy_tree(tree):
  new_tree = ()
  for i in tree:
    # i is not copied
    new_i = (i,) + ()
    new_tree = new_tree + new_i
  return new_tree

Добавление рекурсии создает копии слоя каждый дерева. Обратите внимание, что вы можете копировать кортежи Только:

def copy_tree(tree):
  new_tree = ()
  for i in tree:
    # recursively copy i *if it is a tuple*
    if isinstance(i, tuple):
      new_i = (copy_tree(i),)
    else:
      new_i = (i,)
    new_tree = new_tree + new_i
  return new_tree

Рекурсия исправляет результат, но выбранный вами подход неэффективен - создается и отбрасывается множество временных кортежей. Каждый раз, когда кортеж "расширяется" через +, старый отбрасывается и создается новый.

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

def copy_tree(tree):
    children = []
    for child in tree:
        # we *always* preserve a child, so ternary if expresses this better
        child = copy_tree(child) if isinstance(child, tuple) else child
        children.append(child)
    # create a new tuple including all children
    return tuple(children)

Поскольку этот список существует только для преобразования в кортеж, мы также можем избавиться от него: выражение генератора позволяет передавать преобразованные дочерние элементы непосредственно в конструктор tuple.

def copy_tree(tree):
    # generator expression - only run when consumed by tuple later on
    children = (
        copy_tree(child) if isinstance(child, tuple) else child
        for child in tree
    )
    return tuple(children)

Конечно, вы также можете напрямую поместить выражение генератора в tuple.

Я думаю, что целью вопроса было использование какой-то рекурсии. Следующий код рекурсивно копирует дерево.

def copy_tree(tree):
    new_tree = ()
    for node in tree:
        if type(node) == tuple:
            new_tree += (copy_tree(node),)
        else:
            new_tree += (node,)
    return new_tree


a = ((3, 2), 1, (4,), 5)
b = copy_tree(a)

print(a[0] is b[0])

и последний отпечаток даст вам False.

Вот простая версия, которая копирует дерево, передавая конструктору tuple рекурсивный генератор. Чтобы проверить это, я написал еще одну рекурсивную функцию compare_trees, которую вы можете использовать для проверки того, что соответствующие кортежи не идентичны (с использованием is) и что соответствующие внутренние элементы имеют одинаковое значение (с помощью ==).

def copy_tree(tree):
    return tuple(copy_tree(u) if isinstance(u, tuple) else u for u in tree)

def compare_trees(tree1, tree2, indent=''):
    print(indent, 'tree1', tree1, 'tree2', tree2, 'identical', tree1 is tree2)
    indent += '  '
    for u1, u2 in zip(tree1, tree2):
        if isinstance(u1, tuple) and isinstance(u2, tuple):
            compare_trees(u1, u2, indent)
        else:
            print(indent, 'item1', u1, 'item2', u2, 'equal', u1 == u2)

a = ((3, 2), 1, (4,), 5, (6, (7, 8)))
b = copy_tree(a)
print(b)
compare_trees(a, b)

выход

((3, 2), 1, (4,), 5, (6, (7, 8)))
 tree1 ((3, 2), 1, (4,), 5, (6, (7, 8))) tree2 ((3, 2), 1, (4,), 5, (6, (7, 8))) identical False
   tree1 (3, 2) tree2 (3, 2) identical False
     item1 3 item2 3 equal True
     item1 2 item2 2 equal True
   item1 1 item2 1 equal True
   tree1 (4,) tree2 (4,) identical False
     item1 4 item2 4 equal True
   item1 5 item2 5 equal True
   tree1 (6, (7, 8)) tree2 (6, (7, 8)) identical False
     item1 6 item2 6 equal True
     tree1 (7, 8) tree2 (7, 8) identical False
       item1 7 item2 7 equal True
       item1 8 item2 8 equal True

Я полагаю, это немного иронично, что тестовый код больше и сложнее, чем код, который мы хотим протестировать, но иногда это неизбежно. ;)