Class return key and value of my attributes

A practical way is to add the to_dict method to the class:

def to_dict(self):
    return self.__dict__

To get values as a key / value, just invoke the method: obj.to_dict() .

See the official documentation for __dict__ here .

  

See the working code here .

Yes - there are several ways to do this, and the more sensible ones will work together with your need to assign multiple fields from a formatted line.

Of course objects in Python have the __dict__ attribute, as in the other responses, which stores all the attributes of the object for you. Using __dict__ directly however is not something much done on a daily basis, because it does not discriminate who is who - for example, its self.linha attribute will be present in __dict__ along with the other fields. >

A very nice mechanism to do this kind of thing is to create a base class with a mechanism to access several fields by name from a configuration of the class itself that indicates characteristics of each field.

In this case, you only need the name of the field, its position on the line, and conversion function. The position can be given by the order you place the fields - then you can agree for example a class attribute fields , which is a sequence of pairs (name, conversion function), and put a method that populates and another that retrieves all those values.

class Base:
    fields = [('reg', str), ('indOper', str), ..., ('vlDoc',convFloat), ...]
    def __init__(self, linha):
          self.linha = linha.split('|')

And in fact, it's more practical if this "_fields" is a dictionary containing information about that field. As Python allows you to execute code in class creation, you can declare _fields in the most convenient way - for example, as a single string, and create the appropriate dictionary with a function:

converters = {'float': convFloat,  'int': convInt,  'date': convDate,  'str': str }

def create_fields(spec):
     from collections import OrderedDict
     fields = OrderedDict()
     for i, field_spec in enumerate(spec.split(',')):
          field_spec = field_spec.strip()  # remove espaços em branco
          field_name, converter_name = field_spec.split()
          # em cada campo guarda sua posição e a função de conversão:
          fields[field_name] = i, converters[converter_name] 

And now you can declare each class as:

class reg100(Base):
     fields = create_fields("reg str, indOper str, ..., vlDoc float, ...")

There is also __getattr__ : it is a special function that is called when Python does not find an attribute in an object - there Python calls this method by passing the name of the attribute. This allows the attribute name to be configured in some other way than as an explicitly settable in hardcoded code.

    def __getattr__(self, attr):
        try:       
            field = self.fields[attr]
        except IndexError:
            raise AttributeError
        return field[1](self.linha[field[0]]

With this, and only one row per derived class (and using the __init__ and __getattr__ function declared in the base), you define all classes in your project. And now, with that information in place, you can define common methods at will to retrieve all fields.

For example, to have all fields converted as a list - and more, with the decorator "property" can make it look like an attribute of the class:

@property
def field_values(self):
     return [converter(self.linha[position]) for position, converter in self.fields.values()]

@property
def field_dict(self):
    return {attr_name:value[1](self.linha[value[0]) for name, value in self.fields.items()   }

Place these 4 methods in your base class, and then declare your various classes as:

class Reg100(Base):
    fields = create_fields(""reg str, indOper str, ..., vlDoc float, ...")

and will ration all fields:

>>> r = Reg100(linha)
>>> r.reg 
(retorna o valor correspontente)
>>> r.field_values
(retorna uma lista com os valores, já convertidos para tipos Python)

Remembering that since your goal is to insert everything into a relational database - you could use an ORM like SQLALchmy to make that part easier. ORM alone will not assign linah values to class attributes, or prevent you from digitizing a more complex specification for each field - but you can combine the use of ORM with hints from these hints.