Делает ли массив nums глубокую копию букв [2:5] = ['C', 'D', 'E']?

Я не знаю точных ответов, но на самом деле важным вопросом является номер 2: «Как мне проверить, является ли список поверхностной или глубокой копией?»

Ключевое слово is проверяет идентичность (отличную от равенства). Выражение a is b оценивается как True, если переменные a и b ссылаются на один и тот же объект. Чтобы узнать, является ли список l2 глубокой или поверхностной копией списка l1, выполните is сравнение между элементами.

l1 = [MyObject()]
l2 = l1[:]
print(l1[0] is l2[0])

Я бы предостерег вас от использования примитивных типов данных в списке, поскольку они подлежат непредсказуемой оптимизации. Например, в последний раз, когда я проверял, две целочисленные переменные от 0 до 255 всегда имеют один и тот же идентификатор. Я не знаю, ведут ли строки себя подобным образом.

Произошла путаница в терминах:

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

    >>> x = ['C', 'D', 'E']
    >>> y=['a', 'b','c','d','e']
    >>> y[2:5]=x
    >>> y
    ['a', 'b', 'C', 'D', 'E']
    >>> x[0]='XX'
    >>> y
    ['a', 'b', 'C', 'D', 'E']
    >>> x
    ['XX', 'D', 'E']

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

    >>> z=[[1,3],4]
    >>> y[0:2]=z
    >>> y
    [[1, 3], 4, 'C', 'D', 'E']
    >>> z[0][0]='XX'
    >>> z[1]='OO'
    >>> z
    [['XX', 3], 'OO']
    >>> y
    [['XX', 3], 4, 'C', 'D', 'E']

Давайте разберем ваши вопросы и опасения:

(1) Есть ли letters[2:5] глубокое копирование ['C', 'D', 'E']? Есть ли letters[:] глубокое копирование []?

Нет, ни одна из этих операций не выполняет глубокое копирование.

• letters[2:5] = ['C', 'D', 'E'] — присвоение фрагменту исходного списка. Он заменяет элементы с индексами 2, 3 и 4 новыми значениями, но не создает новую копию списка. Исходный список изменяется на месте.
• letters[:] = [] также является присвоением срезу, но на этот раз он заменяет весь список пустым списком. Опять же, это изменяет исходный список, а не создает новую копию.

(2) Как проверить, является ли список поверхностной или глубокой копией?

Чтобы определить, является ли список поверхностной или глубокой копией, вы можете использовать следующие методы:

Мелкая копия:

• Используйте функцию id(), чтобы проверить, имеют ли исходный список и скопированный список одинаковый адрес памяти. Если да, то это поверхностная копия.
• Измените исходный список и проверьте, не затронут ли скопированный список. Если да, то это мелкая копия.

Пример:

original_list = [[1, 2], [3, 4]]
shallow_copy = original_list[:]
print(id(original_list) == id(shallow_copy))  # True
original_list[0][0] = 10
print(shallow_copy)  # [[10, 2], [3, 4]] (affected by original list)

Глубокая копия:

• Используйте функцию id(), чтобы проверить, имеют ли исходный список и скопированный список разные адреса памяти. Если да, то это может быть глубокая копия.
• Измените исходный список и проверьте, не затронут ли скопированный список. Если это не так, скорее всего, это глубокая копия.

Пример:

import copy
original_list = [[1, 2], [3, 4]]
deep_copy = copy.deepcopy(original_list)
print(id(original_list) != id(deep_copy))  # True
original_list[0][0] = 10
print(deep_copy)  # [[1, 2], [3, 4]] (not affected by original list)

Имейте в виду, что эти методы не являются надежными, и могут быть крайние случаи, когда они не могут точно определить, является ли копия поверхностной или глубокой. Однако в большинстве случаев они должны дать вам хорошее представление.