Python function calling another function

Функции в Python: замыкания

В этой статье мы рассмотрим замыкания (closures) в Python: как их определять и когда их стоит использовать.

Нелокальная переменная во вложенной функции

Прежде чем перейти к тому, что такое замыкание, мы должны сначала понять, что такое вложенная функция и нелокальная (nonlocal) переменная.

Функция, определенная внутри другой функции, называется вложенной функцией. Вложенные функции могут получать доступ к переменным из локальной области видимости объемлющих функций (enclosing scope).

В Python нелокальные переменные по умолчанию доступны только для чтения. Если нам необходимо их модифицировать, то мы должны объявить их явно как нелокальные (используя ключевое слово nonlocal).

Ниже приведен пример вложенной функции, обращающейся к нелокальной переменной.

def print_msg(msg): # объемлющая функция def printer(): # вложенная функция print(msg) printer() # Output: Hello print_msg("Hello")

Мы видим, что вложенная функция printer() смогла получить доступ к нелокальной переменной msg объемлющей функции print_msg(msg) .

Определение замыкания

Что произойдет в приведенном выше примере, если последняя строка функции print_msg() вернет функцию printer() вместо ее вызова? Определим данную функцию следующим образом:

def print_msg(msg): # объемлющая функция def printer(): # вложенная функция print(msg) return printer # возвращаем вложенную функцию # теперь попробуем вызвать эту функцию # Output: Hello another = print_msg("Hello") another()

Функция print_msg() вызывалась со строкой «Hello», а возвращаемая функция была присвоена переменной another . При вызове another() сообщение все еще сохранялось в памяти, хотя мы уже закончили выполнение функции print_msg() .

Этот метод, с помощью которого некоторые данные (в данном случае строка «Hello») прикрепляются к некоторому коду, в Python называется замыканием.

Ссылка на переменную объемлющей функции действительна, даже когда объемлющая функция закончила работу, и переменная вышла из области видимости или сама функция удаляется из текущего пространства имен.

Попробуйте выполнить следующее, чтобы увидеть результат:

>>> del print_msg >>> another() Hello >>> print_msg("Hello") Traceback (most recent call last): . NameError: name 'print_msg' is not defined

Здесь возвращаемая функция все еще работает, даже если исходная функция была удалена.

Когда мы имеем дело с замыканием?

Как видно из приведенного выше примера, мы имеем дело с замыканием в Python, когда вложенная функция ссылается на значение из локальной области видимости объемлющей функции.

Критерии, которые должны быть выполнены для создания замыкания в Python, изложены в следующих пунктах:

• У нас должна быть вложенная функция (функция внутри функции).
• Вложенная функция должна ссылаться на значение, определенное в объемлющей функции.
• Объемлющая функция должна возвращать вложенную функцию.

Когда стоит использовать замыкания?

Так для чего же нужны замыкания?

Замыкания позволяют избежать использования глобальных (global) значений и обеспечивают некоторую форму сокрытия данных. Для этого также может использоваться объектно-ориентированный подход.

Если в классе необходимо реализовать небольшое количество методов (в большинстве случаев один метод), замыкания могут обеспечить альтернативное и более элегантное решение. Но когда количество атрибутов и методов становится больше, лучше реализовать класс.

Вот простой пример, где замыкание может быть более предпочтительным, чем определение класса и создание объектов. Но выбор остается за вами.

def make_multiplier_of(n): def multiplier(x): return x * n return multiplier times3 = make_multiplier_of(3) times5 = make_multiplier_of(5) # Output: 27 print(times3(9)) # Output: 15 print(times5(3)) # Output: 30 print(times5(times3(2)))

Декораторы в Python также широко используют замыкания.

В заключение следует отметить, что можно найти значения, включенные в функцию замыкания.

Все объекты функций имеют атрибут __closure__ , который возвращает кортеж объектов cell , если это функция замыкания. Ссылаясь на приведенный выше пример, мы знаем, что times3 и times5 являются замыканиями.

>>> make_multiplier_of.__closure__ >>> times3.__closure__ (,)

Объект cell имеет атрибут cell_contents, который хранит значение.

>>> times3.__closure__[0].cell_contents 3 >>> times5.__closure__[0].cell_contents 5

Больше примеров замыканий вы можете найти по ссылке.

Источник

Calling a function from another function in Python

In this tutorial, we will learn how to call a function from another function in Python.

Let’s focus on the definition of a function.

Certainly, a function consists of a set of statements to perform a specific task.

This is how a function looks like.

def fun(): # function definition print ("Hey u called fun()") fun() # calling a function

The moment fun() is executed,

• The control goes to function definition.
• After, executing that function it returns back.

Call a function from another function in Python

We are going to understand this concept in two ways mainly,

1. A sample example to show how it works
2. A real-time program to show its usability in programming.

So, in the first step, there are two sample functions namely fun1( ) and fun2( ).

Therefore, we are going to call fun2( ) from fun1( ).

def fun2(): print ("Called by fun1()") def fun1(): # function definition print ("Called by main function") fun2() # calling fun2() from fun1() fun1() # calling a function

Called by main function Called by fun1()

Moreover, the above code shows the possibility of calling many other functions from a function itself.

A program to print all the Armstrong numbers in a given range [a,b]:

While doing the coding for this program, it could be very much clear with the concept of calling a function from another function.

Now, quickly let’s implement it.

A number is said to be Armstrong if and only if,

• The sum of individual digits raised to the power of the number of digits equals the original number.

It seems complex, no it isn’t. Let’s understand by an example.

Therefore sum = (1*1*1) + (5*5*5) + (3*3*3) = 153 [ the digits are cubed as the total digits in n = 3]

As the original number equals the sum, it’s an Armstrong number.

Now moving on to implement the code, by using the concept of calling a function from another function.

def Total_sum(nod,k): s = 0 while(k > 0): r = k % 10 s += (r**nod) # a**b is a raised to power b k //= 10 return s # returns the calculated sum def Number_of_digits(num): # function to calculate number of digits in a number c = 0 while (num>0): c+=1 num//=10 return c def isArmstrong(n): k = n nod = Number_of_digits (k) # calling a Number_of_digits function sum_of_digits = Total_sum (nod,k) # calling Total_sum function from another function isArmstrong() if (sum_of_digits == n): return True return False a = int(input("Enter the lower range :")) b = int(input("Enter the higher range :")) print ("The Armstrong numbers in the given range",a, "and",b,"are") for i in range(a,b+1): if(isArmstrong(i)): print (i)

Output : Enter the lower range : 150 Enter the higher range : 2000 The Armstrong numbers in the given range 150 and 2000 are 153 370 371 407 1634

Hope, the concept is pretty clear and,

This is how the functions come in handy and have more flexibility when they are used to call other functions from their function definition.

One response to “Calling a function from another function in Python”

how to import a function in another program which is inside a function like if i create a program and use a function and inside that function a create another function and now i am creating another program and i want to call that function which is inside the first function. how to do that?

Источник

Call Function from Another Function in Python

To call a function, we have to define that function using the def keyword, so we used that to define the test() function. Then, inside the test() function, we used the print() function to print a message, which would be printed on the execution of this function.

In function calls, we have two terms; Calling Function and Called Function . Here, the Calling Function is the function which invokes another function while the Called Function is the function which is being invoked.

Now, you may have a question about how the function execution works. How to decide where to return, particularly in the nested function call, which we will learn in the next section? The stack, the first-in-last-out data structure, handles function calls. How? Let’s see the following.

In the above diagram, we had a function test() ; when we called it, it was pushed to the stack to hold the reference to know where to return. Then, it executed the test() function and returned.

After that, the function was popped from the stack and returned to a point where it left the program execution and continued.

Now, you might be wondering why to struggle with all these and write functions; it is because the functions serve us with the following features:

• It avoids code repetition, encourages code reusability and thus saves time, money, and memory.
• It assists in hiding the code and lets us understand the modules efficiently.
• Functions help us to break down big problems into smaller modules.
• Functions can only be defined using the def keyword and a colon followed by a function name.
• The statements of a function can only be executed with the function name.

You can read this to see what characters are allowed while writing the name of the function in Python. Now, assume we have a situation where we have to call a function from another. The concept would be the same, and a stack data structure would be used. Let’s see how?

Call Function from Another Function in Python

To call function from another function in Python:

• Write a function_A() function, which prints a message and returns.
• Write another function_B() function which prints a message, calls function_A() that we created in the previous step and returns.
• Now, call function_B() function.

Here, we wrote two functions, function_A() and function_B() , both had one print statement to print a message, but we also called function_A() from function_B() .

Nothing happened until we reached the statement, where called function_B as function_B() . As soon as we called function_B() , it was pushed to the stack, and the execution of the function_B started. It printed the statement I am function B. and called function_A as function_A() .

Now, the function_A is also pushed to stack and execution of function_A started; we got another statement printed on the console as I am function A. . Once we are done with function_A , it would be popped from the stack and returned where we left the function_B .

As we can see in the above code, we had a return statement after calling function_A , so the function_B also popped from the stack and returned where we left the program after calling the function_B .

So now, we only have one print statement to be executed, which printed I am now outside the functions. on the console. At this point, we had three statements printed on the console and the stack was also empty.

Let’s visualize the execution of the above program in the following diagram.

We can also call one function from another within the same and different classes. Let’s learn it below.

Источник