ตัวอย่างง่ายๆ สองวิธีวิธีหนึ่งเรียกจากวิธีอื่น:

def method_a(arg):
    some_data = method_b(arg)

def method_b(arg):
    return some_data

ในไพ ธ อนเราสามารถประกาศdefในสิ่งอื่นdefได้ ดังนั้นหากmethod_bจำเป็นและเรียกร้องเท่านั้นmethod_aฉันควรประกาศmethod_bภายในmethod_aหรือไม่ แบบนี้ :

def method_a(arg):

    def method_b(arg):
        return some_data

    some_data = method_b(arg)

หรือฉันควรหลีกเลี่ยงการทำเช่นนี้?

>>> def sum(x, y):
...     def do_it():
...             return x + y
...     return do_it
... 
>>> a = sum(1, 3)
>>> a
<function do_it at 0xb772b304>
>>> a()
4

นี่คือสิ่งที่คุณกำลังมองหา? มันเรียกว่าปิด

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

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

ปรับปรุง:

ต่อไปนี้เป็นข้อพิสูจน์ว่าการทำรังช้ากว่า (โดยใช้ Python 3.6.1) แม้ว่าจะไม่ค่อยได้รับการยอมรับมากนักในกรณีเล็กน้อยนี้

setup = """
class Test(object):
    def separate(self, arg):
        some_data = self._method_b(arg)

    def _method_b(self, arg):
        return arg+1

    def nested(self, arg):

        def method_b2(self, arg):
            return arg+1

        some_data = method_b2(self, arg)

obj = Test()
"""
from timeit import Timer
print(min(Timer(stmt='obj.separate(42)', setup=setup).repeat()))  # -> 0.24479823284461724
print(min(Timer(stmt='obj.nested(42)', setup=setup).repeat()))    # -> 0.26553459700452575

หมายเหตุผมเพิ่มบางselfข้อโต้แย้งฟังก์ชั่นตัวอย่างของคุณจะทำให้พวกเขามากขึ้นเช่นวิธีการจริง (ถึงแม้จะmethod_b2ยังไม่ได้เป็นเทคนิควิธีการที่Testชั้น) นอกจากนี้ฟังก์ชั่นที่ซ้อนกันจริงเรียกว่าในรุ่นที่แตกต่างจากคุณ

ฟังก์ชั่นภายในของฟังก์ชั่นที่ใช้กันทั่วไปสำหรับการปิดการปิด

(มีเป็นจำนวนมากของการต่อสู้มากกว่าว่าสิ่งที่ทำให้ปิดปิด )

นี่คือตัวอย่างการใช้งานในsum()ตัว มันกำหนดstartเพียงครั้งเดียวและใช้มันจากนั้นใน:

def sum_partial(start):
    def sum_start(iterable):
        return sum(iterable, start)
    return sum_start

ในการใช้งาน:

>>> sum_with_1 = sum_partial(1)
>>> sum_with_3 = sum_partial(3)
>>> 
>>> sum_with_1
<function sum_start at 0x7f3726e70b90>
>>> sum_with_3
<function sum_start at 0x7f3726e70c08>
>>> sum_with_1((1,2,3))
7
>>> sum_with_3((1,2,3))
9

การปิดตัวหลามแบบในตัว

functools.partial เป็นตัวอย่างของการปิด

จากเอกสารหลามมันเทียบเท่ากับ:

def partial(func, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        newkeywords = keywords.copy()
        newkeywords.update(fkeywords)
        return func(*(args + fargs), **newkeywords)
    newfunc.func = func
    newfunc.args = args
    newfunc.keywords = keywords
    return newfunc

(คำชื่นชมถึง @ user225312 ด้านล่างสำหรับคำตอบฉันคิดว่าตัวอย่างนี้ง่ายกว่าที่จะคิดออกและหวังว่าจะช่วยตอบความคิดเห็นของ @ mango)

โดยทั่วไปไม่ไม่ได้กำหนดฟังก์ชั่นภายในฟังก์ชั่น

ถ้าคุณไม่มีเหตุผลที่ดีจริงๆ ซึ่งคุณทำไม่ได้

ทำไมจะไม่ล่ะ?

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

อะไรคือเหตุผลที่ดีในการกำหนดฟังก์ชั่นภายในฟังก์ชั่น?

เมื่อสิ่งที่คุณจริงต้องการคือ dingdang ปิด

เป็นเรื่องปกติที่จะประกาศฟังก์ชันหนึ่งในอีกฟังก์ชันหนึ่ง นี่คือการสร้างตกแต่งที่มีประโยชน์เป็นพิเศษ

อย่างไรก็ตามตามกฎทั่วไปหากฟังก์ชันซับซ้อน (มากกว่า 10 บรรทัด) อาจเป็นความคิดที่ดีที่จะประกาศในระดับโมดูล

ฉันพบคำถามนี้เพราะฉันต้องการตั้งคำถามว่าทำไมมีผลกระทบต่อประสิทธิภาพหากใช้ฟังก์ชันซ้อนกัน ฉันทดสอบการใช้งานฟังก์ชั่นต่อไปนี้โดยใช้ Python 3.2.5 ใน Windows Notebook พร้อมโปรเซสเซอร์ Quad Core 2.5 GHz Intel i5-2530M

def square0(x):
    return x*x

def square1(x):
    def dummy(y):
        return y*y
    return x*x

def square2(x):
    def dummy1(y):
        return y*y
    def dummy2(y):
        return y*y
    return x*x

def square5(x):
    def dummy1(y):
        return y*y
    def dummy2(y):
        return y*y
    def dummy3(y):
        return y*y
    def dummy4(y):
        return y*y
    def dummy5(y):
        return y*y
    return x*x

ฉันวัด 20 ครั้งต่อไปนี้สำหรับสแควร์ 1, สแควร์ 2 และสแควร์ 5:

s=0
for i in range(10**6):
    s+=square0(i)

และได้ผลลัพธ์ดังต่อไปนี้

>>> 
m = mean, s = standard deviation, m0 = mean of first testcase
[m-3s,m+3s] is a 0.997 confidence interval if normal distributed

square? m     s       m/m0  [m-3s ,m+3s ]
square0 0.387 0.01515 1.000 [0.342,0.433]
square1 0.460 0.01422 1.188 [0.417,0.503]
square2 0.552 0.01803 1.425 [0.498,0.606]
square5 0.766 0.01654 1.979 [0.717,0.816]
>>> 

square0ไม่มีฟังก์ชั่นที่ซ้อนกันsquare1มีฟังก์ชั่นที่ซ้อนกันหนึ่งฟังก์ชั่นที่square2ซ้อนกันสองฟังก์ชั่นและsquare5มีห้าฟังก์ชั่นที่ซ้อนกัน ฟังก์ชั่นที่ซ้อนกันจะประกาศเท่านั้น แต่ไม่ได้เรียก

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

แฟ้มงูใหญ่สำหรับการทดสอบทั้งที่สร้างผลลัพธ์นี้สามารถพบได้ที่ideone

เป็นเพียงหลักการเกี่ยวกับ API การเปิดเผย

การใช้ python เป็นความคิดที่ดีที่จะหลีกเลี่ยงการสัมผัส API ในอวกาศ (โมดูลหรือคลาส) ฟังก์ชั่นเป็นสถานที่ที่ดีในการห่อหุ้ม

มันอาจเป็นความคิดที่ดี เมื่อคุณมั่นใจ

1. ฟังก์ชั่นด้านในเท่านั้นที่ใช้โดยฟังก์ชั่นด้านนอก
2. ฟังก์ชั่นภายในมีชื่อที่ดีที่จะอธิบายวัตถุประสงค์ของมันเพราะรหัสพูด
3. รหัสไม่สามารถเข้าใจได้โดยตรงจากเพื่อนร่วมงานของคุณ (หรือเครื่องอ่านรหัสอื่น ๆ )

แม้ว่าการใช้ผิดวิธีเทคนิคนี้อาจทำให้เกิดปัญหาและแสดงถึงข้อบกพร่องในการออกแบบ

เพียงจากประสบการณ์ของฉันอาจเข้าใจผิดคำถามของคุณ

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

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

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

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

อย่าเพิ่มประสิทธิภาพก่อนวัยอันควรเพียงแค่ใช้ "ฟังก์ชั่นด้านใน BAD" ตลอดรหัสหลามทั้งหมดที่คุณเขียน กรุณา.

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

...
some_data = method_b() # not some_data = method_b

มิฉะนั้น some_data จะเป็นฟังก์ชั่น

การมีระดับโมดูลจะทำให้ฟังก์ชั่นอื่นใช้ method_b () และถ้าคุณใช้บางอย่างเช่นสฟิงซ์ (และ autodoc) สำหรับเอกสารประกอบก็จะช่วยให้คุณทำเอกสาร method_b เช่นกัน

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

ทำสิ่งที่ชอบ:

def some_function():
    return some_other_function()
def some_other_function():
    return 42 

ถ้าคุณต้องการเรียกใช้some_function()มันก็จะรันsome_other_function()และส่งคืน 42

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

คุณสามารถใช้มันเพื่อหลีกเลี่ยงการกำหนดตัวแปรส่วนกลาง นี่เป็นทางเลือกสำหรับการออกแบบอื่น ๆ 3 การออกแบบนำเสนอวิธีแก้ไขปัญหา

A) การใช้ฟังก์ชั่นโดยไม่ต้องกลม

def calculate_salary(employee, list_with_all_employees):
    x = _calculate_tax(list_with_all_employees)

    # some other calculations done to x
    pass

    y = # something 

    return y

def _calculate_tax(list_with_all_employees):
    return 1.23456 # return something

B) การใช้ฟังก์ชั่นที่มีกลม

_list_with_all_employees = None

def calculate_salary(employee, list_with_all_employees):

    global _list_with_all_employees
    _list_with_all_employees = list_with_all_employees

    x = _calculate_tax()

    # some other calculations done to x
    pass

    y = # something

    return y

def _calculate_tax():
    return 1.23456 # return something based on the _list_with_all_employees var

C) การใช้ฟังก์ชั่นภายในฟังก์ชั่นอื่น

def calculate_salary(employee, list_with_all_employees):

    def _calculate_tax():
        return 1.23456 # return something based on the list_with_a--Lemployees var

    x = _calculate_tax()

    # some other calculations done to x
    pass
    y = # something 

    return y

โซลูชันC)อนุญาตให้ใช้ตัวแปรในขอบเขตของฟังก์ชันภายนอกโดยไม่จำเป็นต้องประกาศตัวแปรเหล่านั้นในฟังก์ชันภายใน อาจมีประโยชน์ในบางสถานการณ์

ฟังก์ชั่นในฟังก์ชั่นหลาม

def Greater(a,b):
    if a>b:
        return a
    return b

def Greater_new(a,b,c,d):
    return Greater(Greater(a,b),Greater(c,d))

print("Greater Number is :-",Greater_new(212,33,11,999))