Overriding de methodes

Version imprimable

Bonjour a tous, avant de poser ma question, je pense qu'il est important de souligner le fait que je debute en python.

Je me pose des questions sur facon dont est geree l'overriding de methodes en python.
Voila mon code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class FSItem: #element file system def __init__(self): self.__initSize() def __initSize(self): raise NotImplementedError class DirItem(FSItem): #Specialisation d'un element 'file system' : les repertoires def __init__(self): FSItem.__init__(self) def __initSize(self): self.__size = 1 #instanciation d'un objet repertoire dir = DirItem() -> NotImplementedError //Exception
Sauf erreur de ma part, dans la meme situation en C++, c'est la methode la plus specialisee qui est appeler.
Visiblement ce n'est pas le cas ici, python ne va pas chercher la methode __initSize() implementee dans la classe fille (DirItem).

Question 1: Ai-je bien tout compris jusqu'ici ?
Question 2: N'est il pas possible de faire comprendre a python que j'aimerai bien qu'il aille chercher l'implementation de la methode de la classe fille ?

Le but, et vous l'aurez comrpis, c'est d'eviter d'appeler __initSize() dans les constructeurs de toutes les classes qui vont heriter de FSItem.

Merci d'avance pour vos lumieres.

---
Le sage ne dit pas ce qu'il sait, l'idiot ne sait pas ce qu'il dit

16/09/2007, 02h01
GnuVince

T'as pas besoin du __init__ dans DirItem

Dans quelle mesure n'ai-je pas besion d'appeler FSItem.__init__ dans DirItem.__init__ ?

- parce que FSItem.__init__ est automatiquement appele a l'instanciation de DirItem ?
- ou juste parce que dans le cas present FSItem.__init__ ne sert a pas grand chose ?
Saches que le code ci-dessous est un exemple minimaliste destine a illustrer la question posee

Voici le code complet

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
class FSItem: 
    def __init__(self, absPath, relPath):
        self.__hidden = False
        self.__absPath = absPath
        self.__relPath = relPath      
        self.__modTime = None
        self.__size = None
        self.__name = None
        self.__template = None
        self.__type = None   
 
        self.__initPath()
        self.__initName()
        self.__initSize()
        self.__initModTime()
 
    def __initPath(self):
        self.__absPath = os.path.normpath(self.__absPath)
        self.__relPath = os.path.normpath(self.__relPath)
 
    def __initName(self):
        self.__name = os.path.split(self.__absPath)[1]
 
    def __initSize(self):
        raise NotImplementedError
 
    def __initModTime(self):
        stats = os.lstat(self.path)
        self.__modTime =  datetime.date.fromtimestamp(stats[8])
 
    def display(self, indent):
        print "%sabsPath: %s" % (indent, self.__absPath)
        print "%srelPath: %s" % (indent, self.__relPath)
        print "%stype: %s" % (indent, self.__type)
        print "%sname: %s" % (indent, self.__name)
        print "%ssize: %s" % (indent, self.__size)
        print "%smtime: %s" % (indent, self.__modTime)
 
    def move(self, absPath):
        try:
            os.renames(self.path, absPath)
            return True
        except :      
            return False
 
class DirItem(FSItem):
    def __init__(self, absPath, relPath):
        FSItem.__init__(self, absPath, relPath)
        self.__entries = []
        self.__intiated = False
        self.__type = "Directory"
 
    def __initSize(self):
        sizes = []
        os.path.walk(self.__absPath, calcDirSize, sizes)
        total = 0
        for size in sizes:
            total = total + size
        self.__size = total
 
    def buildTree(self):
        for entry in os.listdir(self.__absPath):
            entryAbsPath = os.path.join(self.__absPath, entry)
            entryRelPath = os.path.join(self.__relPath, entry)
            if os.path.isdir(entryAbsPath):
                dir = DirItem(entryAbsPath, entryRelPath)
                self.__entries.append(dir)
            if os.path.isfile(entryAbsPath):               
                file = FileItem(entryAbsPath, entryRelPath)
                self.__entries.append(file)
        self.__intiated = True
 
    def display(self, indent):
        FSItem.display(indent)
        print "%sContent:" % indent
        for entry in self.__entries:
            entry.display(indent + "---")
 
def calcDirSize(arg, dir, files):
    for file in files:
        abs_path = os.path.join(dir, file)
        stats = os.lstat(abs_path)
        size = int(stats[6])
        arg.append(size)    
 
class FileItem(FSItem):
    def __init__(self, absPath, relPath):
        FSItem.__init__(self, absPath, relPath)
        self.__entries = []
        self.__intiated = False
        self.__type = "File"
 
    def __initSize(self):
        self.__size = int(os.stat(self.__absPath)[6])

---
Le sage ne dit pas ce qu'il sait, l'idiot ne sait pas ce qu'il dit.

16/09/2007, 14h03
psycofdj

Python essaye effectivement d'executer la mathode de la classe la plus specialiser mais ici, le probleme, c'est que __initSize est prive.

Citation:

ton problème vient du "name mangling" efféctué par python pour les méthodes commencant par deux underscores.
Afin de simuler les attributs privés, python transforme la méthode __initSize de la classe FSItem en une méthode _FSItem__initSize.
Vraisemblablement, c'est ce qui pose problème car la ligne self.__initSize() semble toujours résolue comme self._FSItem__initSize() et ce que tu voudrais est self._DirItem__initSize()

Si tu remplaces les méthodes __initSize par _initSize (par exemple) tu n'aura pas ce problème, et tu aura le comportement normal d'une méthode pour l'overriding (en python toute les méthodes sont virtuelles) : la méthode la plus spécialisée est appelée.