Ví dụ đơn giản. Hai phương thức, một phương thức được gọi từ phương thức khác:

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

def method_b(arg):
    return some_data

Trong Python chúng ta có thể khai báo defbên trong cái khác def. Vì vậy, nếu method_bđược yêu cầu và chỉ được gọi từ method_a, tôi có nên khai báo method_bbên trong method_akhông? như thế này :

def method_a(arg):

    def method_b(arg):
        return some_data

    some_data = method_b(arg)

Hay tôi nên tránh làm điều này?

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

Đây có phải là những gì bạn đang tìm kiếm? Nó được gọi là đóng cửa .

Bạn không thực sự đạt được nhiều bằng cách làm điều này, trên thực tế, nó chậm method_alại bởi vì nó sẽ xác định và biên dịch lại chức năng khác mỗi khi nó được gọi. Do đó, có lẽ sẽ tốt hơn nếu chỉ thêm tiền tố vào tên hàm với dấu gạch dưới để chỉ ra đó là một phương thức riêng tư - tức là _method_b.

Tôi cho rằng bạn có thể muốn làm điều này nếu định nghĩa của hàm lồng nhau thay đổi mỗi lần vì một số lý do, nhưng điều đó có thể chỉ ra một lỗ hổng trong thiết kế của bạn. Điều đó nói rằng, có là một lý do chính đáng để làm điều này để cho phép các chức năng lồng nhau để sử dụng đối số được truyền cho hàm bên ngoài nhưng không được thông qua một cách rõ ràng về họ, mà đôi khi xảy ra khi viết trang trí chức năng, ví dụ. Đó là những gì đang được hiển thị trong câu trả lời được chấp nhận mặc dù trang trí không được xác định hoặc sử dụng.

Cập nhật:

Đây là bằng chứng cho thấy việc lồng chúng chậm hơn (sử dụng Python 3.6.1), mặc dù phải thừa nhận là không nhiều trong trường hợp tầm thường này:

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

Lưu ý Tôi đã thêm một số selfđối số vào các hàm mẫu của bạn để làm cho chúng giống với các phương thức thực hơn (mặc dù method_b2về mặt kỹ thuật vẫn không phải là một phương thức của Testlớp). Ngoài ra chức năng lồng nhau thực sự được gọi trong phiên bản đó, không giống như của bạn.

Một chức năng bên trong của một chức năng thường được sử dụng để đóng cửa .

(Có rất nhiều tranh cãi về chính xác những gì làm cho một đóng cửa đóng cửa .)

Đây là một ví dụ sử dụng tích hợp sum(). Nó định nghĩa startmột lần và sử dụng nó từ đó về sau:

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

Đang sử dụng:

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

Tích hợp đóng cửa python

functools.partial là một ví dụ về việc đóng cửa.

Từ các tài liệu python , nó gần tương đương với:

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

(Kudos gửi tới @ user225312 bên dưới để biết câu trả lời. Tôi thấy ví dụ này dễ hiểu hơn và hy vọng sẽ giúp trả lời bình luận của @ mango.)

Nói chung, không, không xác định các chức năng bên trong các chức năng.

Trừ khi bạn có một lý do thực sự tốt. Mà bạn không.

Tại sao không?

• Nó ngăn chặn các móc dễ dàng để thử nghiệm đơn vị. Bạn đang thử nghiệm đơn vị, phải không?
• Dù sao nó cũng không thực sự làm xáo trộn nó hoàn toàn , sẽ an toàn hơn khi cho rằng không có gì ở trăn bao giờ.
• Sử dụng hướng dẫn kiểu mã tự động Python tiêu chuẩn để đóng gói các phương thức thay thế.
• Bạn sẽ không cần phải tạo lại một đối tượng hàm cho mã giống hệt nhau mỗi khi bạn chạy hàm ngoài .
• Nếu chức năng của bạn thực sự đơn giản, bạn nên sử dụng một lambdabiểu thức thay thế .

Có gì là một lý do thực sự tốt để xác định các chức năng bên trong chức năng?

Khi những gì bạn thực sự muốn là một đóng cửa dingdang .

Thật sự tốt khi khai báo một chức năng bên trong một chức năng khác. Điều này đặc biệt hữu ích tạo trang trí.

Tuy nhiên, theo nguyên tắc thông thường, nếu chức năng phức tạp (hơn 10 dòng), có thể là một ý tưởng tốt hơn để khai báo nó ở cấp độ mô-đun.

Tôi tìm thấy câu hỏi này vì tôi muốn đặt ra một câu hỏi tại sao có tác động hiệu năng nếu một người sử dụng các hàm lồng nhau. Tôi đã chạy thử nghiệm các chức năng sau bằng Python 3.2.5 trên Máy tính xách tay Windows với bộ xử lý Intel Core i5-2530M Quad Core 2,5 GHz

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

Tôi đã đo 20 lần sau đây, cũng cho hình vuông1, hình vuông2 và hình vuông5:

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

và nhận được kết quả như sau

>>> 
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]
>>> 

square0không có chức năng lồng nhau, square1có một chức năng lồng nhau, square2có hai chức năng lồng nhau và square5có năm chức năng lồng nhau. Các hàm lồng nhau chỉ được khai báo nhưng không được gọi.

Vì vậy, nếu bạn đã xác định 5 chức năng lồng nhau trong một hàm mà bạn không gọi thì thời gian thực hiện của hàm là hai lần của hàm mà không có hàm lồng nhau. Tôi nghĩ nên thận trọng khi sử dụng các hàm lồng nhau.

Tệp Python cho toàn bộ bài kiểm tra tạo đầu ra này có thể được tìm thấy tại ideone .

Đó chỉ là một nguyên tắc về API phơi sáng.

Sử dụng python, đó là một ý tưởng tốt để tránh API phơi sáng ở ngoài không gian (mô-đun hoặc lớp), chức năng là một nơi đóng gói tốt.

Nó có thể là một ý tưởng tốt. khi bạn đảm bảo

1. chức năng bên trong CHỈ được sử dụng bởi chức năng bên ngoài.
2. chức năng nội bộ có một tên tốt để giải thích mục đích của nó bởi vì mã nói chuyện.
3. mã không thể hiểu trực tiếp bởi các đồng nghiệp của bạn (hoặc người đọc mã khác).

Mặc dù, Lạm dụng kỹ thuật này có thể gây ra vấn đề và ngụ ý một lỗ hổng thiết kế.

Chỉ từ exp ​​của tôi, Có thể hiểu nhầm câu hỏi của bạn.

Vì vậy, cuối cùng, câu hỏi chủ yếu là việc triển khai python thông minh đến mức nào hay không, đặc biệt là trong trường hợp hàm bên trong không phải là một bao đóng mà chỉ đơn giản là một hàm trợ giúp chỉ cần trợ giúp.

Trong thiết kế dễ hiểu, chỉ có các chức năng khi cần thiết và không được hiển thị ở nơi khác là thiết kế tốt cho dù chúng được nhúng trong một mô-đun, một lớp như một phương thức, hoặc bên trong một chức năng hoặc phương thức khác. Khi được thực hiện tốt, họ thực sự cải thiện sự rõ ràng của mã.

Và khi chức năng bên trong là một bao đóng cũng có thể giúp làm rõ khá nhiều ngay cả khi chức năng đó không được đưa ra khỏi chức năng chứa để sử dụng ở nơi khác.

Vì vậy, tôi thường nói rằng hãy sử dụng chúng nhưng hãy chú ý đến hiệu suất có thể đạt được khi bạn thực sự quan tâm đến hiệu suất và chỉ xóa chúng nếu bạn thực hiện hồ sơ thực tế cho thấy chúng bị loại bỏ tốt nhất.

Không tối ưu hóa sớm chỉ sử dụng "BAD bên trong" trong tất cả các mã python bạn viết. Xin vui lòng.

Hoàn toàn ổn khi làm theo cách đó, nhưng trừ khi bạn cần sử dụng bao đóng hoặc trả lại chức năng mà tôi có thể đặt ở cấp mô-đun. Tôi tưởng tượng trong ví dụ mã thứ hai bạn có nghĩa là:

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

nếu không, some_data sẽ là hàm.

Có nó ở cấp mô-đun sẽ cho phép các hàm khác sử dụng phương thức_b () và nếu bạn đang sử dụng một cái gì đó như Sphinx (và autodoc) cho tài liệu, nó cũng sẽ cho phép bạn viết tài liệu phương thức_b.

Bạn cũng có thể muốn xem xét chỉ đưa chức năng vào hai phương thức trong một lớp nếu bạn đang làm một cái gì đó có thể được đại diện bởi một đối tượng. Điều này cũng chứa logic nếu đó là tất cả những gì bạn đang tìm kiếm.

Làm một cái gì đó như:

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

nếu bạn chạy some_function()thì nó sẽ chạy some_other_function()và trả về 42.

EDIT: Ban đầu tôi đã nói rằng bạn không nên xác định một chức năng bên trong một chức năng khác nhưng điều đó chỉ ra rằng đôi khi nó thực tế để làm điều này.

Bạn có thể sử dụng nó để tránh xác định các biến toàn cục. Điều này cung cấp cho bạn một sự thay thế cho các thiết kế khác. 3 thiết kế trình bày một giải pháp cho một vấn đề.

A) Sử dụng các chức năng không có toàn cầu

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) Sử dụng các chức năng với toàn cầu

_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) Sử dụng các chức năng bên trong chức năng khá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

Giải pháp C) cho phép sử dụng các biến trong phạm vi của hàm ngoài mà không cần phải khai báo chúng trong hàm bên trong. Có thể hữu ích trong một số tình huống.

Chức năng Trong chức năng python

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