Mehrzeilige Bedingungen in 'if'-Anweisungen gestalten? [geschlossen]

Manchmal breche ich lange Bedingungen in ifs in mehrere Zeilen. Der naheliegendste Weg, dies zu tun, ist:

  if (cond1 == 'val1' and cond2 == 'val2' and
      cond3 == 'val3' and cond4 == 'val4'):
      do_something

Ist optisch nicht sehr sehr ansprechend, da sich die Aktion mit den Bedingungen verbindet. Es ist jedoch der natürliche Weg, die korrekte Python-Einrückung von 4 Leerzeichen zu verwenden.

Im Moment benutze ich:

  if (    cond1 == 'val1' and cond2 == 'val2' and
          cond3 == 'val3' and cond4 == 'val4'):
      do_something

Das ist aber nicht sehr hübsch. :-)

Können Sie einen alternativen Weg empfehlen?

Sie müssen in Ihrer zweiten bedingten Zeile keine 4 Leerzeichen verwenden. Vielleicht verwenden:

if (cond1 == 'val1' and cond2 == 'val2' and 
       cond3 == 'val3' and cond4 == 'val4'):
    do_something

Vergessen Sie auch nicht, dass das Leerzeichen flexibler ist, als Sie vielleicht denken:

if (   
       cond1 == 'val1' and cond2 == 'val2' and 
       cond3 == 'val3' and cond4 == 'val4'
   ):
    do_something
if    (cond1 == 'val1' and cond2 == 'val2' and 
       cond3 == 'val3' and cond4 == 'val4'):
    do_something

Beide sind allerdings ziemlich hässlich.

Vielleicht die Klammern verlieren (der Style Guide rät jedoch davon ab)?

if cond1 == 'val1' and cond2 == 'val2' and \
   cond3 == 'val3' and cond4 == 'val4':
    do_something

Dies gibt Ihnen zumindest eine gewisse Differenzierung.

Oder auch:

if cond1 == 'val1' and cond2 == 'val2' and \
                       cond3 == 'val3' and \
                       cond4 == 'val4':
    do_something

Ich glaube ich bevorzuge:

if cond1 == 'val1' and \
   cond2 == 'val2' and \
   cond3 == 'val3' and \
   cond4 == 'val4':
    do_something

Hier ist der Style Guide , der (seit 2010) die Verwendung von Klammern empfiehlt.

Ich habe in dem entarteten Fall, in dem es einfach UND und ODER sind, auf Folgendes zurückgegriffen.

if all( [cond1 == 'val1', cond2 == 'val2', cond3 == 'val3', cond4 == 'val4'] ):

if any( [cond1 == 'val1', cond2 == 'val2', cond3 == 'val3', cond4 == 'val4'] ):

Es rasiert einige Zeichen und macht deutlich, dass die Bedingung nicht subtil ist.

Jemand muss sich hier für die Verwendung vertikaler Leerzeichen einsetzen! :) :)

if (     cond1 == val1
     and cond2 == val2
     and cond3 == val3
   ):
    do_stuff()

Dies macht jeden Zustand deutlich sichtbar. Es ermöglicht auch eine sauberere Expression komplexerer Bedingungen:

if (    cond1 == val1
     or 
        (     cond2_1 == val2_1
          and cond2_2 >= val2_2
          and cond2_3 != bad2_3
        )
   ):
    do_more_stuff()

Ja, wir tauschen aus Gründen der Klarheit ein bisschen vertikale Immobilien aus. Lohnt sich IMO.

Ich bevorzuge diesen Stil, wenn ich einen schrecklich großen If-Zustand habe:

if (
    expr1
    and (expr2 or expr3)
    and hasattr(thingy1, '__eq__')
    or status=="HappyTimes"
):
    do_stuff()
else:
    do_other_stuff()

Hier ist meine ganz persönliche Einstellung: Lange Bedingungen sind (meiner Ansicht nach) ein Codegeruch, der darauf hindeutet, in eine boolesche Rückgabefunktion / -methode umzuwandeln. Zum Beispiel:

def is_action__required(...):
    return (cond1 == 'val1' and cond2 == 'val2'
            and cond3 == 'val3' and cond4 == 'val4')

Wenn ich nun einen Weg finden würde, mehrzeilige Bedingungen gut aussehen zu lassen, würde ich mich wahrscheinlich damit zufrieden geben, sie zu haben, und das Refactoring überspringen.

Andererseits wirkt es ein Anreiz für das Refactoring, wenn sie meinen ästhetischen Sinn stören.

Mein Fazit ist daher, dass Mehrleitungsbedingungen hässlich aussehen sollten und dies ein Anreiz ist, sie zu vermeiden.

Das verbessert sich nicht so sehr, aber ...

allCondsAreOK = (cond1 == 'val1' and cond2 == 'val2' and
                 cond3 == 'val3' and cond4 == 'val4')

if allCondsAreOK:
   do_something

Ich schlage vor, das andSchlüsselwort in die zweite Zeile zu verschieben und alle Zeilen mit Bedingungen mit zwei statt vier Leerzeichen einzurücken:

if (cond1 == 'val1' and cond2 == 'val2'
  and cond3 == 'val3' and cond4 == 'val4'):
    do_something

Genau so löse ich dieses Problem in meinem Code. Wenn Sie ein Schlüsselwort als erstes Wort in der Zeile haben, ist die Bedingung viel besser lesbar, und durch Verringern der Anzahl der Leerzeichen wird die Bedingung weiter von der Aktion unterschieden.

Es scheint sich zu lohnen, PEP 0008 (Pythons offizieller Styleguide) zu zitieren , da es dieses Problem in bescheidener Länge kommentiert:

Wenn der bedingte Teil einer ifAnweisung lang genug ist, um das Schreiben über mehrere Zeilen zu erfordern, ist zu beachten, dass die Kombination eines zweistelligen Schlüsselworts (dh if) plus eines einzelnen Leerzeichens plus einer öffnenden Klammer eine natürliche 4- Leerzeichen für die nachfolgenden Zeilen der mehrzeiligen Bedingung. Dies kann zu einem visuellen Konflikt mit der eingerückten Code-Suite ifführen, die in der Anweisung verschachtelt ist und natürlich auch in 4 Leerzeichen eingerückt wird. Dieser PEP nimmt keine explizite Position dazu ein, wie (oder ob) solche bedingten Linien visuell weiter von der verschachtelten Suite innerhalb der ifAnweisung unterschieden werden sollen. Akzeptable Optionen in dieser Situation umfassen, sind aber nicht beschränkt auf:

# No extra indentation.
if (this_is_one_thing and
    that_is_another_thing):
    do_something()

# Add a comment, which will provide some distinction in editors
# supporting syntax highlighting.
if (this_is_one_thing and
    that_is_another_thing):
    # Since both conditions are true, we can frobnicate.
    do_something()

# Add some extra indentation on the conditional continuation line.
if (this_is_one_thing
        and that_is_another_thing):
    do_something()

Beachten Sie das "nicht beschränkt auf" im obigen Zitat; Neben den im Styleguide vorgeschlagenen Ansätzen sind auch einige der in anderen Antworten auf diese Frage vorgeschlagenen Ansätze akzeptabel.

Ich mache Folgendes: Denken Sie daran, dass "alle" und "alle" eine Iterierbarkeit akzeptieren. Ich habe also einfach eine lange Bedingung in eine Liste aufgenommen und "alle" die Arbeit machen lassen.

condition = [cond1 == 'val1', cond2 == 'val2', cond3 == 'val3', cond4 == 'val4']

if all(condition):
   do_something

Ich bin überrascht, meine bevorzugte Lösung nicht zu sehen.

if (cond1 == 'val1' and cond2 == 'val2'
    and cond3 == 'val3' and cond4 == 'val4'):
    do_something

Da andes sich um ein Schlüsselwort handelt, wird es von meinem Editor hervorgehoben und unterscheidet sich ausreichend von do_something darunter.

Hinzu kommt, was @krawyoti gesagt hat ... Lange Bedingungen riechen, weil sie schwer zu lesen und schwer zu verstehen sind. Die Verwendung einer Funktion oder einer Variablen macht den Code klarer. In Python bevorzuge ich es, vertikalen Raum zu verwenden, Klammern einzuschließen und die logischen Operatoren am Anfang jeder Zeile zu platzieren, damit die Ausdrücke nicht wie "schwebend" aussehen.

conditions_met = (
    cond1 == 'val1' 
    and cond2 == 'val2' 
    and cond3 == 'val3' 
    and cond4 == 'val4'
    )
if conditions_met:
    do_something

Wenn die Bedingungen wie in einer whileSchleife mehrmals ausgewertet werden müssen , ist die Verwendung einer lokalen Funktion am besten.

Persönlich mag ich es, langen if-Aussagen Bedeutung zu verleihen. Ich müsste den Code durchsuchen, um ein geeignetes Beispiel zu finden, aber hier ist das erste Beispiel, das mir in den Sinn kommt: Nehmen wir an, ich stoße zufällig auf eine skurrile Logik, bei der ich abhängig von vielen Variablen eine bestimmte Seite anzeigen möchte.

Englisch: "Wenn der angemeldete Benutzer KEIN Administratorlehrer ist, sondern nur ein regulärer Lehrer und selbst kein Schüler ..."

if not user.isAdmin() and user.isTeacher() and not user.isStudent():
    doSomething()

Sicher, das mag gut aussehen, aber das Lesen dieser if-Anweisungen ist eine Menge Arbeit. Wie wäre es, wenn wir die Logik dem Etikett zuweisen, das Sinn macht? Das "Label" ist eigentlich der Variablenname:

displayTeacherPanel = not user.isAdmin() and user.isTeacher() and not user.isStudent()
if displayTeacherPanel:
    showTeacherPanel()

Dies mag albern erscheinen, aber Sie haben möglicherweise noch eine andere Bedingung, bei der Sie NUR dann ein anderes Element anzeigen möchten, wenn und nur wenn Sie das Lehrerfenster anzeigen ODER wenn der Benutzer standardmäßig Zugriff auf dieses andere spezifische Feld hat:

if displayTeacherPanel or user.canSeeSpecialPanel():
    showSpecialPanel()

Versuchen Sie, die obige Bedingung zu schreiben, ohne Variablen zum Speichern und Beschriften Ihrer Logik zu verwenden, und Sie erhalten nicht nur eine sehr unordentliche, schwer lesbare logische Anweisung, sondern Sie haben sich auch nur wiederholt. Denken Sie daran, auch wenn es vernünftige Ausnahmen gibt: Wiederholen Sie sich nicht (DRY).

"all" und "any" sind nett für die vielen Bedingungen des gleichen Falltyps. ABER sie bewerten immer alle Bedingungen. Wie in diesem Beispiel gezeigt:

def c1():
    print " Executed c1"
    return False
def c2():
    print " Executed c2"
    return False


print "simple and (aborts early!)"
if c1() and c2():
    pass

print

print "all (executes all :( )"
if all((c1(),c2())):
    pass

print

(Ich habe die Bezeichner leicht geändert, da Namen mit fester Breite nicht für echten Code repräsentativ sind - zumindest nicht für echten Code, auf den ich stoße - und die Lesbarkeit eines Beispiels glauben.)

if (cond1 == "val1" and cond22 == "val2"
and cond333 == "val3" and cond4444 == "val4"):
    do_something

Dies funktioniert gut für "und" und "oder" (es ist wichtig, dass sie zuerst in der zweiten Zeile stehen), aber viel weniger für andere lange Bedingungen. Glücklicherweise scheint Ersteres der häufigere Fall zu sein, während Letzteres häufig leicht mit einer temporären Variablen umgeschrieben werden kann. (Es ist normalerweise nicht schwer, aber es kann schwierig oder viel weniger offensichtlich / lesbar sein, den Kurzschluss von "und" / "oder" beim Umschreiben beizubehalten.)

Da ich diese Frage in Ihrem Blogbeitrag zu C ++ gefunden habe , werde ich angeben, dass mein C ++ - Stil identisch ist:

if (cond1 == "val1" and cond22 == "val2"
and cond333 == "val3" and cond4444 == "val4") {
    do_something
}

Schlicht und einfach, besteht auch pep8-Prüfungen:

if (
    cond1 and
    cond2
):
    print("Hello World!")

In letzter Zeit habe ich die allund any-Funktionen bevorzugt , da ich And and Or-Vergleiche selten mische. Dies funktioniert gut und hat den zusätzlichen Vorteil, dass ich mit dem Verständnis der Generatoren früh versage:

if all([
    cond1,
    cond2,
]):
    print("Hello World!")

Denken Sie daran, eine einzige iterable zu übergeben! Die Übergabe von N-Argumenten ist nicht korrekt.

Hinweis: anyist wie viele orVergleiche, allist wie viele andVergleiche.

Dies lässt sich gut mit dem Verständnis des Generators kombinieren, zum Beispiel:

# Check if every string in a list contains a substring:
my_list = [
    'a substring is like a string', 
    'another substring'
]

if all('substring' in item for item in my_list):
   print("Hello World!")

# or

if all(
    'substring' in item
    for item in my_list
):
    print("Hello World!")

Mehr zum Generatorverständnis

Was ist, wenn wir nur eine zusätzliche Leerzeile zwischen dem Zustand und dem Körper einfügen und den Rest auf kanonische Weise erledigen?

if (cond1 == 'val1' and cond2 == 'val2' and
    cond3 == 'val3' and cond4 == 'val4'):

    do_something

ps Ich benutze immer Tabulatoren, keine Leerzeichen; Ich kann nicht fein einstellen ...

Was ich normalerweise mache ist:

if (cond1 == 'val1' and cond2 == 'val2' and
    cond3 == 'val3' and cond4 == 'val4'
   ):
    do_something

Auf diese Weise markieren die schließende Klammer und der Doppelpunkt visuell das Ende unseres Zustands.

Alle Befragten, die auch Multi-Bedingungen für die if-Anweisung bereitstellen, sind genauso hässlich wie das vorgestellte Problem. Sie lösen dieses Problem nicht, indem Sie dasselbe tun.

Sogar die Antwort von PEP 0008 ist abstoßend.

Hier ist ein weitaus besser lesbarer Ansatz

condition = random.randint(0, 100) # to demonstrate
anti_conditions = [42, 67, 12]
if condition not in anti_conditions:
    pass

Soll ich meine Worte essen? Überzeugen Sie mich, dass Sie mehrere Bedingungen benötigen, und ich werde diese buchstäblich ausdrucken und zu Ihrer Unterhaltung essen.

Ich denke, die Lösung von @ zkanda wäre gut mit einer kleinen Wendung. Wenn Sie Ihre Bedingungen und Werte in ihren jeweiligen Listen hätten, könnten Sie ein Listenverständnis verwenden, um den Vergleich durchzuführen, was die Dinge für das Hinzufügen von Bedingungs- / Wertepaaren etwas allgemeiner machen würde.

conditions = [1, 2, 3, 4]
values = [1, 2, 3, 4]
if all([c==v for c, v in zip(conditions, values)]):
    # do something

Wenn ich eine solche Aussage fest codieren wollte, würde ich sie aus Gründen der Lesbarkeit folgendermaßen schreiben:

if (condition1==value1) and (condition2==value2) and \
   (condition3==value3) and (condition4==value4):

Und nur um eine andere Lösung mit einem iandBediener herauszubringen :

proceed = True
for c, v in zip(conditions, values):
    proceed &= c==v

if proceed:
    # do something

Nur ein paar andere zufällige Ideen der Vollständigkeit halber. Wenn sie für Sie arbeiten, verwenden Sie sie. Ansonsten ist es wahrscheinlich besser, wenn Sie etwas anderes ausprobieren.

Sie können dies auch mit einem Wörterbuch tun:

>>> x = {'cond1' : 'val1', 'cond2' : 'val2'}
>>> y = {'cond1' : 'val1', 'cond2' : 'val2'}
>>> x == y
True

Diese Option ist komplizierter, kann aber auch nützlich sein:

class Klass(object):
    def __init__(self, some_vars):
        #initialize conditions here
    def __nonzero__(self):
        return (self.cond1 == 'val1' and self.cond2 == 'val2' and
                self.cond3 == 'val3' and self.cond4 == 'val4')

foo = Klass()
if foo:
    print "foo is true!"
else:
    print "foo is false!"

Keine Ahnung, ob das für Sie funktioniert, aber es ist eine weitere Option, die Sie in Betracht ziehen sollten. Hier ist noch ein Weg:

class Klass(object):
    def __init__(self):
        #initialize conditions here
    def __eq__(self):
        return (self.cond1 == 'val1' and self.cond2 == 'val2' and
               self.cond3 == 'val3' and self.cond4 == 'val4')

x = Klass(some_values)
y = Klass(some_other_values)
if x == y:
    print 'x == y'
else:
    print 'x!=y'

Die letzten beiden habe ich nicht getestet, aber die Konzepte sollten ausreichen, um Sie zum Laufen zu bringen, wenn Sie das möchten.

(Und fürs Protokoll: Wenn dies nur eine einmalige Sache ist, ist es wahrscheinlich besser, die Methode zu verwenden, die Sie zuerst vorgestellt haben. Wenn Sie den Vergleich an vielen Stellen durchführen, können diese Methoden die Lesbarkeit ausreichend verbessern, um sie durchzuführen du fühlst dich nicht so schlecht wegen der Tatsache, dass sie irgendwie hackig sind.)

Ich habe mich bemüht, auch hier einen vernünftigen Weg zu finden, also bin ich auf eine Idee gekommen (keine Silberkugel, da dies hauptsächlich Geschmackssache ist).

if bool(condition1 and
        condition2 and
        ...
        conditionN):
    foo()
    bar()

Ich finde ein paar Vorteile in dieser Lösung im Vergleich zu anderen, die ich gesehen habe, nämlich, dass Sie genau 4 zusätzliche Einrückungsräume (bool) erhalten, sodass alle Bedingungen vertikal ausgerichtet werden können und der Hauptteil der if-Anweisung eingerückt werden kann ein klarer (ish) Weg. Dies behält auch die Vorteile der Kurzschlussauswertung von Booleschen Operatoren bei, erhöht aber natürlich den Overhead eines Funktionsaufrufs, der im Grunde nichts bewirkt. Sie könnten (gültig) argumentieren, dass jede Funktion, die ihr Argument zurückgibt, hier anstelle von bool verwendet werden könnte, aber wie gesagt, es ist nur eine Idee und letztendlich eine Frage des Geschmacks.

Komischerweise kam mir beim Schreiben und Nachdenken über das "Problem" eine weitere Idee, mit der der Aufwand für einen Funktionsaufruf entfällt. Warum nicht angeben, dass wir mit zusätzlichen Klammerpaaren in eine komplexe Bedingung eintreten werden? Sagen Sie 2 weitere, um einen schönen 2-Leerzeichen-Einzug der Unterbedingungen relativ zum Hauptteil der if-Anweisung zu erhalten. Beispiel:

if (((foo and
      bar and
      frob and
      ninja_bear))):
    do_stuff()

Ich mag das irgendwie, denn wenn du es dir ansiehst, läutet sofort eine Glocke in deinem Kopf und sagt: "Hey, hier ist eine komplexe Sache los!" . Ja, ich weiß, dass Klammern die Lesbarkeit nicht verbessern, aber diese Bedingungen sollten selten genug auftreten. Wenn sie angezeigt werden, müssen Sie sie trotzdem vorsichtig lesen (weil sie komplex sind ).

Wie auch immer, nur zwei weitere Vorschläge, die ich hier nicht gesehen habe. Hoffe das hilft jemandem :)

Sie können es in zwei Zeilen aufteilen

total = cond1 == 'val' and cond2 == 'val2' and cond3 == 'val3' and cond4 == val4
if total:
    do_something()

Oder fügen Sie sogar jeweils eine Bedingung hinzu. Auf diese Weise trennt es zumindest die Unordnung von der if.

Ich weiß, dass dieser Thread alt ist, aber ich habe Python 2.7-Code und PyCharm (4.5) beschwert sich immer noch über diesen Fall:

if foo is not None:
    if (cond1 == 'val1' and cond2 == 'val2' and
        cond3 == 'val3' and cond4 == 'val4'):
            # some comment about do_something
            do_something

Selbst mit der PEP8-Warnung "visuell eingerückte Zeile mit demselben Einzug wie die nächste logische Zeile" ist der tatsächliche Code vollständig in Ordnung? Es ist nicht "Einrückung?"

... es gibt Zeiten, in denen ich mir wünschte, Python hätte die Kugel gebissen und wäre nur mit geschweiften Klammern gegangen. Ich frage mich, wie viele Fehler im Laufe der Jahre aufgrund versehentlicher falscher Einrückungen versehentlich eingeführt wurden ...

Packen Sie Ihre Bedingungen in eine Liste und machen Sie dann etwas. mögen:

if False not in Conditions:
    do_something

Ich finde, wenn ich lange Bedingungen habe, habe ich oft einen kurzen Code-Körper. In diesem Fall rücke ich den Körper nur doppelt ein, also:

if (cond1 == 'val1' and cond2 == 'val2' and
    cond3 == 'val3' and cond4 == 'val4'):
        do_something

  if cond1 == 'val1' and \
     cond2 == 'val2' and \
     cond3 == 'val3' and \
     cond4 == 'val4':
      do_something

oder wenn dies klarer ist:

  if cond1 == 'val1'\
     and cond2 == 'val2'\
     and cond3 == 'val3'\
     and cond4 == 'val4':
      do_something

Es gibt keinen Grund, warum der Einzug in diesem Fall ein Vielfaches von 4 sein sollte, z. B. "Ausgerichtet am öffnenden Trennzeichen":

http://google-styleguide.googlecode.com/svn/trunk/pyguide.html?showone=Indentation#Indentation

Hier ist ein anderer Ansatz:

cond_list = ['cond1 == "val1"','cond2=="val2"','cond3=="val3"','cond4=="val4"']
if all([eval(i) for i in cond_list]):
 do something

Dies macht es auch einfach, eine weitere Bedingung hinzuzufügen, ohne die if-Anweisung zu ändern, indem einfach eine andere Bedingung an die Liste angehängt wird:

cond_list.append('cond5=="val5"')

Ich benutze normalerweise:

if ((cond1 == 'val1' and cond2 == 'val2' and
     cond3 == 'val3' and cond4 == 'val4')):
    do_something()

Wenn unsere if & an else-Bedingung mehrere Anweisungen ausführen muss, können wir wie unten schreiben. Jedes Mal, wenn wir ein anderes Beispiel mit einer Aussage darin haben.

Danke, es funktioniert für mich.

#!/usr/bin/python
import sys
numberOfArgument =len(sys.argv)
weblogic_username =''
weblogic_password = ''
weblogic_admin_server_host =''
weblogic_admin_server_port =''


if numberOfArgument == 5:
        weblogic_username = sys.argv[1]
        weblogic_password = sys.argv[2]
        weblogic_admin_server_host =sys.argv[3]
        weblogic_admin_server_port=sys.argv[4]
elif numberOfArgument <5:
        print " weblogic UserName, weblogic Password and weblogic host details are Mandatory like, defalutUser, passwordForDefaultUser, t3s://server.domainname:7001 ."
        weblogic_username = raw_input("Enter Weblogic user Name")
        weblogic_password = raw_input('Enter Weblogic user Password')
        weblogic_admin_server_host = raw_input('Enter Weblogic admin host ')
        weblogic_admin_server_port = raw_input('Enter Weblogic admin port')
#enfelif
#endIf

Verzeihen Sie meine Noobness, aber es kommt vor, dass ich #Python nicht so gut kenne wie jeder von Ihnen hier, aber es kommt vor, dass ich etwas Ähnliches gefunden habe, als ich meine eigenen Objekte in einer 3D-BIM-Modellierung geschrieben habe, also werde ich meinen Algorithmus anpassen das von Python.

Das Problem, das ich hier finde, ist doppelseitig:

1. Meine Werte scheinen für jemanden fremd zu sein, der versucht, das Skript zu entschlüsseln.
2. Die Codewartung ist mit hohen Kosten verbunden, wenn diese Werte geändert werden (höchstwahrscheinlich) oder wenn neue Bedingungen hinzugefügt werden müssen (fehlerhaftes Schema).

Um all diese Probleme zu umgehen, muss Ihr Skript so aussehen

param_Val01 = Value 01   #give a meaningful name for param_Val(i) preferable an integer
param_Val02 = Value 02
param_Val03 = Value 03
param_Val04 = Value 04   # and ... etc

conditions = 0           # this is a value placeholder

########
Add script that if true will make:

conditions = conditions + param_Val01   #value of placeholder is updated
########

### repeat as needed


if conditions = param_Val01 + param_Val02 + param_Val03 + param_Val04:
    do something

Vorteile dieser Methode:

1. Skript ist lesbar.

2. Das Skript kann einfach gepflegt werden.

3. Bedingungen ist eine 1-Vergleichsoperation mit einer Summe von Werten, die die gewünschten Bedingungen darstellt.
4. Keine Notwendigkeit für mehrstufige Bedingungen

Hoffe es hilft euch allen