Home / Questions / 263723
Accepted
fedorqui
Asked: 2020-05-16 02:43:22 +0800 CST 2020-05-16 02:43:22 +0800 CST

How do I use a class variable in a method that has a different value between the class and its subclass?

  • 772

Suppose I have a class like this:

class Hola(object):
    NOMBRE = 'hola'

    def muestro_cosas(self):
        print('Mi nombre es {}'.format(Hola.NOMBRE))


class HolaPequenito(Hola):
    NOMBRE = 'hola_pequenito'

    ...

As you can see, it HolaPequenitois a subclass of Hola.

Now, I do an implementation of things where I need to use the class variable NOMBRE.

  • If I have an instance of Hola, I will do print (Hola.NOMBRE).
  • If I have an instance of HolaPequenito, I will do print (HolaPequenito.NOMBRE).

However, there are times when I don't know if I will be instantiating Holaor HolaPequenito, because I instantiate them dynamically within a large process, in which I need to know the value of NOMBREthe class that has been instantiated and do something like:

class Hola(object):
    NOMBRE = 'hola'

    def comprueba_cosas(self):
        if NOMBRE == 'hola':  # aquí debo usar la variable de clase
           ...
        elif NOMBRE == 'hola_pequenito':
           ...

That is to say: if I instantiate Holaor HolaPequenitowithout knowing which of the two I am instantiating, how can I access the NOMBRErespective class variable to do some heuristics?

The best I got was to define a class method that returns it to me :

class Hola(object):
    NOMBRE = 'hola'

    @classmethod 
    def bah(cls):     
        return cls.NOMBRE

But I don't know how to combine it to interact with the class variable NOMBREinside a method.

python

1 Answers

  1. Best Answer

    The class attribute can be accessed from the reference to an instance ( selfin this case) in several ways:

    • Using type:

      if type(self).NOMBRE == 'hola':

      which allows us to get the reference to the class ( type object) using the reference of an instance ( self).

    • Using the descriptor __class__directly:

      if self.__dict__.NOMBRE == 'hola':

      Accessing using __dict__is generally considered "non-pythonic" , so using typeis considered the appropriate method. This is common to other "magic" attributes such as __len__, which are semantically considered private and should be accessed through the means provided by the API, such as the buil-tin in these two cases.

      An exception is the hypothetical case of using Python 2 with old-style classes (not derived from object), in which case type(self)it doesn't work since it returns instanceas type, but it does self.__dict_. In Python 3 every class derives by default from Object, so this does not happen.

      Note that typeit does not always return the same as __class__, the function's own documentation suggests it:

      The return value is an object , type generally the same object returned by object.__class__.

      This is because it is perfectly possible to override the __class__ attribute in a derived class. This typically occurs, by its very nature, with proxy objects, without going any further weakref.proxythan the stdlib:

      import weakref


class Foo: 
    pass

obj = Foo()
p = weakref.proxy(obj)

print(type(p))      # <class 'weakproxy'>
print(p.__class__)  # <class '__main__.Foo'>

      So there are certain cases (besides old-style classes) where using __class__directly instead typeis either the solution or a very bad idea depending on the case.

    • Using a class method as a "getter" or "setter" as you expose is also a possibility.

      @classmethod 
def get_nombre(cls):     
    return cls.NOMBRE


if self.get_nombre() == 'hola':

      It is obviously sensitive to possible overrides or overlap with an instance method of the same name in future subclasses.

    • The class attribute can be accessed using simply self.attr. This is so, because Python first looks within the instance attributes, and if nothing is found, it looks within the class attributes.

      The risk is that if at some point a new instance attribute with the same name ( self.attr = algo) is defined, self.attrit will never refer to the class attribute again, but to the instance attribute. There are times when this behavior can be of interest, but if we don't want it, I think it's better to be explicit, as the zen of Python suggests :), and access the class attribute by a reference to the class and not by the instance.

    • 9