How to create a class share methods in memory and not replicate for each object in python3

Question

is more than anything a doubt but, I want to create a class that put in memory methods a single time and then instances that believes it can share these methods without these have to be put in memory for each one of them.

Answer 1

Methods are "put in memory" only once. Methods are sequences of bytecode instructions and will be stored only once. However, properties (methods operate on) are not.

I think, you are confusing the difference of class properties and object properties. Use them as shown in the following examples:

class Foo:
    def __init__(self):
        self.object_prop = None

    def set(self, val):
        self.object_prop = val

    def get(self):
        return self.object_prop

Then you can use it like this:

a = Foo()
a.set(3)
print(a.get())  # prints 3
b = Foo()
b.set(4)
print(a.get())  # prints 3

And the class properties example looks like this:

class Foo:
    class_prop = None

    @classmethod
    def set(cls, val):
        cls.class_prop = val

    @classmethod
    def get(cls):
        return cls.class_prop

a = Foo()
a.set(3)
print(a.get())  # prints 3
b = Foo()
b.set(4)
print(a.get())  # prints 4

Maybe this is, what you are looking for.

In the comments, you pointed out that you are looking for an implementation of singletons in python. In python, singletons are an anti-pattern and need to be avoided at all costs. However, a simple search on StackOverflow gives the following result:

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class Logger(metaclass=Singleton):
    pass

With this implementation, all objects will have the same memory address:

>>> id(Logger())
140202032740616
>>> id(Logger())
140202032740616