resolucion_de_clases_principiante.py

from  __future__ import print_function

class BaseA(object):

    def __init__(self):
        self.a = "A"


class BaseB(object):

    def __init__(self):
        self.b = "B"

# La herencia va de izquierda a derecha
# BaseA -> BaseB
class EjemploUno(BaseA, BaseB):
    pass


def test_uno():
    """Como EjemploUno no tiene constructor usa el
    constructor de la clase que hereda mas cercana en este caso "BaseA".

    Por lo tanto las instancias de EjemploUno solo tienen la propiedad
    "a" y no "b".
    """
    print("test_uno")
    uno = EjemploUno()
    assert hasattr(uno, 'a') and uno.a == "A"
    print("uno.a? %s and uno.a == %s" % (hasattr(uno, 'a'), uno.a))
    assert not hasattr(uno, 'b')
    print("uno.b? %s" % hasattr(uno, 'b'))


class EjemploDos(BaseA, BaseB):

    def __init__(self):
        self.c = "C"


def test_dos():
    """EjemploDos solo tiene la propiedad "c" y no "a" ni "b"
    por que la clase define su propio constructor.
    """
    print("test_dos")
    dos = EjemploDos()
    assert hasattr(dos, 'c') and dos.c == "C"
    print("dos.c? %s and dos.c == %s" % (hasattr(dos, 'c'), dos.c))
    assert not hasattr(dos, 'a')
    print("dos.a? %s" % hasattr(dos, 'a'))
    assert not hasattr(dos, 'b')
    print("dos.b? %s" % hasattr(dos, 'b'))


class EjemploTres(BaseA, BaseB):

    def __init__(self):
        BaseA.__init__(self)
        BaseB.__init__(self)
        self.c = "C"


def test_tres():
    """EjemploTres instancia el constructor de forma directa
    con las clases que hereda. La instancia va a tener
    las propidades "a", "b" y "c"
    """
    print("test_tres")
    tres = EjemploTres()
    assert hasattr(tres, 'a') and tres.a == "A"
    print("tres.a? %s and tres.a == %s" % (hasattr(tres, 'a'), tres.a))
    assert hasattr(tres, 'b') and tres.b == "B"
    print("tres.b? %s and tres.b == %s" % (hasattr(tres, 'b'), tres.b))
    assert hasattr(tres, 'c') and tres.c == "C"
    print("tres.c? %s and tres.c == %s" % (hasattr(tres, 'c'), tres.c))


class EjemploCuatro(BaseA, BaseB):

    def __init__(self):
        super(EjemploCuatro, self).__init__()
        self.c = "C"


def test_cuatro():
    """EjemploCuatro usa "super" para usar el algoritmo de resolucion
    de herencia en python el cual va a resolver que BaseA define constructor
    por lo que EjemploCuatro solo va a tener las propiedades "a" y "c".
    """
    print("test_cuatro")
    cuatro = EjemploCuatro()
    assert hasattr(cuatro, 'a') and cuatro.a == "A"
    print("cuatro.a? %s and cuatro.a == %s" % (hasattr(cuatro, 'a'), cuatro.a))
    assert hasattr(cuatro, 'c') and cuatro.c == "C"
    print("cuatro.c? %s and cuatro.c == %s" % (hasattr(cuatro, 'c'), cuatro.c))
    assert not hasattr(cuatro, 'b')
    print("cuatro.c? %s" % hasattr(cuatro, 'b'))


class EjemploCinco(BaseA, BaseB):

    def __init__(self):
        BaseB.__init__(self)
        self.c = "C"


def test_cinco():
    """EjemploCinco instancia directamente a BaseB
    y no llama a BaseA, saltanto la resolucion
    que la herencia comun.

    La instancia va a tener las propiedades "c" y "b" pero no "a".
    """
    print("test_cinco")
    cinco = EjemploCinco()
    assert hasattr(cinco, 'b') and cinco.b == "B"
    print("cinco.b? %s and cinco.b == %s" % (hasattr(cinco, 'b'), cinco.b))
    assert hasattr(cinco, 'c') and cinco.c == "C"
    print("cinco.c? %s and cinco.c == %s" % (hasattr(cinco, 'c'), cinco.c))
    assert not hasattr(cinco, 'a')
    print("cinco.a? %s" % hasattr(cinco, 'a'))


def main():
    test_uno()
    print()
    test_dos()
    print()
    test_tres()
    print()
    test_cuatro()
    print()
    test_cinco()


if __name__ == '__main__':
    main()