I have a code like:
x = 0
z = 0
b = 0
a = 0
[ ......., a, b, x, z]
As mentioned above, if you want to keep things simple, just use a eg
_ordering attribute, which manually keeps track of ordering. Otherwise, here is a metaclass approach (like the one Django uses), which creates an ordering attribute automatically.
Recording the original ordering
Classes don't keep track of the ordering of the attributes. You can however keep track of which order the field instances were created. For that, you'll have to use your own class for fields (not int). The class keeps track of how many instances have already been made and each instance takes note of its position. Here is how you would do it for your example (storing integers):
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 attribute automatically
Now that your fields have a number which can be used to order them, your parent class needs to use that somehow. You can do this a variety of ways, if I remember correctly, Django uses Metaclasses to do this, which is a bit wild for a simple class.
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.creation_counter) return new_class
Using this metaclass
So, how do you use this? First, you need to use our new
MyOrderedField class when defining your attributes. This new class will keep track of the order in which the fields were created:
class Ordered(object): __metaclass__ = BaseWithOrderedFields x = MyOrderedField(0) z = MyOrderedField(0) b = MyOrderedField(0) a = MyOrderedField(0)
Then you can access the ordered fields in our automatically created attribute
>>> ordered = Ordered() >>> ordered.ordered_fields [('x', 0), ('z', 0), ('b', 0), ('a', 0)]
Feel free to change this to an ordered dict or just return the names or whatever you need. Additionally, you can define an empty class with the
__metaclass__ and inherit from there.
Don't use this!
As you can see, this approach is a little overcomplicated and probably not suitable for most tasks or python developers. If you're newish to python, you'll probably spend more time and effort developing your metaclass than you would have if you just defined the ordering manually. Defining your own ordering manually is almost always going to be the best approach. Django do it automatically because the complicated code is hidden from the end developer, and Django is used far more often than it itself is written/maintained. So only if you're developing a framework for other developers, then metaclasses may be useful for you.