Denominar condições de várias linhas nas instruções 'if'? [fechadas]

Às vezes, quebro longas condições em ifs em várias linhas. A maneira mais óbvia de fazer isso é:

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

Não é muito atraente visualmente, porque a ação combina com as condições. No entanto, é o caminho natural, usando o recuo Python correto de 4 espaços.

No momento estou usando:

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

Mas isso não é muito bonito. :-)

Você pode recomendar uma maneira alternativa?

Você não precisa usar 4 espaços em sua segunda linha condicional. Talvez use:

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

Além disso, não esqueça que o espaço em branco é mais flexível do que você imagina:

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

Ambos são bastante feios.

Talvez perca os colchetes (o Guia de estilo desencoraja isso)?

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

Isso pelo menos lhe dá alguma diferenciação.

Ou até:

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

Eu acho que prefiro:

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

Aqui está o Guia de estilo , que (desde 2010) recomenda o uso de colchetes.

Eu recorri ao seguinte no caso degenerado, onde é simplesmente AND ou OR.

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

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

Ele raspa alguns caracteres e deixa claro que não há sutileza na condição.

Alguém tem que defender o uso do espaço em branco vertical aqui! :)

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

Isso torna cada condição claramente visível. Também permite uma expressão mais limpa de condições mais complexas:

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

Sim, estamos trocando um pouco de imóveis verticais por clareza. Vale a pena IMO.

Prefiro esse estilo quando tenho uma condição if terrivelmente grande:

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

Aqui está minha opinião pessoal: condições longas são (na minha opinião) um cheiro de código que sugere refatorar para uma função / método de retorno booleano. Por exemplo:

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

Agora, se eu encontrasse uma maneira de fazer com que as condições de várias linhas parecessem boas, provavelmente me contentaria em tê-las e pularia a refatoração.

Por outro lado, tê-los perturbando meu senso estético atua como um incentivo à refatoração.

Minha conclusão, portanto, é que várias condições de linha devem parecer feias e isso é um incentivo para evitá-las.

Isso não melhora muito, mas ...

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

if allCondsAreOK:
   do_something

Sugiro mover a andpalavra-chave para a segunda linha e recuar todas as linhas que contêm condições com dois espaços em vez de quatro:

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

É exatamente assim que eu resolvo esse problema no meu código. Ter uma palavra-chave como a primeira palavra na linha torna a condição muito mais legível e a redução do número de espaços distingue ainda mais a condição da ação.

Parece citar PEP 0008 (guia de estilo oficial do Python), uma vez que comenta sobre esse assunto de maneira modesta:

Quando a parte condicional de uma ifinstrução-é longa o suficiente para exigir que ela seja escrita em várias linhas, vale a pena notar que a combinação de uma palavra-chave de dois caracteres (ou seja if), mais um único espaço, além de um parêntese de abertura cria um 4- natural. recuo de espaço para as linhas subseqüentes da condicional multilinha. Isso pode produzir um conflito visual com o conjunto de códigos recuado aninhado dentro da ifinstrução-, que também seria recuado naturalmente para 4 espaços. Esse PEP não assume posição explícita sobre como (ou se) distinguir visualmente essas linhas condicionais do conjunto aninhado dentro da ifdeclaração. As opções aceitáveis ​​nessa situação incluem, mas não estão limitadas a:

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

Observe o "não limitado a" na citação acima; além das abordagens sugeridas no guia de estilo, algumas das sugeridas em outras respostas a essa pergunta também são aceitáveis.

Aqui está o que eu faço, lembre-se de que "todos" e "qualquer" aceitam uma iterável, então apenas coloquei uma condição longa em uma lista e deixei que "todos" fizessem o trabalho.

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

if all(condition):
   do_something

Estou surpreso por não ver minha solução preferida,

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

Como andé uma palavra-chave, ela é destacada pelo meu editor e parece suficientemente diferente da do_something abaixo dela.

Além do que @krawyoti disse ... As condições longas cheiram porque são difíceis de ler e difíceis de entender. O uso de uma função ou variável torna o código mais claro. No Python, prefiro usar o espaço vertical, colocar parênteses e colocar os operadores lógicos no início de cada linha para que as expressões não pareçam "flutuantes".

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

Se as condições precisarem ser avaliadas mais de uma vez, como em um whileloop, é melhor usar uma função local.

Pessoalmente, gosto de adicionar significado a longas declarações if. Eu precisaria pesquisar no código para encontrar um exemplo apropriado, mas aqui está o primeiro exemplo que vem à mente: digamos que eu tenha uma lógica peculiar, na qual desejo exibir uma determinada página, dependendo de muitas variáveis.

Inglês: "Se o usuário logado NÃO for um professor administrador, mas apenas um professor regular e não for um aluno ..."

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

Claro que isso pode parecer bom, mas ler essas instruções if é muito trabalhoso. Que tal atribuirmos a lógica ao rótulo que faz sentido. O "rótulo" é realmente o nome da variável:

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

Isso pode parecer bobagem, mas você pode ter outra condição em que SOMENTE deseja exibir outro item se, e somente se, estiver exibindo o painel do professor OU se o usuário tiver acesso a esse outro painel específico por padrão:

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

Tente escrever a condição acima sem usar variáveis ​​para armazenar e rotular sua lógica, e você não apenas terá uma declaração lógica muito confusa e difícil de ler, mas também se repetirá. Embora existam exceções razoáveis, lembre-se: Não se repita (DRY).

"all" e "any" são bons para as muitas condições do mesmo tipo de caso. MAS eles sempre avaliam todas as condições. Como mostrado neste exemplo:

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

(Modifiquei levemente os identificadores, pois os nomes de largura fixa não são representativos do código real - pelo menos, não o código real que encontro - e desmente a legibilidade de um exemplo.)

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

Isso funciona bem para "e" e "ou" (é importante que eles sejam os primeiros na segunda linha), mas muito menos para outras condições longas. Felizmente, o primeiro parece ser o caso mais comum, enquanto o último é frequentemente reescrito com uma variável temporária. (Geralmente não é difícil, mas pode ser difícil ou muito menos óbvio / legível para preservar o curto-circuito de "e" / "ou" ao reescrever.)

Desde que encontrei esta pergunta em seu post sobre C ++ , incluirei que meu estilo C ++ é idêntico:

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

Puro e simples, também passa nas verificações do pep8:

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

Nos últimos tempos, tenho preferido as funções alle any, uma vez que raramente misturo as comparações And e Or, isso funciona bem e tem a vantagem adicional de Failing Early com a compreensão dos geradores:

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

Lembre-se de passar em um único iterável! Passar N-argumentos não está correto.

Nota: anyé como muitas orcomparações, allé como muitas andcomparações.

Isso combina muito bem com a compreensão do gerador, por exemplo:

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

Mais sobre: compreensão de geradores

E se apenas inserirmos uma linha em branco adicional entre a condição e o corpo e fizermos o resto da maneira canônica?

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

    do_something

ps Eu sempre uso guias, não espaços; Não consigo afinar ...

O que eu costumo fazer é:

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

Dessa forma, a chave de fechamento e o cólon marcam visualmente o fim de nossa condição.

Todos os entrevistados que também fornecem condicionais para a declaração if são tão feios quanto o problema apresentado. Você não resolve esse problema fazendo o mesmo ..

Até a resposta do PEP 0008 é repulsiva.

Aqui está uma abordagem muito mais legível

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

Quer que eu coma minhas palavras? Convença-me de que você precisa de vários condicionais e eu literalmente imprimo e comerei para sua diversão.

Eu acho que a solução do @ zkanda seria boa com uma pequena reviravolta. Se você tivesse suas condições e valores em suas próprias listas respectivas, poderia usar uma compreensão da lista para fazer a comparação, o que tornaria as coisas um pouco mais gerais para adicionar pares de condição / valor.

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

Se eu quisesse codificar uma declaração como essa, escreveria assim para legibilidade:

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

E apenas para lançar outra solução com um iandoperador :

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

if proceed:
    # do something

Apenas algumas outras idéias aleatórias por uma questão de integridade. Se eles funcionarem para você, use-os. Caso contrário, você provavelmente está melhor tentando outra coisa.

Você também pode fazer isso com um dicionário:

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

Essa opção é mais complicada, mas você também pode achar útil:

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

Não sei se isso funciona para você, mas é outra opção a considerar. Aqui está mais uma maneira:

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'

Os dois últimos que eu não testei, mas os conceitos devem ser suficientes para você continuar, se é isso que você quer seguir.

(E, para que conste, se isso é apenas uma coisa única, você provavelmente está melhor usando o método que você apresentou a princípio. Se você estiver fazendo a comparação em vários locais, esses métodos podem melhorar a legibilidade o suficiente para facilitar a leitura. você não se sente tão mal pelo fato de serem meio hacky.)

Eu também tenho lutado para encontrar uma maneira decente de fazer isso, então tive uma idéia (não uma bala de prata, já que isso é principalmente uma questão de gosto).

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

Encontro alguns méritos nessa solução em comparação com outros que já vi, ou seja, você obtém exatamente 4 espaços extras de recuo (bool), permitindo que todas as condições se alinhem verticalmente, e o corpo da instrução if pode ser recuado uma maneira clara (ish). Isso também mantém os benefícios da avaliação de curto-circuito de operadores booleanos, mas é claro que adiciona a sobrecarga de uma chamada de função que basicamente não faz nada. Você poderia argumentar (validamente) que qualquer função retornando seu argumento poderia ser usada aqui em vez de bool, mas, como eu disse, é apenas uma ideia e, em última análise, é uma questão de gosto.

Engraçado o bastante, enquanto escrevia isso e pensava no "problema", tive outra idéia, que remove a sobrecarga de uma chamada de função. Por que não indicar que estamos prestes a entrar em uma condição complexa usando pares extras de parênteses? Diga mais 2, para dar um bom recuo de 2 espaços nas sub-condições em relação ao corpo da instrução if. Exemplo:

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

Eu meio que gosto disso porque quando você olha para ele, um sino toca imediatamente em sua cabeça dizendo "ei, há uma coisa complexa acontecendo aqui!" . Sim, eu sei que parênteses não ajudam na legibilidade, mas essas condições devem aparecer raramente o suficiente, e quando elas aparecerem, você precisará parar e lê-las com cuidado de qualquer maneira (porque são complexas ).

Enfim, apenas mais duas propostas que não vi aqui. Espero que isso ajude alguém :)

Você pode dividi-lo em duas linhas

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

Ou mesmo adicione uma condição de cada vez. Dessa forma, pelo menos separa a desordem da if.

Eu sei que esse segmento é antigo, mas tenho algum código Python 2.7 e o PyCharm (4.5) ainda reclama sobre este caso:

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

Mesmo com o aviso PEP8 "linha recuada visualmente com o mesmo recuo da próxima linha lógica", o código real está completamente OK? Não é "recuar demais"?

... há momentos em que eu gostaria que o Python tivesse mordido a bala e acabado de usar chaves. Gostaria de saber quantos erros foram introduzidos acidentalmente ao longo dos anos devido a erros de identificação acidental ...

Coloque suas condições em uma lista e depois faça o que quiser. gostar:

if False not in Conditions:
    do_something

Acho que, quando tenho condições longas, geralmente tenho um corpo de código curto. Nesse caso, apenas recuo duas vezes o corpo, assim:

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

ou se isso for mais claro:

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

Não há motivo para que o recuo deva ser um múltiplo de 4 nesse caso, por exemplo, consulte "Alinhado ao delimitador de abertura":

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

Aqui está outra abordagem:

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

Isso também facilita a adição de outra condição facilmente, sem alterar a instrução if, simplesmente anexando outra condição à lista:

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

Eu costumo usar:

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

se a nossa condição if & an else precisar executar várias instruções dentro dela, podemos escrever como abaixo. A cada momento, temos outro exemplo com uma declaração dentro dela.

Obrigado, funciona para mim.

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

Perdoe meu noobness, mas acontece que não conheço o #Python como qualquer um de vocês aqui, mas acontece que encontrei algo semelhante ao criar scripts para meus próprios objetos em uma modelagem 3D BIM, então adaptarei meu algoritmo a o do python.

O problema que encontro aqui é de dupla face:

1. Os meus valores parecem estranhos para alguém que pode tentar decifrar o script.
2. A manutenção do código terá um custo alto, se esses valores forem alterados (o mais provável) ou se novas condições forem adicionadas (esquema quebrado)

Para ignorar todos esses problemas, seu script deve ser assim

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

Prós deste método:

1. Script é legível.

2. O script pode ser facilmente mantido.

3. conditions é uma operação de comparação com uma soma de valores que representa as condições desejadas.
4. Não há necessidade de condições multiníveis

Espero que ajude a todos