What's relationship between dict and attrs in python?

Question

I'm a beginner of python. I was learning meta-class but I did not quite understand how dictionary store methods and attributes?

class ModelMetaclass(type):
    def __new__(cls, name, bases, attrs):
        if name=='Model':
            return type.__new__(cls, name, bases, attrs)
        print('Found model: %s' % name)
        mappings = dict()
        for k, v in attrs.items():
            if isinstance(v, Field):
                print('Found mapping: %s ==> %s' % (k, v))
                mappings[k] = v
        for k in mappings.keys():
            attrs.pop(k)
        attrs['__mappings__'] = mappings
        attrs['__table__'] = name 
        return type.__new__(cls, name, bases, attrs)

I assume that attrs can store not only variables but methods. if it was doing so, what's keys and values in this dictionary, attrs?

Methods are just attributes that are callable. Object attributes are often stored in a dictionary, named `__dict__` (also an attribute, via a mechanism called 'slots'). — Martijn Pieters, Sep 17 '17 at 12:44
If you are a beginner, you can safely ignore metaclasses for a while. — chepner, Sep 17 '17 at 12:54
By the way, abbreviating "attributes" to "attrs" can create confusion because there is a popular Python library called [`attrs`](https://www.attrs.org) — mtraceur, Feb 27 '19 at 19:29

Martijn Pieters · Accepted Answer · 2017-09-17T12:55:46.393

All attributes of a class are indeed stored in a dictionary. Note that methods are just attributes too; they just happen to be callable. Python uses dictionaries in a lot of places; the global namespace of a module is a dictionary too, for example. It is usually the job of the object.__getattribute__ hook to translate attribute access into a key lookup in the attribute dictionary.

The body of a class statement is executed like a function, and the resulting local namespace (the dictionary produced by calling locals()) is then handed the metaclass to produce the class object. That's what attrs is bound to in you example code.

See the class statement reference documentation:

The class’s suite is then executed in a new execution frame (see [Naming and binding](The class’s suite is then executed in a new execution frame (see Naming and binding), using a newly created local namespace and the original global namespace. (Usually, the suite contains mostly function definitions.) When the class’s suite finishes execution, its execution frame is discarded but its local namespace is saved. A class object is then created using the inheritance list for the base classes and the saved local namespace for the attribute dictionary.

Bold emphasis mine.

You can find more detail in the Metaclasses section of the datamodel documentation; quoting the Creating the class object section:

Once the class namespace has been populated by executing the class body, the class object is created by calling metaclass(name, bases, namespace, **kwds)

The namespace dictionary is then attached to the newly-created class object by type.__new__().

The datamodel documentation covers this as well, under the Custom classes section:

A class has a namespace implemented by a dictionary object. Class attribute references are translated to lookups in this dictionary, e.g., C.x is translated to C.__dict__["x"] (although there are a number of hooks which allow for other means of locating attributes).

You may want to read up on descriptors as well; methods are created by binding functions found in the class namespace to the instance on which you looked up the method name.

What's relationship between dict and attrs in python?

1 Answers1