variable - stringvar tkinter python 3

Cambiar el tipo de clase de una clase después de los datos insertados

Question

Quiero crear una clase en python, que debería funcionar así:

1. Datos asignados, tal vez vinculados a una variable (por ejemplo, a = exampleclass(data) o simplemente exampleclass(data) )

2. Al ser insertados datos, debe determinar automáticamente algunas propiedades de los datos, y si se cumplen algunas propiedades, automáticamente ...

3. ... cambiar de clase a otra clase

La parte 3 es la parte con la que tengo un problema. ¿Cómo cambio realmente la clase dentro de la clase? por ejemplo:

Si tengo dos clases, una es Small_Numbers , y la otra es Big_numbers ; ahora quiero que cualquier small_number menor de 1000 se transfiera a Big_number y viceversa, testcode:

a = Small_number(50)
type(a) # should return Small_number.
b = Small_number(234234)
type(b) # should return Big_number.
c = Big_number(2)
type(c) # should return Small_number.

¿Es posible hacer esto?

Answer 1

¿Por qué no usar un método de fábrica? Éste decidirá qué clase instanciar dependiendo de los datos pasados. Usando tu ejemplo:

def create_number(number):
    if number < 1000:
        return SmallNumber(number)
    return BigNumber(number)

Answer 2

No lo hagas Use una función de fábrica en su lugar.

def create_number(source):
    if source < 1000:
       return Small_number(source)
    else:
       return Big_number(source)

a = create_number(50)
b = create_number(234234)
c = create_number(2)

Answer 3

Usar un método de fábrica es la forma habitual de resolver esto, especialmente dado que la creación de instancias de una clase no se puede distinguir de llamar a una función en Python.

Sin embargo, si realmente quieres, puedes self.__class__ a self.__class__ :

THRESHOLD = 1000

class Small(object):
    def __init__(self, n):
        if n < THRESHOLD:
            self.n = n
        else:
            self.__class__ = Big
            self.__init__(n)

class Big(object):
    def __init__(self, n):
        if n < THRESHOLD:
            self.__class__ = Small
            self.__init__(n)
        else:
            self.n = n

Esto funciona como se esperaba:

>>> a = Small(100)
>>> type(a)
<class ''Small''>
>>> b = Small(1234)
>>> type(b)
<class ''Big''>
>>> c = Big(2)
>>> type(c)
<class ''Small''>

Si asignar a self.__class__ parece demasiado extraño, entonces puede anular __new__ en __new__ lugar. Este método se llama antes de llamar a __init__ y se puede usar para elegir la clase para instanciar:

THRESHOLD = 1000

class Switcher(object):
    def __new__(cls, n):
        if n < THRESHOLD:
            new_cls = Small
        else:
            new_cls = Big
        instance = super(Switcher, new_cls).__new__(new_cls, n)
        if new_cls != cls:
            instance.__init__(n)
        return instance

class Small(Switcher):
    def __init__(self, n):
        self.n = n

class Big(Switcher):
    def __init__(self, n):
        self.n = n