Python Functions
• function is a block of code which only runs
when it is called.
• You can pass data, known as parameters, into
a function.
• A function can return data as a result.
Creating a Function
• def my_function():
print("Hello from a function")
• Calling a Function
• To call a function, use the function name
followed by parenthesis:
• def my_function():
print("Hello from a function")
my_function()
Arguments
• Information can be passed into functions as
arguments.
• Arguments are specified after the function name,
inside the parentheses. You can add as many
arguments as you want, just separate them with a
comma.
• The following example has a function with one
argument (fname). When the function is called, we
pass along a first name, which is used inside the
function to print the full name:
example
• def my_function(fname):
print(fname + " Refsnes")
my_function("Emil")
my_function("Tobias")
my_function("Linus")
Number of Arguments
• By default, a function must be called with the
correct number of arguments. Meaning that if
your function expects 2 arguments, you have
to call the function with 2 arguments, not
more, and not less.
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil", "Refsnes")
Arbitrary Arguments, *args
• If you do not know how many arguments that
will be passed into your function, add a *
before the parameter name in the function
definition.
• This way the function will receive a tuple of
arguments, and can access the items
accordingly:
example
• def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("Emil", "Tobias", "Linus")
Default Parameter Value
• The following example shows how to use a default
parameter value.
• If we call the function without argument, it uses the
default value:
• def my_function(country = "Norway"):
print("I am from " + country)
my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")
Passing a List as an Argument
• You can send any data types of argument to a
function (string, number, list, dictionary etc.),
and it will be treated as the same data type
inside the function.
• E.g. if you send a List as an argument, it will
still be a List when it reaches the function:
• def my_function(food):
for x in food:
print(x)
fruits = ["apple", "banana", "cherry"]
my_function(fruits)
Return Values
• To let a function return a value, use the return
statement:
• def my_function(x):
return 5 * x
print(my_function(3))
print(my_function(5))
print(my_function(9))
The pass Statement
• function definitions cannot be empty, but if
you for some reason have a function definition
with no content, put in the pass statement to
avoid getting an error.
Map, Filter and Reduce
• Map
Map applies a function to all the items in an
input_list.
Syntax
map(function_to_apply, list_of_inputs)
Program
def multiply(x):
return (x*x)
def add(x):
return (x+x) funcs = [multiply, add]
for i in range(5):
value = list(map(lambda x: x(i), funcs))
print(value)
# Output
• : # [0, 0]
• # [1, 2]
• # [4, 4]
• # [9, 6]
• # [16, 8]
Filter
• filter creates a list of elements for which a
function returns true.
Pgm:
number_list = range(-5, 5)
less_than_zero = list(filter(lambda x: x < 0, number_list))
print(less_than_zero)
# Output: [-5, -4, -3, -2, -1]
The filter resembles a for loop but it is a builtin function
and faster.
Reduce
• Reduce is a really useful function for
performing some computation on a list and
returning the result. It applies a rolling
computation to sequential pairs of values in a
list. For example, if you wanted to compute
the product of a list of integers.
Pgm
product = 1
list = [1, 2, 3, 4]
for num in list:
product = product * num
o/p:# product = 24
from functools import reduce
product = reduce((lambda x, y: x * y), [1, 2, 3, 4])
# Output: 24
Modules
• What is a Module?
• Consider a module to be the same as a code
library.
• A file containing a set of functions you want to
include in your application.
Create a Module
• To create a module just save the code you
want in a file with the file extension .py:
• Save this code in a file named mymodule.py
def greeting(name):
print("Hello, " + name)
Use a Module
• Now we can use the module we just created,
by using the import statement
• Import the module named mymodule, and call
the greeting function:
import mymodule
mymodule.greeting("Jonathan")
Variables in Module
• The module can contain functions, as already described, but also variables
of all types (arrays, dictionaries, objects etc)
• Save this code in the file mymodule.py
• person1 = {
"name": "John",
"age": 36,
"country": "Norway"
}
• Import the module named mymodule, and access the person1 dictionary
import mymodule
a = mymodule.person1["age"]
print(a)
Output: 36
Re-naming a Module
• You can create an alias when you import a
module, by using the as keyword:
• import mymodule as mx
Built-in Modules
• There are several built-in modules in Python,
which you can import whenever you like.
• Import and use the platform module:
Pgm:
import platform
x = platform.system()
print(x)
O/p: windows
• globals()-function in Python returns the dictionary of current global symbol table.
• # Python3 program to demonstrate global() function
•
• # global variable
• a=5
• def func():
• c = 10
• d = c + a
• # Calling globals()
• globals()['a'] = d
• print (d)
•
• # Driver Code
• func()
• o/p:15
• The locals() function returns a dictionary
containing the variables defined in the local
namespace
• reload() –another imported module. Actutal
module you have to reload
Python Classes
• Python is an object oriented programming
language.
• Almost everything in Python is an object, with
its properties and methods.
• To create a class, use the keyword class:
Example
• class MyClass:
x=5
Create Object
• Example
• Create an object named p1, and print the
value of x:
• p1 = MyClass()
print(p1.x)
o/p:5
The __init__() Function
• Use the __init__() function to assign values to
object properties, or other operations that are
necessary to do when the object is being
created
• All classes have a function called __init__(),
which is always executed when the class is
being initiated.
example
• class Person:
def __init__(self, name, age):
self.name = name
self.age = age
p1 = Person("John", 36)
print(p1.name)
print(p1.age)
o/p: John 36
Object Methods
• Objects can also contain methods. Methods in
objects are functions that belong to the
object.
example
• class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def myfunc(self):
print("Hello my name is " + self.name)
p1 = Person("John", 36)
p1.myfunc()
o/p:Hello my name is John
