Python 实例化一个新对象更好，还是简单地更新新数据的属性更好？

更新属性或只是实例化一个新对象更有效吗

例如：

class Position(object):
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    def update_position(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    def new_Position(self, message):
        self.update_position(message[0], message[1], message[2])

def new_Position(message):
    return Position(message[0], message[1], message[2])

---

您不应该进行过早的优化，在更新方法和某种工厂功能之间的选择主要是一种设计选择

无论如何，出于好奇，下面是两个调用之间的代码：

>>> p = Position(1,2,3)
>>> dis.dis(p.new_position)
 11           0 LOAD_FAST                0 (self)
              3 LOAD_ATTR                0 (update_position)
              6 LOAD_FAST                1 (message)
              9 LOAD_CONST               1 (0)
             12 BINARY_SUBSCR       
             13 LOAD_FAST                1 (message)
             16 LOAD_CONST               2 (1)
             19 BINARY_SUBSCR       
             20 LOAD_FAST                1 (message)
             23 LOAD_CONST               3 (2)
             26 BINARY_SUBSCR       
             27 CALL_FUNCTION            3
             30 POP_TOP             
             31 LOAD_CONST               0 (None)
             34 RETURN_VALUE        
>>> dis.dis(new_position)
  2           0 LOAD_GLOBAL              0 (Position)
              3 LOAD_FAST                0 (message)
              6 LOAD_CONST               1 (0)
              9 BINARY_SUBSCR       
             10 LOAD_FAST                0 (message)
             13 LOAD_CONST               2 (1)
             16 BINARY_SUBSCR       
             17 LOAD_FAST                0 (message)
             20 LOAD_CONST               3 (2)
             23 BINARY_SUBSCR       
             24 CALL_FUNCTION            3
             27 RETURN_VALUE

---

您不应该进行过早的优化，在更新方法和某种工厂功能之间的选择主要是一种设计选择

无论如何，出于好奇，下面是两个调用之间的代码：

>>> p = Position(1,2,3)
>>> dis.dis(p.new_position)
 11           0 LOAD_FAST                0 (self)
              3 LOAD_ATTR                0 (update_position)
              6 LOAD_FAST                1 (message)
              9 LOAD_CONST               1 (0)
             12 BINARY_SUBSCR       
             13 LOAD_FAST                1 (message)
             16 LOAD_CONST               2 (1)
             19 BINARY_SUBSCR       
             20 LOAD_FAST                1 (message)
             23 LOAD_CONST               3 (2)
             26 BINARY_SUBSCR       
             27 CALL_FUNCTION            3
             30 POP_TOP             
             31 LOAD_CONST               0 (None)
             34 RETURN_VALUE        
>>> dis.dis(new_position)
  2           0 LOAD_GLOBAL              0 (Position)
              3 LOAD_FAST                0 (message)
              6 LOAD_CONST               1 (0)
              9 BINARY_SUBSCR       
             10 LOAD_FAST                0 (message)
             13 LOAD_CONST               2 (1)
             16 BINARY_SUBSCR       
             17 LOAD_FAST                0 (message)
             20 LOAD_CONST               3 (2)
             23 BINARY_SUBSCR       
             24 CALL_FUNCTION            3
             27 RETURN_VALUE

---

取决于所述类的构造函数有多昂贵。这真的很广泛。它可能在内存或cpu方面很昂贵。它还取决于你是否真的想要一个新对象。如果它是示例中所示的构造函数呢。在哪一点上这样做太贵了？这个问题需要更多的具体用例才能得到一个像样的答案。在您的简单示例中，显然更新对象比保留更多内存来构造新对象更有效。大多数情况下，更新属性的效率更高。在您的示例中可以看到，属性赋值无论如何都会发生在构造函数中，以及创建新对象所需的其他工作。有时，不可变对象更容易使用，然后每次都必须创建新实例。如果你想要一个可变的对象，那么你应该更新属性，如果用户想要一个新的、不同的实例，他总是可以“手动”调用构造函数并从旧实例中获取值，或者使用

copy.deepcopy

。正如其他人已经说过的，创建一个新对象的成本更高，因为python需要做更多的事情，而不仅仅是设置属性，但我认为这样的设计决策不应该仅仅基于微观优化。这取决于所述类的构造函数的成本有多高。这真的很广泛。它可能在内存或cpu方面很昂贵。它还取决于你是否真的想要一个新对象。如果它是示例中所示的构造函数呢。在哪一点上这样做太贵了？这个问题需要更多的具体用例才能得到一个像样的答案。在您的简单示例中，显然更新对象比保留更多内存来构造新对象更有效。大多数情况下，更新属性的效率更高。在您的示例中可以看到，属性赋值无论如何都会发生在构造函数中，以及创建新对象所需的其他工作。有时，不可变对象更容易使用，然后每次都必须创建新实例。如果你想要一个可变的对象，那么你应该更新属性，如果用户想要一个新的、不同的实例，他总是可以“手动”调用构造函数并从旧实例中获取值，或者使用

copy.deepcopy

。正如其他人已经说过的，创建一个新对象的成本更高，因为python需要做更多的事情，而不仅仅是设置属性，但我认为这样的设计决策不应该仅仅基于微观优化。