Polynômes en Python, en utilisant des dictionnaires

Question

J'ai essayé de représenter des polynômes avec des dictionnaires pour contenir les puissances en tant que clés et les éléments en tant que coefficients. J'ai essayé de surcharger la fonction __sub __ mais depuis que je luttais, je devrais juste surcharger la fonction __neg __ et l'appliquer au __sub __ plus tard. Je l'ai fait facilement quand j'ai utilisé des listes pour Python, mais je ne sais pas comment faire avec les dictionnaires. Donc, je voudrais simplement multiplier chaque élément (les coefficients par -1) mais pas les clés (exposants). Après cela, comment puis-je appeler la fonction __neg __ à l'intérieur de la fonction __sub __?

class Polynomial(object):         
    def __init__(self, coefficients): 
    self.coefficients = coefficients 

    def __str__(self): 
    polytostring = ' ' 
    for exponent, coefficient in self.coefficients.iteritems(): 
     if exponent == 0: 
      polytostring += '%s + ' % coefficient 
     else: 
      polytostring += '%sx^%s + ' % (coefficient, exponent) 

    polytostring = polytostring.strip(" + ") 

    return polytostring 


    def __add__(self, other): 
    if isinstance(other, Polynomial): 
     if max(other.coefficients) > max(self.coefficients): 
      coefficients = other.coefficients 
      add_poly = self 
     else: 
      coefficients = self.coefficients 
      add_poly = other 
     for exponent, coefficient in add_poly.coefficients.iteritems(): 
      if exponent in coefficients: 
       coefficients[exponent] += add_poly.coefficients[exponent] 
      else: 
       coefficients[exponent] = coefficient 
    else: 
     coefficients = self.coefficients 

    sum = Polynomial(coefficients) 
    return sum 


    def __neg__(self): 
     pass 
    def __sub__(self,other): 
     pass 

dict1 = {0:1, 1:-1} 
p1 = Polynomial(dict1) 

dict2 = {1:1, 4:-6, 5:-1, 3:2} 
p2 = Polynomial(dict2) 

print p1 
print p2 

p3 = p1+p2 

print "The sum is:", p3.coefficients 
print "The sum in string rep is:", p3 

print p1-p2 

Answer 1

Juste un signe moins unaire appellera neg, par exemple:

def __sub__(self, other): 
    return self + -other 

Mise à jour
Sans voir le message d'erreur explicite et le code, alors il est difficile de comprendre ce que vous avez eu tort, mais en créant une classe Poly simple en tant que sous-classe de dict:

class Poly(dict): 
    def __init__(self, *args, **kwargs): 
     super(Poly, self).__init__(*args, **kwargs) 
    def __str__(self): 
     return "".join(("{:+}x^{}" if e else "{}").format(c, e) 
         for e, c in sorted(self.items()) if c) 
    def __add__(self, other): 
     return Poly({k: self.get(k, 0) + other.get(k, 0) for k in set(self) | set(other)}) 
    def __neg__(self): 
     return Poly({k: -v for k, v in self.items()}) 
    def __sub__(self, other): 
     return self + -other 

>>> x = Poly({0:1, 1:-1}) 
>>> y = Poly({1:1, 4:-6, 5:-1, 3:2}) 
>>> print(x+y) 
1+2x^3-6x^4-1x^5 
>>> print(x-y) 
1-2x^1-2x^3+6x^4+1x^5 

Bien qu'il ne serait vraiment pas difficile d'ajouter un sous directement:

def __sub__(self, other): 
     return Poly({k: self.get(k, 0) - other.get(k, 0) for k in set(self) | set(other)})