Me gustaría crear mi propio tipo de build-in namedtuple que tiene algunas características adicionales. Digamos que creamos una clase:

from collections import namedtuple
MyClass = namedtuple('MyClass', 'field1 field2')

Es inmutable, legible y simple. Ahora puedo crear instancias de MyClass:

myobj = MyClass(field1 = 1, field2 = 3.0)
print(myobj.field1, myobj.field2)

Mi requisito adicional es cuando se crea la instancia. Me gustaría comprobar sifield1 esint tipo yfield2 esfloat. Por ejemplo, si el usuario intenta crear una instancia de MyClass:

obj = MyClass(field1 = 1, field2 = 3.0) # instantiates ok
obj1 = MyClass(field1 = 'sometext', field2 = 3.0) # raises TypeError

Traté de hacer una tupla nombrada personalizada que pueda validar los tipos de datos (MyClass debería ser inmutable) algo como:

MyClass = modifiednamedtuple('MyClass', 'field1 field2', (int, float) )

pero se atascó :(.namedtuple es una función (no puede ser una clase base para modificado namedtuple), mis experimentos con metaclases fallaron.

¿Algún consejo o sugerencia?

ok, se me ocurrió una solución que podría no ser "limpia" o pitónica. Funciona excepto que mis objetos no son inmutables. ¿Cómo hacerlos inmutables? ¿Alguna sugerencia de cómo hacerlo más limpio y legible?

Aquí está mi código .:

def typespecificnamedtuple(name, *attr_definitions):

    def init(self, *args, **kwargs):
        valid_types = dict(attr_definitions) # tuples2dict
        for attr_name, value in kwargs.items():
            valid_type = valid_types[attr_name]
            if not isinstance(value, valid_type):
                raise TypeError('Cannot instantiate class '+ self.__name__+
                    '. Inproper datatype for '+ attr_name + '=' + str(value)+ 
                        ', expected '+str(valid_type) )
            setattr(self, attr_name, value)


    class_dict = {'__init__' : init, '__name__' : name}
    for attr_def in attr_definitions:
        class_dict[attr_def[0]] = attr_def[1] # attr_def is ('name', <type int>)

    customType = type(name, (object, ), class_dict )
    return customType

if __name__ == '__main__':
    MyClass = typespecificnamedtuple('MyClass', ('value', int), ('value2', float)  )
    mc = MyClass(value = 1, value2 = 3.0)
    mc.something = 1    # this assigment is possible :( how to make immutable?
    print(mc.__name__, mc.value, mc.value2, mc.something)
    mc1 = MyClass(value = 1, value2 = 'sometext')   # TypeError exception is raised

y salida de consola .:

MyClass 1 3.0 1
Traceback (most recent call last):
  File "/home/pawel/workspace/prices/prices.py", line 89, in <module>
    mc1 = MyClass(value = 1, value2 = 'sometext')   # TypeError exception is raised
  File "/home/pawel/workspace/prices/prices.py", line 70, in init
    ', expected '+str(valid_type) )
TypeError: Cannot instantiate class MyClass. Inproper datatype for value2=sometext, expected <class 'float'>