`A.__new__(B)` 的用例，即 python 中的“使用一个 class 制作另一个”

Question

I take

A.__new__(B)

to mean "use the A object-creating method to make an (uninitialized) B object".

What are some use cases where I can/should use such abilities?

More details

The question is about when could one use the some_cls.__new__(some_other_cls) capabilities

But since responders claim that the very use of __new__ is probably misled, I will show a situation where I'm (possibly misled) to think that using __new__ might be a good idea.

The actual context is that of json-serializing scikit-learn models in such a way that an edge device can deserialize and run a target method (eg 'predict'). Two important aspects here: (1) scikit-learn estimator classes' __init__ takes parameters concerning the fitting of a model, but the attributes needed to run the predict method are dynamically made in fit method, and (2) a light weight serialized model is preferable, and the edge device is probably running a light weight function (not the original scikit-learn method.

I hope the code below illustrates this situation sufficiently faithfully:

class Greeter:
    def __init__(self, greet):
        self.greet = greet
        
    def fit(self, this):
        self.greet_this_ = self.greet + ' ' + this
        
    def __call__(self):
        if not hasattr(self, 'greet_this_'):
            raise ValueError("Greeter not fit")
        return self.greet_this_

obj = Greeter("hello")
obj.fit('world')
assert obj() == 'hello world'

Here's some serialization code:

import json

def serialize(obj, needed_attrs):
    return json.dumps({a: getattr(obj, a) for a in needed_attrs})

class MethodLess: ...

def deserialize(obj_json, cls=MethodLess):
    obj = cls.__new__(cls)  # make the (unintialized) instance
    # Note: couldn't do obj = cls() because cls might need some inputs
    
    for k, v in json.loads(obj_json).items():  # fill it with it's attributes
        setattr(obj, k, v)

    return obj

obj_json = serialize(obj, ['greet_this_'])
deserialized_obj = deserialize(obj_json, cls=Greeter)
assert deserialized_obj() == 'hello world' == obj()

But we don't even need the original class, just the method we need to call.

class MinimalGreeter:
    def __call__(self):
        if not hasattr(self, 'greet_this_'):
            raise ValueError("Greeter not fit")
        return self.greet_this_
    
obj_json = serialize(obj, ['greet_this_'])
deserialized_obj = deserialize(obj_json, cls=MinimalGreeter)
assert deserialized_obj() == 'hello world' == obj()

Equivalently, in functional form...

def call(self):
    if not hasattr(self, 'greet_this_'):
        raise ValueError("Greeter not fit")
    return self.greet_this_
    
obj_json = serialize(obj, ['greet_this_'])
deserialized_obj = deserialize(obj_json, cls=MethodLess)
assert call(deserialized_obj) == 'hello world' == call(obj) == obj()

Answer 1

I can't think of any reason why you would want to call __new__ directly. But if you are asking why you might return a different type from __new__ , one example would be to return a proxy object or a different implementation based on what constructor arguments are passed. In other words it can be used as an alternative to the factory pattern.

EDIT: An example, as requested:

class _StandardSolver:
    def solve(self, x):
        print('Using standard algorithm')
        return x + 1

class _SpecialSolver:
    def solve(self, x):
        print('Using special algorithm')
        return x * x  # Imagine this algorithm is much more complicated, relying on a lot of class state, etc.

class ComplicatedProblemSolver:
    def __new__(cls, use_special_algo, *args, **kwargs):
        if use_special_algo:
            return _SpecialSolver(*args, **kwargs)
        else:
            return _StandardSolver(*args, **kwargs)

if __name__ == '__main__':
    solver = ComplicatedProblemSolver(use_special_algo=True)
    print('Solution:', solver.solve(5))

Answer 2

I would keep the details of how you (de)serialize an object in the class itself. Then deserialization can decode the JSON blob and extract the values necessary to be passed to __init__ . For example:

import json


class Greeter:
    def __init__(self, greet):
        self.greet = greet
        
    def fit(self, this):
        self.greet_this_ = self.greet + ' ' + this
        
    def __call__(self):
        if not hasattr(self, 'greet_this_'):
            raise ValueError("Greeter not fit")
        return self.greet_this_

    def to_json(self):
        return json.dumps({'greet': self.greet, 'greet_this_': self.greet_this_)

    @classmethod
    def from_json(cls, obj_json):
        d = json.loads(obj_json)
        obj = cls(d['greet'])
        obj.fit(d['greet_this_'])
        return obj
        

obj = Greeter("hello")
obj.fit('world')
assert obj() == 'hello world'


obj_json = obj.to_json()
deserialized_obj = Greeter.from_json(obj_json)
assert deserialized_obj() == 'hello world' == obj()