Làm cách nào để chuyển một hàm sang một hàm khác trong python?

Mọi thứ trong Python đều là đối tượng, thậm chí là hàm hoặc phương thức. Do đó, giống như các biến, Python cho phép truyền các hàm và phương thức dưới dạng đối số

Để truyền một hàm làm đối số cho một hàm khác, hãy viết tên của hàm không có dấu ngoặc đơn trong câu lệnh gọi hàm [giống như những gì chúng ta làm với các biến] và chấp nhận tham chiếu của hàm dưới dạng tham số trong hàm được gọi

def fun2[]:
    print['This is fun2']
    
def fun1[x]:
    print['This is fun1']
    x[]

#passing fun2 to fun1
fun1[fun2]
'''
This is fun1
This is fun2
'''

Hàm chấp nhận chấp nhận hàm khác làm tham số được gọi là hàm bậc cao hơn

Tương tự, chúng ta cũng có thể truyền một phương thức thành viên cho một phương thức thành viên khác của lớp

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

Truyền chức năng với các đối số

Trong một số trường hợp, hàm phụ mà chúng ta đang truyền cũng có thể cần một số đối số. Trong những trường hợp như vậy, chúng ta có thể tạo các đối số trong hàm đầu tiên hoặc chuyển chúng trực tiếp cùng với tham chiếu của hàm

def fun2[arg]:
    print['This is fun2 with parmeter value', arg]
        
def fun1[x, arg]:
    print['This is fun1']
    x[arg]
    
        
fun1[fun2, 101]
'''
This is mem-fun1
This is fun2 with parmeter value 101
'''

Sự kết luận

Các hàm và phương thức cũng là các đối tượng trong Python, điều khiến chúng có thể gọi được là do việc triển khai trước phương thức __call__ trong mã nguồn Python

Một trong những sự thật dựng tóc gáy mà chúng ta học được trong các khóa đào tạo cơ bản về Python của tôi là bạn có thể chuyển các hàm này sang các hàm khác. Bạn có thể chuyển các hàm xung quanh vì trong Python, các hàm là các đối tượng

Bạn có thể không cần biết về điều này trong tuần đầu tiên sử dụng Python, nhưng khi bạn tìm hiểu sâu hơn về Python, bạn sẽ thấy rằng việc hiểu cách chuyển một hàm sang một hàm khác có thể khá thuận tiện.

Đây là phần 1 của loạt bài mà tôi mong đợi về các thuộc tính khác nhau của “đối tượng chức năng”. Bài viết này tập trung vào những điều mà một lập trình viên Python mới nên biết và đánh giá cao về bản chất đối tượng của các hàm Python

Chức năng có thể được tham khảo

Nếu bạn cố gắng sử dụng một hàm mà không đặt dấu ngoặc đơn sau hàm đó thì Python sẽ không phàn nàn nhưng nó cũng sẽ không làm được gì hữu ích

1
2
3
4
5

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

Điều này cũng áp dụng cho các phương thức [là các hàm sống trên các đối tượng]

1
2
3

>>> numbers = [1, 2, 3]
>>> numbers.pop

Python đang cho phép chúng ta tham chiếu đến các đối tượng hàm này, giống như cách chúng ta có thể tham chiếu đến một chuỗi, một số hoặc một đối tượng

1
2

8

1
2
3
4
5
6

>>> "hello"
'hello'
>>> 2.5
2.5
>>> range[10]
range[0, 10]

Vì chúng ta có thể tham chiếu đến các hàm giống như bất kỳ đối tượng nào khác, nên chúng ta có thể trỏ một biến đến một hàm

1
2

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

1

Biến

1
2

9 đó hiện trỏ đến phương thức

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

10 trong danh sách

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

11 của chúng tôi. Vì vậy, nếu chúng ta gọi

1
2

9, nó sẽ làm điều tương tự như việc gọi

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

13 sẽ làm

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

7____18

Lưu ý rằng chúng tôi đã không tạo một chức năng mới. Chúng ta vừa chỉ tên biến

1
2

9 cho hàm

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

13

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

0

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

1

Bạn thậm chí có thể lưu trữ các chức năng bên trong cấu trúc dữ liệu và sau đó tham khảo chúng sau

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

2

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

3

Việc lấy một hàm và đặt tên khác hoặc lưu trữ nó bên trong một cấu trúc dữ liệu không phổ biến lắm, nhưng Python cho phép chúng ta làm những việc này vì các hàm có thể được truyền xung quanh, giống như bất kỳ đối tượng nào khác

Các chức năng có thể được truyền vào các chức năng khác

Các hàm, giống như bất kỳ đối tượng nào khác, có thể được truyền dưới dạng đối số cho một hàm khác

Ví dụ chúng ta có thể định nghĩa một hàm

1
2
3
4
5
6

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

5

Và sau đó chuyển nó vào hàm

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

16 tích hợp để xem nó làm gì

1
2
3
4
5

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

7

Và chúng ta có thể truyền hàm vào chính nó [vâng, điều này thật lạ], nó sẽ chuyển đổi nó thành một chuỗi ở đây

1
2

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

9

Thực tế, có khá nhiều hàm được tích hợp sẵn trong Python có nghĩa là chấp nhận các hàm khác làm đối số

Hàm

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17 tích hợp chấp nhận hai điều làm đối số. một

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

18 và một

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

19

1
2
3
4
5
6

1
2
3

1

Có thể lặp lại đã cho [danh sách, bộ dữ liệu, chuỗi, v.v. ] được lặp lại và hàm đã cho được gọi trên từng mục trong lần lặp đó. bất cứ khi nào hàm trả về

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

70 [hoặc một giá trị trung thực khác] thì mục đó được đưa vào đầu ra

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17

Vì vậy, nếu chúng tôi vượt qua

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17 một hàm

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

73 [trả về

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

70 khi được cung cấp một số lẻ] và một danh sách các số, chúng tôi sẽ nhận lại tất cả các số mà chúng tôi đã cung cấp cho nó là số lẻ

1
2
3

2____53

Đối tượng được trả về từ

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17 là một lazy iterator nên chúng tôi cần chuyển đổi nó thành một

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

76 để thực sự thấy đầu ra của nó

Vì các hàm có thể được truyền vào các hàm, điều đó cũng có nghĩa là các hàm có thể chấp nhận một hàm khác làm đối số. Hàm

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17 giả sử đối số đầu tiên của nó là một hàm. Bạn có thể nghĩ về hàm

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17 khá giống với hàm này

1
2
3
4
5
6

1
2
3

5

Hàm này mong đợi đối số

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

79 là một hàm [về mặt kỹ thuật, nó có thể là bất kỳ hàm nào có thể gọi được]. Khi chúng tôi gọi hàm đó [với

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

80], chúng tôi chuyển một đối số cho nó và sau đó kiểm tra tính trung thực của giá trị trả về của nó

Các hàm Lambda là một ví dụ về điều này

Biểu thức lambda là một cú pháp đặc biệt trong Python để tạo một hàm ẩn danh. Khi bạn đánh giá một biểu thức lambda, đối tượng bạn nhận được được gọi là hàm lambda

1
2
3
4
5

1
2
3

7

Các hàm Lambda gần giống như các hàm Python thông thường, với một vài lưu ý

Không giống như các hàm khác, hàm lambda không có tên [tên của chúng hiển thị là

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

81]. Chúng cũng không thể có chuỗi tài liệu và chúng chỉ có thể chứa một biểu thức Python duy nhất

1
2
3
4
5
6

1
2
3

9

Bạn có thể coi biểu thức lambda là lối tắt để tạo một hàm sẽ đánh giá một biểu thức Python đơn lẻ và trả về kết quả của biểu thức đó

Vì vậy, việc xác định biểu thức lambda không thực sự đánh giá biểu thức đó. nó trả về một hàm có thể đánh giá biểu thức đó sau

1
2
3
4
5

>>> numbers = [1, 2, 3]
>>> numbers.pop

1

Tôi muốn lưu ý rằng cả ba ví dụ trên của

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

82 đều là những ví dụ kém. Nếu bạn muốn một tên biến trỏ đến một đối tượng hàm mà bạn có thể sử dụng sau này, bạn nên sử dụng

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

83 để định nghĩa một hàm. đó là cách thông thường để xác định một chức năng

1
2
3
4
5
6

>>> numbers = [1, 2, 3]
>>> numbers.pop

3

Các biểu thức lambda dùng khi chúng ta muốn xác định một hàm và chuyển nó vào một hàm khác ngay lập tức

Ví dụ ở đây, chúng tôi đang sử dụng

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17 để lấy số chẵn, nhưng chúng tôi đang sử dụng biểu thức lambda nên chúng tôi không phải xác định hàm

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

85 trước khi sử dụng

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

0

>>> numbers = [1, 2, 3]
>>> numbers.pop

5

Đây là cách sử dụng biểu thức lambda thích hợp nhất. truyền một chức năng vào một chức năng khác trong khi xác định tất cả chức năng đã truyền đó trên một dòng mã

Như tôi đã viết trong Sử dụng quá nhiều biểu thức lambda, tôi không phải là người hâm mộ cú pháp biểu thức lambda của Python. Dù bạn có thích cú pháp này hay không, bạn nên biết rằng cú pháp này chỉ là một lối tắt để tạo một hàm

Bất cứ khi nào bạn nhìn thấy biểu thức

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

82, hãy ghi nhớ rằng

1. Biểu thức lambda là một cú pháp đặc biệt để tạo một hàm và chuyển nó sang một hàm khác trên một dòng mã
2. Các hàm lambda giống như tất cả các đối tượng hàm khác. không phải là đặc biệt hơn so với khác và cả hai có thể được thông qua xung quanh

Tất cả các hàm trong Python có thể được truyền dưới dạng đối số cho một hàm khác [điều đó chỉ xảy ra với mục đích duy nhất của các hàm lambda]

Một ví dụ phổ biến. chức năng chính

Bên cạnh chức năng

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17 tích hợp sẵn, bạn sẽ thấy một chức năng được truyền vào một chức năng khác ở đâu?

Đó là một quy ước chung cho các hàm chấp nhận một đối số có thể lặp lại để được sắp xếp/được sắp xếp cũng chấp nhận một đối số có tên gọi là

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

88. Đối số

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

88 này phải là một hàm hoặc một hàm khác có thể gọi được

Tất cả các hàm , , và đều tuân theo quy ước chấp nhận hàm

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

88 này

>>> numbers = [1, 2, 3]
>>> numbers.pop

6

>>> numbers = [1, 2, 3]
>>> numbers.pop

7

Điều đó được gọi cho mỗi giá trị trong lần lặp nhất định và giá trị trả về được sử dụng để sắp xếp/sắp xếp từng mục có thể lặp lại. Bạn có thể coi chức năng chính này giống như việc tính toán một khóa so sánh cho từng mục trong iterable

Trong ví dụ trên, khóa so sánh của chúng tôi trả về một chuỗi chữ thường, vì vậy mỗi chuỗi được so sánh bằng phiên bản chữ thường của nó [dẫn đến thứ tự không phân biệt chữ hoa chữ thường]

Chúng tôi đã sử dụng hàm ________ 401 để thực hiện việc này, nhưng điều tương tự có thể được thực hiện bằng cách sử dụng ________ 402

1
2
3

>>> numbers = [1, 2, 3]
>>> numbers.pop

9

Ghi chú. Thủ thuật

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

02 đó hơi kỳ quặc nếu bạn không quen với cách các lớp hoạt động. Các lớp lưu trữ các phương thức không liên kết sẽ chấp nhận một thể hiện của lớp đó khi được gọi. Chúng tôi thường gõ

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

04 nhưng

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

05 là những gì Python dịch nó sang. Đó là một câu chuyện cho một thời điểm khác

Ở đây chúng tôi đang tìm chuỗi có nhiều chữ cái nhất trong đó

1
2

1
2
3
4
5
6

1

Nếu có nhiều mức tối đa hoặc tối thiểu, thì giá trị sớm nhất sẽ thắng [đó là cách hoạt động của

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

06/

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

07]

1
2
3
4
5

1
2
3
4
5
6

3

Đây là một hàm sẽ trả về một bộ gồm 2 mục chứa độ dài của một chuỗi đã cho và phiên bản chuẩn hóa chữ hoa chữ thường của chuỗi đó

1
2
3

1
2
3
4
5
6

5

Chúng ta có thể chuyển hàm

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

08 này dưới dạng đối số

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

88 cho

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

10 để sắp xếp các chuỗi của chúng ta theo độ dài trước rồi sau đó theo biểu diễn chuẩn hóa chữ hoa chữ thường của chúng

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

0

1
2
3
4
5
6

7

Điều này dựa trên thực tế là các toán tử thứ tự của Python thực hiện các phép so sánh sâu

Các ví dụ khác về việc truyền hàm dưới dạng đối số

Đối số

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

88 được chấp nhận bởi

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

10,

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

06 và

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

07 chỉ là một ví dụ phổ biến về việc chuyển hàm vào hàm

Hai tích hợp Python chấp nhận chức năng khác là

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

15 và

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17

Chúng ta đã thấy rằng

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17 sẽ lọc danh sách của chúng ta dựa trên giá trị trả về của hàm đã cho

1
2
3
4
5
6

1
2
3
4
5
6

9

Hàm

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

15 sẽ gọi hàm đã cho trên mỗi mục trong lần lặp đã cho và sử dụng kết quả của lệnh gọi hàm đó làm mục mới

1
2

>>> "hello"
'hello'
>>> 2.5
2.5
>>> range[10]
range[0, 10]

1

Ví dụ ở đây, chúng tôi đang chuyển đổi số thành chuỗi và bình phương số

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

0

>>> "hello"
'hello'
>>> 2.5
2.5
>>> range[10]
range[0, 10]

3

Ghi chú. như tôi đã lưu ý trong bài viết của mình về việc lạm dụng lambda, cá nhân tôi thích

Tương tự như

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

15 và

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17, cũng có và từ mô-đun

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

23. Cái đầu tiên giống như

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17 ngoại trừ nó dừng lại khi nó tìm thấy một giá trị mà hàm vị ngữ là sai. Cái thứ hai làm ngược lại. nó chỉ bao gồm các giá trị sau khi hàm vị ngữ trở thành sai

>>> "hello"
'hello'
>>> 2.5
2.5
>>> range[10]
range[0, 10]

4

>>> "hello"
'hello'
>>> 2.5
2.5
>>> range[10]
range[0, 10]

5

Và có và , cả hai đều gọi hàm 2 đối số để tích lũy các giá trị khi chúng lặp lại

>>> numbers = [1, 2, 3]
>>> numbers.pop

6

>>> "hello"
'hello'
>>> 2.5
2.5
>>> range[10]
range[0, 10]

7

Lớp trong mô-đun

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

25 là một ví dụ khác. Lớp

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

26 tạo ra các đối tượng giống như từ điển sẽ không bao giờ tăng giá trị

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

27 khi truy cập khóa bị thiếu mà thay vào đó sẽ tự động thêm một giá trị mới vào từ điển

1
2
3
4
5
6

>>> "hello"
'hello'
>>> 2.5
2.5
>>> range[10]
range[0, 10]

9

Lớp

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

26 này chấp nhận một hàm có thể gọi được [hàm hoặc lớp] sẽ được gọi để tạo giá trị mặc định bất cứ khi nào một khóa bị thiếu được truy cập

Đoạn mã trên hoạt động vì

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

29 trả về

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

30 khi được gọi mà không có đối số

1
2

1
2

1

Ở đây, giá trị mặc định là

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

76, trả về một danh sách mới khi được gọi mà không có đối số

1
2
3
4
5

1
2

3

Hàm trong mô-đun

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

32 là một ví dụ khác.

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

33 chấp nhận một hàm và bất kỳ số lượng đối số nào và trả về một hàm mới [về mặt kỹ thuật, nó trả về một ]

Đây là một ví dụ về

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

33 được sử dụng để “liên kết” đối số từ khóa

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

35 với hàm

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

36

1
2

4

1
2

5

Hàm

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

37 được trả về bây giờ thực hiện điều tương tự như khi

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

36 được gọi với

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

39

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

7____77

Bạn cũng sẽ tìm thấy các hàm chấp nhận hàm trong các thư viện của bên thứ ba, như và trong numpy. Bất cứ khi nào bạn thấy một lớp hoặc một hàm có tài liệu nói rằng một trong các đối số của nó phải là một đối tượng có thể gọi được hoặc có thể gọi được, điều đó có nghĩa là “bạn có thể chuyển một hàm vào đây”

Một chủ đề tôi đang bỏ qua. chức năng lồng nhau

Python cũng hỗ trợ các hàm lồng nhau [các hàm được xác định bên trong các hàm khác]. Các hàm lồng nhau cung cấp năng lượng cho cú pháp của Python

Tôi sẽ không thảo luận về các hàm lồng nhau trong bài viết này vì các hàm lồng nhau đảm bảo việc khám phá các biến không cục bộ, bao đóng và các khía cạnh kỳ lạ khác của Python mà bạn không cần biết khi lần đầu tiên bắt đầu coi các hàm là

Tôi dự định viết một bài tiếp theo về chủ đề này và liên kết với nó ở đây sau. Trong thời gian chờ đợi, nếu bạn quan tâm đến các hàm lồng nhau trong Python, thì việc tìm kiếm các hàm bậc cao hơn trong Python có thể hữu ích

Xử lý các chức năng như các đối tượng là bình thường

Python có các hàm hạng nhất, có nghĩa là

1. Bạn có thể gán chức năng cho các biến
2. Bạn có thể lưu trữ các chức năng trong danh sách, từ điển hoặc cấu trúc dữ liệu khác
3. Bạn có thể chuyển các chức năng vào các chức năng khác
4. Bạn có thể viết các hàm trả về các hàm

Có vẻ lạ khi coi các hàm là đối tượng, nhưng điều đó không có gì lạ trong Python. Theo tính toán của tôi, khoảng 15% Python tích hợp có nghĩa là chấp nhận các hàm làm đối số [

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

06,

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

07,

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

10,

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

15,

class MyClass:
    def fun2[self]:
        print['This is mem-fun2']
        
    def fun1[self, x]:
        print['This is mem-fun1']
        x[]
        
obj = MyClass[]
obj.fun1[obj.fun2]
'''
This is mem-fun1
This is mem-fun2
'''

17,

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

45,

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

46,

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

47,

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

48,

>>> def greet[]:
..     print["Hello world!"]
...
>>> greet

49]

Công dụng quan trọng nhất của các hàm hạng nhất của Python là

1. Truyền hàm

   class MyClass:
       def fun2[self]:
           print['This is mem-fun2']
           
       def fun1[self, x]:
           print['This is mem-fun1']
           x[]
           
   obj = MyClass[]
   obj.fun1[obj.fun2]
   '''
   This is mem-fun1
   This is mem-fun2
   '''

   88 cho các hàm

   >>> def greet[]:
   ..     print["Hello world!"]
   ...
   >>> greet
   
   

   10,

   >>> def greet[]:
   ..     print["Hello world!"]
   ...
   >>> greet
   
   

   06 và

   >>> def greet[]:
   ..     print["Hello world!"]
   ...
   >>> greet
   
   

   07 tích hợp
2. Truyền các chức năng vào các trình trợ giúp vòng lặp như

   class MyClass:
       def fun2[self]:
           print['This is mem-fun2']
           
       def fun1[self, x]:
           print['This is mem-fun1']
           x[]
           
   obj = MyClass[]
   obj.fun1[obj.fun2]
   '''
   This is mem-fun1
   This is mem-fun2
   '''

   17 và

   >>> def greet[]:
   ..     print["Hello world!"]
   ...
   >>> greet
   
   

   55
3. Chuyển một “hàm tạo giá trị mặc định của nhà máy” cho các lớp như

   >>> def greet[]:
   ..     print["Hello world!"]
   ...
   >>> greet
   
   

   26
4. Chức năng “Đánh giá một phần” bằng cách chuyển chúng vào

   >>> def greet[]:
   ..     print["Hello world!"]
   ...
   >>> greet
   
   

   57

Chủ đề này đi sâu hơn nhiều so với những gì tôi đã thảo luận ở đây, nhưng cho đến khi bạn thấy mình đang viết các hàm trang trí, có lẽ bạn không cần phải khám phá chủ đề này nữa

Bạn có thể chuyển một hàm vào một hàm Python khác không?

Bạn có thể chuyển chức năng này sang chức năng khác không?