python - multiple - ¿Cómo leer los atributos de clase en el mismo orden que declarado?

importar clases en python

Question

Estoy escribiendo una metaclase que lee los atributos de clase y los almacena en una lista, pero quiero que la lista (cls.columns) respete el orden de las declaraciones (es decir: mycol2 , mycol3 , zut , cool , menfin , a en mi ejemplo) :

import inspect
import pprint
class Column(object):
pass
class ListingMeta(type):
def __new__(meta, classname, bases, classDict):
cls = type.__new__(meta, classname, bases, classDict)
cls.columns = inspect.getmembers(cls, lambda o: isinstance(o, Column))
cls.nb_columns = len(cls.columns)
return cls
class Listing(object):
__metaclass__ = ListingMeta
mycol2 = Column()
mycol3 = Column()
zut = Column()
cool = Column()
menfin = Column()
a = Column()
pprint.pprint(Listing.columns)

Resultado:

[(''a'', <__main__.Column object at 0xb7449d2c>),
(''cool'', <__main__.Column object at 0xb7449aac>),
(''menfin'', <__main__.Column object at 0xb7449a8c>),
(''mycol2'', <__main__.Column object at 0xb73a3b4c>),
(''mycol3'', <__main__.Column object at 0xb744914c>),
(''zut'', <__main__.Column object at 0xb74490cc>)]

Esto no respeta el orden de declaración de los atributos de Column() para la clase de Listing . Si uso classDict directamente, tampoco sirve de nada.

¿Cómo puedo proceder?

Answer 1

Aquí está la solución que desarrollé:

import inspect
class Column(object):
creation_counter = 0
def __init__(self):
self.creation_order = Column.creation_counter
Column.creation_counter+=1
class ListingMeta(type):
def __new__(meta, classname, bases, classDict):
cls = type.__new__(meta, classname, bases, classDict)
cls.columns = sorted(inspect.getmembers(cls,lambda o:isinstance(o,Column)),key=lambda i:i[1].creation_order)
cls.nb_columns = len(cls.columns)
return cls
class Listing(object):
__metaclass__ = ListingMeta
mycol2 = Column()
mycol3 = Column()
zut = Column()
cool = Column()
menfin = Column()
a = Column()
for colname,col in Listing.columns:
print colname,''=>'',col.creation_order

Answer 2

Basado en la solución de @Duncan, pero más simple (solo para python3 ). Usamos ese hecho, ese método __prepare__ devuelve un OrderDict lugar de un dict simple, por lo que todos los atributos recopilados antes de la llamada __new__ serán ordenados.

from collections import OrderedDict
class OrderedClass(type):
@classmethod
def __prepare__(mcs, name, bases):
return OrderedDict()
def __new__(cls, name, bases, classdict):
result = type.__new__(cls, name, bases, dict(classdict))
result.__fields__ = list(classdict.keys())
return result
class Column:
pass
class MyClass(metaclass=OrderedClass):
mycol2 = Column()
mycol3 = Column()
zut = Column()
cool = Column()
menfin = Column()
a = Column()

Ahora puede usar el atributo __fields__ para acceder a los atributos en el orden requerido:

m = MyClass()
print(m.__fields__)
[''__module__'', ''__qualname__'', ''mycol2'', ''mycol3'', ''zut'', ''cool'', ''menfin'', ''a'']

Tenga en cuenta que habrá attrs ''__module__'' , ''__qualname__'' nacidos de la clase de type . Para deshacerse de ellos, puede filtrar los nombres de la siguiente manera (cambiar OrderedClass.__new__ ):

def __new__(cls, name, bases, classdict):
result = type.__new__(cls, name, bases, dict(classdict))
exclude = set(dir(type))
result.__fields__ = list(f for f in classdict.keys() if f not in exclude)
return result

solo dará atributos de MyClass:

[''mycol2'', ''mycol3'', ''zut'', ''cool'', ''menfin'', ''a'']

por favor, recuerde que su respuesta solo es factible en python3.x, porque no hay definición de preparación en python2.7

Answer 3

En la versión actual de Python, el orden de clases se conserva. Ver PEP520 para más detalles.

En versiones anteriores del lenguaje (3.5 y siguientes, pero no 2.x), puede proporcionar una metaclase que use un OrderedDict para el espacio de nombres de la clase.

import collections
class OrderedClassMembers(type):
@classmethod
def __prepare__(self, name, bases):
return collections.OrderedDict()
def __new__(self, name, bases, classdict):
classdict[''__ordered__''] = [key for key in classdict.keys()
if key not in (''__module__'', ''__qualname__'')]
return type.__new__(self, name, bases, classdict)
class Something(metaclass=OrderedClassMembers):
A_CONSTANT = 1
def first(self):
...
def second(self):
...
print(Something.__ordered__)
# [''A_CONSTANT'', ''first'', ''second'']

Sin embargo, este enfoque no te ayuda con las clases existentes, donde necesitarás usar la introspección.

Answer 4

Para Python 3.6, este se ha convertido en el comportamiento predeterminado. Ver PEP520: PEP520

class OrderPreserved:
a = 1
b = 2
def meth(self): pass
print(list(OrderPreserved.__dict__.keys()))
# [''__module__'', ''a'', ''b'', ''meth'', ''__dict__'', ''__weakref__'', ''__doc__'']

Answer 5

Si está utilizando Python 2.x, necesitará un truco como el que propone Lennart. Si está utilizando Python 3.x, lea PEP 3115 ya que contiene un ejemplo que hace lo que desea. Simplemente modifique el ejemplo para que solo observe sus instancias de Columna ():

 # The custom dictionary
class member_table(dict):
def __init__(self):
self.member_names = []
def __setitem__(self, key, value):
# if the key is not already defined, add to the
# list of keys.
if key not in self:
self.member_names.append(key)
# Call superclass
dict.__setitem__(self, key, value)
# The metaclass
class OrderedClass(type):
# The prepare function
@classmethod
def __prepare__(metacls, name, bases): # No keywords in this case
return member_table()
# The metaclass invocation
def __new__(cls, name, bases, classdict):
# Note that we replace the classdict with a regular
# dict before passing it to the superclass, so that we
# don''t continue to record member names after the class
# has been created.
result = type.__new__(cls, name, bases, dict(classdict))
result.member_names = classdict.member_names
return result
class MyClass(metaclass=OrderedClass):
# method1 goes in array element 0
def method1(self):
pass
# method2 goes in array element 1
def method2(self):
pass

Answer 6

Supongo que deberías poder hacer una clase en la que reemplaces su __dict__ con un ordered-dict

Answer 7

Una respuesta que excluye métodos:

from collections import OrderedDict
from types import FunctionType
class StaticOrderHelper(type):
# Requires python3.
def __prepare__(name, bases, **kwargs):
return OrderedDict()
def __new__(mcls, name, bases, namespace, **kwargs):
namespace[''_field_order''] = [
k
for k, v in namespace.items()
if not k.startswith(''__'') and not k.endswith(''__'')
and not isinstance(v, (FunctionType, classmethod, staticmethod))
]
return type.__new__(mcls, name, bases, namespace, **kwargs)
class Person(metaclass=StaticOrderHelper):
first_name = ''First Name''
last_name = ''Last Name''
phone_number = ''000-000''
@classmethod
def classmethods_not_included(self):
pass
@staticmethod
def staticmethods_not_included(self):
pass
def methods_not_included(self):
pass
print(Person._field_order)