Contoh sederhana. Dua metode, satu dipanggil dari yang lain:

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

def method_b(arg):
    return some_data

Dengan Python kita bisa mendeklarasikan defdi dalam yang lain def. Jadi, jika method_bdiperlukan dan dipanggil hanya dari method_a, haruskah saya menyatakan method_bdi dalam method_a? seperti ini :

def method_a(arg):

    def method_b(arg):
        return some_data

    some_data = method_b(arg)

Atau haruskah saya menghindari melakukan ini?

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

Apakah ini yang Anda cari? Ini disebut penutupan .

Anda tidak benar-benar mendapatkan banyak dengan melakukan ini, bahkan melambat method_akarena akan mendefinisikan dan mengkompilasi ulang fungsi lain setiap kali dipanggil. Mengingat itu, mungkin akan lebih baik untuk hanya awalan nama fungsi dengan garis bawah untuk menunjukkan itu metode pribadi - yaitu _method_b.

Saya kira Anda mungkin ingin melakukan ini jika definisi fungsi bersarang bervariasi setiap kali karena beberapa alasan, tetapi itu mungkin menunjukkan kesalahan dalam desain Anda. Yang mengatakan, ada adalah alasan yang sah untuk melakukan hal ini untuk memungkinkan fungsi bersarang menggunakan argumen yang dilewatkan ke fungsi luar tapi tidak secara eksplisit diteruskan kepada mereka, yang kadang-kadang terjadi ketika menulis dekorator fungsi, misalnya. Itu yang ditunjukkan dalam jawaban yang diterima meskipun dekorator tidak didefinisikan atau digunakan.

Memperbarui:

Inilah bukti bahwa bersarangnya lebih lambat (menggunakan Python 3.6.1), meskipun diakui tidak banyak dalam kasus sepele ini:

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

Catatan saya menambahkan beberapa selfargumen ke fungsi sampel Anda untuk membuatnya lebih seperti metode nyata (meskipun method_b2secara teknis masih bukan metode Testkelas). Fungsi bersarang juga disebut dalam versi itu, tidak seperti milik Anda.

Fungsi di dalam fungsi biasanya digunakan untuk penutupan .

(Ada banyak perdebatan tentang apa yang sebenarnya membuat penutupan menjadi penutupan .)

Berikut ini contoh menggunakan built-in sum(). Ini mendefinisikan startsekali dan menggunakannya sejak saat itu:

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

Digunakan:

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

Built-in python closure

functools.partial adalah contoh penutupan.

Dari python docs , kira-kira sama dengan:

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 ke @ user225312 di bawah untuk jawabannya. Saya menemukan contoh ini lebih mudah untuk diketahui, dan mudah-mudahan akan membantu menjawab komentar @ mangga.)

Secara umum, tidak, jangan mendefinisikan fungsi di dalam fungsi.

Kecuali Anda memiliki alasan yang sangat bagus. Yang mana tidak.

Kenapa tidak?

• Ini mencegah kait mudah untuk pengujian unit. Anda adalah unit testing, bukan?
• Itu tidak benar-benar mengaburkan sepenuhnya , lebih aman untuk tidak menganggap apa pun dengan python.
• Gunakan pedoman gaya kode automagic Python standar untuk merangkum metode sebagai gantinya.
• Anda tidak perlu membuat ulang objek fungsi untuk kode yang sama setiap kali Anda menjalankan fungsi luar .
• Jika fungsi Anda benar-benar sesederhana itu, Anda seharusnya menggunakan lambdaekspresi .

Apa adalah alasan yang sangat baik untuk mendefinisikan fungsi dalam fungsi?

Ketika apa yang sebenarnya Anda inginkan adalah penutupan dingdang .

Sebenarnya tidak masalah untuk mendeklarasikan satu fungsi di dalam fungsi lainnya. Ini berguna khusus membuat dekorator.

Namun, sebagai aturan praktis, jika fungsinya kompleks (lebih dari 10 baris), mungkin lebih baik untuk mendeklarasikannya pada level modul.

Saya menemukan pertanyaan ini karena saya ingin mengajukan pertanyaan mengapa ada dampak kinerja jika seseorang menggunakan fungsi bersarang. Saya menjalankan tes untuk fungsi-fungsi berikut menggunakan Python 3.2.5 pada Notebook Windows dengan prosesor Intel Core i5-2530M Quad Core 2.5 GHz 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

Saya mengukur 20 kali berikut, juga untuk square1, square2, dan square5:

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

dan mendapat hasil sebagai berikut

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

square0tidak memiliki fungsi bersarang, square1memiliki satu fungsi bersarang, square2memiliki dua fungsi bersarang dan square5memiliki lima fungsi bersarang. Fungsi bersarang hanya dideklarasikan tetapi tidak dipanggil.

Jadi, jika Anda telah menetapkan 5 fungsi tersarang dalam fungsi yang tidak Anda panggil maka waktu eksekusi dari fungsi tersebut adalah dua kali dari fungsi tanpa fungsi bersarang. Saya pikir harus berhati-hati saat menggunakan fungsi bersarang.

File Python untuk seluruh tes yang menghasilkan output ini dapat ditemukan di ideone .

Itu hanya prinsip tentang API eksposur.

Menggunakan python, Ini ide yang bagus untuk menghindari paparan API di luar angkasa (modul atau kelas), fungsinya adalah tempat enkapsulasi yang baik.

Itu bisa jadi ide yang bagus. ketika Anda memastikan

1. fungsi dalam HANYA digunakan oleh fungsi luar.
2. fungsi orang dalam memiliki nama yang baik untuk menjelaskan tujuannya karena kode berbicara.
3. kode tidak dapat langsung dipahami oleh kolega Anda (atau pembaca kode lainnya).

Meskipun demikian, penyalahgunaan teknik ini dapat menyebabkan masalah dan menyiratkan cacat desain.

Hanya dari exp saya, Mungkin salah paham pertanyaan Anda.

Jadi pada akhirnya sebagian besar pertanyaan tentang seberapa pintar implementasi python adalah atau tidak, terutama dalam kasus fungsi dalam tidak menjadi penutup tetapi hanya dalam fungsi yang dibutuhkan penolong saja.

Dalam desain bersih yang dapat dimengerti hanya memiliki fungsi di mana mereka dibutuhkan dan tidak diekspos di tempat lain adalah desain yang baik apakah mereka tertanam dalam modul, kelas sebagai metode, atau di dalam fungsi atau metode lain. Ketika dilakukan dengan baik, mereka benar-benar meningkatkan kejelasan kode.

Dan ketika fungsi bagian dalam adalah penutup yang juga dapat membantu dengan kejelasan sedikit bahkan jika fungsi itu tidak dikembalikan dari fungsi yang mengandung untuk digunakan di tempat lain.

Jadi saya akan mengatakan secara umum menggunakannya tetapi waspada terhadap kemungkinan hit kinerja ketika Anda benar-benar khawatir tentang kinerja dan hanya menghapusnya jika Anda membuat profil aktual yang menunjukkan mereka sebaiknya dihapus.

Jangan lakukan optimasi prematur hanya dengan menggunakan "fungsi dalam BURUK" di seluruh kode python yang Anda tulis. Silahkan.

Tidak apa-apa melakukannya seperti itu, tetapi kecuali jika Anda perlu menggunakan penutupan atau mengembalikan fungsi saya mungkin akan dimasukkan ke tingkat modul. Saya membayangkan dalam contoh kode kedua yang Anda maksud:

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

jika tidak, some_data akan menjadi fungsinya.

Setelah itu di tingkat modul akan memungkinkan fungsi lain menggunakan method_b () dan jika Anda menggunakan sesuatu seperti Sphinx (dan autodoc) untuk dokumentasi, itu akan memungkinkan Anda untuk mendokumentasikan method_b juga.

Anda juga mungkin ingin mempertimbangkan hanya menempatkan fungsionalitas dalam dua metode di kelas jika Anda melakukan sesuatu yang dapat diwakili oleh suatu objek. Ini juga mengandung logika jika hanya itu yang Anda cari.

Lakukan sesuatu seperti:

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

jika Anda menjalankannya some_function()maka akan menjalankan some_other_function()dan mengembalikan 42.

EDIT: Saya awalnya menyatakan bahwa Anda tidak boleh mendefinisikan fungsi di dalam yang lain tapi itu menunjukkan bahwa praktis untuk melakukan hal ini kadang-kadang.

Anda dapat menggunakannya untuk menghindari mendefinisikan variabel global. Ini memberi Anda alternatif untuk desain lain. 3 desain menghadirkan solusi untuk masalah.

A) Menggunakan fungsi tanpa global

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) Menggunakan fungsi dengan global

_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) Menggunakan fungsi di dalam fungsi lain

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

Solusi C) memungkinkan untuk menggunakan variabel dalam lingkup fungsi luar tanpa harus menyatakannya dalam fungsi dalam. Mungkin bermanfaat dalam beberapa situasi.

Function In function 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))