If else abfragen

[Bl3nder]

Hallo Leute,

Ich hätte eine Frage über die Effizienz der folgenden 3 Beispiele die immer das gleiche herausgeben und welche Ihr benutzen würdet und eine Erklärung dazu ... als Ich angefangen habe mit dem Programmieren habe Ich immer die Else Variante benutzt bis mir jemand gesagt hat das Ich das benötigt und nun weiß Ich gar nicht mehr wofür Ich überhaupt noch Else in den gezeigten Fällen unten brauche.Ich habe leider auch nichts passendes in PEP8 gefunden -> Ausschnitt füge Ich unten an ... Da für mich das kein direkten Unterschied macht muss es bestimmt ein Vorteil bei der einen oder anderen Variante geben. Ich danke euch .

Code: Alles auswählen

def ohne_else(a, b):
    if a > b:
        return a + 1
    return a - 1


def mit_else(a, b):
    if a > b:
        return a + 1
    else:
        return a - 1

def einzeler(a, b):
    return a + 1 if a > b else a - 1



def main(a, b):
    print(ohne_else(a, b))
    print(mit_else(a, b))
    print(einzeler(a, b))


if __name__ == "__main__":
    main(5, 4)

PEP 8:

Code: Alles auswählen

# Correct:

def foo(x):
    if x >= 0:
        return math.sqrt(x)
    else:
        return None

def bar(x):
    if x < 0:
        return None
    return math.sqrt(x)

[Sirius3]

In diesem Fall sind alle drei Varianten identisch. Es kommt darauf an, was der Code ausdrücken will. Für mich wäre die zweite Variante am lesbaren.

[kbr]

Die Frage nach der Effizienz finde ich in diesen Fällen unerheblich, so es denn überhaupt Unterschiede gibt. Wichtig ist die Lesbarkeit. Ich tendiere zur ersten Variante (ohne else), solange der Code dafür kompakt genug ist. Ansonsten zur Zweiten (mit else).

[Bl3nder]

@ Sirius3 & @kbr Von der Lesbarkeit Stimme Ich euch zu nur @kbr wenn man sag Ich mal 1000 Else in seinem Code hätte finde Ich schon das es was aus macht das Ich da Ich nur leider noch nicht solange Programmiere weiß Ich nicht was im Hintergrund abläuft -> eventuell der gleiche Sprungbefehl ??? .... Also meint Ihr es macht kein Unterschied und würdet lieber else benutzt damit man den Code besser versteht ?

Und mal ein bisschen weiter gedacht selbst wenn man sich folgendes Vorstellt

Code: Alles auswählen

def andere_funktion():
	mach_etwas


def funktion(a,b):
	if a<b:
		return False
	else:
		andere_funktion()
	

funktion(1,2)

Kommt man in diesen Szenarien nicht zwangsläufig wieder dort irgendwann an den Punkt wo man wieder was zurückgeben will ??? Dann hätte man sich ja wieder das else sparen können?
Ich danke euch .

[__deets__]

Du findest falsch. Da läuft nix „im Hintergrund“.

[Bl3nder]

@ __deets__ hatte es nochmal schnell angepasst deswegen hat sich das etwas überschnitten wieso sollte man den dann Else benutzen -> Ich hoffe du kannst mein Gedankengang verstehen bei dem Beispielprogramm was Ich nur zur visuellen darstellung erstellt habe

[Nufnus]

wenn man sag Ich mal 1000 Else in seinem Code hätte

Mehr als einen else Zweig lässt Python bei mir pro zu prüfender Bedingung nicht zu (würde ja auch keinen Sinn machen, denn es bedeutet ja "ansonsten - In allen anderen Fällen").
In deinem Beispiel aus dem ersten post kannst du das "else" halt wie schön erwähnt weg lassen (warum verstehst du?), musst du aber nicht. Kommt aufs gleiche raus. Ich finde es lesbarer mit dem else.

Stell dir z.B. mal so ein "Wenn dann, ansonsten wenn, in allen anderen Fällen" Szenario vor:

Code: Alles auswählen

def do_somethg(a):

    if a == 1:
        print("rot")  
    elif a == 2:
        print("gruen")
    elif a == 3:
        print("blau")
    else:
        print("dong")

Wenn du da jetzt das else weg lassen würdest, dann würde er _immer_ "dong" schreiben und nicht nur, falls a weder 1, 2 noch 3 ist.
(In C# hätte man für sowas eher das switch Konstrukt benutzt, ich weiß nicht ob es sowas in Python gibt)

[Bl3nder]

@Nufnus es war mehr der Gedanke wenn du viele Konstruke mit if else hättest .... und etwas in dem Hintergrund gemacht werden würde ... dann hätte man so zeit spraren können.Und stimmt in dem Fall würde es Sinn machen .... jedoch nicht wenn du die Farbe wieder zurückgeben würdest wie Ich oben da dann die Funktion verlassen werden würde.Ich glaube in 3.10 sollen switch case fälle kommen

[kbr]

In Python 3.10 kommt nicht switch/case, sondern type pattern matching. Das ist etwas anderes. Vergiss mit oder ohne else etwas Laufzeit-Optimieren zu wollen. Schreib lesbaren Code. Das ist erst einmal wichtig.

[__blackjack__]

@Bl3nder: Das kommt IMHO auf den Kontext an. Wenn man einen von zwei Werten zurückgeben will die sozusagen gleichranging sind, dann würde ich ``if``/``else`` verwenden. Wenn der Wert beim ``if`` beispielsweise ein „early exit“ ist, dann würde ich nur ``if`` schreiben und den anderen, semantisch nicht wirklich gleichwertigen Fall danach hinschreiben. Also in Deinem ersten Beitrag eher `mit_else()`.

Aber eigentlich in dem kurzen Fall den bedingten Ausdruck, aber wahrscheinlich ohne die Wiederholung von `a` in den Alternativen:

Code: Alles auswählen

def einzeiler(a, b):
    return a + (1 if a > b else -1)

Und bei den beiden PEP 8 Varianten hätte ich wohl `bar()` gewählt. Weil das da eine Sonderbehandlung für Werte <0 ist, und der ”Normalfall” der ein sinnvolles Ergebis liefert.

Also eigentlich hätte ich da natürlich weger der Einfachheit aber wahrscheinlich auch einen bedingten Ausdruck verwendet.

Bei dem `funktion()`-Beispiel hinkt es daran das die `funktion()` entweder explizit `False` oder implizit `None` zurückgibt, was schräg und unerwartet ist, und der Aufruf mit dem Rückgabewert auch gar nichts macht.

@Nufnus: Switch gibt es nicht (pattern matching ab Python 3.10 geht so ein bisschen in die Richtung). Oft kann man einfache ``switch``-Fälle mit einer Abbildung lösen:

Code: Alles auswählen

def do_somethingg(a):
    print({1: "rot", 2: "grün", 3: "blau"}.get(a, "dong"))

Wenn es komplizierter wird auch mal Abbildungen von Werten auf Funktionen — möglicherweise ``lambda``-Funktionen. Und in einigen Fällen kommt man um ``if``/``elif``/``else`` nicht herum.

[Nufnus]

@Bl3nder: Ach so, es geht dir um Laufzeitoptimierung. Ich dachte es geht eher allgemein um den Zweck von else Zweigen.
Aber du hattest ja eigentlich auch geschrieben du hast eine Frage zur Effizienz.

@blackjack, und kbr: Danke für die Hinweise mit dem pattern matching / Abbildungen

[Bl3nder]

Ich danke euch allen für die Antworten . Ich werde dann in Zukunft doch wieder mit Else arbeiten da es hier die meisten machen würden bzw. wie Blackjack ausgeführt hat eventuell wenn man das ganze zusammenfassen kann in einem Return trotzdem vielen danke

Und nufnus es war auch mehr allgemein gefragt nur hätte man sich das sparen können und hätte man sein Code damit optimiert hätte man zwei fliegen mit einer Klappe geschlagen nur so verzichtet man nur auf Lesbarkeit wenn man kein Vorteil hat das ist es nicht wert

[DeaD_EyE]

Am besten gefällt mir diese Funktion, da man die Abbruchbedingung oben stehen hat und das Ergebnis unten.
Um es visuell zu verdeutlichen habe ich noch eine Leerzeile eingefügt.

Code: Alles auswählen

def bar(x):
    if x < 0:
        return None
        
    return math.sqrt(x)

Problem: Jede Funktion, die bar() aufruft, muss dann zuerst prüfen, ob der Rückgabewert None ist und wenn nicht, dann damit irgendwas machen.

Bei der Funktion mit_else finde ich die Version mit if-else besser:

Code: Alles auswählen

def mit_else(a, b):
    if a > b:
        return a + 1
    else:
        return a - 1

Mach dir mal um die Geschwindigkeit erstmal keine Sorgen. Viel wichtiger ist es, dass man seinen eigenen Code nach einem halben Jahr noch versteht und andere auch.