python oop initialization instance-variables

Class design: Initializing and updating instance variables elegantly

Sometimes I want to write a class with instance variables which should on the one hand be initialized inside __init__, but on the other hand also later be updatable via different functions (function_1 - function_3) either from the inside after some event happened or from the outside.

The update functions depend all on the same input parameter, but work the same in initialization and later update. They may be either members of the class (@staticmethod or not) or utility functions imported from some package.

For the later update, the "meta" update function (update_member_variables) clearly should be a procedure, i. e. return nothing and only modify the member variables as a side effect. However, for initialization it should better be a pure function and return the variables' values so that they can be assigned to the variables inside __init__.

This conflict always puts me through the following cycle of duplicated code, declarations outside __init__ and None-initializations, but never leads to a satisfying solution:

from some_utils import function_1, function_2, function_3


# A: duplicate code in update_member_variables
class Class:
    def __init__(self, parameter):
        self._variable_1 = function_1(parameter)
        self._variable_2 = function_2(parameter)
        self._variable_3 = function_3(parameter)

    def update_member_variables(self, parameter):
        self._variable_1 = function_1(parameter)
        self._variable_2 = function_2(parameter)
        self._variable_3 = function_3(parameter)


# B: instance variables declared outside __init__
class Class:
    def __init__(self, parameter):
        self.update_member_variables(parameter)

    def update_member_variables(self, parameter):
        self._variable_1 = function_1(parameter)
        self._variable_2 = function_2(parameter)
        self._variable_3 = function_3(parameter)


# C: boilerplate None-assignments
class Class:
    def __init__(self, parameter):
        self._variable_1 = None
        self._variable_2 = None
        self._variable_3 = None
        self.update_member_variables(parameter)

    def update_member_variables(self, parameter):
        self._variable_1 = function_1(parameter)
        self._variable_2 = function_2(parameter)
        self._variable_3 = function_3(parameter)


# D: back to duplicated code in update_member_variables
class Class:
    def __init__(self, parameter):
        (
            self._variable_1,
            self._variable_2,
            self._variable_3
        ) = self._derive_values(parameter)

    def _derive_values(self, parameter):
        return (
            function_1(parameter),
            function_2(parameter),
            function_3(parameter),
        )

    def update_member_variables(self, parameter):
        (
            self._variable_1,
            self._variable_2,
            self._variable_3
        ) = self._derive_values(parameter)

It is tempting to choose B, but because of all the warnings against member variable declarations outside of __init__, I usually stick with C or D although they seem bloated and bulky.

Isn't there any better way to solve this situation? Maybe outside the box? Or is the most "elegant" or clean one already among A-D?