5/6/22, 9:56 AM Session3 Functions
A function is a block of code which only runs when it is called
Built in functions
In [1]:
type(12)
int
Out[1]:
In [5]:
min('bac')
'a'
Out[5]:
In [6]:
max('bac')
'c'
Out[6]:
In [8]:
len('bac')
3
Out[8]:
In [7]:
min('ba c')
' '
Out[7]:
In [9]:
len('ba c')
4
Out[9]:
Math functions
In [11]:
radians=0.7
ht=sin(radians)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_11616/741569380.py in <module>
1 radians=0.7
----> 2 ht=sin(radians)
NameError: name 'sin' is not defined
Python has a math module that provides most of the familiar mathematical functions. Before we can
use the module, we have to import it:
In [17]:
import math
file:///C:/Users/GVPCOE/Desktop/Python sessions/Session3 Functions.html 1/10
5/6/22, 9:56 AM Session3 Functions
This statement creates a module object named math
In [18]:
print(math)
<module 'math' (built-in)>
In [16]:
type(math)
module
Out[16]:
In [19]:
# To display list of functions in a module- syntax dir(module_name)
dir(math)
['__doc__',
Out[19]:
'__loader__',
'__name__',
'__package__',
'__spec__',
'acos',
'acosh',
'asin',
'asinh',
'atan',
'atan2',
'atanh',
'ceil',
'comb',
'copysign',
'cos',
'cosh',
'degrees',
'dist',
'e',
'erf',
'erfc',
'exp',
'expm1',
'fabs',
'factorial',
'floor',
'fmod',
'frexp',
'fsum',
'gamma',
'gcd',
'hypot',
'inf',
'isclose',
'isfinite',
'isinf',
'isnan',
'isqrt',
'lcm',
'ldexp',
'lgamma',
'log',
file:///C:/Users/GVPCOE/Desktop/Python sessions/Session3 Functions.html 2/10
5/6/22, 9:56 AM Session3 Functions
'log10',
'log1p',
'log2',
'modf',
'nan',
'nextafter',
'perm',
'pi',
'pow',
'prod',
'radians',
'remainder',
'sin',
'sinh',
'sqrt',
'tan',
'tanh',
'tau',
'trunc',
'ulp']
To access one of the functions, you have to specify the name of the module and the name of the
function, separated by a dot
In [35]:
radians=math.pi/4
ht=math.sin(radians)
print(ht)
0.7071067811865476
In [27]:
s=1
n=2
ratio = s/n
decibels = 10 * math.log10(ratio)
print(decibels)
-3.010299956639812
In [36]:
math.sqrt(2) / 2.0
0.7071067811865476
Out[36]:
Creating a Function
In [53]:
def function_name():
print("Hello")
def is a keyword that indicates that this is a function definition.
The rules for function names are the same as for variable names: letters, numbers and some
punctuation marks are legal, but the first character can’t be a number.
file:///C:/Users/GVPCOE/Desktop/Python sessions/Session3 Functions.html 3/10
5/6/22, 9:56 AM Session3 Functions
You can’t use a keyword as the name of a function, and you should avoid having a variable and a
function with the same name.
The empty parentheses after the name indicate that this function doesn’t take any arguments. Later
we will build functions that take arguments as their inputs.
The first line of the function definition is called the header; the rest is called the body. The header
has to end with a colon and the body has to be indented. By convention, the indentation is always
four spaces. The body can contain any number of statements.
To end the function, you have to enter an empty line (this is not necessary in a script).
In [54]:
function_name()
Hello
To call a function, use the function name followed by paranthesis
In [55]:
type(function_name)
function
Out[55]:
Once you have defined a function, you can use it inside another function.
In [57]:
def repeat_hello():
function_name()
function_name()
function_name()
In [58]:
repeat_hello()
Hello
Hello
Hello
Parameters and Arguments
A parameter is the variable listed inside the parantheses in the function definition. ex: bruce
An argument is the value that is sent to the function when it is called. ex: 10
In [60]:
def print_twice(bruce):
print(bruce)
print(bruce)
In [61]:
print_twice(10)
10
10
file:///C:/Users/GVPCOE/Desktop/Python sessions/Session3 Functions.html 4/10
5/6/22, 9:56 AM Session3 Functions
In [63]:
import math
print_twice(math.pi)
3.141592653589793
3.141592653589793
In [64]:
print_twice('Spam '*4)
Spam Spam Spam Spam
Spam Spam Spam Spam
In [66]:
x='Hello'
print_twice(x)
Hello
Hello
In [70]:
x=10
r=print_twice(x)
print(r)
10
10
None
Void functions might display something on the screen but they don’t have a return value. If you try
to assign the result to a variable r,you get a special value called None.
To return a result from a function, we use the return statement in our function.
In [71]:
def addtwo(a, b):
added = a + b
return added
In [72]:
x=addtwo(3,5)
In [73]:
x=addtwo(3,5)
print(x)
In [4]:
def oper(a, b):
sub=a-b
added = a + b
return sub
In [5]:
x=oper(3,5)
print(x)
-2
file:///C:/Users/GVPCOE/Desktop/Python sessions/Session3 Functions.html 5/10
5/6/22, 9:56 AM Session3 Functions
Number of Arguments
By default, a function must be called with the correct number of arguments.
In [7]:
x=oper(5)
print(x)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_1400/1195630256.py in <module>
----> 1 x=oper(5)
2 print(x)
TypeError: oper() missing 1 required positional argument: 'b'
In [14]:
def my_function(x):
return 5 * x
y=my_function(5)
print(y)
25
Default Parameter Value
If we call the function without argument, it uses the default value:
In [8]:
def my_function(country = "Norway"):
print("I am from " + country)
In [9]:
my_function()
I am from Norway
In [10]:
my_function("Sweden")
I am from Sweden
In [11]:
my_function("India")
I am from India
Example: Write a program to define a function with multiple return values
In [45]:
def fun():
a=input("enter first value")
b=input("enter second value")
c=input("enter second value")
return a,b,c
d=fun()
print(d)
file:///C:/Users/GVPCOE/Desktop/Python sessions/Session3 Functions.html 6/10
5/6/22, 9:56 AM Session3 Functions
enter first value10
enter second value20
enter second value30
('10', '20', '30')
Recursion
Python also accepts function recursion, which means a defined function can call itself.
In [25]:
def tri_recursion(k):
if(k > 0):
result = k + tri_recursion(k - 1)
print(result)
else:
result = 0
return result
output=tri_recursion(3)
1
3
6
Python - Global Variables
Variables that are created outside of a function are known as global variables. Global variables can
be used by everyone, both inside of functions and outside.
Example Create a variable outside of a function, and use it inside the function
In [26]:
x = "awesome"
def myfunc():
print("Python is " + x)
myfunc()
Python is awesome
If you create a variable with the same name inside a function, this variable will be local, and can only
be used inside the function. The global variable with the same name will remain as it was, global and
with the original value.
Example Create a variable inside a function, with the same name as the global variable
In [27]:
x = "awesome"
def myfunc():
x = "fantastic"
print("Python is " + x)
myfunc()
print("Python is " + x)
file:///C:/Users/GVPCOE/Desktop/Python sessions/Session3 Functions.html 7/10
5/6/22, 9:56 AM Session3 Functions
Python is fantastic
Python is awesome
The global Keyword
Normally, when you create a variable inside a function, that variable is local, and can only be used
inside that function. To create a global variable inside a function, you can use the global keyword.
Example If you use the global keyword, the variable belongs to the global scope:
In [28]:
def myfunc():
global x
x = "fantastic"
myfunc()
print("Python is " + x)
Python is fantastic
Example
To change the value of a global variable inside a function, refer to the variable by using the global
keyword:
In [29]:
x = "awesome"
def myfunc():
global x
x = "fantastic"
myfunc()
print("Python is " + x)
Python is fantastic
Lambda Functions
Sometimes, we don’t want to use the normal way to define a function, especially if our function is
just one line. In this case, we can use anonymous function in Python, which is a function that is
defined without a name. This type of functions also called labmda function, since they are defined
using the labmda keyword.
A lambda function can take any number of arguments, but can only have one expression.
lambda arguments : expression
The expression is executed and the result is returned:
Example: Define a labmda function, which square the in put number. And call the function with input
2 and 5
In [31]:
square = lambda x: x**2
file:///C:/Users/GVPCOE/Desktop/Python sessions/Session3 Functions.html 8/10
5/6/22, 9:56 AM Session3 Functions
print(square(2))
print(square(5))
4
25
Example: Define a labmda function, which add x and y.
In [32]:
my_adder = lambda x, y: x + y
print(my_adder(2, 4))
6
Example: Add 10 to argument a, and return the result:
In [33]:
x = lambda a : a + 10
print(x(5))
15
Say you have a function definition that takes one argument, and that argument will be multiplied
with an unknown number:
Use that function definition to make a function that always doubles the number you send in:
In [38]:
def myfunc(n):
return lambda a : a * n
mydoubler = myfunc(2)
print(mydoubler(11))
22
use the same function definition to make a function that always triples the number you send in:
In [40]:
def myfunc(n):
return lambda a : a * n
mytripler = myfunc(3)
print(mytripler(11))
33
use the same function definition to make both functions, in the same program:
In [41]:
def myfunc(n):
return lambda a : a * n
mydoubler = myfunc(2)
mytripler = myfunc(3)
print(mydoubler(11))
print(mytripler(11))
22
33
In [ ]:
file:///C:/Users/GVPCOE/Desktop/Python sessions/Session3 Functions.html 9/10
5/6/22, 9:56 AM Session3 Functions
file:///C:/Users/GVPCOE/Desktop/Python sessions/Session3 Functions.html 10/10
