如何获得在 Python 中创建类实例的顺序？

Question

这就是我想要做的。我正在尝试制作一个创建Note由NoteBlocks 组成的笔记应用程序。人们通常会Note从第一个块创建到最后一个块，所以我想以某种方式按创建顺序对类实例进行排序。有没有办法以某种方式获取实例的创建数量？我创建的第一个实例有 1，第二个有 2，依此类推。或者，我已经想到了另一种方法来做到这一点。如果我能以某种方式使新创建NoteBlock的块指向已创建的前一个块，我将能够像简单的链表一样对它们进行排序。我能想到的最糟糕的方法是给每个实例一个物理self.created_at属性，以便在创建时对其进行排序，但我认为这是一种愚蠢的方法，希望还有另一种方法。鉴于我的情况，你建议我做什么？from datetime import datetimeClass NoteBlock():  def __init__(self):    self.contents = None    self.previous = None    self.created_at = datetime.now()    returna = Foo()b = Foo()c = Foo()d = Foo()

Answer 1

您可以使用类变量来跟踪创建的实例数：

class NoteBlock:

    instance_count = 0  # <== Note strange placement:

                        #     it's a class variable (also

                        #     called "class attribute")

    def __init__(self):

        NoteBlock.instance_count += 1   # <== Note class namespace (NoteBlock)

        self.instance_number = NoteBlock.instance_count

    def __str__(self):

        return str(self.instance_number)

note1 = NoteBlock()

note2 = NoteBlock()

note3 = NoteBlock()

note4 = NoteBlock()

# ...and for good measure, assign note2 another instance

#

note2 = NoteBlock()

print(note1)

print(note2)

print(note3)

print(note4)

输出：

1

5

3

4

Answer 2

对象不会自动保存实例化时间；为此，您必须添加一个属性并在__init__当时保存（如您所示）。

但是，如果您不喜欢创建对象本身的属性，您也可以在外部按顺序包含对象的数据结构，例如一个简单的列表：

foos = []

foos.append(Foo())

...

foos.append(Foo())

...

foos.append(Foo())

...

foos[0] #the first created

foos[1] #the second

foos[2] #the third

Answer 3

我想扩展 Hkoof 提供的类变量解决方案，通过添加对实例的直接引用，这也有助于保持类一致的实例列表，允许访问上一个/下一个创建的实例。

唯一的问题（实际上，其他解决方案也没有涵盖）是实例的删除需要显式的方法调用，这是del不够的：__del__仅在没有对对象的引用时才调用。由于显然无法知道用户/程序员是否保留了对它的任何引用，因此我们需要一种明确的方法来做到这一点；它不能确保实例将被垃圾收集，因为只有在没有对它的引用时才会发生这种情况。

class NoteBlock(object):

    instancies = []

    def __init__(self, id):

        self.id = id

    def __new__(cls, *args, **kwargs):

        instancy = object.__new__(cls)

        cls.instancies.append(instancy)

        return instancy

    def delete(self):

        self.instancies.remove(self)

    # the following property methods are only useful for "browsing" between the

    # instance list

    @property

    def previous(self):

        try:

            # "-1" index returns the last object in the instancies list, we

            # don't want that...

            previous_index = self.instancies.index(self) - 1

            assert previous_index >= 0

            return self.instancies[previous_index]

        except:

            return

    @property

    def next(self):

        try:

            return self.instancies[self.instancies.index(self) + 1]

        except:

            return

# create some random objects

from random import randrange

scope_instance_list = []

print('Creating instancies:')

for i in range(8):

    index = randrange(100)

    block = NoteBlock(index)

    scope_instance_list.append(block)

    print('\t{} - Block {} created'.format(i + 1, index))

# remove a single instance

toRemoveIndex = randrange(8)

toRemove = scope_instance_list.pop(toRemoveIndex)

print('\nRemoving instance n. {} ({})...'.format(toRemoveIndex + 1, format(toRemove.id)))

# we can't use "del", as the __del__ magic method only works as soon as there is

# *no* reference left for the object: since we're keeping the "instancies" list

# it will never be called, then we need to use an "internal" way to do that;

# keep in mind that if you have *any* reference to that object, it will never be

# garbage collected until it's "released".

toRemove.delete()

print('Done!\n')

# show the current instance list, including previous and next instancies,

# according to the existing objects

print('Remaining instance list (class instance based):')

for i, inst in enumerate(block.instancies):

    print('\t{} - Block {}: previous: {}, next: {}'.format(

        i + 1, 

        inst.id, 

        inst.previous.id if inst.previous else None, 

        inst.next.id if inst.next else None))

示例输出：

Creating instancies:

    1 - Block 10 created

    2 - Block 23 created

    3 - Block 4 created

    4 - Block 28 created

    5 - Block 9 created

    6 - Block 67 created

    7 - Block 70 created

    8 - Block 73 created

Removing instance n. 5 (9)...

Done!

Remaining instance list (class instance based):

    1 - Block 10: previous: None, next: 23

    2 - Block 23: previous: 10, next: 4

    3 - Block 4: previous: 23, next: 28

    4 - Block 28: previous: 4, next: 67

    5 - Block 67: previous: 28, next: 70

    6 - Block 70: previous: 67, next: 73

    7 - Block 73: previous: 70, next: None