如何获取原始订单中的字段？

Question

我有一个类似的代码：

class Ordered(object):
    x = 0
    z = 0
    b = 0
    a = 0

print(dir(Ordered))

它打印：

[ ......., a, b, x, z]

如何以原始顺序获取字段：x，z，b，a？ 我在 Django 模型中看到了类似的行为。

Answer 1

如上所述，如果您想让事情变得简单，只需使用 _ordering 属性即可手动跟踪排序。否则，这里有一种元类方法（就像 Django 使用的方法），它自动创建一个排序属性。

记录原始顺序

类不跟踪属性的顺序。但是，您可以跟踪字段实例的创建顺序。为此，您必须使用自己的字段类（而不是 int）。该类会跟踪已创建的实例数量，并且每个实例都会记录其位置。以下是您在示例中的操作方法（存储整数）：

class MyOrderedField(int):
  creation_counter = 0

  def __init__(self, val):
    # Set the instance's counter, to keep track of ordering
    self.creation_counter = MyOrderedField.creation_counter
    # Increment the class's counter for future instances
    MyOrderedField.creation_counter += 1

自动创建 ordered_items 属性

现在您的字段有一个可用于对它们进行排序的数字，您的父类需要以某种方式使用它。你可以通过多种方式来做到这一点，如果我没记错的话，Django 使用元类来做到这一点，这对于一个简单的类来说有点疯狂。

class BaseWithOrderedFields(type):
  """ Metaclass, which provides an attribute "ordered_fields", being an ordered
      list of class attributes that have a "creation_counter" attribute. """

  def __new__(cls, name, bases, attrs):
    new_class = super(BaseWithOrderedFields, cls).__new__(cls, name, bases, attrs)
    # Add an attribute to access ordered, orderable fields
    new_class._ordered_items = [(name, attrs.pop(name)) for name, obj in attrs.items()
                                    if hasattr(obj, "creation_counter")]
    new_class._ordered_items.sort(key=lambda item: item[1].creation_counter)
    return new_class

使用这个元类

那么，如何使用它呢？首先，您在定义属性时需要使用我们新的 MyOrderedField 类。这个新类将跟踪创建字段的顺序：

class Ordered(object):
  __metaclass__ = BaseWithOrderedFields

  x = MyOrderedField(0)
  z = MyOrderedField(0)
  b = MyOrderedField(0)
  a = MyOrderedField(0)

然后您可以在我们自动创建的属性 ordered_fields 中访问有序字段：

>>> ordered = Ordered()
>>> ordered.ordered_fields
[('x', 0), ('z', 0), ('b', 0), ('a', 0)]

随意将其更改为有序字典或仅返回名称或任何您需要的内容。此外，您可以使用 __metaclass__ 定义一个空类并从那里继承。

不要使用这个！

正如您所看到的，这种方法有点过于复杂，可能不适合大多数任务或 python 开发人员。如果您是 Python 新手，那么与手动定义排序相比，您可能会花费更多的时间和精力来开发元类。手动定义自己的排序几乎总是最好的方法。 Django 会自动执行此操作，因为复杂的代码对最终开发人员来说是隐藏的，并且 Django 的使用频率远高于其本身的编写/维护频率。因此，只有当您正在为其他开发人员开发框架时，元类可能对您有用。

Answer 2

当威尔发布他的答案时，我已经完成了 80% 的工作，但我决定无论如何都要发布，这样我的努力就不会白费（我们的答案基本上描述了同样的事情）。

Django 是这样做的。我选择保留与 Django 相同的命名法、方法和数据结构，因此这个答案对于试图了解 Django 中字段名称如何排序的人也可能有用。

from bisect import bisect

class Field(object):
    # A global creation counter that will contain the number of Field objects
    # created globally.
    creation_counter = 0

    def __init__(self, *args, **kwargs):
        super(Field, self).__init__(*args, **kwargs)
        # Store the creation index in the "creation_counter" of the field.
        self.creation_counter = Field.creation_counter
        # Increment the global counter.
        Field.creation_counter += 1
        # As with Django, we'll be storing the name of the model property
        # that holds this field in "name".
        self.name = None

    def __cmp__(self, other):
        # This specifies that fields should be compared based on their creation
        # counters, allowing sorted lists to be built using bisect.
        return cmp(self.creation_counter, other.creation_counter)

# A metaclass used by all Models
class ModelBase(type):
    def __new__(cls, name, bases, attrs):
        klass = super(ModelBase, cls).__new__(cls, name, bases, attrs)
        fields = []
        # Add all fields defined for the model into "fields".
        for key, value in attrs.items():
            if isinstance(value, Field):
                # Store the name of the model property.
                value.name = key
                # This ensures the list is sorted based on the creation order
                fields.insert(bisect(fields, value), value)
        # In Django, "_meta" is an "Options" object and contains both a
        # "local_fields" and a "many_to_many_fields" property. We'll use a
        # dictionary with a "fields" key to keep things simple.
        klass._meta = { 'fields': fields }
        return klass

class Model(object):
    __metaclass__ = ModelBase

现在让我们定义一些示例模型：

class Model1(Model):
    a = Field()
    b = Field()
    c = Field()
    z = Field()

class Model2(Model):
    c = Field()
    z = Field()
    b = Field()
    a = Field()

然后让我们测试它们：

>>>> [f.name for f in Model1()._meta['fields']]
['a', 'b', 'c', 'z']
>>>> [f.name for f in Model2()._meta['fields']]
['c', 'z', 'b', 'a']

希望这有助于澄清威尔的答案中尚未明确的任何内容。

Answer 3

class SchemaItem():
    def __init__(self,item):
        self.item = item
        time.sleep(0.1)
        self.order = datetime.now()

    def __str__(self):
        return "Item = %s, Order = %s"%(self.item, self.order)

class DefiningClass():
    B       = SchemaItem("B")
    C       = SchemaItem("C")
    A       = SchemaItem("A")
    PRODUCT = SchemaItem("PRODUCT")
    ASSSET  = SchemaItem("ASSET")
    TENOR   = SchemaItem("TENOR")

    def get_schema(self):
        self_class = self.__class__
        attributes = [x for x in dir(self_class) if x not in ["class","name","schema","values"]]
        schema     = [(attribute_name,getattr(self_class,attribute_name)) for attribute_name in attributes if isinstance(getattr(self_class,attribute_name),SchemaItem)]
        return dict(schema)

# Actual usage
ss = [(name,schema_item) for name,schema_item in s.get_schema().items()]
print "Before = %s" % ss
ss.sort(key=lambda a:a[1].order)
print "After =%s" % ss

Answer 4

Django 的模型和表单元类与字段描述符一起工作以维持原始顺序。如果不跳过很多的障碍，就不可能完成你所要求的事情。如果您仍然感兴趣，请参阅 Django 源代码。

Answer 5

您无法跟踪类变量的添加顺序。这些属性（以及对象上的属性）在内部存储为字典，该字典针对快速查找进行了优化，并且不支持排序。

您可以看到这个事实：

class A(object):
    x = 0
    y = 0
    z = 0

A.__dict__.items()

#  [('__module__', '__main__'), 
#   ('__dict__', <attribute '__dict__' of 'A' objects>), 
#   ('y', 0), ('x', 0), ('z', 0), 
#   ('__weakref__', <attribute '__weakref__' of 'A' objects>), 
#   ('__doc__', None)]

如果您希望属性按特定顺序排列，您可以添加另一个包含以下信息的字段：

class B(object):
    x = 0
    y = 0
    z = 0
    a = 0
    _ordering = ['x', 'y', 'z', 'a']

print B._ordering
# => ['x', 'y', 'z', 'a']

旁注：在 python 2.7 和 3.2 中，有序字典将作为标准库的一部分引入。

Answer 6

现在只使用Python 3.6！

class OrderedClass():
    x = 0
    z = 0
    a = 0
    b = 0

print(list(OrderedClass.__dict__))

这输出我：

['__module__', 'x', 'z', 'a', 'b', '__dict__', '__weakref__', '__doc__']