Ich habe 6 Variablen, in denen es jeweils unbekannte Zahlen gibt. Da die Zahlen dort so groß sind, möchte ich die Hauptzahl finden und sie als nächstes für sich selbst und für die anderen teilen, nur um Zahlen wie 1 oder weniger zu haben.

Beispiel:

a1=85550 
b1=-18996 
c1=45500 
d1=-60000 
e1=74666 
f1=-35666

In diesem Fall ist a1 das Dur, also muss ich es teilen, damit es selbst 1 hat und der Rest eine 0-Dezimalstelle hat.

Ich habe es versucht, aber einige Werte sind 0, also ist es falsch.

if abs(a1>b1) and abs(a1>c1) and abs(a1>d1) and abs(a1>e1) and abs(a1>f1):
    a11=a1/a1
    b11=b1/a1
    c11=c1/a1
    d11=d1/a1
    e11=e1/a1
    f11=f1/a1
else:
    if abs(b1>a1) and abs(b1>c1) and abs(b1>d1) and abs(b1>e1) and abs(b1>f1):
        a11=a1/b1
        b11=b1/b1
        c11=c1/b1
        d11=d1/b1
        e11=e1/b1
        f11=f1/b1
    else:
        if abs(c1>a1) and abs(c1>b1) and abs(c1>d1) and abs(c1>e1) and abs(c1>f1):
            a11=a1/c1
            b11=b1/c1
            c11=c1/c1
            d11=d1/c1
            e11=e1/c1
            f11=f1/c1
        else:
            if abs(d1>a1) and abs(d1>c1) and abs(d1>b1) and abs(d1>e1) and abs(d1>f1):
                a11=a1/d1
                b11=b1/d1
                c11=c1/d1
                d11=d1/d1
                e11=e1/d1
                f11=f1/d1
            else:
                if abs(e1>a1) and abs(e1>c1) and abs(e1>d1) and abs(e1>b1) and abs(e1>f1):
                    a11=a1/e1
                    b11=b1/e1
                    c11=c1/e1
                    d11=d1/e1
                    e11=e1/e1
                    f11=f1/e1
                else:
                    if abs(f1>a1) and abs(f1>c1) and abs(f1>d1) and abs(f1>e1) and abs(f1>b1):
                        a11=a1/f1
                        b11=b1/f1
                        c11=c1/f1
                        d11=d1/f1
                        e11=e1/f1
                        f11=f1/f1
0
user3047319 29 Nov. 2013 im 01:00

4 Antworten

Beste Antwort

Behalten Sie Ihre Werte in einer Liste:

values = [a1, b1, c1, d1, e1, f1]

Jetzt ist die Aufgabe einfach:

max_value = max(values, key=abs)
values = [v/max_value for v in values]

Für Ihre Eingabe würde das geben:

>>> a1=85550 
>>> b1=-18996 
>>> c1=45500 
>>> d1=-60000 
>>> e1=74666 
>>> f1=-35666
>>> values = [a1, b1, c1, d1, e1, f1]
>>> max_value = max(values, key=abs)
>>> [v/max_value for v in values]
[1.0, -0.22204558737580363, 0.5318527177089422, -0.701344243132671, 0.8727761542957335, -0.4169023962594974]

Dies setzt voraus, dass Sie Python 3 verwenden. In Python 2 gibt der Operator / für Ganzzahlen eine Ganzzahlausgabe aus. Sie möchten also Folgendes verwenden:

max_value = float(max(values, key=abs))

Nur um einen der Operanden zu einer Gleitkommazahl zu machen. Andernfalls erhalten Sie stattdessen [1, -1, 0, -1, 0, -1].

Der Rest Ihres Codes kann nur die Zahlen in values mit Indizierung verwenden:

>>> values[0]
1.0

Oder Sie können die Werte mit der Sequenzzuweisung wieder den ursprünglichen Namen zuweisen:

>>> a1, b1, c1, d1, e1, f1 = values
>>> b1
-0.22204558737580363

Im Allgemeinen möchten Sie Ihre Daten jedoch aus Ihren Variablennamen heraushalten.

3
Martijn Pieters 28 Nov. 2013 im 21:16

Platzieren Sie Ihre Werte in einer Liste.

l = [85550, -18996, 45500, -60000, 74666, -35666]

Sortieren Sie die Liste in umgekehrter Reihenfolge.

l.sort(reverse = True)

Dann map eine Funktion, die jeden Wert durch l[0] oder den größten bekannten Wert teilt.

result = map(lambda x: x / l[0], l)

Die Antwort ist jeder Wert in der Liste, der als Ganzzahl durch den Maximalwert einschließlich des Maximalwerts geteilt wird.

[1, 0, 0, -1, -1, -1]

Wenn eine Ganzzahldivision unerwünscht ist, setzen Sie x in einen Float.

result = map(lambda x: x / l[0], l)

[1.0, 0.8727761542957335, 0.5318527177089422, -0.22204558737580363, -0.4169023962594974, -0.701344243132671]

Alternative: Anstatt die Liste zu sortieren, schreiben Sie nur die Zuordnungsfunktion, um x / max(l) zu durchlaufen.

result = map(lambda x: x / max(l), l)
-3
Makoto 28 Nov. 2013 im 21:14

Das / in Python gibt Ihnen eine Ganzzahl (ganze Zahl), wenn Sie Ganzzahlen teilen. Wenn die Antwort nicht genau ist, wird sie abgerundet. also ist 1/2 0, nicht 0,5.

Anstatt von

a / b

Versuchen Sie, einen in einen Float umzuwandeln:

a / float(b)

Dann erhalten Sie beispielsweise 0,5, wo Sie es erwarten.

Sie können eine Zahl auch direkt als Float schreiben. 1.0/2 gibt beispielsweise 0,5 an, weil 1.0 ein Gleitkommawert und keine Ganzzahl ist.

(auch, was alle anderen über die Verwendung von Listen sagen)

1
andrew cooke 28 Nov. 2013 im 21:07

Verwenden Sie den Operator /, um zwei Zahlen, x und y, zu teilen:

z = x / y
0
Nathan Fellman 28 Nov. 2013 im 21:02