les points négatifs et positifs des listes

Question

J'essaie d'écrire une fonction qui me permette d'additionner uniquement les nombres positifs d'une liste et uniquement les nombres négatifs d'une liste. Je ne sais pas par où commencer pour coder. Toute aide serait la bienvenue, merci !

exemple :

negpos([-5,5,6,-8,9])

devrait revenir :

[-13, 20]

Answer 1

Essayez-le pour la taille :

def negpos (lst):
    (neg, pos) = (0, 0)
    for elem in lst:
        if elem < 0:
            neg = neg + elem
        else:
            pos = pos + elem
    return [neg, pos]

print negpos ([-5,5,6,-8,9])

Il maintient simplement deux accumulateurs et ajoute à celui qui est pertinent. La sortie est :

[-13, 20]

comme souhaité.

Answer 2

Vérifiez filter y sum . Le premier argument de filter est une fonction qui renvoie Vrai si la valeur doit être incluse, et Faux si elle ne doit pas l'être. Passez-lui une fonction qui ne sélectionne que les entiers inférieurs à 0 la première fois, et la seconde fois, passez-lui une fonction qui ne sélectionne que les entiers supérieurs à 0, puis passez la liste résultante à la fonction sum . Si vous avez besoin d'aide au-delà, ajoutez un commentaire et je vous aiderai, mais je pense que vous apprendrez davantage que si je vous donne le code source directement.

Answer 3

Les expressions génératrices peuvent rendre la vie facile et très efficace :

def negpos( inlist ):
    p = sum(x for x in inlist if x > 0)
    n = sum(x for x in inlist if x < 0)
    return (n,p)

Il pourrait aussi être plus approprié de retourner un tuple fixe plutôt qu'une liste, ce que j'ai fait.

Answer 4

Sans aucune fantaisie

>>> neg=0
>>> pos=0
>>> for i in [-5,5,6,-8,9]:
...   if i<0: neg+=i
...   if i>0: pos+=i
...
>>> print neg,pos
-13 20

Answer 5

Utilisation de sum avec une expression génératrice filtrée est le moyen le plus simple d'additionner un sous-ensemble d'une séquence :

positive_tally = sum(x for x in seq if x > 0)
negative_tally = sum(x for x in seq if x < 0)

En les combinant en un seul negpos serait assez facile, mais probablement inutile à moins que vous ne fassiez cela à plusieurs endroits différents.

Par curiosité, j'ai décidé de faire une comparaison de temps réel entre l'approche par expression de générateur et l'approche simple for boucle :

code1 = """
data = [-5,5,6,-8,9]
def negpos(seq):
  neg, pos = 0, 0
  for x in seq:
    if x >= 0:
      pos += x
    else:
      neg += x
  return neg, pos
"""
code2 = """
data = [-5,5,6,-8,9]
def negpos(seq):
  neg = sum(x for x in seq if x < 0)
  pos = sum(x for x in seq if x > 0)
  return neg, pos
"""
command = "negpos(data)"
timer1 = timeit.Timer(command, code1)
timer2 = timeit.Timer(command, code2)
timer1.repeat()
timer2.repeat()

Sur mon système, l'interface dédiée for s'avère être environ deux fois plus rapide (ce n'est pas particulièrement surprenant, puisque la boucle est exécutée deux fois avec l'approche basée sur le générateur, mais il est toujours intéressant de le confirmer).