IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Overriding de methodes


Sujet :

Python

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre régulier
    Profil pro
    Inscrit en
    Septembre 2007
    Messages
    8
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2007
    Messages : 8
    Par défaut Overriding de methodes
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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

  2. #2
    Membre émérite
    Avatar de GnuVince
    Profil pro
    Développeur informatique
    Inscrit en
    Avril 2004
    Messages
    679
    Détails du profil
    Informations personnelles :
    Localisation : Canada

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2004
    Messages : 679
    Par défaut
    T'as pas besoin du __init__ dans DirItem

  3. #3
    Membre régulier
    Profil pro
    Inscrit en
    Septembre 2007
    Messages
    8
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2007
    Messages : 8
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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.

  4. #4
    Membre régulier
    Profil pro
    Inscrit en
    Septembre 2007
    Messages
    8
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2007
    Messages : 8
    Par défaut
    Python essaye effectivement d'executer la mathode de la classe la plus specialiser mais ici, le probleme, c'est que __initSize est prive.

    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.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [SWT] CLabel : override la methode shortenText
    Par soft-war dans le forum SWT/JFace
    Réponses: 2
    Dernier message: 19/06/2008, 12h10
  2. Overrider une methode
    Par Gregory.M dans le forum Windows Presentation Foundation
    Réponses: 13
    Dernier message: 24/05/2008, 11h38
  3. Overrider une methode
    Par Gregory.M dans le forum Windows Forms
    Réponses: 1
    Dernier message: 23/05/2008, 19h48
  4. Réponses: 2
    Dernier message: 16/11/2006, 11h55

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo