จัดแต่งทรงผมแบบหลายเงื่อนไขในงบ 'ถ้า'? [ปิด]

บางครั้งฉันแบ่งเงื่อนไขที่ยาวifเป็นหลายบรรทัด วิธีที่ชัดเจนที่สุดในการทำเช่นนี้คือ:

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

ไม่ดึงดูดสายตามากนักเพราะการกระทำนั้นกลมกลืนกับเงื่อนไข อย่างไรก็ตามเป็นวิธีที่เป็นธรรมชาติโดยใช้การย่อหน้า Python ที่ถูกต้องจำนวน 4 ช่อง

สำหรับช่วงเวลาที่ฉันใช้:

  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

ทั้งสองอย่างนั้นค่อนข้างน่าเกลียด

อาจสูญเสียวงเล็บเหลี่ยม ( Style Guideไม่สนับสนุนสิ่งนี้)?

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

นี่คือStyle Guideซึ่ง (ตั้งแต่ปี 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 (
    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ซึ่งจะเป็นการเยื้องตามธรรมชาติถึง 4 ช่องว่าง PEP นี้จะใช้เวลาไม่มีตำแหน่งอย่างชัดเจนเกี่ยวกับวิธีการ (หรือว่า) เพื่อการมองเห็นความแตกต่างของสายตามเงื่อนไขดังกล่าวจากชุดที่ซ้อนกันภายในif-statement ตัวเลือกที่ยอมรับได้ในสถานการณ์นี้รวมถึง แต่ไม่ จำกัด เพียง:

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

หมายเหตุ "ไม่ จำกัด เฉพาะ" ในเครื่องหมายคำพูดด้านบน นอกเหนือจากแนวทางที่แนะนำในคู่มือแนะนำสไตล์แล้วแนวทางที่แนะนำในคำตอบอื่น ๆ สำหรับคำถามนี้ก็เป็นที่ยอมรับเช่นกัน

นี่คือสิ่งที่ฉันทำโปรดจำไว้ว่า "ทั้งหมด" และ "ใด ๆ " ยอมรับการทำซ้ำดังนั้นฉันจึงใส่เงื่อนไขที่ยาวในรายการและปล่อยให้ "ทั้งหมด" ทำงาน

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 ฉันต้องการใช้พื้นที่แนวตั้งล้อมรอบวงเล็บและวางตัวดำเนินการเชิงตรรกะที่จุดเริ่มต้นของแต่ละบรรทัดเพื่อให้นิพจน์ไม่เหมือน "floating"

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

หากเงื่อนไขต้องได้รับการประเมินมากกว่าหนึ่งครั้งเช่นเดียวกับการwhileวนซ้ำการใช้ฟังก์ชั่นท้องถิ่นจะดีที่สุด

ส่วนตัวผมชอบที่จะเพิ่มความหมายให้กับงบยาว ฉันจะต้องค้นหารหัสเพื่อค้นหาตัวอย่างที่เหมาะสม แต่นี่เป็นตัวอย่างแรกที่นึกได้: สมมติว่าฉันเกิดปัญหาตรรกะบางอย่างที่ฉันต้องการแสดงหน้าบางอย่างขึ้นอยู่กับตัวแปรหลายตัว

ภาษาอังกฤษ: "ถ้าผู้ใช้ที่เข้าสู่ระบบไม่ใช่อาจารย์ผู้ดูแลระบบ แต่เป็นเพียงครูประจำและไม่ใช่นักเรียนเอง ... "

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

แน่นอนว่านี่อาจดูดี แต่การอ่านหากคำสั่งทำงานหนักมาก วิธีการเกี่ยวกับเรากำหนดตรรกะเพื่อฉลากที่เหมาะสม "label" เป็นชื่อตัวแปรจริง:

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

สิ่งนี้อาจดูงี่เง่า แต่คุณอาจมีเงื่อนไขอื่นที่คุณต้องการแสดงรายการอื่นเฉพาะในกรณีที่คุณแสดงพาเนลครูหรือหากผู้ใช้มีการเข้าถึงพาเนลเฉพาะอื่น ๆ ตามค่าเริ่มต้น:

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

ลองเขียนเงื่อนไขข้างต้นโดยไม่ใช้ตัวแปรในการจัดเก็บและติดฉลากตรรกะของคุณและไม่เพียง แต่คุณจะจบลงด้วยคำสั่งทางตรรกะที่ยุ่งเหยิงและอ่านยาก แต่คุณก็ต้องทำซ้ำด้วยตัวเอง ในขณะที่มีข้อยกเว้นที่สมเหตุสมผลโปรดจำไว้ว่า: อย่าทำซ้ำตัวเอง (DRY)

"ทั้งหมด" และ "ใด ๆ " เป็นสิ่งที่ดีสำหรับเงื่อนไขประเภทเดียวกันหลายกรณี แต่พวกเขามักจะประเมินเงื่อนไขทั้งหมด ดังที่แสดงในตัวอย่างนี้:

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

สิ่งนี้ใช้ได้ดีสำหรับ "และ" และ "หรือ" (เป็นสิ่งสำคัญที่จะต้องอยู่ในบรรทัดที่สองเป็นอันดับแรก) แต่ก็น้อยกว่ามากสำหรับเงื่อนไขที่ยาวนานอื่น ๆ โชคดีที่อดีตดูเหมือนจะเป็นกรณีทั่วไปมากขึ้นในขณะที่หลังมักจะเขียนใหม่ได้อย่างง่ายดายด้วยตัวแปรชั่วคราว (โดยทั่วไปจะไม่ยาก แต่อาจเป็นเรื่องยากหรือชัดเจนน้อยกว่า / อ่านได้เพื่อรักษาการลัดวงจรของ "และ" / "หรือ" เมื่อเขียนใหม่)

เนื่องจากฉันพบคำถามนี้จากการโพสต์บล็อกของคุณเกี่ยวกับ C ++ฉันจะระบุว่าสไตล์ C ++ ของฉันเหมือนกัน:

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

ธรรมดาและเรียบง่ายผ่านการตรวจสอบ pep8 ด้วย:

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

ในครั้งล่าสุดที่ฉันได้รับการเลือกallและanyฟังก์ชั่นเนื่องจากฉันไม่ค่อยผสมและและหรือเปรียบเทียบการทำงานนี้ได้ดีและมีข้อได้เปรียบเพิ่มเติมของความล้มเหลวในช่วงต้นด้วยความเข้าใจกำเนิด:

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

เพียงจำไว้ว่าให้ส่งผ่าน iterable เดียว! การส่งผ่านอาร์กิวเมนต์ 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

ปล. ฉันมักจะใช้แท็บไม่ใช่ที่ว่าง ฉันไม่สามารถปรับแต่ง ...

สิ่งที่ฉันมักจะทำคือ:

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'

สองครั้งสุดท้ายที่ฉันยังไม่ได้ทดสอบ แต่แนวคิดควรจะเพียงพอที่จะให้คุณไปถ้านั่นคือสิ่งที่คุณต้องการไปด้วย

(และสำหรับบันทึกถ้านี่เป็นเพียงครั้งเดียวคุณน่าจะดีกว่าโดยใช้วิธีที่คุณนำเสนอในตอนแรกถ้าคุณทำการเปรียบเทียบในหลาย ๆ ที่วิธีการเหล่านี้อาจช่วยให้อ่านง่ายขึ้น คุณไม่รู้สึกแย่เกี่ยวกับความจริงที่ว่าพวกเขาเป็นพวกแฮ็ค)

ฉันพยายามดิ้นรนเพื่อหาวิธีที่เหมาะสมในการทำสิ่งนี้เช่นกันดังนั้นฉันจึงเกิดความคิดขึ้น (ไม่ใช่กระสุนเงินเพราะนี่เป็นเรื่องของรสนิยม)

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

ฉันพบข้อดีสองสามอย่างในวิธีนี้เทียบกับคนอื่นที่ฉันเคยเห็นนั่นคือคุณจะได้รับการเยื้องพิเศษ (bool) 4 ช่องซึ่งช่วยให้ทุกเงื่อนไขเรียงตัวในแนวตั้งและเนื้อหาของคำสั่ง if สามารถเยื้องใน วิธีที่ชัดเจน (ish) สิ่งนี้ยังคงประโยชน์ของการประเมินการลัดวงจรของตัวดำเนินการบูลีน แต่แน่นอนว่าเป็นการเพิ่มค่าใช้จ่ายในการเรียกใช้ฟังก์ชันที่โดยทั่วไปไม่ได้ทำอะไรเลย คุณสามารถโต้แย้ง (ถูกต้อง) ว่าฟังก์ชันใด ๆ ที่ส่งคืนอาร์กิวเมนต์สามารถใช้ที่นี่แทนบูลได้ แต่อย่างที่ฉันพูดมันเป็นเพียงแนวคิดและท้ายที่สุดมันก็เป็นเรื่องของรสนิยม

ตลกพอที่ฉันเขียนเรื่องนี้และคิดเกี่ยวกับ "ปัญหา" ฉันจึงคิดอีกแนวคิดหนึ่งซึ่งจะเอาค่าใช้จ่ายของการเรียกฟังก์ชัน ทำไมไม่ระบุว่าเรากำลังจะเข้าสู่เงื่อนไขที่ซับซ้อนโดยใช้วงเล็บคู่พิเศษ บอกเด็กอีก 2 คนว่าให้เว้นวรรค 2 อันของเงื่อนไขย่อยที่สัมพันธ์กับเนื้อความของคำสั่ง if ตัวอย่าง:

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 "บรรทัดที่มีการเยื้องทางสายตาที่มีการเยื้องเหมือนกับบรรทัดตรรกะถัดไป" แต่รหัสจริงก็โอเคอย่างสมบูรณ์? ไม่ใช่ "การเยื้องมากเกินไป"

... มีบางครั้งที่ฉันหวังว่าหลามจะทำให้กระสุนปืนหายไปและใช้เครื่องมือจัดฟันแบบหยิก ฉันสงสัยว่ามีข้อผิดพลาดเกิดขึ้นกี่ครั้งในช่วงหลายปีที่ผ่านมาเนื่องจากการเยื้องโดยไม่ตั้งใจ ...

บรรจุเงื่อนไขของคุณลงในรายการแล้วทำ smth ชอบ:

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

ให้อภัย noobness ของฉัน แต่มันเกิดขึ้นที่ฉันไม่รู้ #Python เหมือนกับที่คุณทุกคนที่นี่ แต่มันเกิดขึ้นที่ฉันพบสิ่งที่คล้ายกันเมื่อสคริปต์วัตถุของตัวเองในแบบจำลอง BIM 3D ดังนั้นฉันจะปรับอัลกอริทึมของฉัน ของหลาม

ปัญหาที่ฉันพบที่นี่เป็นสองด้าน:

1. ค่าของฉันดูเหมือนต่างประเทศสำหรับคนที่อาจพยายามถอดรหัสสคริปต์
2. การบำรุงรักษาโค้ดจะมีค่าใช้จ่ายสูงหากค่าเหล่านั้นเปลี่ยนไป (น่าจะเป็นได้มากที่สุด) หรือหากต้องเพิ่มเงื่อนไขใหม่ (schema ที่ใช้งานไม่ได้)

ทำเพื่อหลีกเลี่ยงปัญหาเหล่านี้สคริปต์ของคุณต้องเป็นแบบนี้

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. ไม่จำเป็นต้องมีเงื่อนไขหลายระดับ

หวังว่ามันจะช่วยคุณทุกคน