Hàm python lồng nhau là gì?

Chúng ta có thể làm rất nhiều việc với các hàm như chuyển một hàm làm đối số cho một hàm khác, gọi một hàm từ một hàm khác, v.v. Trong Python, chúng ta cũng có thể tạo một hàm bên trong một hàm khác.

Nội dung chính Show

Định nghĩa một hàm lồng nhau
Ý nghĩa của các hàm lồng nhau
Điều đó có nghĩa là gì khi một chức năng được lồng vào nhau?
Chúng ta có thể gọi một hàm lồng nhau trong Python không?
Làm tổ chức năng là gì đưa ra một ví dụ?

Một hàm được tạo bên trong một hàm khác được gọi là hàm lồng nhau hoặc hàm bên trong. Trong chương này, chúng ta sẽ đọc về các hàm lồng nhau và ý nghĩa của chúng

Định nghĩa một hàm lồng nhau

Một hàm lồng nhau được xác định bằng cách tạo nó đơn giản bằng từ khóa def bên trong một hàm khác.

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

def outer():  # outer function
    print("This is outer function")
	
    def inner():
        print("This is inner function")
	
    inner()  # calling inner function
 
outer()  # calling outer function

Đây là chức năng bên ngoài
Đây là chức năng bên trong

Chúng tôi đã định nghĩa một hàm có tên là inner() bên trong một hàm khác có tên là outer(). Do đó, inner() là một hàm lồng nhau.

Khi hàm outer() được gọi, phần thân của nó được thực thi. Bên trong phần thân của nó, hàm inner() được định nghĩa và sau đó được gọi. Do đó, trước tiên chúng ta gọi hàm outer(), sau đó gọi là hàm inner()

Lưu ý rằng một hàm bên trong luôn được gọi từ bên trong hàm mà nó được định nghĩa. Như vậy, để gọi hàm bên trong, chúng ta cần gọi hàm bên ngoài

Một hàm lồng nhau có thể truy cập các biến được xác định trong hàm mà nó được tạo. Điều này được thể hiện trong ví dụ sau

def outer():  # outer function
    x = 10

    def inner():
        print("Inside inner func", x)

    inner()  # calling inner function
    print("Inside outer func", x)
 
outer()  # calling outer function

Bên trong chức năng bên trong 10
Chức năng bên trong bên ngoài 10

Trong ví dụ này, chúng tôi đã định nghĩa một biến x có giá trị là 10 trong hàm outer(). Khi chúng tôi in giá trị của x trong hàm lồng nhau, nó đã được in. Điều này có nghĩa là hàm lồng nhau có thể truy cập biến x được xác định trong hàm cha của nó

Vì vậy, từ các ví dụ trên, bạn phải hiểu rằng các hàm lồng nhau chỉ là các hàm bình thường được định nghĩa và gọi bên trong một số hàm khác

Hãy xem thêm một ví dụ

def find_power(num):  # outer function

    def power(n):
        return num ** n

    return power(2)  # calling inner function and returning the value returned by it

print(find_power(10))  # calling outer function

Đây là một ví dụ thẳng về phía trước. Hàm

def outer():  # outer function
    x = 10

    def inner():
        print("Inside inner func", x)

    inner()  # calling inner function
    print("Inside outer func", x)
 
outer()  # calling outer function

4 được gọi bằng cách chuyển 10 làm đối số, làm cho tham số num của nó bằng 10. Bên trong hàm

def outer():  # outer function
    x = 10

    def inner():
        print("Inside inner func", x)

    inner()  # calling inner function
    print("Inside outer func", x)
 
outer()  # calling outer function

4, hàm lồng nhau

def outer():  # outer function
    x = 10

    def inner():
        print("Inside inner func", x)

    inner()  # calling inner function
    print("Inside outer func", x)
 
outer()  # calling outer function

6 được gọi bằng cách chuyển 2 làm đối số, làm cho tham số n của hàm

def outer():  # outer function
    x = 10

    def inner():
        print("Inside inner func", x)

    inner()  # calling inner function
    print("Inside outer func", x)
 
outer()  # calling outer function

6 bằng 2. Bên trong hàm

def outer():  # outer function
    x = 10

    def inner():
        print("Inside inner func", x)

    inner()  # calling inner function
    print("Inside outer func", x)
 
outer()  # calling outer function

6, hàm

def outer():  # outer function
    x = 10

    def inner():
        print("Inside inner func", x)

    inner()  # calling inner function
    print("Inside outer func", x)
 
outer()  # calling outer function

9 lũy thừa n (2) được trả về. Cuối cùng, giá trị này được trả về bởi hàm

def outer():  # outer function
    x = 10

    def inner():
        print("Inside inner func", x)

    inner()  # calling inner function
    print("Inside outer func", x)
 
outer()  # calling outer function

6 được trả về bởi hàm

def outer():  # outer function
    x = 10

    def inner():
        print("Inside inner func", x)

    inner()  # calling inner function
    print("Inside outer func", x)
 
outer()  # calling outer function

Ý nghĩa của các hàm lồng nhau

Có thể có nhiều lý do để sử dụng các hàm lồng nhau. Hãy xem một số trong số họ

Các hàm lồng nhau có thể đóng vai trò là các hàm trợ giúp của hàm mà chúng được xác định. Hãy xem một ví dụ trong đó hàm lồng đóng vai trò là hàm trợ giúp cho hàm cha của nó

def print_even(lst):

    def find_even(num):
        if num % 2 == 0:
            return True
        else:
            return False

    new_list = []

    for num in lst:
        if find_even(num) == True:
            new_list.append(num)
	
    print("Final list:", new_list)
 
mylist = [1, 2, 4, 5, 6, 7, 10, 11, 12]
print_even(mylist)

Danh sách cuối cùng. [2, 4, 6, 10, 12]

Ở đây, hàm

def find_power(num):  # outer function

    def power(n):
        return num ** n

    return power(2)  # calling inner function and returning the value returned by it

print(find_power(10))  # calling outer function

2 nhận một danh sách làm đối số và in ra một danh sách mới chứa tất cả các phần tử chẵn của danh sách nhận được. Bạn hẳn đã hiểu phần còn lại của chương trình

Bên trong hàm

def find_power(num):  # outer function

    def power(n):
        return num ** n

    return power(2)  # calling inner function and returning the value returned by it

print(find_power(10))  # calling outer function

2, chúng ta có một hàm lồng nhau

def find_power(num):  # outer function

    def power(n):
        return num ** n

    return power(2)  # calling inner function and returning the value returned by it

print(find_power(10))  # calling outer function

4 nhận một số làm đối số và trả về True nếu số truyền vào là số chẵn, ngược lại trả về False. Trong chương trình này, hàm lồng nhau do đó hoạt động như một hàm trợ giúp chỉ kiểm tra xem số đã truyền có phải là số chẵn hay không và không bị ảnh hưởng bởi bất kỳ mã hoặc biến nào khác bên trong hàm

def find_power(num):  # outer function

    def power(n):
        return num ** n

    return power(2)  # calling inner function and returning the value returned by it

print(find_power(10))  # calling outer function

2 bên ngoài

Có thể thấy một trường hợp sử dụng khác của các hàm lồng nhau từ ví dụ sau

def get_factorial(num):

    def factorial(num):
        if num == 0 or num == 1:
            return 1
        else:
            return num * factorial(num - 1)

    if not isinstance(num, int):
        raise TypeError("Failed! The value must be a number")

    if num < 0:
        raise ValueError("Failed! The number must be non-negative")
	
    return factorial(num)

print(get_factorial(5))

Trong ví dụ trên, hàm

def find_power(num):  # outer function

    def power(n):
        return num ** n

    return power(2)  # calling inner function and returning the value returned by it

print(find_power(10))  # calling outer function

6 nhận một số làm đối số và trả về giai thừa của số đó. Bên trong hàm

def find_power(num):  # outer function

    def power(n):
        return num ** n

    return power(2)  # calling inner function and returning the value returned by it

print(find_power(10))  # calling outer function

6, chúng tôi đang thực hiện một số xử lý lỗi, trong đó chúng tôi đưa ra ngoại lệ TypeError nếu số được truyền không phải là số nguyên và ngoại lệ

def find_power(num):  # outer function

    def power(n):
        return num ** n

    return power(2)  # calling inner function and returning the value returned by it

print(find_power(10))  # calling outer function

8 là số được truyền nhỏ hơn 0 (Bạn có thể tìm hiểu về cách tăng ngoại lệ từ chương này . Nếu không có ngoại lệ nào được đưa ra trong cả hai lần kiểm tra, thì hàm lồng nhau có tên

def find_power(num):  # outer function

    def power(n):
        return num ** n

    return power(2)  # calling inner function and returning the value returned by it

print(find_power(10))  # calling outer function

9 được gọi để trả về giai thừa của số.

Bây giờ, giả sử nếu mã cho cả xử lý lỗi và tính giai thừa được viết trong hàm

def find_power(num):  # outer function

    def power(n):
        return num ** n

    return power(2)  # calling inner function and returning the value returned by it

print(find_power(10))  # calling outer function

6 mà không sử dụng hàm lồng nhau

def find_power(num):  # outer function

    def power(n):
        return num ** n

    return power(2)  # calling inner function and returning the value returned by it

print(find_power(10))  # calling outer function

9, thì độ phức tạp của mã bên trong

def find_power(num):  # outer function

    def power(n):
        return num ** n

    return power(2)  # calling inner function and returning the value returned by it

print(find_power(10))  # calling outer function

6 sẽ tăng lên

Vì vậy, đến bây giờ, bạn hẳn đã biết khi nào bạn có thể sử dụng các hàm lồng nhau để giảm độ phức tạp của các hàm của mình. Hãy xem xét thêm một số trường hợp khi các hàm lồng nhau có thể được sử dụng

Đôi khi chúng ta có thể muốn ngăn một số chức năng được truy cập trực tiếp từ bất kỳ đâu trong chương trình của bạn. Trong trường hợp đó, chúng ta có thể đặt hàm đó (chẳng hạn như

def print_even(lst):

    def find_even(num):
        if num % 2 == 0:
            return True
        else:
            return False

    new_list = []

    for num in lst:
        if find_even(num) == True:
            new_list.append(num)
	
    print("Final list:", new_list)
 
mylist = [1, 2, 4, 5, 6, 7, 10, 11, 12]
print_even(mylist)

3) dưới dạng một hàm lồng bên trong một hàm khác (chẳng hạn như

def print_even(lst):

    def find_even(num):
        if num % 2 == 0:
            return True
        else:
            return False

    new_list = []

    for num in lst:
        if find_even(num) == True:
            new_list.append(num)
	
    print("Final list:", new_list)
 
mylist = [1, 2, 4, 5, 6, 7, 10, 11, 12]
print_even(mylist)

4). Chúng tôi biết rằng một chức năng lồng nhau không thể được truy cập bên ngoài chức năng mà nó được xác định và do đó chúng tôi sẽ không thể truy cập chức năng đó từ các phần khác của chương trình nữa. Để gọi hàm f2() lồng nhau, trước tiên chúng ta sẽ phải gọi hàm cha của nó là

def print_even(lst):

    def find_even(num):
        if num % 2 == 0:
            return True
        else:
            return False

    new_list = []

    for num in lst:
        if find_even(num) == True:
            new_list.append(num)
	
    print("Final list:", new_list)
 
mylist = [1, 2, 4, 5, 6, 7, 10, 11, 12]
print_even(mylist)

4, hàm này sẽ gọi

def print_even(lst):

    def find_even(num):
        if num % 2 == 0:
            return True
        else:
            return False

    new_list = []

    for num in lst:
        if find_even(num) == True:
            new_list.append(num)
	
    print("Final list:", new_list)
 
mylist = [1, 2, 4, 5, 6, 7, 10, 11, 12]
print_even(mylist)

3 bên trong nó. Việc ẩn một số dữ liệu hoặc mã (chức năng trong trường hợp của chúng tôi) được gọi là đóng gói

Nhưng tại sao chúng ta lại đóng gói một chức năng?

Để trả lời câu hỏi đó, hãy lấy một trường hợp sử dụng mà chúng ta muốn dự đoán xem một công ty sẽ lãi hay lỗ. Giả sử chúng ta có một hàm chứa logic tính toán lợi nhuận kỳ vọng của một công ty. Logic này có thể chứa một số thông tin mà chúng tôi không muốn ai biết. Nếu chúng ta không muốn bất kỳ phần nào khác của chương trình truy cập trực tiếp logic trong hàm này, chúng ta có thể đặt nó dưới dạng một hàm lồng bên trong một hàm khác. Nhìn vào cấu trúc hàm sau

def profit_or_loss():

    def get_profit():
        # calculates profit
        return profit

    if profit > 0:
        return "Profit"
    else:
        return "Loss"

profit_or_loss()

Giả sử

def print_even(lst):

    def find_even(num):
        if num % 2 == 0:
            return True
        else:
            return False

    new_list = []

    for num in lst:
        if find_even(num) == True:
            new_list.append(num)
	
    print("Final list:", new_list)
 
mylist = [1, 2, 4, 5, 6, 7, 10, 11, 12]
print_even(mylist)

7 là hàm lồng nhau với logic tính toán và trả về lợi nhuận kỳ vọng, và

def print_even(lst):

    def find_even(num):
        if num % 2 == 0:
            return True
        else:
            return False

    new_list = []

    for num in lst:
        if find_even(num) == True:
            new_list.append(num)
	
    print("Final list:", new_list)
 
mylist = [1, 2, 4, 5, 6, 7, 10, 11, 12]
print_even(mylist)

8 là hàm được gói gọn bên trong. Bây giờ, nếu người dùng muốn biết liệu sẽ có lãi hay lỗ, thì họ sẽ gọi hàm

def print_even(lst):

    def find_even(num):
        if num % 2 == 0:
            return True
        else:
            return False

    new_list = []

    for num in lst:
        if find_even(num) == True:
            new_list.append(num)
	
    print("Final list:", new_list)
 
mylist = [1, 2, 4, 5, 6, 7, 10, 11, 12]
print_even(mylist)

8. Hàm này sẽ gọi hàm

def print_even(lst):

    def find_even(num):
        if num % 2 == 0:
            return True
        else:
            return False

    new_list = []

    for num in lst:
        if find_even(num) == True:
            new_list.append(num)
	
    print("Final list:", new_list)
 
mylist = [1, 2, 4, 5, 6, 7, 10, 11, 12]
print_even(mylist)

7 để lấy lợi nhuận và sẽ trả về “Thành công” nếu lợi nhuận là số dương, ngược lại trả về “Lỗ”. Bằng cách này, không có phần nào khác của chương trình có thể truy cập hàm

def print_even(lst):

    def find_even(num):
        if num % 2 == 0:
            return True
        else:
            return False

    new_list = []

    for num in lst:
        if find_even(num) == True:
            new_list.append(num)
	
    print("Final list:", new_list)
 
mylist = [1, 2, 4, 5, 6, 7, 10, 11, 12]
print_even(mylist)

7 lồng nhau

Các hàm lồng nhau cũng được sử dụng để tạo các bao đóng. Chúng tôi sẽ đọc về đóng cửa trong Đóng cửa

Bây giờ bạn đã hiểu hàm lồng nhau là gì và sử dụng chúng ở đâu, hãy bắt đầu đưa chúng vào chương trình của bạn bất cứ khi nào cần thiết

Để học từ các video đơn giản, bạn luôn có thể xem khóa học video Python của chúng tôi trên CodesDope Pro. Nó có hơn 500 câu hỏi thực hành và hơn 20 dự án

Điều đó có nghĩa là gì khi một chức năng được lồng vào nhau?

Trong lập trình máy tính, một hàm lồng nhau (hoặc thủ tục lồng nhau hoặc chương trình con) là một hàm được định nghĩa bên trong một hàm khác, hàm bao quanh .

Chúng ta có thể gọi một hàm lồng nhau trong Python không?

Hàm lồng nhau trong Python . Nó thực thi khi display_name() được gọi bên trong hàm hello() .

Làm tổ chức năng là gì đưa ra một ví dụ?

Ví dụ, ở đây chúng ta định nghĩa một hàm lồng nhau tên là square, và gọi nó hai lần. foo (double a, double b) { double square (double z) { return z * z; . The nested function can access all the variables of the containing function that are visible at the point of its definition.