เป็นไปได้ไหมที่จะส่งต่อประกาศฟังก์ชันใน Python

เป็นไปได้ไหมที่จะส่งต่อประกาศฟังก์ชันใน Python ฉันต้องการเรียงลำดับรายการโดยใช้cmpฟังก์ชั่นของตัวเองก่อนที่จะมีการประกาศ

print "\n".join([str(bla) for bla in sorted(mylist, cmp = cmp_configs)])

ฉันจัดระเบียบโค้ดเพื่อกำหนดนิยามของcmp_configsวิธีหลังจากการภาวนา มันล้มเหลวด้วยข้อผิดพลาดนี้:

NameError: name 'cmp_configs' is not defined

มีวิธีใดที่จะ "ประกาศ" cmp_configsวิธีการก่อนที่มันจะใช้? มันจะทำให้โค้ดของฉันดูสะอาดขึ้นไหม

ฉันคิดว่าบางคนจะถูกล่อลวงให้บอกฉันว่าฉันควรจัดระเบียบรหัสของฉันใหม่เพื่อที่ฉันจะได้ไม่มีปัญหานี้ อย่างไรก็ตามมีบางกรณีที่อาจหลีกเลี่ยงไม่ได้เช่นเมื่อใช้การเรียกซ้ำบางรูปแบบ ถ้าคุณทำไม่ได้เช่นตัวอย่างนี้สมมติว่าผมมีกรณีที่มันเป็นความจริงที่จำเป็นเพื่อส่งต่อประกาศฟังก์ชั่น

พิจารณากรณีนี้ที่จำเป็นต้องใช้ฟังก์ชันการประกาศล่วงหน้าใน Python:

def spam():
    if end_condition():
        return end_result()
    else:
        return eggs()

def eggs():
    if end_condition():
        return end_result()
    else:
        return spam()

ที่ไหนend_conditionและend_resultมีการกำหนดไว้ก่อนหน้านี้

เป็นทางออกเดียวที่จะจัดระเบียบรหัสใหม่และมักจะใส่คำจำกัดความก่อนที่จะเรียก?

หากคุณไม่ต้องการกำหนดฟังก์ชั่นก่อนที่จะใช้งานและการกำหนดในภายหลังเป็นไปไม่ได้สิ่งที่เกี่ยวกับการกำหนดในโมดูลอื่น ๆ ?

ในทางเทคนิคคุณยังคงนิยามไว้ก่อน แต่มันก็สะอาด

คุณสามารถสร้างการสอบถามซ้ำดังนี้:

def foo():
    bar()

def bar():
    foo()

ฟังก์ชันของไพ ธ อนนั้นไม่ระบุชื่อเช่นเดียวกับค่าที่ไม่ระบุชื่อ แต่ก็สามารถผูกกับชื่อได้

ในรหัสข้างต้นfoo()ไม่เรียกฟังก์ชั่นที่มีชื่อ foo มันเรียกฟังก์ชั่นที่เกิดขึ้นจะถูกผูกไว้กับชื่อfooที่จุดที่มีการโทร มันเป็นไปได้ที่จะกำหนดที่fooอื่นbarแล้วจะเรียกฟังก์ชั่นใหม่

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

สิ่งที่คุณสามารถทำได้คือห่อคำภาวนาให้เป็นหน้าที่ของมันเอง

ดังนั้น

foo()

def foo():
    print "Hi!"

จะทำลาย แต่

def bar():
    foo()

def foo():
    print "Hi!"

bar()

จะทำงานอย่างถูกต้อง

กฎทั่วไปในPythonคือไม่ว่าการทำงานควรจะกำหนดไว้ที่สูงขึ้นในรหัส (ในPascal) แต่ที่มันควรจะกำหนดไว้ก่อนที่จะใช้งาน

หวังว่าจะช่วย

หากคุณเริ่มต้นสคริปต์ของคุณผ่านสิ่งต่อไปนี้:

if __name__=="__main__":
   main()

ดังนั้นคุณอาจไม่ต้องกังวลกับสิ่งต่าง ๆ เช่น "การประกาศล่วงหน้า" คุณเห็นแล้วผู้แปลจะโหลดฟังก์ชั่นทั้งหมดของคุณแล้วเริ่มฟังก์ชั่น main () ของคุณ แน่นอนให้แน่ใจว่าคุณมีการนำเข้าทั้งหมดถูกต้องด้วย ;-)

ลองคิดดูสิฉันไม่เคยได้ยินเรื่องเช่น "การประกาศล่วงหน้า" ในภาษาไพ ธ อน ... แต่จากนั้นอีกครั้งฉันอาจจะผิด ;-)

หากการเรียกไปยัง cmp_configs อยู่ภายในนิยามฟังก์ชันของตัวเองคุณควรจะใช้ได้ ฉันจะยกตัวอย่าง

def a():
  b()  # b() hasn't been defined yet, but that's fine because at this point, we're not
       # actually calling it. We're just defining what should happen when a() is called.

a()  # This call fails, because b() hasn't been defined yet, 
     # and thus trying to run a() fails.

def b():
  print "hi"

a()  # This call succeeds because everything has been defined.

โดยทั่วไปการวางโค้ดของคุณไว้ในฟังก์ชั่น (เช่น main ()) จะช่วยแก้ปัญหาของคุณได้ เพียงแค่เรียก main () ที่ท้ายไฟล์

ฉันขอโทษสำหรับการฟื้นฟูหัวข้อนี้ แต่มีกลยุทธ์ที่ไม่ได้กล่าวถึงที่นี่ซึ่งอาจมีผลบังคับใช้

การใช้การไตร่ตรองเป็นไปได้ที่จะทำสิ่งที่คล้ายเพื่อส่งต่อการประกาศ ตัวอย่างเช่นสมมติว่าคุณมีส่วนของรหัสที่มีลักษณะดังนี้:

# We want to call a function called 'foo', but it hasn't been defined yet.
function_name = 'foo'
# Calling at this point would produce an error

# Here is the definition
def foo():
    bar()

# Note that at this point the function is defined
    # Time for some reflection...
globals()[function_name]()

ดังนั้นด้วยวิธีนี้เราได้กำหนดฟังก์ชันที่เราต้องการเรียกก่อนที่มันจะถูกกำหนดจริง ๆ แล้วเป็นการประกาศล่วงหน้า ในหลามคำสั่งglobals()[function_name]()เป็นเช่นเดียวกับfoo()ถ้าfunction_name = 'foo'ด้วยเหตุผลที่กล่าวข้างต้นตั้งแต่หลามต้องค้นหาแต่ละฟังก์ชั่นก่อนที่จะเรียกมันว่า ถ้าใครจะใช้timeitโมดูลเพื่อดูว่าทั้งสองงบเปรียบเทียบพวกเขามีต้นทุนการคำนวณที่แน่นอน

แน่นอนว่าตัวอย่างที่นี่ไม่มีประโยชน์มาก แต่ถ้าใครมีโครงสร้างที่ซับซ้อนซึ่งจำเป็นต้องใช้งานฟังก์ชั่น แต่จะต้องประกาศก่อน (หรือโครงสร้างมันทำให้รู้สึกเล็กน้อยที่จะมีมันในภายหลัง) เพียงแค่สามารถเก็บสตริงและ ลองเรียกใช้ฟังก์ชันในภายหลัง

ไม่มีสิ่งใดในไพ ธ อนเหมือนกับการประกาศล่วงหน้า คุณเพียงแค่ต้องทำให้แน่ใจว่าฟังก์ชั่นของคุณถูกประกาศก่อนที่จะต้องมีการ โปรดทราบว่าเนื้อความของฟังก์ชันไม่ถูกตีความจนกว่าจะมีการใช้งานฟังก์ชัน

ลองพิจารณาตัวอย่างต่อไปนี้:

def a():
   b() # won't be resolved until a is invoked.

def b(): 
   print "hello"

a() # here b is already defined so this line won't fail.

คุณสามารถคิดว่าเนื้อความของฟังก์ชันเป็นเพียงสคริปต์อื่นที่จะถูกตีความเมื่อคุณเรียกใช้ฟังก์ชัน

ไม่ฉันไม่เชื่อว่ามีวิธีใดที่จะส่งต่อประกาศฟังก์ชันใน Python

ลองนึกภาพคุณเป็นล่าม Python เมื่อคุณไปถึงที่หมาย

print "\n".join([str(bla) for bla in sorted(mylist, cmp = cmp_configs)])

อย่างใดอย่างหนึ่งคุณรู้ว่า cmp_configs คืออะไรหรือคุณไม่ ในการดำเนินการต่อคุณต้องรู้ cmp_configs ไม่สำคัญว่าจะมีการสอบถามซ้ำหรือไม่

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

คุณสามารถทำได้โดยไม่ต้องมีการแจ้งล่วงหน้า:

def main():
  make_omelet()
  eat()

def make_omelet():
  break_eggs()
  whisk()
  fry()

def break_eggs():
  for egg in carton:
    break(egg)

# ...

main()

# declare a fake function (prototype) with no body
def foo(): pass

def bar():
    # use the prototype however you see fit
    print(foo(), "world!")

# define the actual function (overwriting the prototype)
def foo():
    return "Hello,"

bar()

เอาท์พุท:

Hello, world!

คุณไม่สามารถส่งต่อประกาศฟังก์ชันใน Python หากคุณมีการดำเนินการทางตรรกะก่อนที่คุณจะได้กำหนดฟังก์ชั่นแสดงว่าคุณอาจมีปัญหาอยู่ดี ใส่การกระทำของคุณในif __name__ == '__main__'ตอนท้ายของสคริปต์ของคุณ (โดยการดำเนินการฟังก์ชั่นที่คุณชื่อ "หลัก" ถ้ามันไม่สำคัญ) และรหัสของคุณจะเป็นแบบแยกส่วนและคุณจะสามารถใช้มันเป็นโมดูลหากคุณต้องการ ถึง.

นอกจากนี้ให้แทนที่รายการนั้นเข้าใจด้วยตัวสร้างด่วน (เช่นprint "\n".join(str(bla) for bla in sorted(mylist, cmp=cmp_configs)))

นอกจากนี้อย่าใช้cmpซึ่งเลิกใช้แล้ว ใช้keyและจัดให้มีฟังก์ชั่นน้อยกว่า

นำเข้าไฟล์ของตัวเอง สมมติว่าไฟล์ชื่อ test.py:

import test

if __name__=='__main__':
    test.func()
else:
    def func():
        print('Func worked')

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

คุณสามารถให้ฟังก์ชันก่อนการอ้างอิง

"อย่างไรก็ตามมีบางกรณีที่อาจหลีกเลี่ยงไม่ได้เช่นเมื่อใช้การเรียกซ้ำบางรูปแบบ"

ไม่เห็นว่าเป็นไปได้อย่างไรจากระยะไกล โปรดระบุตัวอย่างของสถานที่ที่คุณไม่สามารถกำหนดฟังก์ชั่นก่อนการใช้งานได้

รอสักครู่ เมื่อโมดูลของคุณไปถึงคำสั่งการพิมพ์ในตัวอย่างของคุณก่อนที่จะcmp_configsถูกกำหนดสิ่งที่คุณคาดหวังให้ทำคืออะไร?

หากการโพสต์คำถามโดยใช้การพิมพ์กำลังพยายามแสดงสิ่งนี้:

fn = lambda mylist:"\n".join([str(bla)
                         for bla in sorted(mylist, cmp = cmp_configs)])

ดังนั้นจึงไม่มีข้อกำหนดที่จะกำหนด cmp_configsก่อนที่จะดำเนินการคำสั่งนี้เพียงแค่กำหนดไว้ในภายหลังในรหัสและทุกอย่างจะดี

ตอนนี้ถ้าคุณกำลังพยายามอ้างอิงcmp_configsเป็นค่าเริ่มต้นของการโต้เถียงกับแลมบ์ดานี่ก็เป็นอีกเรื่อง

fn = lambda mylist,cmp_configs=cmp_configs : \
    "\n".join([str(bla) for bla in sorted(mylist, cmp = cmp_configs)])

ตอนนี้คุณต้องcmp_configsกำหนดตัวแปรก่อนที่จะถึงบรรทัดนี้

[แก้ไข - ส่วนต่อไปนี้ปรากฎว่าไม่ถูกต้องเนื่องจากค่าอาร์กิวเมนต์เริ่มต้นจะได้รับมอบหมายเมื่อรวบรวมฟังก์ชั่นและค่าดังกล่าวจะถูกนำมาใช้แม้ว่าคุณจะเปลี่ยนค่าของ cmp_configs ในภายหลัง]

โชคดีที่ Python ให้การรองรับแบบที่เป็นอยู่ไม่สนใจสิ่งที่คุณกำหนดcmp_configsดังนั้นคุณสามารถนำหน้าด้วยคำสั่งนี้:

cmp_configs = None

และคอมไพเลอร์จะมีความสุข เพียงให้แน่ใจว่าได้ประกาศของจริงcmp_configsก่อนที่คุณจะเรียกfnก่อนที่คุณเคยวิงวอน

วิธีหนึ่งคือการสร้างฟังก์ชั่นการจัดการ กำหนดตัวจัดการต้นและวางตัวจัดการด้านล่างวิธีการทั้งหมดที่คุณต้องการโทร

จากนั้นเมื่อคุณเรียกใช้เมธอดตัวจัดการเพื่อเรียกใช้ฟังก์ชั่นของคุณมันจะพร้อมใช้งานเสมอ

ผู้ดำเนินการอาจโต้แย้ง nameOfMethodToCallตัวจัดการอาจจะใช้การโต้เถียงจากนั้นใช้คำสั่ง if เพื่อเรียกวิธีการที่ถูกต้อง

นี่จะช่วยแก้ปัญหาของคุณ

def foo():
    print("foo")
    #take input
    nextAction=input('What would you like to do next?:')
    return nextAction

def bar():
    print("bar")
    nextAction=input('What would you like to do next?:')
    return nextAction

def handler(action):
    if(action=="foo"):
        nextAction = foo()
    elif(action=="bar"):
        nextAction = bar()
    else:
        print("You entered invalid input, defaulting to bar")
        nextAction = "bar"
    return nextAction

nextAction=input('What would you like to do next?:')

while 1:
    nextAction = handler(nextAction)

ใช่เราสามารถตรวจสอบสิ่งนี้ได้

อินพุต

print_lyrics() 
def print_lyrics():

    print("I'm a lumberjack, and I'm okay.")
    print("I sleep all night and I work all day.")

def repeat_lyrics():
    print_lyrics()
    print_lyrics()
repeat_lyrics()

เอาท์พุต

I'm a lumberjack, and I'm okay.
I sleep all night and I work all day.
I'm a lumberjack, and I'm okay.
I sleep all night and I work all day.
I'm a lumberjack, and I'm okay.
I sleep all night and I work all day.

ดังที่บีเจโฮเมอร์กล่าวถึงความคิดเห็นข้างต้นกฎทั่วไปใน Python ไม่ใช่ฟังก์ชั่นที่ควรกำหนดไว้สูงกว่าในรหัส (เช่นเดียวกับใน Pascal) แต่ควรกำหนดไว้ก่อนการใช้งาน

หวังว่าจะช่วย