Diyelim ki a function Asadece function BB içinde mi tanımlanmalı?

Basit bir örnek. Biri diğerinden çağrılan iki yöntem:

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

def method_b(arg):
    return some_data

Python'da bir defbaşkasının içinde ilan edebiliriz def. Öyleyse, method_bgerekliyse ve sadece içinden çağrılıyorsa method_a, method_biçeriden method_ami beyan etmeliyim ? bunun gibi :

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

    some_data = method_b(arg)

Yoksa bunu yapmaktan kaçınmalı mıyım?

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

Aradığın bu muydu? Buna kapatma deniyor .

Bunu yaparak pek bir şey kazanmazsınız, aslında yavaşlar method_açünkü her çağrıldığında diğer işlevi tanımlar ve yeniden derler. Buna göre, bunun özel bir yöntem olduğunu belirtmek için işlev adının önüne alt çizgi koymak muhtemelen daha iyi olacaktır - yani _method_b.

Sana varsayalım olabilir iç içe işlevin tanımı nedense her seferinde değişik eğer bunu yapmak istiyor, ama bu senin tasarımında bir kusur gösterebilir. Oradaki söyledi olup iç içe işlev dış işleve geçirilen ancak açıkça örneğin, fonksiyon dekoratörler yazarken bazen meydana geldiği, onlara bindirilmemekte argümanları kullanmasına izin vermek Bunu yapmak için geçerli bir sebep. Bir dekoratör tanımlanmamasına veya kullanılmamasına rağmen, kabul edilen cevapta gösterilen şey budur.

Güncelleme:

Kuşkusuz bu önemsiz durumda çok fazla olmasa da, onları iç içe yerleştirmenin (Python 3.6.1 kullanarak) daha yavaş olduğunun kanıtı:

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

Not selfÖrnek işlevlerinize onları gerçek yöntemler gibi yapmak için bazı argümanlar ekledim ( method_b2yine de teknik olarak Testsınıfın bir yöntemi olmasa da ). Ayrıca, sizinkinden farklı olarak, bu sürümde yuvalanmış işlev de çağrılır.

Bir işlevin içindeki işlev, genellikle kapanışlar için kullanılır .

(A Orada çekişme çok üzerinde tam olarak ne yapar bir kapatma kapatma .)

İşte yerleşik kullanan bir örnek sum(). Bir startkez tanımlar ve bundan sonra onu kullanır:

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

Kullanımda:

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

Yerleşik python kapatma

functools.partial bir kapanış örneğidir.

Python belgelerinden kabaca şuna eşdeğerdir:

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

(Yanıt için aşağıdaki @ user225312'ye tebrikler. Bu örneği daha kolay buluyorum ve umarım @ mango'nun yorumunu yanıtlamaya yardımcı olurum.)

Genel olarak hayır, fonksiyonların içindeki fonksiyonları tanımlamayın.

Gerçekten iyi bir sebebin yoksa. Sen yapmıyorsun.

Neden olmasın?

• Ünite testi için kolay kancaları önler . Birim test ediyorsun, değil mi?
• Aslında onu tamamen gizlemiyor , python'da hiçbir şeyin olmadığını varsaymak daha güvenli.
• Bunun yerine yöntemleri kapsüllemek için standart Python otomatik sihirli kod stili yönergelerini kullanın.
• Sen edilecek gereksiz özdeş kodu için size dış işlevini çalıştırmak her zaman bir işlev nesnesi yeniden .
• İşleviniz gerçekten bu kadar basitse, bunun yerine bir lambdaifade kullanmalısınız .

Ne olduğunu fonksiyonları içinde işlevlerini tanımlamak için gerçekten iyi bir sebebi var mı?

Ne zaman ne aslında istediğiniz bir Dingdang olan kapatma .

Bir işlevi diğerinin içinde belirtmek aslında sorun değil. Bu, özellikle dekoratörler oluşturmak için kullanışlıdır.

Bununla birlikte, genel bir kural olarak, işlev karmaşıksa (10 satırdan fazla), onu modül düzeyinde bildirmek daha iyi bir fikir olabilir.

Bu soruyu buldum çünkü iç içe geçmiş işlevler kullanılıyorsa neden performans etkisi olduğunu sormak istedim. Dört Çekirdekli 2.5 GHz Intel i5-2530M işlemciye sahip bir Windows dizüstü bilgisayarda Python 3.2.5 kullanarak aşağıdaki işlevler için testler yaptım

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

Aşağıdaki 20 kez kare1, kare2 ve kare5 için ölçtüm:

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

ve aşağıdaki sonuçları aldı

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

square0yuvalanmış bir işlevi yoktur square1, bir yuvalanmış işlevi square2vardır, iki yuvalanmış işlevi vardır vesquare5 beş yuvalanmış işlevi vardır. İç içe geçmiş işlevler yalnızca bildirilir ancak çağrılmaz.

Dolayısıyla, çağırmadığınız bir işlevde 5 iç içe geçmiş işlev tanımladıysanız, işlevin yürütme süresi iç içe geçmiş bir işlev olmadan işlevin iki katıdır. İç içe geçmiş işlevleri kullanırken dikkatli olunması gerektiğini düşünüyorum.

Bu çıktıyı oluşturan tüm testin Python dosyası ideone'da bulunabilir .

Bu sadece maruziyet API'leri ile ilgili bir ilkedir.

Python kullanarak, API dış uzayda (modül veya sınıf) maruziyetten kaçınmak iyi bir fikirdir, işlev iyi bir kapsülleme yeridir.

İyi bir fikir olabilir. emin olduğunuzda

1. iç işlev YALNIZCA dış işlev tarafından kullanılır.
2. içeriden öğrenen işlevin amacını açıklamak için iyi bir adı vardır çünkü kod konuşur.
3. kod, meslektaşlarınız (veya diğer kod okuyucular) tarafından doğrudan anlaşılamaz.

Yine de, bu tekniği Kötüye Kullan, sorunlara neden olabilir ve bir tasarım hatası anlamına gelir.

Sadece uzmanımdan, Belki sorunuzu yanlış anlarsınız.

Dolayısıyla, sonuçta bu büyük ölçüde python uygulamasının ne kadar akıllı olduğu veya olmadığı ile ilgili bir sorudur, özellikle de iç işlevin bir kapanma olmadığı, yalnızca yalnızca bir işlev için gerekli olan yardımcı olması durumunda.

Yalnızca ihtiyaç duyulduğu yerde işlevlere sahip olan ve başka bir yerde açığa çıkmayan temiz anlaşılır tasarımda, bunlar bir modüle, bir yöntem olarak bir sınıfa veya başka bir işlev veya yönteme gömülmüş olsalar da, iyi tasarımdır. İyi yapıldığında, kodun netliğini gerçekten geliştirirler.

Ve iç işlev, başka bir yerde kullanılmak üzere kapsayıcı işlevden döndürülmemiş olsa bile, açıklığa oldukça yardımcı olabilecek bir kapanış olduğunda.

Bu nedenle, genel olarak bunları kullanın derim, ancak gerçekten performans konusunda endişelendiğinizde olası performans vuruşunun farkında olun ve yalnızca, en iyi şekilde kaldırılabileceklerini gösteren gerçek bir profilleme yaparsanız kaldırın.

Yazdığınız tüm python kodlarında sadece "iç işlevler KÖTÜ" kullanarak erken optimizasyon yapmayın. Lütfen.

Bunu bu şekilde yapmak tamamen sorun değil, ancak bir kapatma kullanmanız veya işlevi geri almanız gerekmedikçe, muhtemelen modül seviyesine koyardım. İkinci kod örneğinde şunu kastettiğinizi hayal ediyorum:

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

aksi takdirde, bazı_veriler işlev olacaktır.

Modül düzeyinde olması, diğer işlevlerin method_b () kullanmasına izin verir ve Sphinx gibi bir şey kullanıyorsanız ve dokümantasyon için (ve autodoc) , method_b'yi de belgelemenizi sağlar.

Ayrıca, bir nesne tarafından temsil edilebilecek bir şey yapıyorsanız, işlevselliği bir sınıftaki iki yönteme koymayı da düşünebilirsiniz. Bu da mantığı içerir, eğer aradığınız buysa.

Şöyle bir şey yapın:

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

Eğer çalıştıracak some_function()olsaydın, o zaman çalışır some_other_function()ve 42'yi döndürür.

DÜZENLEME: Başlangıçta başka bir fonksiyonun içinde bir fonksiyon tanımlamamanız gerektiğini söylemiştim, ancak bazen bunu yapmanın pratik olduğu belirtilmişti.

Global değişkenleri tanımlamaktan kaçınmak için kullanabilirsiniz. Bu size diğer tasarımlar için bir alternatif sunar. Bir probleme çözüm sunan 3 tasarım.

A) Küresel olmayan işlevleri kullanma

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) Küresellerle işlevleri kullanma

_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) Başka bir işlevin içindeki işlevleri kullanma

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

Çözüm C) , değişkenleri iç işlevde bildirmeye gerek kalmadan dış işlev kapsamında kullanmaya izin verir. Bazı durumlarda faydalı olabilir.

İşlev python işlevinde

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