Передача списка в объект класса по ссылке, как сделать?

Question

[andrey_ado]

Передаю в качестве параметра в объект класса список. Ожидалось, что он будет меняться в объекте, но этого не происходит.
Получается список передается по значению? Код весь не буду вставлять.
Начало:

my_object = m_table(root,
                                 mheader,
                                 item_list                                 
                                 )

m_table- таблица на Tkiner, в которую предается список item_list. в обекте ссылка на список отдается self.item_list.

def __init__(self, parent=None,
                 header_list,
                 item_list
                 ):
self.header_list = header_list
self.item_list = item_list

В таблице список изменяется, окно закрывается.

root.mainloop()
print(item_list)

Список каким был, таким и остался

Answer 1

[throughtheether]

Код покажите, скорее всего вы что-то неправильно делаете.
Вот пример.

>>> def f1(l):
	l=l+[0]
	
>>> def f2(l):
	l+=[0]
	
>>> def f3(l):
	l.append(0)

>>> mylist=[1,2,3]
>>> f1(mylist)
>>> mylist
[1, 2, 3]
>>> f2(mylist)
>>> mylist
[1, 2, 3, 0]
>>> f3(mylist)
>>> mylist
[1, 2, 3, 0, 0]

В первой функции выражение l=l+[0] создает локальную переменную l, которая ссылается на некий новый список, состоящий из элементов списка, переданного в функцию, с добавленным элементом (0). То есть l слева и l справа - это разные переменные.

Во второй функции происходит (неявно) вызов метода объекта-списка, переданного в функцию, поэтому список в результате ("снаружи") изменяется. В третьей функции происходит явный вызов метода объекта, переданного в функцию.

Хотел бы отметить, специалистом по CS (в части теории языков программирования) не являюсь, мог напутать с терминологией.

Есть на эту тему хорошая статья.

UPD:
Первый пример подробнее:

>>> def f1(l):
	print "Value at function start: {}, id: {}".format(l,id(l))
	l=l+[0]
	print "Value at function end: {}, id: {}".format(l,id(l))

	
>>> mylist=[1,2,3]
>>> f1(mylist)
Value at function start: [1, 2, 3], id: 44215272
Value at function end: [1, 2, 3, 0], id: 5440176
>>> mylist
[1, 2, 3]

Видно по разным id, что происходит обращение к разным переменным.

Comments

[andrey_ado]

Статьи мы читали и тоже думали, что отдав список функции или объекту, получим изменения в исходном списке, но...

[throughtheether]

andrey_ado:

В таблице список изменяется,

Вот этот код интересует, как именно меняется список.
Потому что в таком случае:

self.header_list = header_list
self.item_list = item_list

Имена self.header_list и self.item_list ссылаются именно те списки, поданные в виде параметров метода.

Пример:

class m_table(object):
    def __init__(self, parent,header_list,item_list):
        self.header_list = header_list
        self.item_list = item_list
        print "self.header_list: {}, header_list: {}".format(id(self.header_list),id(header_list))
        print "self.item_list: {}, item_list: {}".format(id(self.item_list),id(item_list))
    def mutate(self):
        print "mutating self lists..."
        self.header_list.append(999)
        self.item_list.append(999)
        print "mutated self.header_list: {}, value: {}".format(id(self.header_list),self.header_list)
        print "mutated self.item_list: {}, value: {}".format(id(self.item_list),self.item_list)
my_header_list=['header1','header2']
my_item_list=['item1','item2']
print "my_header_list before: {}, {}".format(my_header_list,id(my_header_list))
print "my_item_list before: {}, {}".format(my_item_list,id(my_item_list))

my_object=m_table(None, my_header_list,my_item_list)
my_object.mutate()
print "my_header_list after: {}, {}".format(my_header_list,id(my_header_list))
print "my_item_list after: {}, {}".format(my_item_list,id(my_item_list))

Вывод:

>>> ================================ RESTART ================================
>>> 
my_header_list before: ['header1', 'header2'], 46100392
my_item_list before: ['item1', 'item2'], 46091760
self.header_list: 46100392, header_list: 46100392
self.item_list: 46091760, item_list: 46091760
mutating self lists...
mutated self.header_list: 46100392, value: ['header1', 'header2', 999]
mutated self.item_list: 46091760, value: ['item1', 'item2', 999]
my_header_list after: ['header1', 'header2', 999], 46100392
my_item_list after: ['item1', 'item2', 999], 46091760

Answer 2

[bromzh]

Автор, ты несёшь бред. Ты прочитал статью, но ничего из неё не понял. Вот тебе доки, просвящайся.
Давай ещё на русском продублирую, раз с английским туго
1) Когда ты присваиваешь одну переменную другой, на самом деле происходит лишь копирование ссылок на объект. В итоге, 2 переменные ссылаются на 1 объект. Вот тебе простейшее доказательство, если ты мне не веришь. Пожалуйста, вбей этот текст в интерпретатор питона и убедись сам:

class A(object):
    def __init__(self, item):
        self.field = item

c = [1, 2]
a = A(c)
id(a.field) == id(c) # => True. Где тут разные id, покажи? 
c[0] = 100
a.field # => [100, 2] Копия создаётся, говоришь? Как ты тогда объяснишь, что изменяли мы c, а a.field вдруг тоже изменилось?
a.field[1] = 200
c #=> [100, 200] Ты всё ещё уверен, что это копия?

Автор в статье как раз и пытается донести мысль, что переменная - это не сам объект (объект хранится в памяти), а только лишь его адрес. И когда ты пишешь знак равенства, на деле переменной слева всего лишь присваивается тот адрес, на который указывает переменная справа. После присваивания 2 переменные стали ссылаться на 1 объект в памяти.
Если этот объект неизменяемый (строка, кортеж, число, и т.д.), то ты никак его изменить не сможешь. И когда ты переменной, указывающей на этот объект присваиваешь новое значение, на деле, переменная просто начинает указывать на другой объект, а тот который был до этого не меняется. Даже когда пишешь i += 1, i будет указывать уже на другой объект
Если же переменная указывает на мутабельный объект (экземпляр класса, список, словарь и т.д.), то над ней можно совершить некие действия, который изменят состояние объекта. И это изменённое состояние и будут отображать другие переменные, которые ссылаются на этот объект. Таким образом, можно изменить 1 переменную, а изменения прочитать из другой.

2) В питоне нет понятия "объявить переменную". Сам факт присваивания переменной чего-нибудь либо затирает старую ссылку (но не объект!) на объект, либо создаёт новую связь.
Так вот, есть такое понятие, как область видимости. Если ты создашь новую переменную внутри функции, извне она будет не видна. А вот если ты возьмёшь в качестве имени внутренней переменной уже использовавшееся ранее, то эта внутренняя переменная затенит внешнюю. Внутри функции не будет доступа к внешней переменной с тем же именем, вместо неё будет внутренняя.

Так вот автор (и доки) так и говорят: если ты внутри функции попытаешься присвоить переменной с именем одного из аргумента какое-то новое значение, то это значение будет локальным внутри данной функции, а извне её значение переменной, которую передали в качестве аргумента будет старым. Более того, даже если ты сперва присвоил внутренней переменной внешнюю, но потом ещё раз присвоишь что-то другой, то во внутренней будет другая ссылка. Поясняю:

def foo(a):
    print(id(a))
    a = [1] # Теперь a затеняет внешнюю переменную, т.е. указывает на другой объект
    print(id(a))

b = [0, 1]
foo(b) # Id будут разные, хотя имя одно, но после присвоения переменная потеряла связь с внешней

И вот пока ты внутренней переменной не присвоил что-то новое, изменяя её ты изменишь и внешнюю переменную.
И после "смерти" объекта ничего не изменится, как ты писал. Объект удаляется из памяти не сразу, это делает сборщик мусора, и только в том случае, если ссылок на объект в программе нет. Но тогда ты и не сможешь своё значение получить.

И список - это такой же мутабельный тип, как и произвольный класс, так что "передача по ссылке" для него работает (в доках об этом русским по белому написано, можешь почитать), так что создавать отдельный класс было глупо, в проблеме ты всё равно не разобрался.

Comments

[andrey_ado]

В вашем случае объект еще жив, когда вы выводите значение, а у меня уже умер.

[bromzh]

andrey_ado: это никак не влияет на результат. В питоне всё по ссылке передаётся, и присваивание на самом деле приравнивает ссылки. Это легко проверить, достаточно посмотреть id объекта. Если тип объекта, на который ссылаются 2 переменных мутабельный, то все переменные, которые указывают на него будут возвращать изменённое значение. Если же переменной присвоить новое значение (а не изменить её содержимое), то она просто будет указывать на другую область памяти, счётчик объектов-указателей уменьшится на 1.

class Foo(object):
   ...:         def foo(self, lst):
   ...:                 self.lst = lst
   ...:                 self.lst[0] = 100
   ...:         

In [2]: a = [1, 2, 3]

In [3]: foo = Foo()

In [4]: foo.foo(a)

In [5]: b = foo.lst

In [6]: a
Out[6]: [100, 2, 3]

In [7]: b
Out[7]: [100, 2, 3]

In [8]: foo.lst
Out[8]: [100, 2, 3]

In [9]: id(a)
Out[9]: 139912620342856

In [10]: id(b)
Out[10]: 139912620342856

In [11]: id(foo.lst)
Out[11]: 139912620342856

In [12]: del foo

In [13]: a
Out[13]: [100, 2, 3]

In [14]: b
Out[14]: [100, 2, 3]

[andrey_ado]

bromzh: влияет на результат. И id разные у self.item_list и item_listt , то есть при self.item_list = item_list создается копия item_list. Да и в первом ответ тоже разные ид. Кстати спасибо автору первого ответа за ссылку на статью. В ней нерусским по белому написано :"The variable is not the object"
Я попробовал передать в таблицу объект, класс которого имеет только список, в этом случае список меняется и в таблице и изменения остаются после закрытия окна.