Changing the class type of a class after inserted data

Question

I want to create a class in python, which should work like this:

1. Data assigned, maybe bound to a variable (eg a = exampleclass(data) or just exampleclass(data))

2. Upon being inserted data, it should automatically determine some properties of the data, and if some certain properties are fullfilled, it will automatically...

3. ... change class to another class

The part 3 is the part that i have problem with. How do i really change the class inside of the class? for example:

If I have two classes, one is Small_Numbers, and the other is Big_numbers; now I want any small_number smaller than 1000 to be transferred into a Big_number and vice versa, 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.

Is this possible to do?

Answer 1

Why not using a factory method? This one will decide which class to instanciate depending on the passed data. Using your example:

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

Answer 2

Don't. Use a factory function instead.

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

Using a factory method is the usual way to solve this, especially since instantiating a class is indistinguishable from calling a function in Python.

However, if you really want, you can assign to 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

This works as expected:

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

If assigning to self.__class__ seems too strange, then you can override __new__ instead. This method is called before __init__ is called and it can be used to pick the class to instantiate:

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