How to provide two different ways to instantiate

Let's say I have a class AmbiguousClass which has two attributes, a and b (let's say they are both int, but it could be more general). They are related by some invertible equation, so that I can calculate a from b and reciprocally.

I want to give the user the possibility to instantiate an AmbiguousClass by providing either a or b, depending on what is easier for them. Note that both ways to instantiate the variable can have the same signature, so this is not the typical polymorphism example. Providing none or both should result in an error/warning.

My best guess was something like this:

class AmbiguousClass():
    def __init__(self, a=None, b=None):
        #if no parameter is provided, we raise an error (can not instantiate)
        if a is None and b is None:
            raise SomeCustomError()

        #if both a and b are provided, this seems redundant, a warning is raised
        elif a is not None and b is not None:
            warnings.warn(f"are you sure that you need to specify both a and b?")
            self.a = a 
            self.b = b

        # if a is provided, we calculate b from it
        elif a is not None:
            self.a = a
            self.b = calculateB(self.a)

        # if b is provided:
        elif b is not None:
            self.b =b
            self.a = calculateA(self.b)

And then, the user would have to instantiate the class by specifying which keyword he is providing:

var1, var2 = AmbiguousClass(a=3), AmbiguousClass(b=6)

However, this feels a bit clunky, especially if the user decides to provide an argument without providing a keyword (it will by default be a, but that is not clear from the user's point of view and might lead to unexpected behaviors).

How can I do this within the __init__ function in a way that is clear and will avoid unexpected behavior?

I would enforce using custom constructors that only take a single parameter and clearly indicate which parameter is provided, thus avoiding ambiguity.

class AmbiguousClass:
    def __init__(self, a, b, _is_from_cls=False):
        if not _is_from_cls:
            raise TypeError(
                "Cannot instantiate AmbiguousClass directly."
                " Use classmethods 'from_a' or 'from_b' instead."
            )
        self.a = a
        self.b = b

    @classmethod
    def from_a(cls, a):
        b = calculateB(a)
        return cls(a=a, b=b, _is_from_cls=True)

    @classmethod
    def from_b(cls, b):
        a = calculateA(b)
        return cls(a=a, b=b, _is_from_cls=True)


var1 = AmbiguousClass.from_a(a=3)
var2 = AmbiguousClass.from_b(b=6)
var3 = AmbiguousClass(3, 6)  # will raise a TypeError
var4 = AmbiguousClass(3, 6, True)  # will not raise a TypeError but the user explicitly overwrites the default parameter.

You can enforce the use of keywords in the constructor.

This may be a matter of preference but I like to do as much "lazy" processing as possible - i.e., do the bare minimum during class construction

Something like this:

import warnings

class SomeCustomException(Exception):
    ...

class AmbiguousClass:
    def __init__(self, *, a=None, b=None):
        if a is None and b is None:
            raise SomeCustomException('At least one parameter must be specified')
        if a is not None and b is not None:
            warnings.warn('Are you sure that you need to specify both a and b?')
        self._a = a
        self._b = b
    def calculateA(self):
        return 999
    def calculateB(self):
        return 666
    @property
    def a(self):
        if self._a is None:
            self._a = self.calculateA()
        return self._a
    @property
    def b(self):
        if self._b is None:
            self._b = self.calculateB()
        return self._b


print(AmbiguousClass(a=3).b)

A better practice would be to not allow any ambiguity at all in the first place. That is, enforce the use of keyword arguments, and disallow the caller to provide both arguments at the same time--there is simply no good reason for it.

Enforcing keyword arguments can be done with the * syntax, while disallowing both arguments to be provided can be done by using a boolean comparison:

class UnambiguousClass:
    def __init__(self, *, a=None, b=None):
        assert (a is None) != (b is None), "Exactly one of `a` and `b` must be provided."
        if a is None:
             self.a = calculateA(b)
             self.b = b
        else:
             self.a = a
             self.b = calculateB(a)

Pythonic Approach for AmbiguousClass Instantiation with Two Different Ways

When designing a class like AmbiguousClass, where the instantiation can be done using two different attributes (a and b), while ensuring both are not provided simultaneously, you can indeed achieve a more Pythonic and cleaner implementation. To do this, we can utilize class methods as alternative constructors, allowing the user to provide a or b more intuitively without relying solely on keyword arguments.

Here's a more Pythonic approach using class methods:

class AmbiguousClass():
    def __init__(self, a=None, b=None):
        # If no parameter is provided, raise an error (cannot instantiate)
        if a is None and b is None:
            raise ValueError("Either 'a' or 'b' must be provided.")

        # If both a and b are provided, raise a warning
        elif a is not None and b is not None:
            warnings.warn("Are you sure that you need to specify both 'a' and 'b'?")

        # If a is provided, calculate b from it
        elif a is not None:
            self.a = a
            self.b = self.calculateB(self.a)

        # If b is provided:
        elif b is not None:
            self.b = b
            self.a = self.calculateA(self.b)

    @classmethod
    def from_a(cls, a):
        # Instantiate using 'a'
        return cls(a=a)

    @classmethod
    def from_b(cls, b):
        # Instantiate using 'b'
        return cls(b=b)

    @staticmethod
    def calculateB(a):
        # Your implementation to calculate 'b' from 'a'
        pass

    @staticmethod
    def calculateA(b):
        # Your implementation to calculate 'a' from 'b'
        pass

With this implementation, The use can now instantiate AmbiguousClass using the alternative constructors from_a() and from_b(), which provides clarity on what attribute they are providing. This approach helps to avoid unexpected behavior when you provide an argument without specifying the keyword.

Here's how you can now instantiate the class:

# Using the from_a() constructor
var1 = AmbiguousClass.from_a(3)

# Using the from_b() constructor
var2 = AmbiguousClass.from_b(6)

This approach promotes better readability and reduces the chances of unintentional errors, offering a more Pythonic and user-friendly way to instantiate AmbiguousClass with either a or b.