Python: la Suppression des négatifs à partir d'une liste de nombres

La question est de supprimer les négatifs de nombres.

Quand remove_negs([1, 2, 3, -3, 6, -1, -3, 1]) est exécutée, le résultat est: [1, 2, 3, 6, -3, 1]. Le résultat est supposé être [1, 2, 3, 6, 3, 1]. ce qui se passe, c'est que si il y a deux nombres négatifs dans une ligne (par exemple, -1, -3) puis le deuxième numéro sera pas supprimé.
def main():
nombre = input("Entrez une liste de nombres: ")
remove_negs(nombre)

def remove_negs(num_list): 
  '''Remove the negative numbers from the list num_list.'''
    for item in num_list: 
        if item < 0: 
           num_list.remove(item) 

    print num_list

main()
Sonne comme une bonne job pour une compréhension de liste qui vérifie val >= 0.
Ne pas supprimer des éléments à partir d'une liste que vous itération sur que des que des variations de l'index des articles et vous pouvez vous retrouver à sauter sur certains éléments.
Comme les autres ont dit, ne pas changer le contenu du conteneur de données pendant que vous êtes à parcourir. Itérer sur une copie de l'élément dans la liste(num_list):
Aussi, vous ne devez pas appeler remove pour supprimer un élément lorsque vous savez déjà où il est. C'est (un) qui sont potentiellement mauvais, parce que remove supprime le premier élément égal à item, qui peut ne pas être celui que vous voulez, et (b) la lenteur, car cela signifie que vous avez à la recherche à toute la liste pour trouver le produit même si vous avez déjà un savait où il était. del num_list[index] est toujours la meilleure. Mais comment savez-vous de l'index? Simple: for index, item in enumerate(num_list):. (Ceci est une note de côté; il ne résolvent pas votre problème... mais il y a déjà de bonnes réponses et commentaires.)

OriginalL'auteur user3161743 | 2014-01-06

  1. 12

    C'est généralement une mauvaise idée de supprimer des éléments d'une liste lors de l'itération (voir le lien dans mon commentaire pour une explication de pourquoi il en est ainsi). Une meilleure approche serait d'utiliser un compréhension de liste:

    num_list = [item for item in num_list if item >= 0]

    Avis que la ligne ci-dessus crée un nouveau liste et ayants droit num_list. Vous pouvez aussi faire une "place" affectation de la forme

    num_list[:] = ...

    qui n'est pas de créer une nouvelle liste dans la mémoire, mais au lieu de cela modifie l'emplacement mémoire déjà pointé par num_list. Cette différence est expliquée plus en détail ici.

    Je ne pense pas que l'OP a vraiment besoin de muter num_list ici, de sorte que la version originale (sans la tranche d'affectation) est probablement l'amende. Peut-être qu'il serait encore mieux de présenter et d'expliquer la différence?
    Oui, peut-être que vous avez raison. Je vais modifier pour expliquer la différence.
    Vous avez dit "Le résultat est supposé être [1, 2, 3, 6, 3, 1]." C'est exactement ce que arshajii du code produit. Si vous le faisiez à la façon dont vous êtes en prétendant vouloir, le résultat serait [1, 2, 3, 3, 6, 1, 3, 1].

    OriginalL'auteur arshajii

  2. 8

    Beaucoup plus simple:

    >>> a = [ 1, 2, 3, -3, 6, -1, -3, 1]
>>> [x for x in a if x >= 0 ]
[1, 2, 3, 6, 1]

    Si vraiment vous ne voulez boucle, essayez ceci:

    def remove_negs(num_list): 
    r = num_list[:]
    for item in num_list: 
        if item < 0: 
           r.remove(item) 
    print r

    Ce fait ce que vous voulez:

    >>> remove_negs([ 1, 2, 3, -3, 6, -1, -3, 1])
[1, 2, 3, 6, 1]

    La clé est que l'instruction d'affectation r = num_list[:] fait une copie de num_list. Afin de ne pas confondre la boucle, Nous avons ensuite supprimer des éléments de r plutôt qu'à partir de la liste nous sommes en boucle.

    Plus: Python traitement des variables est un peu subtile. Python conserve les noms de variables, comme r ou num_list séparé de données variables, telles que [1, 2, 3, 6, 1]. Les noms ne sont que des pointeurs vers les données. Considérons l'instruction d'affectation:

    r = num_list

    Après cette instruction est exécutée, r et num_list à la fois pour les mêmes données. Si vous faites un changement à rde données de l', vous êtes également un changement d' num_listde données de l'parce qu'ils pointent vers le même de données. Maintenant, pensez à:

    r = num_list[:]

    Cette instruction indique à python pour modifier num_listde données de l'pour ne prendre que certains de ses éléments. De ce fait, python fait une copie de num_list's de données. Il se trouve que [:] spécifie que nous voulons tous de num_listde données de l'inchangée, mais qui ne l'empêche pas de python à en faire une copie. La copie est attribué à r. Cela signifie que r et mum_list pointent désormais à différents de données. Nous pouvons apporter des modifications à rde données de l'et il n'a pas d'incidence sur num_listde données de l'parce qu'ils ont différents de données.

    Si cela est nouveau pour vous, vous pouvez jeter un oeil à ce tutoriel sur python approche pour les noms de variables et de données variables: La compréhension de Python variables et Gestion de la Mémoire

    Exemples:

    >>> a = [ 1, 2, 3, -3, 6, -1, -3, 1]
>>> b = a   # a and b now point to the same place
>>> b.remove(-1) 
>>> a
[1, 2, 3, -3, 6, -3, 1]

    Contraste avec:

    >>> a = [ 1, 2, 3, -3, 6, -1, -3, 1]
>>> b = a[:] # a and b now point to different data
>>> b
[1, 2, 3, -3, 6, -1, -3, 1]
>>> b.remove(-1)
>>> b
[1, 2, 3, -3, 6, -3, 1]
>>> a
[1, 2, 3, -3, 6, -1, -3, 1]
    ce n' [:]?
    Bonne question. Voir mise à jour de réponse.

    OriginalL'auteur John1024

  3. 3

    Une autre solution

    filter( lambda x: x>0, [ 1, 2, 3, -3, 6, -1, -3, 1])
[1, 2, 3, 6, 1]

    OriginalL'auteur sergiohzlz

  4. 1

    À partir d'un commentaire sur arshajii réponse:

    mais c'est de retirer les nombres négatifs. j'ai besoin de l'signes négatifs retirés, mais toujours garder le numéro dans la liste.

    Supprimant les nombres négatifs est exactement ce que votre code est clairement en train de faire, et c'est aussi la seule façon d'obtenir le résultat souhaité:

    Le résultat est supposé être [1, 2, 3, 6, 3, 1]

    Mais si vous voulez vraiment à "supprimer les signes négatifs" à partir des chiffres, c'est encore plus facile. Par exemple, pour supprimer le signe négatif de -3, vous venez de le nier et obtenir 3, droit? Vous pouvez faire cela en place, comme dans votre code existant:

    for index, item in enumerate(num_list): 
    if item < 0: 
       num_list[index] = -item

    ... ou dans une compréhension de liste, comme dans arshajii:

    num_list = [-item if item < 0 else item for item in num_list]

    Et c'est encore plus facile avec le abs fonction, ce qui est exactement ce que fait—nie de nombres négatifs, les feuilles positive et zéro seul:

    num_list = [abs(item) for item in num_list]

    De toute façon, bien sûr, cela vous donnera [1, 2, 3, 3, 6, 1, 3, 1], qui est la mauvaise réponse... mais si votre commentaire est correct, c'est la réponse que vous avez demandé.

    OriginalL'auteur abarnert

  5. 1

    Autres la la classique variable operator non-variable Essayer quelques yoda conditions trop =)

    >>> [i for i in x if 0 <= i]
[1, 2, 3, 6, 1]

    OriginalL'auteur alvas

  6. 0

    de bande que le nombre de leurs signes négatifs, c'est la meilleure chose à faire

    def remove_negs(somelist):
    for each in somelist:
        if each < 0:
            somelist[somelist.index(each)] = -each
    print(somelist)

    par exemple

    rNegatives([-2,5,11,-1])

    imprime

    [2,5,11,1]

    OriginalL'auteur Hiskel Kelemework

  7. 0

    Je pense que une solution élégante peut être comme ceci:

    import numpy as np

x = [1, 2, 3, -3, 6, -1, -3, 1] # raw data
x = np.array(x) # convert the python list to a numpy array, to enable 
                  matrix operations 
x = x[x >=0] # this section `[x >=0]` produces vector of True and False 
               values, of the same length as the list x
             # as such, this statement `x[x >=0]` produces only the 
               positive values and the zeros

print(x)   
[1 2 3 6 1] # the result

    OriginalL'auteur Amjad