'İf' ifadelerinde çok satırlı koşullar oluşturuluyor mu? [kapalı]

Bazen uzun koşulları ifbirkaç çizgiye bölerim. Bunu yapmanın en belirgin yolu:

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

Görsel olarak çok çekici değil, çünkü eylem koşullarla karışıyor. Bununla birlikte, 4 boşluğun doğru Python girintisini kullanmanın doğal yoludur.

Şu an için kullanıyorum:

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

Ama bu çok hoş değil. :-)

Alternatif bir yol önerebilir misiniz?

İkinci koşullu satırınızda 4 boşluk kullanmanıza gerek yoktur. Belki kullanın:

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

Ayrıca, beyaz alanın düşündüğünüzden daha esnek olduğunu unutmayın:

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

Her ikisi de oldukça çirkin.

Belki köşeli parantezlerini kaybedebilirsiniz ( Stil Kılavuzu bunu engelliyor)?

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

Bu en azından size biraz farklılaşma sağlıyor.

Ya da:

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

Bence tercih ederim:

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

İşte (2010'dan beri) parantez kullanılmasını öneren Stil Kılavuzu .

Ben sadece AND veya OR's olduğu dejenere durumda aşağıdakilere başvurdum.

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

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

Birkaç karakteri tıraş eder ve koşulun incelikli olmadığını netleştirir.

Birisi burada dikey boşluk kullanımını savunmak zorunda! :)

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

Bu, her koşulu açıkça görünür kılar. Ayrıca daha karmaşık koşulların daha temiz ifadesine izin verir:

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

Evet, anlaşılır olması için biraz dikey emlak ticareti yapıyoruz. Buna değer IMO.

Çok büyük bir if-koşulum olduğunda bu stili tercih ederim:

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

İşte benim kişisel kişisel bakışım: uzun koşullar (benim görüşüme göre), bir boole döndüren işlev / yönteme yeniden düzenleme öneren bir kod kokusudur. Örneğin:

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

Şimdi, çok hatlı koşulları iyi göstermenin bir yolunu bulsaydım, muhtemelen kendime sahip olmaktan memnun olurdum ve yeniden düzenlemeyi atlarım.

Öte yandan, estetik anlayışımı bozmalarını sağlamak, yeniden düzenleme için bir teşvik görevi görür.

Sonuç olarak, birden fazla çizgi koşulunun çirkin görünmesi gerektiği ve bu durum onları önlemek için bir teşviktir.

Bu pek gelişmiyor ama ...

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

if allCondsAreOK:
   do_something

andAnahtar kelimeyi ikinci satıra taşımanızı ve dört yerine iki boşluk içeren koşulları içeren tüm satırlara girintiyi öneririm :

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

Kodumda bu sorunu tam olarak nasıl çözdüğüm budur. Satırdaki ilk kelime olarak bir anahtar kelimeye sahip olmak, koşulu çok daha okunabilir hale getirir ve boşluk sayısını azaltmak koşulu eylemden daha da ayırır.

Bu konuyu mütevazi bir uzunlukta yorumladığı için PEP 0008'den (Python'un resmi stil rehberi) alıntı yapmaya değer görünüyor :

Bir durumun koşullu kısmı, ifbirden çok satırda yazılmasını gerektirecek kadar uzun olduğunda, iki karakterlik bir anahtar kelimenin (yani if), artı tek bir boşluğun ve bir açılış parantezinin doğal bir 4- çok satırlı koşullu izleyen satırlar için boşluk girintisi. Bu, ifdoğal olarak 4 boşluğa girintilenecek olan -statement içine yerleştirilmiş girintili kod takımıyla görsel bir çatışma oluşturabilir . Bu PEP, bu koşullu çizgilerin if-statement içindeki yuvalanmış süitten görsel olarak nasıl ayırt edileceği (veya edilip edilmeyeceği) konusunda açık bir pozisyon almaz. Bu durumda kabul edilebilir seçenekler aşağıdakileri içerir, ancak bunlarla sınırlı değildir:

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

Yukarıdaki alıntıda "sınırlı değil" ifadesine dikkat edin; stil rehberinde önerilen yaklaşımların yanı sıra, bu sorunun diğer cevaplarında önerilenlerden bazıları da kabul edilebilir.

İşte yaptığım şey, "tüm" ve "herhangi bir" öğelerinin yinelemeyi kabul ettiğini unutmayın, bu yüzden bir listeye uzun bir koşul koydum ve "tüm" ün işi yapmasına izin verdim.

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

if all(condition):
   do_something

Tercih ettiğim çözümü görmemeye şaşırdım,

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

Yana andbir anahtar kelimedir, benim editör tarafından vurgulanan ve onun altındaki do_something yeterince farklı görünüyor alır.

@Krawyoti'nin söylediklerine ek olarak ... Uzun koşullar kokuyor çünkü okunması zor ve anlaşılması zor. Bir işlev veya değişken kullanmak kodu daha net hale getirir. Python'da, dikey boşluk kullanmayı, parantez içine almayı ve mantıksal işleçleri her satırın başına yerleştirmeyi tercih ederim, böylece ifadeler "yüzen" gibi görünmez.

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

Koşulların bir whiledöngüde olduğu gibi birden fazla değerlendirilmesi gerekiyorsa , yerel bir işlev kullanmak en iyisidir.

Şahsen, uzun if ifadelerine anlam katmayı seviyorum. Uygun bir örnek bulmak için kod aramak zorunda kalacak, ama akla gelen ilk örnek: diyelim ki birçok değişkene bağlı olarak belirli bir sayfayı görüntülemek istediğim bazı ilginç mantıkla karşılaşıyorum.

Türkçe: "Oturum açmış olan kullanıcı yönetici öğretmen DEĞİL, sadece normal bir öğretmense ve öğrencinin kendisi değilse ..."

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

Elbette bu iyi görünebilir, ancak ifadeleri okumak çok iş ise. Mantıklı olan etikete mantığı atamaya ne dersin. "Etiket" aslında değişken adıdır:

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

Bu aptalca görünebilir, ancak SADECE başka bir öğeyi görüntülemek istediğiniz başka bir koşulunuz olabilir ve yalnızca öğretmen panelini görüntülüyorsanız VEYA kullanıcı varsayılan olarak diğer belirli panele erişimi varsa:

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

Yukarıdaki koşulu mantığınızı saklamak ve etiketlemek için değişkenler kullanmadan yazmayı deneyin ve sadece çok dağınık, okunması zor bir mantıksal ifade ile değil, aynı zamanda kendinizi tekrarladınız. Makul istisnalar olsa da unutmayın: Kendinizi Tekrarlamayın (KURU).

"all" ve "any" ifadeleri, aynı türden birçok durum için uygundur. AMA her zaman tüm koşulları değerlendirir. Bu örnekte gösterildiği gibi:

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

(Sabit genişlikli adlar gerçek kodu temsil etmediği için hafifçe değiştirdim - en azından karşılaştığım gerçek kodu değil - ve bir örneğin okunabilirliğini taşıyacak.)

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

Bu, "ve" ve "veya" (ilk önce ikinci satırda olmaları önemlidir), ancak diğer uzun koşullar için çok daha az işe yarar. Neyse ki, birincisi daha sık görülen bir durum gibi görünüyor, ikincisi genellikle geçici bir değişkenle kolayca yeniden yazılıyor. (Genellikle zor değildir, ancak yeniden yazarken "ve" / "veya" kısa devresini korumak zor veya çok daha az belirgin / okunaklı olabilir.)

Bu soruyu C ++ ile ilgili blog yayından bulduğumdan , C ++ stilimin aynı olduğunu ekleyeceğim:

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

Sade ve basit, ayrıca pep8 kontrollerini de geçer:

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

Son zamanlarda, allve anyişlevlerini tercih ediyorum, çünkü And ve Or karşılaştırmalarını nadiren karıştırıyorum ve bu iyi çalışıyor ve Jeneratörlerin Anlayışı ile Erken Başarısızlık ek avantajına sahip:

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

Sadece tek bir yinelenebilir geçmek unutmayın! N argümanlarını iletmek doğru değil.

Not: anybirçok orkarşılaştırma allgibidir, birçok andkarşılaştırma gibidir.

Bu, jeneratör kavrayışlarıyla güzel bir şekilde birleşir, örneğin:

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

Daha fazla bilgi için: jeneratör kavrama

Durum ve vücut arasına yalnızca ek bir boş satır ekler ve gerisini kanonik şekilde yaparsak ne olur?

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

    do_something

ps Ben boşluklar değil, her zaman sekmeleri kullanın; İnce ayar yapamıyorum ...

Genelde yaptığım şey:

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

bu şekilde kapatma desteği ve kolon görsel olarak durumumuzun sonunu gösterir.

İf ifadesi için çok koşullu olan tüm katılımcılar da sunulan sorun kadar çirkin. Bu sorunu aynı şeyi yaparak çözemezsiniz.

PEP 0008 yanıtı bile iticidir.

İşte çok daha okunabilir bir yaklaşım

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

Sözlerimi yememi ister misin? Beni çok koşullu koşullara ihtiyacınız olduğuna ikna edin ve ben bunu gerçekten yazdırabilir ve eğlenceniz için yiyeceğim.

Bence @ zkanda'nın çözümü küçük bir bükülme ile iyi olurdu. Koşullarınız ve değerleriniz kendi listelerinde olsaydı, karşılaştırma yapmak için bir liste kavrama kullanabilirsiniz, bu da koşul / değer çiftleri eklemek için işleri biraz daha genel hale getirir.

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

Eğer böyle bir ifadeyi kodlamak isteseydim, okunaklılık için şöyle yazardım:

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

Ve sadece bir iandoperatörle başka bir çözüm atmak için :

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

if proceed:
    # do something

Tamlık uğruna sadece birkaç rastgele fikir. Sizin için çalışıyorlarsa kullanın. Aksi takdirde, muhtemelen başka bir şey denemek daha iyidir.

Bunu bir sözlükle de yapabilirsiniz:

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

Bu seçenek daha karmaşıktır, ancak bunu yararlı da bulabilirsiniz:

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

Bu sizin için işe yarıyorsa, ama düşünmek için başka bir seçenek. İşte bir yol daha:

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'

Son iki test etmedim, ama gitmek istediğin şey buysa kavramların seni idare etmesi için yeterli olmalı.

(Ve kayıt için, eğer bu sadece bir defalık bir şeyse, muhtemelen ilk başta sunduğunuz yöntemi kullanmaktan daha iyisinizdir. Karşılaştırmayı birçok yerde yapıyorsanız, bu yöntemler okunabilirliği arttırabilir bir tür hileli olmaları konusunda o kadar kötü hissetmezsiniz.)

Bunu da yapmak için iyi bir yol bulmak için uğraşıyorum, bu yüzden sadece bir fikir buldum (gümüş bir kurşun değil, çünkü bu çoğunlukla bir zevk meselesi).

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

Bu çözümde gördüğüm diğerlerine kıyasla birkaç değer buluyorum, yani, tüm koşulların dikey olarak hizalanmasına izin veren fazladan 4 boşluk (bool) elde edersiniz ve if ifadesinin gövdesi girintili olabilir açık (ish) bir yol. Bu ayrıca, boole operatörlerinin kısa devre değerlendirmesinin faydalarını korur, ancak elbette temelde hiçbir şey yapmayan bir işlev çağrısının ek yükünü ekler. Tartışmasını döndüren herhangi bir işlevin bool yerine burada kullanılabileceğini iddia edebilirsiniz (geçerli olarak), ama dediğim gibi, bu sadece bir fikir ve sonuçta bir zevk meselesi.

Yeterince komik, bunu yazarken ve "problem" hakkında düşünürken , bir fonksiyon çağrısının yükünü kaldıran başka bir fikir buldum . Ekstra parantez çiftlerini kullanarak karmaşık bir duruma girmek üzere olduğumuzu neden belirtmiyorsunuz? 2 ifadesi daha varsa, if ifadesinin gövdesine göre alt koşulların güzel bir 2 boşluk girintisini verin. Misal:

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

Bunu sevdim çünkü ona baktığınızda, kafanızda hemen "zil , burada karmaşık bir şey oluyor!" . Evet, parantezlerin okunabilirliğe yardımcı olmadığını biliyorum, ancak bu koşullar nadiren yeterli görünmelidir ve ortaya çıktıklarında, onları durdurmalı ve yine de dikkatlice okumalısınız (çünkü karmaşıktırlar ).

Her neyse, burada görmediğim sadece iki teklif daha. Umarım bu birine yardımcı olur :)

İki satıra bölebilirsiniz

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

Ya da her seferinde bir koşul ekleyin. Bu şekilde, en azından dağınıklığı ayırır if.

Bu iş parçacığı eski biliyorum, ama bazı Python 2.7 kodu var ve PyCharm (4.5) hala bu dava hakkında şikayet ediyor:

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 uyarısı ile "bir sonraki mantıksal satırla aynı girintili görsel olarak girintili çizgi" ile bile, gerçek kod tamam mı? "Aşırı girintili mi?"

... Python'un mermiyi ısırmasını ve sadece kıvırcık parantezlerle gitmesini istediğim zamanlar var. Yanlışlıkla yanlış girintiden dolayı yıllar boyunca yanlışlıkla kaç hata getirildiğini merak ediyorum ...

Koşullarınızı bir liste halinde paketleyin, ardından ikram edin. sevmek:

if False not in Conditions:
    do_something

Uzun koşullara sahip olduğumda, genellikle kısa bir kod gövdesim olduğunu görüyorum. Bu durumda, vücudu iki kez girintiliyorum, böylece:

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

veya bu daha açıksa:

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

Bu durumda girintinin 4'ün katı olması için bir neden yoktur, örneğin bkz. "Açıcı ayırıcı ile hizalanmış":

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

İşte başka bir yaklaşım:

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

Bu ayrıca, listeye başka bir koşul ekleyerek if ifadesini değiştirmeden kolayca başka bir koşul eklemeyi kolaylaştırır:

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

Genellikle kullanıyorum:

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

if & else koşulumuz, aşağıdaki gibi yazabileceğimizden çok sayıda ifade yürütmek zorundaysa. İçimizde bir ifade ile başka örnek varsa.

Teşekkürler benim için çalışıyor.

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

Noobness'imi affedin, ama buradaki #Python hakkında sizin kadar bilgili olmadığım oluyor, ancak 3D BIM modellemesinde kendi nesnelerimi yazarken benzer bir şey bulduğum için algoritmamı Python'un

Burada bulduğum problem çift taraflı:

1. Senaryoyu deşifre etmeye çalışabilecek biri için yabancı gibi görünüyor.
2. Bu değerler değiştirilirse (en olası) veya yeni koşulların eklenmesi gerekiyorsa (bozuk şema) kod bakımı yüksek bir maliyetle gelir

Tüm bu sorunları atlamak için komut dosyanızın böyle gitmesi gerekir

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

Bu yöntemin artıları:

1. Komut dosyası okunabilir.

2. Script bakımı kolay olabilir.

3. koşullar, istenen koşulları temsil eden değerlerin toplamı ile 1 karşılaştırma işlemidir.
4. Çok seviyeli koşullara gerek yok

Umarım hepinize yardım eder