Python 无法创建覆盖为\uuu new的新对象实例__

我试图使用Python的

\uuuu new\uuuu

，以便在实例化类时返回与实际对象实例不同的内容（这是否聪明是另一种讨论）。下面是一个简单的示例，其中我从

\uuuuu new\uuuuu

返回了两个类实例的列表，而不是实际的类实例

class Foo(object):
    def __new__(cls, param):
        cls.__init__(cls, param=param)

def __init__(self, param):
    # remember that `self` here is `Foo`! so...
    self.param = param
    # ...means Foo.param = param, setting it class-wide!

从复制导入deepcopy
类TestClass：
def _;新__;（self，param=None）：
self.\uuuu init\uuuu（self，param=param）
return[deepcopy（self），deepcopy（self）]
def uuu init uuuu（self，param=None）：
self.param=param
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
a=TestClass（参数=1）
b=TestClass（参数=2）
打印（a[0]。参数）#打印2！

但是，我似乎无法使用此方法创建实际的对象实例，这可以在最小的示例中看到。

print

语句应打印1，但打印2，这意味着传递给

TestClass

的第二次调用的参数将覆盖第一次调用的参数。我猜

a

和

b

是对同一个静态类TestClass的引用，而我的deepcopy也没有帮助，因为它对静态类没有任何意义

如何调整

TestClass

的

\uuuuu new\uuuuu

和

\uuuuuu init\uuuuu

，以便我实际创建新实例（即print语句应该打印1，而不是2）

（Python 3.5）

编辑/小说明：我实际上不希望TestClass是静态的（如果这是正确的行话），但我的非功能性实现似乎产生了类似于静态类的东西

解决方案

感谢Kay，以下代码可以正常工作：

class TestClass（对象）：
定义新（cls，参数）：
instance1=对象。\uuuu新建\uuuuu（cls）
实例1.\uuuu init\uuuu（参数）
instance2=对象。\uuuuu新建\uuuuuu（cls）
实例2.初始化（参数）
返回实例1，实例2
定义初始化（self，param）：
self.param=param

您正在调用

\uuuu new\uuu

self

的第一个参数，但实际上它是类，通常称为

cls

。因此，您正在向类而不是实例写入

要实际获得两个实例，请使用：

class X(object):
    def __new__(cls, param):
        self1 = object.__new__(cls)
        self1.__init__(param)
        self2 = object.__new__(cls)
        self2.__init__(param)
        return self1, self2

---

您不能使用deepcopy，因为它将调用

X.\uuuu new\uuuu（）

（没有

param

参数），这将导致循环。

您正在调用

\uu new\uuuuuu>
self
的第一个参数，但它实际上是类，通常称为
cls
。因此，您正在向类而不是实例写入

要实际获得两个实例，请使用：

class X(object):
    def __new__(cls, param):
        self1 = object.__new__(cls)
        self1.__init__(param)
        self2 = object.__new__(cls)
        self2.__init__(param)
        return self1, self2

您不能使用deepcopy，因为它将调用
X.\uuu new\uuuu（）
（没有
param
参数），这将导致循环。
如果为
\uu new\uu>使用正确的参数，则会突出显示导致
param
在类范围内共享的特定问题。正如@Kay在他的回答中提到的，
\uuuuuu new\uuuuu
接受类作为第一个参数，而不是实例

class Foo(object):
    def __new__(cls, param):
        cls.__init__(cls, param=param)

def __init__(self, param):
    # remember that `self` here is `Foo`! so...
    self.param = param
    # ...means Foo.param = param, setting it class-wide!

这就是错误所在，因为
\uuuu init\uuu
在需要实例时会得到一个类

class Foo(object):
    def __new__(cls, param):
        cls.__init__(cls, param=param)

def __init__(self, param):
    # remember that `self` here is `Foo`! so...
    self.param = param
    # ...means Foo.param = param, setting it class-wide!

如果为
\uuuu new\uuuu
使用正确的参数，则会突出显示导致
参数在类范围内共享的特定问题。正如@Kay在他的回答中提到的，
\uuuuuu new\uuuuu
接受类作为第一个参数，而不是实例

class Foo(object):
    def __new__(cls, param):
        cls.__init__(cls, param=param)

def __init__(self, param):
    # remember that `self` here is `Foo`! so...
    self.param = param
    # ...means Foo.param = param, setting it class-wide!

这就是错误所在，因为
\uuuu init\uuu
在需要实例时会得到一个类

class Foo(object):
    def __new__(cls, param):
        cls.__init__(cls, param=param)

def __init__(self, param):
    # remember that `self` here is `Foo`! so...
    self.param = param
    # ...means Foo.param = param, setting it class-wide!

@卡罗利霍瓦特，OP承认这项任务的可疑意义。当然，你不应该在生产中这样做。但是如果你只想了解
\uuuu new\uuuu
的意思，那么我想这个问题是可以接受的。@KarolyHorvath为什么不呢？OP希望
TestClass（1）
给出两个类型为
TestClass
的对象的元组，其属性
param
等于
1
。这很奇怪，我不想在野外遇到任何东西，但这是一个有效的学习工具。太好了，谢谢！很明显，这个例子没有意义，它实际上只是了解
\uuuu new\uuuu
@KarolyHorvath的一个代理，OP承认了这个任务的可疑意义。当然，你不应该在生产中这样做。但是如果你只想了解
\uuuu new\uuuu
的意思，那么我想这个问题是可以接受的。@KarolyHorvath为什么不呢？OP希望
TestClass（1）
给出两个类型为
TestClass
的对象的元组，其属性
param
等于
1
。这很奇怪，我不想在野外遇到任何东西，但这是一个有效的学习工具。太好了，谢谢！显然，这个例子没有意义，它实际上只是学习
\uuuuu new\uuuuu
的一个代理。谢谢，这帮助我理解了！谢谢，这让我明白了！