les valeurs sum () et non-entières de python

Question

Existe-t-il un moyen simple et rapide d'utiliser sum () avec des valeurs non entières?

Je peux donc l'utiliser comme ceci:

class Foo(object):
    def __init__(self,bar)
        self.bar=bar

mylist=[Foo(3),Foo(34),Foo(63),200]
result=sum(mylist) # result should be 300

J'ai essayé de remplacer __ add __ et __ int __ , etc., mais je n'ai pas encore trouvé de solution

.

EDIT:

La solution consiste à implémenter:

 def __radd__(self, other):
    return other + self.bar

comme suggéré par Will dans son post. Mais comme toujours, tous les chemins mènent à Rome, mais je pense que c'est la meilleure solution car je n'ai pas besoin de __ add __ dans ma classe

Answer 1

C'est un peu délicat - la fonction sum () prend le départ et l'ajoute au suivant et ainsi de suite

Vous devez implémenter la méthode __ radd __ :

class T:
    def __init__(self,x):
        self.x = x
    def __radd__(self, other):
        return other + self.x

test = (T(1),T(2),T(3),200)
print sum(test)

Answer 2

Il se peut également que vous deviez implémenter la fonction __ radd __ , qui représente "l'inverse de l'ajout" " et est appelé lorsque les arguments ne peuvent pas être résolus dans le message "transmettre". direction. Par exemple, x + y est évalué en tant que x .__ add __ (y) si possible, mais si cela n'existe pas, Python essaie y .__ radd __ (x ) .

Puisque la fonction sum () commence par le nombre entier 0 , la première chose à faire est d'essayer d'évaluer:

0 + Foo(3)

qui nécessitera la mise en oeuvre de Foo .__ radd __ .

Answer 3

Essayez:

import operator
result=reduce(operator.add, mylist)

sum () fonctionne probablement plus vite, mais il est spécialisé uniquement pour les nombres intégrés. Bien sûr, vous devez encore fournir une méthode pour ajouter vos objets Foo (). Exemple complet:

class Foo(object):
    def __init__(self, i): self.i = i
    def __add__(self, other):
        if isinstance(other, int):
            return Foo(self.i + other)
        return Foo(self.i + other.i)
    def __radd__(self, other):
        return self.__add__(other)

import operator
mylist = [Foo(42), Foo(36), Foo(12), 177, Foo(11)]
print reduce(operator.add, mylist).i

Answer 4

Ou si vous ne souhaitez rien importer,

result = reduce((lambda x,y:x+y), mylist)

Un autre petit avantage est que vous ne devez pas nécessairement déclarer une méthode __ add __ dans vos objets Foo, si cela s'avère être la seule circonstance dans laquelle vous souhaitez effectuer une addition. . (Mais il serait probablement utile de définir __ add __ pour une flexibilité future.)

Answer 5

Essayez d’utiliser la méthode __ int __ , puis de mapper chaque élément de votre liste à la fonction int pour obtenir les valeurs:

class Foo(object):
    def __init__(self,bar):
        self.bar = bar
    def __int__(self):
        return self.bar

mylist = [Foo(3),Foo(34),Foo(63),200]
result = sum(map(int,mylist))
print(result)