python - 如何在 Python 中内存类实例化？

Question

好的，这是现实世界的场景:我正在编写一个应用程序，并且我有一个代表某种类型文件的类(在我的例子中，这是照片，但该细节与问题无关)。 Photo 类的每个实例对于照片的文件名都应该是唯一的。

问题是，当用户告诉我的应用程序加载文件时，我需要能够识别文件何时已加载，并为该文件名使用现有实例，而不是在同一文件名上创建重复实例。

对我来说，这似乎是一个使用内存的好情况，并且有很多这样的例子，但在这种情况下，我不仅仅是内存一个普通的函数，我需要内存 __init__( )。这带来了一个问题，因为当 __init__() 被调用时已经为时已晚，因为已经创建了一个新实例。

在我的研究中，我发现了 Python 的 __new__() 方法，我实际上能够编写一个可行的简单示例，但是当我尝试在我的真实世界对象上使用它时它就崩溃了，我不知道为什么(我唯一能想到的是我的真实世界对象是我无法真正控制的其他对象的子类，因此这种方法存在一些不兼容)。这就是我所拥有的:

class Flub(object):
    instances = {}

    def __new__(cls, flubid):
        try:
            self = Flub.instances[flubid]
        except KeyError:
            self = Flub.instances[flubid] = super(Flub, cls).__new__(cls)
            print 'making a new one!'
            self.flubid = flubid
        print id(self)
        return self

    @staticmethod
    def destroy_all():
        for flub in Flub.instances.values():
            print 'killing', flub


a = Flub('foo')
b = Flub('foo')
c = Flub('bar')

print a
print b
print c
print a is b, b is c

Flub.destroy_all()

哪个输出这个:

making a new one!
139958663753808
139958663753808
making a new one!
139958663753872
<__main__.Flub object at 0x7f4aaa6fb050>
<__main__.Flub object at 0x7f4aaa6fb050>
<__main__.Flub object at 0x7f4aaa6fb090>
True False
killing <__main__.Flub object at 0x7f4aaa6fb050>
killing <__main__.Flub object at 0x7f4aaa6fb090>

太完美了!对于给定的两个唯一 id，只创建了两个实例，而 Flub.instances 显然只列出了两个。

但是当我尝试对我正在使用的对象采用这种方法时，我得到了各种关于 __init__() 如何只接受 0 个参数而不是 2 个参数的荒谬错误。所以我会改变一些事情，然后它会告诉我 __init__() 需要一个参数。太奇怪了。

在和它打了一阵子之后，我基本上放弃了，把所有的__new__()黑魔法都移到了一个叫做get的静态方法中，这样我就可以调用Photograph.get(filename) 如果文件名不在 Photograph.instances 中，它只会调用 Photograph(filename)。

有人知道我哪里出错了吗？有没有更好的方法来做到这一点？

另一种思考方式是，它类似于单例，只是它不是全局单例，只是每个文件名的单例。

Here's my real-world code using the staticmethod get如果你想一起看。

Answer 1

让我们看看关于您的问题的两点。

使用备忘录

你可以使用 memoization，但你应该装饰 class，而不是 __init__ 方法。假设我们有这个 memoizator:

def get_id_tuple(f, args, kwargs, mark=object()):
    """ 
    Some quick'n'dirty way to generate a unique key for an specific call.
    """
    l = [id(f)]
    for arg in args:
        l.append(id(arg))
    l.append(id(mark))
    for k, v in kwargs:
        l.append(k)
        l.append(id(v))
    return tuple(l)

_memoized = {}
def memoize(f):
    """ 
    Some basic memoizer
    """
    def memoized(*args, **kwargs):
        key = get_id_tuple(f, args, kwargs)
        if key not in _memoized:
            _memoized[key] = f(*args, **kwargs)
        return _memoized[key]
    return memoized

现在你只需要装饰类:

@memoize
class Test(object):
    def __init__(self, somevalue):
        self.somevalue = somevalue

让我们看看测试？

tests = [Test(1), Test(2), Test(3), Test(2), Test(4)]
for test in tests:
    print test.somevalue, id(test)

输出如下。请注意，相同的参数会产生相同的返回对象的 id:

1 3072319660
2 3072319692
3 3072319724
2 3072319692
4 3072319756

无论如何，我更愿意创建一个函数来生成对象并对其进行内存。对我来说似乎更干净，但这可能是一些无关紧要的小问题:

class Test(object):
    def __init__(self, somevalue):
        self.somevalue = somevalue

@memoize
def get_test_from_value(somevalue):
    return Test(somevalue)

使用 __new__:

当然，您也可以覆盖 __new__。前几天我发了an answer about the ins, outs and best practices of overriding __new__这可能会有所帮助。基本上，它说总是将 *args, **kwargs 传递给您的 __new__ 方法。

一方面，我更喜欢内存一个创建对象的函数，或者甚至编写一个特定的函数来处理永远不会为相同参数重新创建对象的函数。当然，不过，这主要是我的意见，而不是规则。