In Python we can declare def inside another def. So, if method_b is required for and called only from method_a, should I declare method_b inside method_a? like this :
You don’t really gain much by doing this, in fact it slows method_a down because it’ll define and recompile the other function every time it’s called. Given that, it would probably be better to just prefix the function name with underscore to indicate it’s a private method — i.e. _method_b.
I suppose you might want to do this if the nested function’s definition varied each time for some reason, but that may indicate a flaw in your design. That said, there is a valid reason to do this to allow the nested function to use arguments that were passed to the outer function but not explicitly passed on to them, which sometimes occurs when writing function decorators, for example. It’s what is being shown in the accepted answer although a decorator is not being defined or used.
Update:
Here’s proof that nesting them is slower (using Python 3.6.1), although admittedly not by much in this trivial case:
Note I added some self arguments to your sample functions to make them more like real methods (although method_b2 still isn’t technically a method of the Test class). Also the nested function is actually called in that version, unlike yours.
>>>
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.3870.015151.000[0.342,0.433]
square1 0.4600.014221.188[0.417,0.503]
square2 0.5520.018031.425[0.498,0.606]
square5 0.7660.016541.979[0.717,0.816]>>>
I found this question because I wanted to pose a question why there is a performance impact if one uses nested functions. I ran tests for the following functions using Python 3.2.5 on a Windows Notebook with a Quad Core 2.5 GHz Intel i5-2530M processor
I measured the following 20 times, also for square1, square2, and square5:
s=0
for i in range(10**6):
s+=square0(i)
and got the following results
>>>
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]
>>>
square0 has no nested function, square1 has one nested function, square2 has two nested functions and square5 has five nested functions. The nested functions are only declared but not called.
So if you have defined 5 nested funtions in a function that you don’t call then the execution time of the function is twice of the function without a nested function. I think should be cautious when using nested functions.
The Python file for the whole test that generates this output can be found at ideone.
So in the end it is largely a question about how smart the python implementation is or is not, particularly in the case of the inner function not being a closure but simply an in function needed helper only.
In clean understandable design having functions only where they are needed and not exposed elsewhere is good design whether they be embedded in a module, a class as a method, or inside another function or method. When done well they really improve the clarity of the code.
And when the inner function is a closure that can also help with clarity quite a bit even if that function is not returned out of the containing function for use elsewhere.
So I would say generally do use them but be aware of the possible performance hit when you actually are concerned about performance and only remove them if you do actual profiling that shows they best be removed.
Do not do premature optimization of just using “inner functions BAD” throughout all python code you write. Please.
It’s perfectly OK doing it that way, but unless you need to use a closure or return the function I’d probably put in the module level. I imagine in the second code example you mean:
...
some_data = method_b() # not some_data = method_b
otherwise, some_data will be the function.
Having it at the module level will allow other functions to use method_b() and if you’re using something like Sphinx (and autodoc) for documentation, it will allow you to document method_b as well.
You also may want to consider just putting the functionality in two methods in a class if you’re doing something that can be representable by an object. This contains logic well too if that’s all you’re looking for.
if you were to run some_function() it would then run some_other_function() and returns 42.
EDIT: I originally stated that you shouldn’t define a function inside of another but it was pointed out that it is practical to do this sometimes.
回答 10
您可以使用它来避免定义全局变量。这为您提供了其他设计的替代方案。提供解决方案的3种设计。
A)使用没有全局变量的函数
def calculate_salary(employee, list_with_all_employees):
x = _calculate_tax(list_with_all_employees)# some other calculations done to xpass
y =# something return y
def _calculate_tax(list_with_all_employees):return1.23456# return something
B)在全局函数中使用函数
_list_with_all_employees =Nonedef 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 xpass
y =# somethingreturn y
def _calculate_tax():return1.23456# return something based on the _list_with_all_employees var
C)在另一个函数中使用函数
def calculate_salary(employee, list_with_all_employees):def _calculate_tax():return1.23456# return something based on the list_with_a--Lemployees var
x = _calculate_tax()# some other calculations done to xpass
y =# something return y
You can use it to avoid defining global variables. This gives you an alternative for other designs. 3 designs presenting a solution to a problem.
A) Using functions without globals
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) Using functions with globals
_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) Using functions inside another function
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
Solution C) allows to use variables in the scope of the outer function without having the need to declare them in the inner function. Might be useful in some situations.
回答 11
函数在函数python中
defGreater(a,b):if a>b:return a
return b
defGreater_new(a,b,c,d):returnGreater(Greater(a,b),Greater(c,d))print("Greater Number is :-",Greater_new(212,33,11,999))
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))