在“ if”语句中设置多行条件的样式？[关闭]

有时我将ifs中的长条条件分解为几行。最明显的方法是：

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

在视觉上不是很吸引人，因为动作与条件融为一体。但是，这是使用正确的4个空格的Python缩进的自然方法。

目前，我正在使用：

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

但这不是很漂亮。:-)

您能推荐一种替代方法吗？

您不需要在第二条条件行上使用4个空格。可能使用：

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

这至少使您与众不同。

甚至：

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

这是《样式指南》，（自2010年起）建议使用括号。

在简并的情况下，我采用了以下内容：简而言之，其为AND或OR。

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

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

它可以刮掉几个字符，并清楚表明该条件没有任何微妙之处。

有人必须在这里提倡使用垂直空格！:)

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

是的，为了清楚起见，我们将权衡一些垂直房地产。IMO值得。

当我有一个非常大的if条件时，我更喜欢这种风格：

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

这是我非常个人的看法：（在我看来）长时间条件是一种代码气味，建议将其重构为布尔返回函数/方法。例如：

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

现在，如果我找到一种使多行条件看起来不错的方法，那么我可能会发现自己对满足这些条件感到满意，而无需进行重构。

另一方面，让它们扰乱我的审美意识可以促进重构。

因此，我的结论是，多个线路条件看起来很丑陋，这是避免它们的诱因。

这并没有太大改善，但是...

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

if allCondsAreOK:
   do_something

我建议将and关键字移至第二行，并将包含条件的所有行缩进，而不是四个空格：

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

这正是我在代码中解决此问题的方式。将关键字作为该行中的第一个单词使该条件更具可读性，并且减少空格的数量进一步将条件与动作区分开。

似乎值得引用PEP 0008（Python的官方样式指南），因为它以适度的长度评论了这个问题：

当- if语句的条件部分足够长以至于需要将其写成多行时，值得注意的是，两个字符关键字（即if），一个空格和一个左括号的组合会产生自然的4-多行条件的后续行的空格缩进。这可能与嵌套在if-statement中的缩进代码套件产生视觉冲突，该缩进代码套件自然也会缩进4个空格。对于如何（或是否）在视觉上进一步将这些条件行与if-statement 内的嵌套套件区分开，此PEP没有明确的位置。在这种情况下，可接受的选项包括但不限于：

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

注意上面引用中的“不限于”；除了在样式指南中建议的方法外，在此问题的其他答案中建议的一些方法也是可以接受的。

这就是我的工作，请记住“ all”和“ any”接受迭代，因此我将一个长条件放在列表中，然后让“ all”完成工作。

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

if all(condition):
   do_something

我很惊讶没有看到我的首选解决方案，

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

由于and是一个关键字，因此我的编辑器将其突出显示，并且看起来与其下方的do_something完全不同。

加上@krawyoti所说的话...长时间的气味会散发出来，因为它们难以阅读且难以理解。使用函数或变量可使代码更清晰。在Python中，我更喜欢使用垂直空间，将括号括起来，并将逻辑运算符放在每行的开头，以使表达式看起来不像“浮动”。

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

如果需要多次评估条件（例如在while循环中），则最好使用局部函数。

就个人而言，我喜欢在长if语句中添加含义。我将不得不在代码中进行搜索以找到合适的示例，但这是我想到的第一个示例：假设我碰巧遇到了一些古怪的逻辑，我想根据许多变量来显示特定页面。

英语：“如果登录的用户不是管理员教师，而是普通教师，而不是学生本身...”

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

当然，这看起来不错，但是如果需要大量阅读，请阅读这些内容。我们如何将逻辑分配给有意义的标签。“标签”实际上是变量名：

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

这看起来似乎很愚蠢，但是您可能还有另一种情况，您仅在显示教师面板或默认情况下用户有权访问其他特定面板时才要显示其他项目：

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

尝试在不使用变量来存储和标记逻辑的情况下编写上述条件，不仅会得到非常混乱，难以理解的逻辑语句，而且还会重复自己。尽管有合理的例外情况，但请记住：不要重复自己（DRY）。

“ all”和“ any”对于相同类型案例的许多条件都很好。但是他们总是评估所有条件。如本例所示：

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

（我对标识符进行了小幅修改，因为固定宽度的名称不代表真实代码-至少不代表我遇到的真实代码-这将掩盖示例的可读性。）

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

这对于“ and”和“ or”非常有效（重要的是它们排在第二行），但对于其他较长条件则远不如此。幸运的是，前者似乎是更常见的情况，而后者通常很容易用一个临时变量重写。（通常并不难，但是在重写时保留“和” /“或”的短路可能很困难或不太明显/可读性。）

由于我从您的博客文章中找到了有关C ++的问题，因此我将介绍我的C ++样式是相同的：

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

简单明了，还通过了pep8检查：

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

近年来，我一直偏爱alland any函数，因为我很少将And和Or混合使用，因此效果很好，并且具有生成器理解失败的额外优势：

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

只记得传递一个可迭代的值！传递N参数是不正确的。

注意：any就像很多or比较，all就像很多and比较。

这与生成器理解很好地结合在一起，例如：

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

更多信息：生成器理解

如果我们仅在条件和身体之间插入一条额外的空白行，而其余部分以规范的方式进行，该怎么办？

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

    do_something

ps我总是使用制表符，而不是空格。我无法微调...

我通常要做的是：

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

这样，右括号和冒号在视觉上标志着我们病情的结束。

也为if语句提供多条件的所有受访者与所提出的问题一样丑陋。您不能通过做同样的事情来解决此问题。

甚至PEP 0008的答案也是令人反感的。

这是一种更具可读性的方法

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

要我吃我的话吗？说服我，您需要多条件，并且我会逐字打印出来，并出于娱乐目的而食用。

我认为@zkanda的解决方案稍作改动就可以了。如果您在各自的列表中有条件和值，则可以使用列表推导进行比较，这将使添加条件/值对的过程更加通用。

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

如果我确实想对这样的语句进行硬编码，出于可读性考虑，我会这样写：

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

并与iand操作员一起提出另一个解决方案：

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

if proceed:
    # do something

出于完整性考虑，仅提供了一些其他随机想法。如果它们对您有用，请使用它们。否则，您最好尝试其他方法。

您也可以使用字典来做到这一点：

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

这个选项比较复杂，但是您可能还会发现它有用：

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

邓诺（Dunno）是否适合您，但这是您可以考虑的另一种选择。这是另一种方式：

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'

我还没有测试过最后两个，但是如果您想使用这些概念，那么它们的概念应该足以让您开始工作。

（从记录来看，如果这只是一次性的事情，那么使用最初介绍的方法可能会更好。如果在很多地方进行比较，这些方法可能会增强可读性，从而使您不会因为它们有点hacky而感到难过。）

我一直在努力寻找一种合适的方法来做到这一点，所以我只是想出了一个主意（不是灵丹妙药，因为这主要是一个品味问题）。

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

与我见过的其他解决方案相比，我发现此解决方案有一些优点，即，您恰好获得了额外的4个缩进空间（布尔），允许所有条件垂直排列，并且if语句的主体可以缩进一种清晰的方式 这也保留了对布尔运算符进行短路评估的好处，但是当然会增加基本上不执行任何操作的函数调用的开销。您可能会（有效地）争辩说，可以在此处使用任何返回其参数的函数而不是bool，但是就像我说的那样，这只是一个主意，最终是一个品味问题。

有趣的是，当我写这篇文章并思考“问题”时，我想到了另一个想法，它消除了函数调用的开销。为什么不通过使用额外的圆括号来表明我们将要输入复杂的条件？再说2个，相对于if语句的主体，给子条件一个2的空格缩进。例：

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

我之所以喜欢这样，是因为当您看着它时，头上的铃铛立即响起，说：“嘿，这是一件复杂的事情！” 。是的，我知道括号并不能帮助提高可读性，但是这些条件应该很少出现，并且当它们出现时，您无论如何都要停下来仔细阅读它们（因为它们很复杂））。

无论如何，只有两个我在这里没有看到的建议。希望这可以帮助某人:)

您可以将其分为两行

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

甚至一次添加一个条件。这样，至少可以将混乱与混乱分开if。

我知道这个线程很旧，但是我有一些Python 2.7代码，PyCharm（4.5）仍然抱怨这种情况：

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

即使PEP8警告“带有与下一个逻辑行相同的缩进的可视缩进行”，实际代码也完全可以吗？这不是“缩进过度”吗？

...有时候我希望Python会咬住子弹，并且用花括号将其消失。我不知道这些年来由于偶然的错误压痕而意外引入了多少个错误...

将您的条件打包到一个列表中，然后再做。喜欢：

if False not in Conditions:
    do_something

我发现当我的条件很长时，我通常会有一个简短的代码主体。在这种情况下，我只是将身体缩进两次，因此：

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

或者，如果更清楚：

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

在这种情况下，缩进没有理由应为4的倍数，例如，请参见“与开孔定界符对齐”：

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

这是另一种方法：

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

这也使您可以轻松地添加另一个条件，而无需更改if语句，只需将另一个条件附加到列表即可：

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

我通常使用：

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

如果我们的if＆else条件必须在其中执行多个语句，则我们可以像下面这样编写。每当我们有if else例子时，里面都有一个语句。

谢谢它为我工作。

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

请原谅我，但是碰巧我对#Python的了解不如在座的任何人，但是碰巧我在3D BIM建模中编写自己的对象时发现了类似的东西，因此我将使算法适应python的

我在这里发现的问题是双面的：

1. 对于可能会尝试解密脚本的人，我认为我似乎很陌生。
2. 如果更改了这些值（最可能的话），或者必须添加新的条件（损坏的架构），则代码维护的成本将很高。

要绕过所有这些问题，您的脚本必须像这样

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

这种方法的优点：

1. 脚本可读。

2. 脚本可以轻松维护。

3. 条件是对表示所需条件的值之和进行的1比较操作。
4. 无需多级条件

希望对大家有帮助