Python 3. Вопрос по работе интерпретатора.

[VVP_vic]

Моя задача на примитивном примере:
Исходный список: a=['a','b','c','d']
Нужно получить:a=[['X','b','c','d'],['a','X','c','d'],['a','b','X','d'],['a','b','c','X']]
т.е. последовательно менять один из элементов исходного списка на 'X' и добавлять каждый полученный список в исходный.

Код: [Выделить]

# coding: utf-8
a=[['a','b','c','d']]
b=['a','b','c','d']
for i in range(0,len(b)):
    c=b
    c[i]='X'
    a.append(c)
print(a)
print(b)полученный результат:
[['a', 'b', 'c', 'd'], ['X', 'X', 'X', 'X'], ['X', 'X', 'X', 'X'], ['X', 'X', 'X', 'X'], ['X', 'X', 'X', 'X']]
['X', 'X', 'X', 'X']
Он показывает, что интерпретатор даже список b поменял который вне пределов цикла, потому что видимо с=b, и все четыре новых списка он тоже приравнял к последнему с неправильному, т.к. он постепенно менял и b.
На числовых значениях такого не происходит. Т.е. он не меняет значение b, если я к нему приравняю с, а потом с изменю, b не поменяется.
Вопрос: как мне обойти эту особенность интерпретатора, если он меняет даже то, что вроде менять не должен?

[Sly_tom_cat]

В питоне списки это исключительно ссылочная структура - т.е. с=b это просто получить в переменную с еще одну ссылку на то, на что ссылается b. т.е. у вас всего один список (b он же с) в программе изменяется.

Копировать список нужно явно: с = b[:] или c = b.copy()

Кроме того, у вас первый элемент не такой как по заданию. Нужно а присваивать пустой список в начале.

[Azure]

Как на меня генератором списка проще

Код: (python) [Выделить]

template = ['a', 'b', 'c', 'd']
result = [template[:i]+['X']+template[i+1:] for i in range(len(template))]или

Код: (python) [Выделить]

lt = len(template)
result = [['X' if i==j else template[i] for i in range(lt)] for j in range(lt)]

[shura1]

Кто сказал, что в Питоне нет tmwtdi)))

Так, в порядке бреда - Python3:

Код: [Выделить]

from functools import reduce
a = ['a', 'b', 'c', 'd']
reduce(lambda x, y: x.append(a[:]) or x[-1].__setitem__(y, 'X') or x, range(len(a)), [])

[Sly_tom_cat]

Jshura, вы уже вовсе какой-то хакерский код привели, у Azure, хоть понятно что и как...

Azure, да ошибся - поправил.

[shura1]

Sly_tom_cat,
Я ж и говорю в порядке бреда))) Зато работает)

===

Для ТС - можно сказать, что в Питоне нет переменных - есть имена и значения. (В стандартном Python tutorial из документации термин variable не употребляется).

Когда вы пишете b=a, вы даете имя "b" значению, которое уже имеет имя "a". Результатом являтся то, что одно значение имеет два имени.

Есть разница при присваивании имен неизменяемым (immutable) и изменяемым (mutable) значениям. Числа, строки, кортежи (tuples) неизменяемы. Поэтому при

Код: [Выделить]

a = "hello"
b = a

неважно, ссылаются ли имена a и b на одинаковые строки или разные. Вышеуказанный код семантически равнозначен следующему

Код: [Выделить]

a = "hello"
b = "hello"

Совсем другое дело, когда значения изменяемы (mutable). Из стандартных типов данных Питона это списки, словари, множества. При

Код: [Выделить]

a = [1,2,3]
b = a
дается два разных имени одному и тому же значению. Поэтому, когда вы меняете значение, пользуясь именем "а", вы, естественно, можете наблюдать эти изменения и пользуясь именем "b"

Код: [Выделить]

a[0] = 100
print(b[0]) # ==> 100
Что бы имя "b" содержало копию значения, на которое ссылается имя "а" - надо (не поверите) скопировать значение. Общий способ такой:

Код: [Выделить]

from copy import copy
b = copy(a)
Для списков существует более краткий путь -

Код: [Выделить]

b = a[:]

[Sly_tom_cat]

К сказанному Jshura, добавлю.

Когда вы работаете с immutable то каждое присвоение это создание нового экземпляра данных.
Так, если вы предварительно присвоите

a=5

а потом присвоите

a=a+1

то фактически в памяти создается:
- при присвоении a=5: экземпляр класса int со значением 5
- при присвоении a=a+1: новый экземпляр класса int со значением 6
При этом во втором присвоении на экземпляр класс int со значением 5(старое значение а) теряется ссылка от а. Если при этом на это значение никто больше не ссылался, то экземпляр становится мусором, который позже (когда интерпритирору потребуется память, будет утилизирован (преобразован в свободную память) сборщиком мусора.

При этом, если вы напишите

a="hello"
b=a

То на экземпляр строки "hello" будут ссылаться две переменных, но как только вы напишите присвоение (например)

b = b[:-1]

То будет создан новый экземпляр строки "hell" и уже на него будет ссылаться b.
Даже если вы захотите в строке поменять один символ, интрепритатор создаст новый экземпляр строки, например

b.replace('o', 'a')

То даже в этом случае - возвращаемое значение - это копия начальной строки b c замененным символом (т.е. новый экземпляр строки)

Но, в отличии от первого примера с цифрами - в примере со строками мусор не появляется, т.к. на экземпляр строки "hello" у нас продолжает ссылаться a.

[VVP_vic]

Спасибо всем огромное! Разобрался в происходящих процессах и понял где ошибался!