Style des conditions multilignes dans les instructions «si»? [fermé]

Parfois, je casse de longues conditions ifsur plusieurs lignes. La façon la plus évidente de le faire est:

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

N'est pas très très attrayant visuellement, car l'action se confond avec les conditions. Cependant, c'est la manière naturelle d'utiliser l'indentation Python correcte de 4 espaces.

Pour le moment j'utilise:

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

Mais ce n'est pas très joli. :-)

Pouvez-vous recommander une autre façon?

Vous n'avez pas besoin d'utiliser 4 espaces sur votre deuxième ligne conditionnelle. Peut-être utiliser:

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

N'oubliez pas non plus que l'espace est plus flexible que vous ne le pensez:

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

Les deux sont assez laids cependant.

Peut-être perdre les crochets (le Guide de style décourage cela cependant)?

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

Cela vous donne au moins une certaine différenciation.

Ou même:

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

Je pense que je préfère:

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

Voici le Style Guide , qui (depuis 2010) recommande d'utiliser des crochets.

J'ai eu recours à ce qui suit dans le cas dégénéré où il s'agit simplement de ET ou de OU.

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

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

Il rase quelques caractères et montre clairement qu'il n'y a aucune subtilité à la condition.

Quelqu'un doit défendre l' utilisation des espaces verticaux ici! :)

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

Cela rend chaque condition clairement visible. Il permet également une expression plus nette des conditions plus complexes:

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

Oui, nous échangeons un peu d'immobilier vertical pour plus de clarté. Ça vaut le coup IMO.

Je préfère ce style quand j'ai une condition if terriblement grande:

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

Voici mon point de vue très personnel: les conditions longues sont (à mon avis) une odeur de code qui suggère une refactorisation en une fonction / méthode à retour booléen. Par exemple:

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

Maintenant, si je trouvais un moyen de rendre les conditions multilignes plus belles, je me contenterais probablement de les avoir et de sauter le refactoring.

En revanche, les faire perturber mon sens esthétique incite à la refactorisation.

Ma conclusion, par conséquent, est que les conditions de plusieurs lignes doivent sembler moches et c'est une incitation à les éviter.

Cela ne s'améliore pas tellement mais ...

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

if allCondsAreOK:
   do_something

Je suggère de déplacer le andmot - clé vers la deuxième ligne et de mettre en retrait toutes les lignes contenant des conditions avec deux espaces au lieu de quatre:

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

C'est exactement ainsi que je résous ce problème dans mon code. Le fait d'avoir un mot-clé comme premier mot de la ligne rend la condition beaucoup plus lisible et la réduction du nombre d'espaces distingue encore la condition de l'action.

Il semble intéressant de citer PEP 0008 (le guide de style officiel de Python), car il commente ce problème de manière modeste:

Lorsque la partie conditionnelle d'une ifdéclaration est suffisamment longue pour exiger qu'elle soit écrite sur plusieurs lignes, il convient de noter que la combinaison d'un mot clé à deux caractères (c'est-à-dire if), plus un seul espace, plus une parenthèse ouvrante crée un 4- naturel retrait d'espace pour les lignes suivantes du conditionnel multiligne. Cela peut produire un conflit visuel avec la suite de code en retrait imbriquée à l'intérieur de la ifdéclaration, qui serait également naturellement en retrait sur 4 espaces. Ce PEP ne prend pas de position explicite sur la manière (ou l'opportunité) de distinguer visuellement ces lignes conditionnelles de la suite imbriquée à l'intérieur de la ifdéclaration. Les options acceptables dans cette situation incluent, sans s'y limiter:

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

Notez le "non limité à" dans la citation ci-dessus; outre les approches suggérées dans le guide de style, certaines de celles suggérées dans d'autres réponses à cette question sont également acceptables.

Voici ce que je fais, rappelez-vous que "tous" et "tous" accepte un itérable, donc je mets simplement une condition longue dans une liste et laisse "tous" faire le travail.

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

if all(condition):
   do_something

Je suis surpris de ne pas voir ma solution préférée,

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

Étant donné qu'il ands'agit d'un mot clé, il est mis en surbrillance par mon éditeur et semble suffisamment différent du do_something en dessous.

Pour ajouter à ce que @krawyoti a dit ... Les longues conditions sentent parce qu'elles sont difficiles à lire et difficiles à comprendre. L'utilisation d'une fonction ou d'une variable rend le code plus clair. En Python, je préfère utiliser l'espace vertical, entourer les parenthèses et placer les opérateurs logiques au début de chaque ligne afin que les expressions ne ressemblent pas à "flottantes".

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

Si les conditions doivent être évaluées plusieurs fois, comme dans une whileboucle, il est préférable d'utiliser une fonction locale.

Personnellement, j'aime ajouter du sens aux longues instructions if. Je devrais rechercher dans le code pour trouver un exemple approprié, mais voici le premier exemple qui me vient à l'esprit: disons que je rencontre une logique excentrique où je veux afficher une certaine page en fonction de nombreuses variables.

Anglais: "Si l'utilisateur connecté n'est PAS un enseignant administrateur, mais est juste un enseignant régulier, et n'est pas un élève lui-même ..."

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

Bien sûr, cela peut sembler correct, mais lire ces déclarations if représente beaucoup de travail. Que diriez-vous d'attribuer la logique à une étiquette qui a du sens. Le "label" est en fait le nom de la variable:

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

Cela peut sembler idiot, mais vous pouvez avoir une autre condition dans laquelle vous souhaitez afficher UNIQUEMENT un autre élément si, et seulement si, vous affichez le panneau de l'enseignant OU si l'utilisateur a accès à cet autre panneau spécifique par défaut:

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

Essayez d'écrire la condition ci-dessus sans utiliser de variables pour stocker et étiqueter votre logique, et non seulement vous vous retrouvez avec une déclaration logique très compliquée et difficile à lire, mais vous venez également de vous répéter. Bien qu'il existe des exceptions raisonnables, n'oubliez pas: ne vous répétez pas (SEC).

"all" et "any" sont agréables pour les nombreuses conditions du même type de cas. MAIS ils évaluent toujours toutes les conditions. Comme le montre cet exemple:

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

(J'ai légèrement modifié les identifiants car les noms à largeur fixe ne sont pas représentatifs du vrai code - du moins pas du vrai code que je rencontre - et démentiront la lisibilité d'un exemple.)

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

Cela fonctionne bien pour "et" et "ou" (il est important qu'ils soient premiers sur la deuxième ligne), mais beaucoup moins pour les autres conditions longues. Heureusement, les premiers semblent être le cas le plus courant tandis que les seconds sont souvent facilement réécrits avec une variable temporaire. (Ce n'est généralement pas difficile, mais il peut être difficile ou beaucoup moins évident / lisible de conserver le court-circuitage de "et" / "ou" lors de la réécriture.)

Depuis que j'ai trouvé cette question dans votre article de blog sur C ++ , je vais inclure que mon style C ++ est identique:

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

Clair et simple, passe également les contrôles pep8:

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

Ces derniers temps, j'ai préféré les fonctions allet any, car je mélange rarement les comparaisons And et Or, cela fonctionne bien et présente l'avantage supplémentaire de ne pas arriver tôt avec la compréhension des générateurs:

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

N'oubliez pas de passer en un seul itérable! Passer des N-arguments n'est pas correct.

Remarque: anyc'est comme beaucoup de orcomparaisons, allc'est comme beaucoup de andcomparaisons.

Cela se combine bien avec les compréhensions de générateur, par exemple:

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

En savoir plus sur: la compréhension du générateur

Et si nous insérons seulement une ligne vierge supplémentaire entre la condition et le corps et faisons le reste de manière canonique?

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

    do_something

ps J'utilise toujours des tabulations, pas des espaces; Je ne peux pas affiner ...

Ce que je fais habituellement, c'est:

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

de cette façon l'accolade de fermeture et le côlon marquent visuellement la fin de notre condition.

Tous les répondants qui fournissent également des conditions multiples pour l'instruction if sont tout aussi laids que le problème présenté. Vous ne résolvez pas ce problème en faisant la même chose ..

Même la réponse PEP 0008 est répugnante.

Voici une approche beaucoup plus lisible

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

Vous voulez que je mange mes mots? Convainquez-moi que vous avez besoin de multi-conditions et je vais littéralement l'imprimer et le manger pour votre amusement.

Je pense que la solution de @ zkanda serait bonne avec une petite touche. Si vous aviez vos conditions et valeurs dans leurs propres listes respectives, vous pourriez utiliser une compréhension de liste pour faire la comparaison, ce qui rendrait les choses un peu plus générales pour ajouter des paires condition / valeur.

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

Si je voulais coder en dur une déclaration comme celle-ci, je l'écrirais comme ceci pour la lisibilité:

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

Et juste pour lancer une autre solution avec un iandopérateur :

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

if proceed:
    # do something

Juste quelques autres idées aléatoires par souci d'exhaustivité. S'ils fonctionnent pour vous, utilisez-les. Sinon, vous feriez probablement mieux d'essayer autre chose.

Vous pouvez également le faire avec un dictionnaire:

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

Cette option est plus compliquée, mais vous pouvez également la trouver utile:

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

Ne sais pas si cela fonctionne pour vous, mais c'est une autre option à considérer. Voici une autre façon:

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'

Je n'ai pas testé les deux derniers, mais les concepts devraient être suffisants pour vous permettre de continuer si c'est ce que vous voulez.

(Et pour mémoire, s'il ne s'agit que d'une seule fois, vous feriez probablement mieux d'utiliser la méthode que vous avez présentée au début. Si vous faites la comparaison à de nombreux endroits, ces méthodes peuvent améliorer suffisamment la lisibilité pour rendre vous ne vous sentez pas si mal du fait qu'ils sont un peu hacky.)

J'ai eu du mal à trouver un moyen décent de le faire aussi, alors j'ai juste eu une idée (pas une balle d'argent, car c'est principalement une question de goût).

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

Je trouve quelques mérites dans cette solution par rapport aux autres que j'ai vus, à savoir, vous obtenez exactement 4 espaces supplémentaires d'indentation (bool), permettant à toutes les conditions de s'aligner verticalement, et le corps de l'instruction if peut être indenté dans d'une manière claire (ish). Cela conserve également les avantages de l'évaluation en court-circuit des opérateurs booléens, mais ajoute bien sûr la surcharge d'un appel de fonction qui ne fait essentiellement rien. Vous pourriez argumenter (valablement) que n'importe quelle fonction renvoyant son argument pourrait être utilisée ici au lieu de bool, mais comme je l'ai dit, c'est juste une idée et c'est finalement une question de goût.

Assez drôle, alors que j'écrivais ceci et pensais au «problème», j'ai eu une autre idée, qui supprime les frais généraux d'un appel de fonction. Pourquoi ne pas indiquer que nous allons entrer dans une condition complexe en utilisant des paires de parenthèses supplémentaires? Disons, 2 de plus, pour donner un joli retrait de 2 espaces des sous-conditions par rapport au corps de l'instruction if. Exemple:

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

J'aime un peu ça parce que quand vous le regardez, une cloche sonne immédiatement dans votre tête en disant "hé, il se passe quelque chose de complexe ici!" . Oui, je sais que les parenthèses n'aident pas à la lisibilité, mais ces conditions devraient apparaître assez rarement, et quand elles apparaîtront, vous devrez quand même vous arrêter et les lire attentivement (car elles sont complexes ).

Quoi qu'il en soit, juste deux autres propositions que je n'ai pas vues ici. J'espère que cela aide quelqu'un :)

Vous pouvez le diviser en deux lignes

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

Ou même ajouter une condition à la fois. De cette façon, au moins, il sépare l'encombrement du if.

Je sais que ce fil est ancien, mais j'ai du code Python 2.7 et PyCharm (4.5) se plaint toujours de ce cas:

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

Même avec l'avertissement PEP8 "ligne visuellement indentée avec le même retrait que la ligne logique suivante", le code réel est complètement OK? Ce n'est pas "trop ​​indenté?"

... il y a des moments où je souhaite que Python ait mordu la balle et soit parti avec des accolades frisées. Je me demande combien de bugs ont été introduits accidentellement au fil des ans en raison d'une indentation accidentelle ...

Mettez vos conditions dans une liste, puis faites un smth. comme:

if False not in Conditions:
    do_something

Je trouve que lorsque j'ai de longues conditions, j'ai souvent un corps de code court. Dans ce cas, je viens de double indentation du corps, ainsi:

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 si c'est plus clair:

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

Il n'y a aucune raison que le retrait soit un multiple de 4 dans ce cas, par exemple, voir "Aligné avec le délimiteur d'ouverture":

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

Voici une autre approche:

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

Cela permet également d'ajouter facilement une autre condition sans modifier l'instruction if en ajoutant simplement une autre condition à la liste:

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

J'utilise habituellement:

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

si notre condition if & an else doit exécuter plusieurs instructions à l'intérieur, nous pouvons écrire comme ci-dessous. Chaque fois que nous avons sinon un exemple avec une déclaration à l'intérieur.

Merci ça marche pour moi.

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

Pardonnez ma noblesse, mais il se trouve que je ne connais pas aussi bien #Python que n'importe lequel d'entre vous ici, mais il se trouve que j'ai trouvé quelque chose de similaire lors de l'écriture de mes propres objets dans une modélisation BIM 3D, donc j'adapterai mon algorithme à celui du python.

Le problème que je trouve ici, est double face:

1. Les valeurs peuvent sembler étrangères à quelqu'un qui pourrait essayer de déchiffrer le script.
2. La maintenance du code aura un coût élevé, si ces valeurs sont modifiées (le plus probable), ou si de nouvelles conditions doivent être ajoutées (schéma cassé)

Faites pour contourner tous ces problèmes, votre script doit aller comme ça

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

Avantages de cette méthode:

1. Le script est lisible.

2. Le script peut être facilement maintenu.

3. conditions est une opération de comparaison à une somme de valeurs qui représente les conditions souhaitées.
4. Pas besoin de conditions à plusieurs niveaux

J'espère que cela vous aidera tous