Apa fungsi bersarang di python?

Kita dapat melakukan banyak hal dengan fungsi seperti meneruskan fungsi sebagai argumen ke fungsi lain, memanggil fungsi dari fungsi lain, dll. Di Python, kita juga bisa membuat fungsi di dalam fungsi lain.

Table of Contents Show

Mendefinisikan Fungsi Bersarang
Signifikansi Fungsi Bersarang
Apa yang dilakukan fungsi bersarang?
Apa contoh fungsi bersarang?
Apa artinya bersarang di Python?
Bisakah kita memanggil fungsi bersarang di Python?

Fungsi yang dibuat di dalam fungsi lain disebut fungsi bersarang atau fungsi dalam. Dalam bab ini, kita akan membaca tentang fungsi bersarang dan signifikansinya

Mendefinisikan Fungsi Bersarang

Fungsi bersarang didefinisikan hanya dengan membuatnya menggunakan kata kunci def di dalam fungsi lain.

Ini sebuah contoh

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

Ini adalah fungsi luar
Ini adalah fungsi batin

Kami mendefinisikan fungsi bernama inner() di dalam fungsi lain bernama outer(). Jadi, inner() adalah fungsi bersarang.

Saat fungsi outer() dipanggil, badannya dieksekusi. Di dalam tubuhnya, fungsi inner()_ didefinisikan dan kemudian dipanggil. Jadi, pertama-tama kita memanggil fungsi outer()_ yang selanjutnya disebut fungsi inner()

Perhatikan bahwa fungsi dalam selalu dipanggil dari dalam fungsi di mana ia didefinisikan. Jadi, untuk memanggil fungsi dalam, kita perlu memanggil fungsi luar

Fungsi bersarang dapat mengakses variabel yang ditentukan dalam fungsi tempat ia dibuat. Hal ini ditunjukkan dalam contoh berikut

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

Fungsi dalam 10
Fungsi luar dalam 10

Dalam contoh ini, kita mendefinisikan variabel x yang memiliki nilai 10 dalam fungsi outer(). Saat kami mencetak nilai x dalam fungsi bersarang, itu dicetak. Ini berarti bahwa fungsi bersarang dapat mengakses variabel x yang didefinisikan dalam fungsi induknya

Jadi, dari contoh di atas Anda pasti sudah mengerti bahwa fungsi bersarang hanyalah fungsi normal yang didefinisikan dan dipanggil di dalam beberapa fungsi lain

Mari kita lihat satu contoh lagi

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

Ini adalah contoh langsung. Fungsi

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 dipanggil dengan memberikan 10 sebagai argumen, membuat parameter num sama dengan 10. Di dalam fungsi

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, fungsi bersarang

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 dipanggil dengan meneruskan 2 sebagai argumen, membuat parameter n dari fungsi

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 sama dengan 2. Di dalam fungsi

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,

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 dipangkatkan n (2) dikembalikan. Terakhir, nilai ini dikembalikan oleh fungsi

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 dikembalikan oleh fungsi

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

Signifikansi Fungsi Bersarang

Ada banyak alasan untuk menggunakan fungsi bersarang. Mari kita lihat beberapa di antaranya

Fungsi bersarang dapat berfungsi sebagai fungsi pembantu dari fungsi di mana mereka didefinisikan. Mari kita lihat contoh di mana fungsi bersarang berfungsi sebagai fungsi pembantu untuk fungsi induknya

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)

Daftar akhir. [2, 4, 6, 10, 12]

Di sini fungsi

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 menerima daftar sebagai argumen dan mencetak daftar baru yang berisi semua elemen genap dari daftar yang diterima. Anda pasti sudah memahami sisa programnya

Di dalam fungsi

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, kami memiliki fungsi bersarang

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 yang menerima nomor sebagai argumen dan mengembalikan True jika nomor yang diteruskan genap, selain itu mengembalikan False. Dalam program ini, fungsi bersarang berfungsi sebagai fungsi pembantu yang hanya memeriksa apakah angka yang diteruskan genap dan tidak terpengaruh oleh kode atau variabel lain di dalam fungsi

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 luar

Kasus penggunaan lain dari fungsi bersarang dapat dilihat dari contoh berikut

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

Dalam contoh di atas, fungsi

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 mengambil sebuah angka sebagai argumen dan mengembalikan faktorial dari angka tersebut. Di dalam fungsi

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, kami melakukan beberapa penanganan kesalahan, di mana kami menaikkan pengecualian TypeError jika nomor yang diteruskan bukan bilangan bulat dan pengecualian

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 adalah nomor yang diteruskan kurang dari 0 (Anda dapat mempelajari tentang menaikkan pengecualian dari bab ini . Jika tidak ada pengecualian yang dilemparkan di kedua pemeriksaan, maka fungsi bersarang bernama

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 dipanggil yang mengembalikan faktorial dari angka tersebut.

Sekarang anggaplah jika kode untuk penanganan kesalahan dan perhitungan faktorial ditulis dalam fungsi

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 tanpa menggunakan fungsi bersarang

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, kompleksitas kode di dalam

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

Jadi sekarang, Anda pasti sudah mengetahui kapan Anda dapat menggunakan fungsi bersarang untuk mengurangi kompleksitas fungsi Anda. Mari kita lihat beberapa kasus lagi saat fungsi bersarang dapat digunakan

Terkadang kami mungkin ingin mencegah beberapa fungsi diakses langsung dari mana saja di program Anda. Dalam hal ini, kita dapat menempatkan fungsi tersebut (misalnya

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) sebagai fungsi bersarang di dalam fungsi lain (misalnya

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). Kami tahu bahwa fungsi bersarang tidak dapat diakses di luar fungsi di mana ia didefinisikan, dan karenanya kami tidak akan dapat mengakses fungsi itu dari bagian lain dari program lagi. Untuk memanggil fungsi bersarang f2(), pertama-tama kita harus memanggil fungsi induknya

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 yang akan memanggil

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 di dalamnya. Penyembunyian beberapa data atau kode ini (berfungsi dalam kasus kami) dikenal sebagai enkapsulasi

Tetapi mengapa kita merangkum suatu fungsi?

Untuk menjawabnya, mari kita ambil kasus penggunaan di mana kita ingin memprediksi apakah suatu perusahaan akan untung atau rugi. Misalkan kita memiliki fungsi yang berisi logika yang menghitung keuntungan yang diharapkan dari sebuah perusahaan. Logika ini mungkin berisi beberapa informasi yang tidak ingin diketahui orang lain. Jika kita tidak ingin bagian lain dari program mengakses logika dalam fungsi ini secara langsung, kita dapat menempatkannya sebagai fungsi bersarang di dalam fungsi lain. Perhatikan struktur fungsi berikut

def profit_or_loss():

    def get_profit():
        # calculates profit
        return profit

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

profit_or_loss()

Misalkan

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 adalah fungsi bersarang dengan logika yang menghitung dan mengembalikan keuntungan yang diharapkan, dan

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 adalah fungsi di dalamnya yang dienkapsulasi. Sekarang, jika pengguna ingin mengetahui apakah akan ada untung atau rugi, maka dia akan memanggil fungsi

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. Fungsi ini akan memanggil fungsi

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 untuk mendapatkan keuntungan, dan akan mengembalikan "Sukses" jika keuntungannya positif, selain itu mengembalikan "Rugi". Dengan cara ini, tidak ada bagian lain dari program yang dapat mengakses fungsi

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 bersarang

Fungsi bersarang juga digunakan untuk membuat penutupan. Kita akan membaca tentang penutupan di Penutupan

Sekarang setelah Anda memahami apa itu fungsi bersarang dan di mana menggunakannya, mulailah memasukkannya ke dalam program Anda jika diperlukan

Untuk belajar dari video sederhana, Anda selalu dapat melihat kursus video Python kami di CodesDope Pro. Ini memiliki lebih dari 500 soal latihan dan lebih dari 20 proyek

Apa yang dilakukan fungsi bersarang?

Fungsi bersarang dapat mengakses fungsi lokal lainnya, variabel, konstanta, tipe, kelas, dll. yang berada dalam cakupan yang sama, atau dalam cakupan terlampir apa pun, tanpa penerusan parameter eksplisit , yang sangat menyederhanakan penerusan data masuk dan keluar dari fungsi bersarang. Ini biasanya diperbolehkan untuk membaca dan menulis.

Apa contoh fungsi bersarang?

Misalnya, dengan menyarangkan fungsi AVERAGE dan SUM dalam argumen fungsi IF, rumus berikut menjumlahkan sekumpulan angka (G2. G5) hanya jika rata-rata dari kumpulan angka lainnya (F2. F5) lebih besar dari 50. Jika tidak, ia mengembalikan 0. Fungsi AVERAGE dan SUM bersarang di dalam fungsi IF

Apa artinya bersarang di Python?

Fungsi bersarang (atau dalam, bersarang) adalah fungsi yang kita definisikan di dalam fungsi lain untuk secara langsung mengakses variabel dan nama yang didefinisikan dalam fungsi terlampir. Nested functions have many uses, primarily for creating closures and decorators.