Memory alias between inherited and super classes in Python - class

Question

I build an inherited class (Folder) which creates an instance of itself. The problem is: the new instance which it creates copies the super class memory. I don't want this to enable recursive folder exploration. Let's say:
class FileOperator():
__dir = '.'
def __init__(self, dir:str):
self.__dir = dir
def get_dir(self):
return self.__dir
class Folder(FileOperator):
__sub_folders = {}
__files = {}
def __init__(self, dir:str):
super().__init__(dir)
def new_folder(self, name:str):
new_dir = self.get_dir() + name + '/'
folder = Folder(new_dir)
self.__sub_folders[name] = folder
return folder
def get_folder(self, name:str)
return self.__sub_folders[name]
This way we want to build new folders with same names under different folders and each instance would have different list of folders. Such as:
f = folder.get_folder('Data1').get_folder('subData1').get_folder('Data1')
When we do:
folder = Folder('./demo_data/')
sub_folder = folder.new_folder('demo_sub')
it creates a new sub_folder which has the same subfolders with its super's. sub_folder includes itself in its __sub_folders dictionary. When we try to reach a specific folder (e.g.: under categoryA, itemB), it confuses the other files and folders with same name in the dictionary. What it should do is to distinguish the two different subfolders with same name in different root folder.
So, we are not able to separate different sub folders when we access them with their names in the dictionary because each instance has the same list of subfolders generated so far. Therefore it confuses the names of different folder instances.
We need separated instances to access different folders with same name.
Should we use deepcopy here? (if yes, how?) Or should we have another meta class that controls the system with IoC (inversion of control)?