méthodes de classe Python

Question

j'ai une classe comme suit:

class X: 
    def __init__(self): 
      self.sum_x =0.0 
      self.sum_x_squared=0.0 
      self.var_x =0.0 
      self.sum_y =0.0 
      self.sum_y_squared=0.0 
      self.var_y =0.0 

    def update(self,data): 
     [x,y,vx,vy]=data 
     self.update_sums(self.sum_x,self.sum_x_squared,x) 
     self.update_sums(self.sum_y,self.sum_y_squared,y) 
     . 


    def update_sums(self,sums,squares,val): 
      sums += val 
      squares += val*val 
      . 

Je voudrais transmettre les variables membres sum_x, sum_x_squared etc à la fonction update_sums pour la mise à jour comment ce que je fais, je suis confus.

Merci

Answer 1

self.sumx, self.sum_x_squared?

Answer 2

Pas besoin. Vous avez un accès direct à self.sumx, etc.

Etes-vous sûr que les fonctions appartiennent à la classe X? Vous semblez manquer le formatage des points-virgules et des espaces.

Answer 3

Vous n'avez pas besoin de les passer, update_sums peut y accéder comme le peut la mise à jour.

Answer 4

vous n'avez pas besoin de passer rien que la self, que vous êtes mandaté pour faire de toute façon:

def update_sums(self, val): 
    self.sum += val 
    self.sum_squared += val * val 
    ... 

l'appel sera le suivant: self.update_sums(x)

La façon dont vous avez conçu la classe jusqu'à présent est pas très utile ou flexible, je vous suggère quelque chose le long de ces lignes:

class X: 
    def __init__(self): 
      self.sums = [0] * 4 
      self.sums_squared = [0] * 4 

    def update(self, data): 
     self.update_sums(data) 

    def update_sums(self, vals): 
      self.sums = [i + j for i, j in zip(self.sums, vals)] 
      self.sums_squared = [i + j*j for i, j in zip(self.sums, vals)] 

Il est toujours pas idéal, parce que je ne sais pas ce que e Le but de tout cela est, mais il vaut mieux avoir toutes ces valeurs.

Answer 5

D'abord, notez que votre question n'a rien à voir avec classmethod (qui fait classe méthodes en Python) - il est tout à fait à peu près normal exemple méthodes (vous devez modifier votre titre ... ou votre question, si vous faire signifie qu'il est d'environ classe méthodes).

Pour le Q tel quel, la seule façon de faire ce que vous voulez est de passer les noms des attributs que la méthode doit définir (ou assez de données pour laisser la méthode reconstruire les noms), par exemple:

def update(self,data): 
    x, y, vx, vy = data 
    self.update_sums('x' , x) 
    self.update_sums('y' , y) 

def update_sums(self, attname, val): 
    sums = 'sum_' + attname 
    setattr(self, sums, getattr(self, sums, 0) + val) 
    sums = 'sum_' + attname + '_squared' 
    setattr(self, sums, getattr(self, sums, 0) + val * val) 

Je ne recommanderais pas cette approche, en général, car il rend le code plus volumineux, moins lisible, et un peu moins efficace que l'approche élémentaire de tout coder en dur les noms d'attributs. Si la méthode auxiliaire (ici update_sums) encapsule beaucoup de logique délicate que vous êtes vraiment très désireux d'éviter de dupliquer, peut-être; mais si éliminer la répétition est une tâche très utile, il faut du goût et de l'équilibre pour éviter d'aller trop loin ;-).

Answer 6

Il me semble qu'il y a une autre classe qui veut être libérée. Je supprimerais la duplication par refactorisation du code comme ceci:

class SumOfSquares(object): 
    def __init__(self): 
     self.sum = 0.0 
     self.squares = 0.0 

    def update(self, val): 
     self.sum += val 
     self.squares += val * val 

class X(object): 
    def __init__(self): 
     self.x = SumOfSquares() 
     self.y = SumOfSquares() 

    def update(self,data): 
     [x,y,vx,vy]=data 
     self.x.update(x) 
     self.y.update(y)