{"id":2712,"date":"2020-09-28T08:50:38","date_gmt":"2020-09-28T08:50:38","guid":{"rendered":"https:\/\/idiagress.com\/vinaaypatil\/?p=2712"},"modified":"2023-10-28T12:50:00","modified_gmt":"2023-10-28T12:50:00","slug":"1-7-user-defined-functions-in-python","status":"publish","type":"post","link":"https:\/\/idiagress.com\/vinaaypatil\/2020\/09\/28\/1-7-user-defined-functions-in-python\/","title":{"rendered":"1.7 User Defined Functions in Python"},"content":{"rendered":"\n

In our previous example of finding the roots of a quadratic equation using the Bisection Method, we observed that a piece of code was repeated twice: once to calculate the positive root and then again to find the negative root. This repetition involves the same logic with just a change in variables.<\/p>\n\n\n\n

 <\/td><\/tr>
# Bisection loop for positive roots<\/i>
<\/span>while<\/span> ((_a*_x*_x) + (_b*_x)) != _c <\/span>and<\/span> _iter < _limit:
<\/span>    <\/span><\/span>if<\/span> ((_a*_x*_x) + (_b*_x)) > _c:
<\/span>        <\/span><\/span>_high = _x
<\/span>    <\/span><\/span>else<\/span>:
<\/span>        <\/span><\/span>_low = _x
<\/span>    <\/span><\/span>_iter = _iter+<\/span>1
<\/span>    <\/span><\/span>_x = (_high + _low)\/<\/span>2
<\/span>    <\/span><\/span>print<\/span>(<\/span>“At”<\/span>, _iter, <\/span>” iteration solution is: “<\/span>, _x)
<\/span>     <\/span>
<\/span>print<\/span>(<\/span>“After “<\/span>, _iter, <\/span>” iterations the positive root of Equation is: “<\/span>, _x)<\/span><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
<\/div>\n\n\n\n

For the negative roots, we repeat the same code with a change in variables: <\/p>\n\n\n\n

‘_nhigh<\/mark><\/strong>‘ replaces ‘_high<\/mark>,’ <\/p>\n\n\n\n

and <\/p>\n\n\n\n

‘_nlow<\/mark>‘ replaces ‘_low<\/mark>.’<\/p>\n\n\n\n

 <\/td><\/tr>
# Bisection loop for negative roots<\/i>
<\/span>while<\/span> ((_a*_x*_x) + (_b*_x)) != _c <\/span>and<\/span> _iter < _limit:
<\/span>    <\/span><\/span>if<\/span> ((_a*_x*_x) + (_b*_x)) > _c:
<\/span>        <\/span><\/span>_nhigh = _x
<\/span>    <\/span><\/span>else<\/span>:
<\/span>        <\/span><\/span>_nlow = _x
<\/span>    <\/span><\/span>_iter = _iter+<\/span>1
<\/span>    <\/span><\/span>_x = (_nhigh + _nlow)\/<\/span>2
<\/span>    <\/span><\/span>print<\/span>(<\/span>“At”<\/span>, _iter, <\/span>” iteration solution is: “<\/span>, _x)
<\/span>     <\/span>
<\/span>print<\/span>(<\/span>“After “<\/span>, _iter, <\/span>” iterations the negative root of Equation is: “<\/span>, _x) _x)<\/span><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
<\/div>\n\n\n\n

When a piece of code repeats with only variable values changing, Python offers a powerful feature: User-Defined Functions (UDFs). By defining a UDF at the start of our program, we can call the function anytime within the program to repeat the code. Let’s illustrate this with the same Bisection Loop code.<\/p>\n\n\n\n

Defining a User-Defined Function<\/h3>\n\n\n\n

To define a UDF in Python, you use the def<\/code> command. You assign a name to the function and declare the variables to be passed into it.<\/p>\n\n\n\n

<\/div>\n\n\n\n
def bisection_loop(_x, _high, _low, _iter=0):<\/code><\/pre>\n\n\n\n
In this function definition, ‘_x,’ ‘_high,’ ‘_low,’ and ‘_iter’ are the variables that change values during execution. ‘_iter’ is assigned a default value of ‘0.’ <\/p>\n\n\n\n
We can define any \u2018names\u2019 for the variables. We can use names like \u2018a,\u2019 \u2018b\u2019 also. However, to avoid confusion at this early stage, we are sticking to previous variable names. Additionally, we can set the default value for a variable in the function definition itself. We have done this for \u2018_iter<\/b>\u2019 and set the default value to \u20180\u2019<\/b><\/em>.\u00a0<\/span><\/p>\n\n\n\n
We declare the rest of our code below the \u2018def\u2019 command.<\/p>\n\n\n\n
 <\/td><\/tr>
def<\/span> bisection_loop<\/span>(_x, _high, _low, _iter=<\/span>0<\/span>):
<\/span>    <\/span><\/span>while<\/span> ((_a*_x*_x) + (_b*_x)) != _c <\/span>and<\/span> _iter < _limit:
<\/span>        <\/span><\/span>if<\/span> ((_a*_x*_x) + (_b*_x)) > _c:
<\/span>            <\/span><\/span>_high = _x
<\/span>        <\/span><\/span>else<\/span>:
<\/span>            <\/span><\/span>_low = _x
<\/span>        <\/span><\/span>_iter = _iter+<\/span>1
<\/span>        <\/span><\/span>_x = (_high + _low)\/<\/span>2
<\/span>        <\/span><\/span>print<\/span>(<\/span>“At”<\/span>, _iter, <\/span>” iteration solution is: “<\/span>, _x)
<\/span>    <\/span><\/span>print<\/span>(<\/span>“After “<\/span>, _iter, <\/span>” iterations the positive root of Equation is: “<\/span>, _x)<\/span><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
<\/div>\n\n\n\n
Once declared at the start of the program, we can call the function later in the program using the following syntax –<\/p>\n\n\n\n
function_name(variable1, variable2, ..., variableN)<\/code><\/pre>\n\n\n\n
In the case of our function, we can call it in the following manner –\u00a0<\/span><\/p>\n\n\n\n
bisection_loop (2, 50, 5 )<\/code><\/pre>\n\n\n\n
<\/div>\n\n\n\n
Here’s how Python interprets the call:<\/p>\n\n\n\n
bisection_loop<\/span>(_x, _high, _low, _iter=<\/span>0<\/span>):   <\/span>corresponds to <\/span>bisection_loop<\/span>(2,50,5)<\/span> <\/p>\n\n\n\n
<\/div>\n\n\n\n