Python: Entfernen die negative aus einer Liste von zahlen

Die Frage, ist das entfernen von negativen zahlen.

Wenn remove_negs([1, 2, 3, -3, 6, -1, -3, 1]) ausgeführt wird, das Ergebnis ist: [1, 2, 3, 6, -3, 1]. Das Ergebnis ist wohl [1, 2, 3, 6, 3, 1]. was geschieht, ist, dass, wenn es zwei negative zahlen in einer Zeile (z.B.-1, -3), dann die zweite Zahl wird nicht entfernt.
def main():
Zahl = input("Geben Sie eine Liste von zahlen: ")
remove_negs(zahlen)

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()

Klingt wie ein guter job für eine Liste Verständnis, welche Prüfungen für val >= 0.
Nicht entfernen Sie Elemente aus einer Liste Sie sind iteriert wie ändert sich der index der Elemente und man konnte am Ende überspringt einige der Elemente.
Wie andere gesagt haben, nicht ändern Sie den Inhalt des Daten-Containers während der Iteration durch. Iterieren über eine Kopie - for item in Liste(num_list):
Auch, sollten Sie nicht nennen remove um ein Element zu löschen, wenn Sie bereits wissen, wo es ist. Dies ist (a) möglicherweise falsch, weil remove löscht das erste Element, das gleich item werden, die möglicherweise nicht die, die Sie wollen, und (b) langsamer, weil es heißt, Sie Suche die ganze Liste, das Element zu finden, obwohl Sie bereits wusste, wo es war. del num_list[index] ist immer besser. Aber wie Sie wissen, der index? Einfach: for index, item in enumerate(num_list):. (Dies ist alles eine Randnotiz; es wird nicht die Lösung Ihres eigentlichen Problems... aber es sind schon gute Antworten und Kommentare.)

InformationsquelleAutor user3161743 | 2014-01-06

12

Es ist generell eine schlechte Idee, zum entfernen von Elementen aus einer Liste während der Iteration über (siehe der link in meinem Kommentar um eine Erklärung, warum dies so ist). Ein besserer Ansatz wäre die Verwendung einer list comprehension:
```
num_list = [item for item in num_list if item >= 0]
```
Beachten Sie, dass die obige Zeile erzeugt ein neue Liste und weist num_list. Sie können auch ein "in-place" Zuordnung der form
```
num_list[:] = ...
```
die nicht eine neue Liste erstellen, in der Erinnerung, sondern ändert den Speicherort bereits gezeigt, durch num_list. Dieser Unterschied wird im detail erläutert hier.

Ich glaube nicht, dass die OP muss wirklich mutieren num_list hier, so der original-version (ohne die slice-Zuweisung) war wohl in Ordnung. Vielleicht wäre es sogar besser zu zeigen und erklären Sie den Unterschied?
Ja, vielleicht haben Sie Recht. Ich werde Bearbeiten, um zu erklären den Unterschied.
Sie sagte: "Das Ergebnis ist wohl [1, 2, 3, 6, 3, 1]." Das ist genau das, was arshajii code produziert. Wenn Sie Tat es so, wie Sie sind, behaupten zu wollen, das Ergebnis wäre [1, 2, 3, 3, 6, 1, 3, 1].

InformationsquelleAutor arshajii
7

Viel einfacher:
```
>>> a = [ 1, 2, 3, -3, 6, -1, -3, 1]
>>> [x for x in a if x >= 0 ]
[1, 2, 3, 6, 1]
```
Wenn Sie wirklich wollen, um eine Schleife, versuchen Sie dies:
```
def remove_negs(num_list): 
    r = num_list[:]
    for item in num_list: 
        if item < 0: 
           r.remove(item) 
    print r
```
Das tut, was Sie wollen:
```
>>> remove_negs([ 1, 2, 3, -3, 6, -1, -3, 1])
[1, 2, 3, 6, 1]
```
Der Schlüssel ist, dass die abtretungserklärung r = num_list[:] macht eine Kopie von num_list. Um nicht zu verwechseln Sie die Schleife, die Wir dann entfernen Sie Elemente aus r anstatt aus der Liste, die wir sind, Durchlaufen.

Mehr: Python ' s Behandlung von Variablen ist ein bisschen subtiler. Python hält, variable Namen, wie r oder num_list getrennt von den Variablen Daten, wie [1, 2, 3, 6, 1]. Die Namen sind lediglich Zeiger auf die Daten. Betrachten Sie die Zuweisungsanweisung:
```
r = num_list
```
Nachdem diese Anweisung ausgeführt, r und num_list beide auf die gleichen Daten verweisen. Wenn Sie eine änderung vornehmen, um r's-Daten, Sie sind auch eine änderung num_list's die Daten, da Sie beide auf das gleichen Daten. Betrachten Sie jetzt:
```
r = num_list[:]
```
Diese Aussage sagt python zu ändern num_list's-Daten, indem Sie nur bestimmte Elemente davon. Weil dieses, python macht eine Kopie von num_list's Daten. Es passiert einfach so, dass [:] gibt an, dass wir wollen, dass alle num_list's-Daten unverändert, aber das bedeutet nicht aufhören python Kopie. Die Kopie zugeordnet ist r. Dies bedeutet, dass r und mum_list jetzt zu verschiedenen Daten. Wir können änderungen machen, um r's Daten, und es hat keinen Einfluss auf num_list's-Daten, weil Sie verschiedenen Daten.

Wenn dies neu für Sie, möchten Sie vielleicht Blick auf dieses tutorial zu python-Ansatz auf Variablen-Namen und Variablen-Daten: Grundlegendes zu Python-Variablen und Speicher-Management

Beispiele:
```
>>> 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]
```
Kontrast:
```
>>> 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]
```
was bedeutet [:]?
Gute Frage. Siehe aktualisierte Antwort.

InformationsquelleAutor John1024

Andere Lösung

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

InformationsquelleAutor sergiohzlz

1

Aus einem Kommentar auf arshajii Antwort:

aber, dass die Beseitigung der negativen zahlen. ich brauche das negative Vorzeichen entfernt, aber immer noch halten Sie die Nummer in der Liste.

Entfernen der negativen zahlen ist genau das, was Ihr code ist ganz klar versuchen zu tun, und es ist auch der einzige Weg, um das gewünschte Ergebnis zu erhalten:

Das Ergebnis wohl sein [1, 2, 3, 6, 3, 1]

Aber wenn Sie wirklich wollen, um "das negative Zeichen" von den zahlen, das ist noch einfacher. Zum Beispiel entfernen Sie das negative Vorzeichen von -3 Sie einfach negieren und bekommen 3, richtig? Sie können dies tun, in-place, wie Sie in den existierenden code:
```
for index, item in enumerate(num_list): 
    if item < 0: 
       num_list[index] = -item
```
... oder in einer Liste Verständnis, wie in arshajii:
```
num_list = [-item if item < 0 else item for item in num_list]
```
Und es ist sogar einfacher, mit der abs - Funktion, die macht genau das—negiert negative zahlen, Blätter, positiven und null-allein:
```
num_list = [abs(item) for item in num_list]
```
Entweder Weg ist natürlich, dies wird Ihnen [1, 2, 3, 3, 6, 1, 3, 1], das ist die falsche Antwort... aber wenn dein Kommentar richtig ist, es ist die Antwort, die Sie gefragt haben.

InformationsquelleAutor abarnert
1

Andere die die herkömmlichen variable operator non-variable Versuchen, einige yoda conditions auch =)
```
>>> [i for i in x if 0 <= i]
[1, 2, 3, 6, 1]
```
InformationsquelleAutor alvas

strip-Nummern aus Ihren negativen Zeichen, das ist die einfachste Sache zu tun

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

beispielsweise

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

druckt

[2,5,11,1]

InformationsquelleAutor Hiskel Kelemework

Ich denke eine elegante Lösung kann wie folgt Aussehen:

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

InformationsquelleAutor Amjad

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.