Assigning separate logger to each class instance in Python as the instance's attribute

I am writing a library for simulating a certain distributed process, where we distinguish between one central entity and corresponding decentralised clients. Each client is represented as an instance of a general class client that serves as a boilerplate for it. During the simulation, each instance is independently kept in memory and has associated attributes that store its simulation data. I am trying to implement how to differentiate between different loggers for the central entity and each corresponding instance of a client class.

For now, my workaround is as follows: the Central Entity and Client Class are kept in different modules. On the top of each module, I import different loggers from my custom factory class to initialize at the beginning of each module.

class Loggers:
    @staticmethod
    def central_logger():
        central_logger = logging.getLogger("central_logger")
        central_logger.setLevel(logging.DEBUG)
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        ch = logging.StreamHandler()
        ch.setLevel(logging.DEBUG)
        ch.setFormatter(formatter)
        central_logger.addHandler(ch)
        central_logger.propagate = False
        return central_logger
    @staticmethod
    def client_logger():
        # Creating a head logger for the nodes
        client_logger = logging.getLogger("node_logger")
        client_logger.setLevel(logging.DEBUG)
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        zh = logging.StreamHandler()
        zh.setLevel(logging.DEBUG)
        zh.setFormatter(formatter)
        client_logger.addHandler(zh)
        client_logger.propagate = False
        return client_logger

This way, I am able to differentiate between central logger and client_logger. However, I tried to initialize an instance of the logger as an attribute of a class. For example:

class Client:
    def __init__(self) -> None:
        self.logger = Loggers.client_logger(*here we could pass arguments to individualise the logger for a particular client*)

This, however - does not return a satisfactory result, as each client is resetting to a default general logger by the end.

Is there a smart way to initialize a logger as an attribute of a class in the scenario described above?

Keeping your logger class as is here's how you could only initialise the logger once and have a child logger for each Client instance.

# Initialise logger
Loggers.client_logger()

class Client:
    def __init__():
        self.logger = logging.getLogger("node_logger").get_child(str(id(self)))