Chức năng lồng nhau bằng Python

Question

lợi ích gì hay hàm ý chúng ta có thể nhận được với mã Python như thế này:

class some_class(parent_class): 
    def doOp(self, x, y): 
     def add(x, y): 
      return x + y 
     return add(x, y) 

Tôi thấy điều này trong một dự án mã nguồn mở, làm một cái gì đó hữu ích bên trong hàm lồng nhau, nhưng làm như hoàn toàn không có gì bên ngoài nó ngoại trừ việc gọi nó. (Mã thực tế có thể được tìm thấy here.) Tại sao một người nào đó có thể mã hóa nó như thế này? Có một số lợi ích hay tác dụng phụ nào khi viết mã bên trong hàm lồng nhau chứ không phải ở hàm bên ngoài, bình thường?

Answer 1

Thông thường bạn làm điều đó để làm cho closures:

def make_adder(x): 
    def add(y): 
     return x + y 
    return add 

plus5 = make_adder(5) 
print(plus5(12)) # prints 17 

chức năng Nội có thể truy cập các biến từ phạm vi kèm theo (trong trường hợp này, biến địa phương x) . Nếu bạn không truy cập bất kỳ biến nào từ phạm vi kèm theo, chúng thực sự chỉ là các hàm bình thường với một phạm vi khác.

Answer 2

Tôi không thể định hình bất kỳ lý do chính đáng nào cho mã như thế.

Có thể có lý do cho chức năng bên trong trong các phiên bản cũ hơn, như các Op khác.

Ví dụ, điều này làm cho hơi ý nghĩa hơn:

class some_class(parent_class): 
    def doOp(self, op, x, y): 
     def add(x, y): 
      return x + y 
     def sub(x,y): 
      return x - y 
     return locals()[op](x,y) 

some_class().doOp('add', 1,2) 

nhưng sau đó các chức năng bên trong phải được ("private") phương pháp lớp học thay vì:

class some_class(object): 
    def _add(self, x, y): 
     return x + y 
    def doOp(self, x, y): 
     return self._add(x,y) 

Answer 3

Ý tưởng đằng sau các phương pháp địa phương tương tự như biến cục bộ: không gây ô nhiễm không gian tên lớn hơn. Rõ ràng những lợi ích bị hạn chế vì hầu hết các ngôn ngữ cũng không cung cấp chức năng như vậy trực tiếp.

Answer 4

Bạn có chắc là mã này chính xác như thế này không? Lý do bình thường để làm một cái gì đó như thế này là để tạo ra một phần - một hàm với các tham số nướng. Việc gọi hàm bên ngoài trả về một hàm có thể gọi mà không cần tham số và do đó có thể được lưu trữ và sử dụng ở đâu đó mà không thể truyền tham số. Tuy nhiên, mã bạn đã đăng sẽ không làm điều đó - nó gọi hàm ngay lập tức và trả về kết quả, chứ không phải là có thể gọi được. Nó có thể hữu ích để đăng mã thực tế bạn đã thấy.

Answer 5

Ngoài bộ tạo hàm, nơi tạo chức năng nội bộ gần như là định nghĩa của trình tạo hàm, lý do tôi tạo hàm lồng nhau là để cải thiện khả năng đọc. Nếu tôi có một hàm nhỏ mà sẽ chỉ được gọi bởi hàm bên ngoài, sau đó tôi định nghĩa nội tuyến để bạn không phải bỏ qua để xác định hàm đó đang làm gì. Tôi luôn có thể di chuyển phương thức bên trong bên ngoài phương thức đóng gói nếu tôi thấy cần phải sử dụng lại hàm này vào một ngày sau đó.

Toy dụ:

import sys 

def Foo(): 
    def e(s): 
     sys.stderr.write('ERROR: ') 
     sys.stderr.write(s) 
     sys.stderr.write('\n') 
    e('I regret to inform you') 
    e('that a shameful thing has happened.') 
    e('Thus, I must issue this desultory message') 
    e('across numerous lines.') 
Foo() 

Answer 6

Một lợi ích tiềm năng của việc sử dụng các phương thức bên trong là nó cho phép bạn sử dụng các biến cục bộ của phương thức bên ngoài mà không chuyển chúng làm đối số.

def helper(feature, resultBuffer): 
    resultBuffer.print(feature) 
    resultBuffer.printLine() 
    resultBuffer.flush() 

def save(item, resultBuffer): 

    helper(item.description, resultBuffer) 
    helper(item.size, resultBuffer) 
    helper(item.type, resultBuffer) 

có thể được viết như sau, mà cho là đọc tốt hơn

def save(item, resultBuffer): 

    def helper(feature): 
    resultBuffer.print(feature) 
    resultBuffer.printLine() 
    resultBuffer.flush() 

    helper(item.description) 
    helper(item.size) 
    helper(item.type)