méthodes de méthode

Version imprimable

26/09/2007, 16h20
airod

méthodes de méthode
bonjour, je me demande s'il est possible de créer des méthode dans une méthode.
je m'explique.
En C#, on peu créer des accesseurs qui permet d'obtenir le contenu d'une variable ou de la modifier en fonction de la maniére dont on utilise la méthode.
j'aimerai reproduire ce comportement en python.

du style :
Code:

1 2 3 4 5 def accesMaVar(self): def setMaVar(self): return self.MaVar def getMaVar(self,value): self.MaVar=value
seulement, ca ne fonctionne pas. Alors je me demande si cela est possible?
merci.
26/09/2007, 16h37
anthyme

http://www.developpez.net/forums/sho...d.php?t=396298

Code:

1
2
3
4
5
6
7
8
9
 
class Foo:
  def __init__(self):
    self.bar = 'bar'
 
foo = Foo()
foo.bar # => 'bar'
foo.bar = 'baz'
foo.bar # => 'baz'

Voici pourquoi je pose cette question, si qqu'un peut m'expliquer.

bout de code extrait dufichier Image.py de la bibliothèque PIL

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def rotate(self, angle, resample=NEAREST, expand=0):
        "Rotate image.  Angle given as degrees counter-clockwise."

        if expand:
            import math
            angle = -angle * math.pi / 180
            matrix = [
                 math.cos(angle), math.sin(angle), 0.0,
                -math.sin(angle), math.cos(angle), 0.0
                 ]
            def transform(x, y, (a, b, c, d, e, f)=matrix):
                return a*x + b*y + c, d*x + e*y + f #### c'est bien une fonction encapsulé dans une autre, non !!?

            # calculate output size
            w, h = self.size
            xx = []
            yy = []
            for x, y in ((0, 0), (w, 0), (w, h), (0, h)):
                x, y = transform(x, y)
                xx.append(x)
                yy.append(y)
            w = int(math.ceil(max(xx)) - math.floor(min(xx)))
            h = int(math.ceil(max(yy)) - math.floor(min(yy)))

26/09/2007, 21h06
Guigui_

Regarde le lien de anthyme. Ce que tu veux faire se faire avec les property.

Dans le bout de code de PIL, il s'agit simplement d'une fonction locale à une autre
26/09/2007, 21h48
GnuVince
Oui, tu peux faire des fonctions "nested":
Code:

1 2 3 4 5 6 7 def foo(): def square(x): return x * x print "Hello!", square(9) foo() # => "Hello! 81"
Mais c'est pas la même chose que des propriétés.
27/09/2007, 10h17
airod

ok, je comprend bien le truc maintenant.

ce type de fonction permet de découper les traitements d'une fonction en sous fonction appellable dans la fonction elle même, mais inaccessible de l'extérieur. C'est bien ca !?
Ca permet de réduire la redondance de code dans une même fonction!

Pour ce qui est de ce que je veux faire pour mon objet, c'est compris, puisque je le faisais déjà, je voulais juste savoir si l'on pouvait faire plus condenser...

merci

un petit post supplémentaire pour soumettre une méthode qui me permet de n'avoir qu'une méthode d'accés au données d'un objet.

Code:

1
2
3
4
5
6
7
8
9
10
11
def accesFond(self,type,value=None):
        if type=='r':
            return self.canvas['bg']
        elif type=='w':
            if value!=None:
                try:
                    self.canvas['bg']=value
                except:
                    return 
            else:
                return "ERREUR aucune valeur"