Stylizacja warunków wielowierszowych w wyrażeniach 'if'? [zamknięte]

Uciekłem się do następującego przypadku, w którym jest po prostu I ' s or or.

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

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

To ogoli kilka znaków i daje do zrozumienia, że nie ma subtelności w tym stanie.

ktoś musi walczyć z używaniem pionowych białych znaków tutaj! :)

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

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

Preferuję ten styl, gdy mam strasznie duży if-warunek:

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

Oto moje bardzo osobiste zdanie: long conditions to (moim zdaniem) zapach kodu sugerujący refaktoryzację w funkcję/metodę zwracającą boolean. Na przykład:

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

Teraz, gdybym znalazł sposób, aby Warunki wieloliniowe wyglądały dobrze, prawdopodobnie byłbym zadowolony z ich posiadania i pominąłbym refaktoryzację.

Mój wniosek jest więc taki, że wiele linii warunki powinny wyglądać brzydko i jest to zachęta do ich unikania.

To nie poprawia się tak bardzo, ale...

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

if allCondsAreOK:
   do_something

Proponuję przenieść słowo kluczowe and do drugiej linii i wciąć wszystkie linie zawierające Warunki z dwoma spacjami zamiast czterech:

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

Wydaje się, że warto zacytować PEP 0008 (oficjalny przewodnik stylu Pythona), ponieważ komentuje ten problem skromnie:

Gdy część warunkowa instrukcji if - jest wystarczająco długa, aby wymagać, aby była zapisywana w wielu wierszach, warto zauważyć, że kombinacja dwuznakowego słowa kluczowego (tj. if) plus pojedyncza spacja plus nawias otwierający tworzy naturalne 4-spacyjne wcięcie dla kolejnych wierszy wielowierszowego warunkowego. To może tworzy wizualny konflikt z wciętym pakietem kodu zagnieżdżonym wewnątrz instrukcji if -, która również naturalnie byłaby wcięta do 4 spacji. Ten PEP nie zajmuje jednoznacznego stanowiska co do sposobu (lub czy) dalszego wizualnego odróżnienia takich linii warunkowych od zagnieżdżonego pakietu wewnątrz instrukcji if -. Dopuszczalne opcje w tej sytuacji obejmują, ale nie są ograniczone do:

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

Zwróć uwagę na "nie ograniczone do" w cytacie powyżej; poza podejściami sugerowanymi w stylu przewodnik, niektóre z tych sugerowanych w innych odpowiedziach na to pytanie są również dopuszczalne.

Oto co robię, pamiętaj, że " wszystkie "i" dowolne "akceptują iterowalne, więc po prostu umieszczam długi warunek na liście i pozwalam "wszystkim" wykonać pracę.

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

if all(condition):
   do_something

Dodając do tego, co powiedział @ krawyoti... Długie warunki pachną, ponieważ są trudne do odczytania i trudne do zrozumienia. Użycie funkcji lub zmiennej sprawia, że kod jest jaśniejszy. W Pythonie wolę używać pionowych spacji, zamykać nawiasy i umieszczać operatory logiczne na początku każdej linii, aby wyrażenia nie wyglądały jak "pływające".

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

Jeśli warunki muszą być ocenione więcej niż raz, jak w pętli while, to najlepiej jest użyć funkcji lokalnej.

Dziwi mnie, że nie widzę mojego preferowanego rozwiązania.]}

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

Ponieważ and jest słowem kluczowym, zostaje ono podświetlone przez mojego redaktora i wygląda wystarczająco inaczej niż do_something pod nim.

Osobiście lubię dodawać znaczenie długim wypowiedziom if. Musiałbym przeszukiwać kod, aby znaleźć odpowiedni przykład, ale oto pierwszy przykład, który przychodzi mi na myśl: powiedzmy, że natrafiłem na jakąś dziwaczną logikę, w której chcę wyświetlić określoną stronę w zależności od wielu zmiennych.

Angielski: "jeśli zalogowany użytkownik nie jest nauczycielem administratora, ale jest tylko zwykłym nauczycielem, a sam nie jest uczniem..."

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

Jasne, że to może wyglądać dobrze, ale czytanie te, jeśli wypowiedzi to dużo pracy. Może przypiszemy logikę etykiecie, która ma sens. "Label" jest właściwie nazwą zmiennej:

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

Może to wydawać się głupie, ale możesz mieć jeszcze jeden warunek, w którym chcesz wyświetlić inny element tylko wtedy, gdy wyświetlasz panel nauczyciela lub jeśli użytkownik ma domyślnie dostęp do tego innego panelu:

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

Spróbuj zapisać powyższy warunek bez użycia zmiennych do przechowywania i etykietowania logiki, a nie tylko kończysz z bardzo niechlujnym, trudnym do odczytania logicznym stwierdzeniem, ale też po prostu powtarzasz się. Chociaż istnieją uzasadnione wyjątki, pamiętaj: nie powtarzaj się (suche).

" wszystkie "i" dowolne " są miłe dla wielu warunków tego samego typu. Ale zawsze oceniają wszystkie warunki. Jak pokazano w tym przykładzie:

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

(lekko zmodyfikowałem identyfikatory, ponieważ nazwy o stałej szerokości nie są reprezentatywne dla prawdziwego kodu – przynajmniej nie prawdziwego kodu, który napotkam – i podważę czytelność przykładu.)

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

To działa dobrze Dla "and "I" or " (ważne, aby były pierwsze na drugiej linii), ale znacznie mniej dla innych długich warunków. Na szczęście te pierwsze wydają się być bardziej powszechnym przypadkiem, podczas gdy te drugie są często łatwo przepisywane zmienną tymczasową. (Zazwyczaj nie jest to trudne, ale zachowanie zwarcia "i" / " lub " podczas przepisywania może być trudne lub znacznie mniej oczywiste/czytelne.)

Ponieważ znalazłem to pytanie z Twojego postu na blogu o C++, dodam, że mój styl C++ jest identyczny:

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

Prosty i prosty, również przechodzi kontrole pep8:

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

W ostatnim czasie preferowałem funkcje all i any, Ponieważ rzadko mieszam i porównuję I or działa to dobrze, a dodatkową zaletą jest brak wcześnie zrozumienia generatorów:

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

Tylko pamiętaj, aby przejść w jednym iterable! Podanie N-argumentów nie jest poprawne.

Uwaga: any jest jak wiele or porównań, all jest jak wiele and porównania.

To ładnie łączy się z generatorami, na przykład:

# 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!")

Więcej na: generator pojęć

Co jeśli wstawimy tylko dodatkową pustą linię między stanem a ciałem, a resztę zrobimy w kanoniczny sposób?

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

    do_something

P. S. Zawsze używam tabulatorów, nie spacji; nie mogę dostroić...

To co zwykle robię to:

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

W ten sposób klamra zamykająca i dwukropek wizualnie oznaczają koniec naszego stanu.

Wszyscy respondenci, którzy również dostarczają wielu warunków dla twierdzenia if, są tak samo brzydcy jak przedstawiony problem. Nie rozwiązuje się tego problemu, robiąc to samo..

Nawet odpowiedź PEP 0008 jest odpychająca.

Tutaj jest o wiele bardziej czytelne podejście

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

Myślę, że rozwiązanie @zkanda byłoby dobre z drobnym zwrotem akcji. Jeśli masz swoje warunki i wartości na swoich własnych listach, możesz użyć zrozumienia listy do porównania, co uczyniłoby rzeczy nieco bardziej ogólne dla dodawania par warunek / wartość.

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

Gdybym chciał zakodować taką wypowiedź, napisałbym ją tak dla czytelności:

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

I po prostu rzucić inne rozwiązanie tam z iand operator :

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

if proceed:
    # do something

Tylko kilka innych przypadkowych pomysłów dla kompletności. Jeśli pracują dla Ciebie, używaj ich. W przeciwnym razie lepiej będzie spróbować czegoś innego.

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

Ta opcja jest bardziej skomplikowana, ale może okazać się przydatna:

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!"

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'

(i tak na marginesie, jeśli to tylko jednorazowa rzecz, prawdopodobnie lepiej będzie użyć metody, którą przedstawiłeś na początku. Jeśli robisz porównanie w wielu miejscach, metody te mogą poprawić czytelność na tyle, aby nie czuć się tak źle z powodu faktu, że są one trochę chwiejne.)

Ciężko mi znaleźć przyzwoity sposób, aby to zrobić, więc wpadłem na pomysł (nie Srebrna kula, ponieważ to głównie kwestia gustu).

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

Znajduję kilka zalet w tym rozwiązaniu w porównaniu do innych, które widziałem, a mianowicie, otrzymujesz dokładnie dodatkowe 4 przestrzenie wcięć (bool), pozwalając wszystkim warunkom wyrównać się pionowo, a ciało instrukcji if może być wcięte w jasny (Owalny) sposób. Pozwala to również zachować korzyści płynące z oceny zwarciowej funkcji logicznej operatorów, ale oczywiście dodaje narzut wywołania funkcji, która w zasadzie nic nie robi. Można argumentować (prawomocnie), że każda funkcja zwracająca swój argument może być użyta tutaj zamiast bool, ale jak powiedziałem, to tylko pomysł i ostatecznie to kwestia gustu.

Dość zabawne, kiedy to pisałem i myślałem o "problemie", wpadłem na jeszcze jeden pomysł, który usuwa narzut wywołania funkcji. Dlaczego nie wskazać, że mamy zamiar wejść w kompleks warunek przy użyciu dodatkowych par nawiasów? Powiedzmy, 2 więcej, aby dać ładne 2 wcięcie przestrzeni pod-warunków w stosunku do ciała instrukcji if. Przykład:

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

Można podzielić na dwie linie

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

Lub nawet dodać jeden warunek na raz. W ten sposób, przynajmniej oddziela bałagan od if.

Wiem, że ten wątek jest stary, ale mam trochę kodu Pythona 2.7 i PyCharm (4.5) wciąż narzeka na ten przypadek:

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

Nawet z ostrzeżeniem PEP8 "wizualnie wcięta linia z tym samym wcięciem co następna linia logiczna", rzeczywisty kod jest całkowicie w porządku? To nie jest "nadmierne wcięcia?"

...czasami chciałbym, żeby Python ugryzł kulę i po prostu odszedł z kręconymi aparatami. Ciekawe ile błędów zostało przypadkowo wprowadzonych przez lata z powodu przypadkowego błędne wcięcie...

Spakuj swoje warunki do listy, a następnie zrób smth. like:

if False not in Conditions:
    do_something

Stwierdzam, że kiedy mam długie warunki, często mam krótki kod. W takim razie po prostu podwoję ciałko, czyli:

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

Lub jeśli jest to jaśniejsze:

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

Nie ma powodu, dla którego wcięcie powinno być wielokrotnością 4 w tym przypadku, np. patrz "wyrównane z otwierającym ogranicznikiem":

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

Oto inne podejście:

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

To również ułatwia dodanie kolejnego warunku bez zmiany instrukcji if, po prostu dodając kolejny warunek do listy:

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

Zwykle używam:

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

Jeśli nasz warunek if & an else musi wykonać wiele instrukcji wewnątrz niego, to możemy napisać jak poniżej. Każdy, gdy mamy przykład if else z jednym stwierdzeniem w środku .

Thanks it work for me.

#!/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

Wybaczcie mój noobness, ale zdarza się, że nie jestem tak obeznany z # Python jak ktokolwiek z was tutaj, ale zdarza się, że znalazłem coś podobnego podczas skryptowania własnych obiektów w modelowaniu 3D BIM, więc dostosuję mój algorytm do tego Pythona.

Problem, który znajduję tutaj, jest dwustronny:

/ Align = "center" bgcolor = "# e0ffe0 " / cesarz chin / / align = center /
1. utrzymanie kodu będzie kosztować, jeśli te wartości zostaną zmienione (większość prawdopodobne), lub jeśli trzeba dodać nowe warunki (złamany schemat)

Zrobić aby ominąć wszystkie te problemy, Twój skrypt musi iść tak

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

Zalety tej metody:

1. Skrypt jest czytelny.

2. Skrypt może być łatwy w utrzymaniu.

3. conditions jest operacją porównawczą 1 do sumy wartości, która reprezentuje pożądane warunki.
4. nie ma potrzeby stosowania warunków wielopoziomowych

Mam nadzieję, że pomoże wam wszystkim