Movatterモバイル変換

Presented byV Babu RavipatiUnit -3

2Functions1. Reusability2. Easy debugging

14. Python - FunctionsA function is a block of organized, reusable code that is used to perform a single,related action. Functions provides better modularity for your application and a highdegree of code reusing.As you already know, Python gives you many built-in functions like print() etc. but youcan also create your own functions. These functions are called user-defined functions.

Defining a FunctionHere are simple rules to define a function in Python:• Function blocks begin with the keyword def followed by thefunction name (shouldnot be keyword) and parentheses ( ) .• Any input parameters or arguments should be placed withinthese parentheses. You can also define parameters orarguments inside these parentheses.• The first statement of a function can be an optional statement- the documentation string of the function or docstring.• The code block within every function starts with a colon (:) andis indented.• The statement return [expression] exits a function, optionallypassing back an expression to the caller. A return statementwith no arguments is the same as return None.

Syntax:def functionname( parameters ):"function_docstring“function_suite[expression]returnExampleDef add(a,b):sum=a+breturn suma=int(input(“enter first number”))b=int(input(“enter second number”))res=add(a,b)print(“result = “res)

Function Arguments:A function by using the following types of formal arguments::• Required arguments• Keyword arguments• Default arguments• Variable-length argumentsRequired arguments:Required arguments are the arguments passed to a function in correct positional order.def printme( name, age):print ("Name: ", name)print ("Age ", age)return;printme(name=“Ramu”, age=29);This would produce following result:Name: RamuAge 29

Keyword arguments:• Keyword arguments are related to the function calls.When you use keyword arguments in a function call,the caller identifies the arguments by the parametername.• This allows you to skip arguments or place them outof order because the Python interpreter is able touse the keywords provided to match the values withparameters.

Following example gives more clear picture. Note, here order of the parameterdoes not matter:def printinfo( name, age ): "Test function"print ("Name: ", name)print ("Age ", age)returnprintinfo(age=50, name="miki" )This would produce following result:Name: miki Age 50

Default arguments:A default argument is an argument that assumes a default value if a value isnot provided in the function call for that argument.Following example gives idea on default arguments, it would print default ageif it is not passed:def printinfo( name, age = 35 ): “Test function"print ("Name: ", name)print ("Age ", age)returnprintinfo( age=50, name="miki" )printinfo( name="miki" )This would produce following result:Name: miki Age 50 Name: miki Age 35

Variable-length arguments:You may need to process a function for more arguments than you specifiedwhile defining the function. These arguments are called variable-lengtharguments and are not named in the function definition, unlike required anddefault arguments.The general syntax for a function with non-keyword variable arguments is this:def functionname([formal_args,] *var_args_tuple ):"function_docstring"function_suitereturn [expression]

An asterisk (*) is placed before the variable name that will hold the values ofall nonkeyword variable arguments. This tuple remains empty if no additionalarguments are specified during the function call. For example:def printinfo( arg1, *vartuple ):"This is test"print ("Output is: “)print (arg1)for var in vartuple:print varreturnprintinfo( 10 )printinfo( 70, 60, 50 )This would produce following result:Output is:10Output is:706050

Lambda FunctionLambda functions are also called anonymousfunctions. An anonymous function is afunction defined without a name. As weknow to define a normal function in python,we need to use the def keyword. But in thiscase of anonymous functions, we use thelambda keyword to define the functions.

The characteristics of lambda function• The lambda function can take manyarguments but can return only one expression.• Syntactically, lambda functions are restrictedto only a single expression.• We can use them as an anonymous functioninside other functions.• Lambda function is reusable.

Why should we use lambda functions?Lambda functions are used when weneed a function for a short period oftime. This is commonly used when wewant to pass a function as an argumentto higher-order functions, that is,functions that take other functions astheir arguments

Why should we use lambda functions?

17Fruitful FunctionsProperties of Fruitful functions are1. Return Value2. Incremental Development3. Composition4. Boolean type

1.Return Valuedef sum()a=10b=15c=a+bprint(c)Sum()def sum(a,b)c=a+breturn cPrint(sum(10,15))

def area(radius):temp = 3.14159 * radius**2return tempdef area(radius):return 3.14159 * radius**2Sometimes it is useful to have multiple return statements, one in each branch of aconditional.def absolute_value(x):if x < 0:return -xelse:return x

2.Incremental developmentTo deal with increasingly complex programs, we aregoing to suggest a technique called incrementaldevelopment. The goal of incremental development is toavoid long debugging sessions by adding and testingonly a small amount of code at a time.As an example, suppose you want to find the distancebetween two points, given by the coordinates (x1, y1)and (x2, y2). By the Pythagorean theorem, the distanceis:

def distance(x1, y1, x2, y2):"""Return the distance between points(x1, y1) and (x2, y2) as a float"""return 0.0

def distance(x1, y1, x2, y2):"""Return the distance between points(x1, y1) and (x2, y2) as a float"""dx = x2 - x1dy = y2 - y1print 'dx is ', dxprint 'dy is ', dyreturn 0.0

def distance(x1, y1, x2, y2):"""Return the distance between points(x1, y1) and (x2, y2) as a float"""dx, dy = x2 - x1, y2 - y1result =(dx**2 + dy**2)**0.5return result

def distance(x1, y1, x2, y2):"""Return the distance between points(x1, y1) and (x2, y2) as a float"""result =((x2-x1)**2 + (y2-y1)**2)**0.5return result

def distance(x1, y1, x2, y2):"""Return the distance between points(x1, y1) and (x2, y2) as a float"""return((x2-x1)**2 + (y2-y1)**2)**0.5

The key aspects of the process are:1. Start with a working program and make smallincremental changes. At any point, if there is an error,you will know exactly where it is.2. Use temporary variables to hold intermediate valuesso you can output and check them.3. Once the program is working, you might want toremove some of the scaffolding or consolidatemultiple statements into compound expressions, butonly if it does not make the program difficult to read.

3.CompositionAs you should expect by now, you can call one functionfrom within another. This ability is called composition.def area2(xc, yc, xp, yp):radius = distance(xc, yc, xp, yp)result = area(radius)return resultdef area2(xc, yc, xp, yp):return area(distance(xc, yc, xp, yp))

4.Creating Boolean functionsFunctions that return a Boolean value(True or False) can be used inconditional statements (i.e. if…else…)05/02/09Python Mini-Course: Day 2 - Lesson 828

is_divisible functiondef is_divisible(x, y):if x % y == 0:return Trueelse:return Falseis_divisible(16,4)is_divisible(16,3)05/02/09Python Mini-Course: Day 2 - Lesson 829

Scope of Variables:All variables in a program may not be accessible at all locations in that program. Thisdepends on where you have declared a variable.The scope of a variable determines the portion of the program where you can access aparticular identifier. There are two basic scopes of variables in Python:Global variablesLocal variablesGlobal vs. Local variables:Variables that are defined inside a function body have a local scope, and those definedoutside have a global scope.This means that local variables can be accessed only inside the function in which theyare declared whereas global variables can be accessed throughout the program body byall functions. When you call a function, the variables declared inside it are brought intoscope.

Example:total = 0; # This is global variable.def sum( arg1, arg2 ):"Add both the parameters"total = arg1 + arg2;print "Inside the function local total : ", totalreturn total;# Now you can call sum functionsum( 10, 20 );print "Outside the function global total : ", totalThis would produce following result:Inside the function local total : 30Outside the function global total : 0

There is one more example where argument is being passed by reference but inside thefunction, but the reference is being over-written.def changeme( mylist ): "This changes a passed list"mylist = [1,2,3,4];print("Values inside the function: ", mylist)returnmylist = [10,20,30];changeme( mylist );Print("Values outside the function: ", mylist)The parameter mylist is local to the function changeme. Changing mylist within the functiondoes not affect mylist. The function accomplishes nothing and finally this would producefollowing result:Values inside the function: [1, 2, 3, 4]Values outside the function: [10, 20, 30]

Pass by reference vs valueAll parameters (arguments) in the Python language are passed by reference. It means ifyou change what a parameter refers to within a function, the change also reflects backin the calling function. For example:def changeme( mylist ): "This changes a passed list“mylist.append([1,2,3,4]);print ("Values inside the function: ", mylist)returnmylist = [10,20,30];changeme( mylist );print ("Values outside the function: ", mylist)So this would produce following result:Values inside the function: [10, 20, 30, [1, 2, 3, 4]]Values outside the function: [10, 20, 30, [1, 2, 3, 4]]

JNTUK python programming python unit 3.pptx

Movatterモバイル変換

Change Language

JNTUK python programming python unit 3.pptx

Embed presentation

Recommended

More Related Content

Similar to JNTUK python programming python unit 3.pptx

More from Venkateswara Babu Ravipati

Recently uploaded

JNTUK python programming python unit 3.pptx