Потому что вы не всегда можете контролировать классы, которые вы используете так, как вы их определяете. В качестве одного из примеров они могут быть программами на C, имеющими привязки Python (например, GTK, openalpr, части ядра). Не говоря уже о том, что даже если вы взяли стороннюю библиотеку и добавили методы копирования в каждый класс, как вы собираетесь встраивать это в управление зависимостями?

ел бы создать копию объекта. Я хочу, чтобы новый объект обладал всеми свойствами старого объекта (значения полей). Но я хочу иметь независимые объекты. Таким образом, если я изменю значения полей нового объекта, на старый объект это не должно повлиять.

Ответы на вопрос(4)

Решение Вопроса

вы можете использоватьcopy.deepcopy() функция.

Для получения более подробной информации о мелком и глубоком копировании, пожалуйста, обратитесь к другим ответам на этот вопрос и хорошее объяснение вэтот ответ на связанный вопрос.

 Aaron Hall♦14 дек. 2018 г., 14:26
Этот ответ был помечен как «Не ответ», удален и не удален - мета обсуждение здесь:meta.stackoverflow.com/questions/377844/...
 Sven Marnach14 дек. 2018 г., 16:32
@AaronHall Спасибо, что сообщили мне знать! Это, конечно, не самый лучший ответ, который я написал, но я вроде согласен с решением, что его нельзя удалять принудительно. Я немного освежу это, но так как уже есть ответы со всеми деталями (особенно вашими), я буду кратким.

def copy(obj):
    return type(obj)(obj)

(Конечно, я не говорю здесь о «глубоких копиях», это отдельная история, и которая может быть не очень ясным понятием - насколько глубоко достаточно глубоко?)

Согласно моим тестам с Python 3, для неизменяемых объектов, таких как кортежи или строки, он возвращает один и тот же объект (поскольку нет необходимости делать поверхностную копию неизменяемого объекта), но для списков или словарей он создает независимую поверхностную копию. ,

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

 Alexey21 февр. 2018 г., 14:13
@JaredSmith, не было заявлено, что вопрос был овсе объекты. Было даже неясно, было ли это о глубокой или мелкой копии (я бы предположил, что это обычная мелкая копия, но принятый ответ - о глубокой). Что касается пользовательских классов, если они ваши, вы можете просто соблюдать такие соглашения в их__init__ метод. Итак, я подумал, что этот метод может быть достаточно хорош для определенных целей. В любом случае меня заинтересуют информативные комментарии по этому предложению.
 Jared Smith21 февр. 2018 г., 13:55
Это аккуратно и все, но не отвечает на вопрос, так как ваша функция копирования не работает для пользовательских классов, и вопрос был ообъекты.
 Alexey21 февр. 2018 г., 14:49
@JaredSmith, я видел, что естьcopy.copy метод для создания мелких копий, но, возможно, наивно, мне кажется, что ответственность за обеспечение «конструктора поверхностных копий» должна лежать на классе. В таком случае, почему бы не предоставить такой же интерфейс интерфейса к нему, какdict а такжеlist делать? Итак, если ваш класс хочет взять на себя ответственность за копирование своих объектов, почему бы не добавитьif isinstance(arg, type(self)) пункт в__init__?
 Jared Smith21 февр. 2018 г., 15:05
Потому что вы не всегда можете контролировать классы, которые вы используете так, как вы их определяете. В качестве одного из примеров они могут быть программами на C, имеющими привязки Python (например, GTK, openalpr, части ядра). Не говоря уже о том, что даже если вы взяли стороннюю библиотеку и добавили методы копирования в каждый класс, как вы собираетесь встраивать это в управление зависимостями?
 Jared Smith21 февр. 2018 г., 14:24
Рассмотреть возможностьclass Foo(object): def __init__(self, arg): super(Foo, self).__init__() self.arg = arg Основное, как это получается. Если я сделаюfoo = Foo(3) bar = copy(foo) print(foo.arg) # 3 print(bar.arg) # <__main__.Foo object at ...> Это означает, что вашcopy функция нарушена даже для самых основных классов. Опять же, это аккуратный трюк (следовательно, нет DV), но не ответ.
Как я могу создать копию объекта в Python?

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

Вы имеете в виду изменчивый объект тогда.

В Python 3 списки получаютcopy Метод (в 2, вы бы использовали фрагмент, чтобы сделать копию):

>>> a_list = list('abc')
>>> a_copy_of_a_list = a_list.copy()
>>> a_copy_of_a_list is a_list
False
>>> a_copy_of_a_list == a_list
True
Мелкие копии

Мелкие копии - это всего лишь копии самого внешнего контейнера.

list.copy это мелкая копия:

>>> list_of_dict_of_set = [{'foo': set('abc')}
... ]
>>> list_of_dict_of_set = [{'foo': set('abc')}]
>>> lodos_copy = list_of_dict_of_set.copy()
>>> lodos_copy[0]['foo'].pop()
'c'
>>> lodos_copy
[{'foo': {'b', 'a'}}]
>>> list_of_dict_of_set
[{'foo': {'b', 'a'}}]

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

Глубокие копии

Глубокие копии - это рекурсивные копии каждого предмета интерьера.

>>> lodos_deep_copy = copy.deepcopy(list_of_dict_of_set)
>>> lodos_deep_copy[0]['foo'].add('c')
>>> lodos_deep_copy
[{'foo': {'c', 'b', 'a'}}]
>>> list_of_dict_of_set
[{'foo': {'b', 'a'}}]

Изменения не отражаются в оригинале, только в копии.

Неизменные предметы

Неизменяемые объекты обычно не нужно копировать. На самом деле, если вы попытаетесь, Python просто выдаст вам оригинальный объект:

>>> a_tuple = tuple('abc')
>>,;> tuple_copy_attempt = a_tuple.copy()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'copy'

У кортежей даже нет метода копирования, поэтому давайте попробуем его с фрагментом:

>>> tuple_copy_attempt = a_tuple[:]

Но мы видим, что это тот же объект:

>>> tuple_copy_attempt is a_tuple
True

Аналогично для строк:

>>> s = 'abc'
>>> s0 = s[:]
>>> s == s0
True
>>> s is s0
True

и для Frozensets, хотя у них естьcopy метод:

>>> a_frozenset = frozenset('abc')
>>> frozenset_copy_attempt = a_frozenset.copy()
>>> frozenset_copy_attempt is a_frozenset
True
Когда копировать неизменяемые объекты

Неизменные предметыдолжен копировать, если вам нужно скопировать изменяемый объект интерьера.

>>> tuple_of_list = [],
>>> copy_of_tuple_of_list = tuple_of_list[:]
>>> copy_of_tuple_of_list[0].append('a')
>>> copy_of_tuple_of_list
(['a'],)
>>> tuple_of_list
(['a'],)
>>> deepcopy_of_tuple_of_list = copy.deepcopy(tuple_of_list)
>>> deepcopy_of_tuple_of_list[0].append('b')
>>> deepcopy_of_tuple_of_list
(['a', 'b'],)
>>> tuple_of_list
(['a'],)

Как мы видим, когда внутренний объект копии видоизменяется, оригиналне менять.

Пользовательские объекты

Пользовательские объекты обычно хранят данные в__dict__ атрибут или в__slots__ (структура памяти, подобная кортежу.)

Чтобы сделать копируемый объект, определите__copy__ (для мелких копий) и / или__deepcopy__ (для глубоких копий).

from copy import copy, deepcopy

class Copyable:
    __slots__ = 'a', '__dict__'
    def __init__(self, a, b):
        self.a, self.b = a, b
    def __copy__(self):
        return type(self)(self.a, self.b)
    def __deepcopy__(self, memo): # memo is a dict of id's to copies
        id_self = id(self)        # memoization avoids unnecesary recursion
        _copy = memo.get(id_self)
        if _copy is None:
            _copy = type(self)(
                deepcopy(self.a, memo), 
                deepcopy(self.b, memo))
            memo[id_self] = _copy 
        return _copy

Обратите внимание, чтоdeepcopy хранит памятный словарьid(original) (или идентификационные номера) для копирования. Чтобы получить хорошее поведение с рекурсивными структурами данных, убедитесь, что вы еще не сделали копию, и, если она у вас есть, верните ее.

Итак, давайте сделаем объект:

>>> c1 = Copyable(1, [2])

А такжеcopy делает поверхностную копию:

>>> c2 = copy(c1)
>>> c1 is c2
False
>>> c2.b.append(3)
>>> c1.b
[2, 3]

А такжеdeepcopy сейчас делает глубокую копию:

>>> c3 = deepcopy(c1)
>>> c3.b.append(4)
>>> c1.b
[2, 3]

Мелкая копия сcopy.copy()

#!/usr/bin/env python3

import copy

class C():
    def __init__(self):
        self..y = [2]

# It copies.
c = C()
d = copy.copy(c)
d.x = [3]
assert c.x == [1]
assert d.x == [3]

# It's shallow.
c = C()
d = copy.copy(c)
d.x[0] = 3
assert c.x == [3]
assert d.x == [3]

Глубокая копия сcopy.deepcopy()

#!/usr/bin/env python3
import copy
class C():
    def __init__(self):
        self..y = [2]
c = C()
d = copy.deepcopy(c)
d.x[0] = 3
assert c.x == [1]
assert d.x == [3]

Документация:https://docs.python.org/3/library/copy.html

Проверено на Python 3.6.5.

Ваш ответ на вопрос