# Functions¶

Reusing the same code is required many times within a same program. Functions help us to do so. We write the things we have to do repeatedly in a function then call it where ever required. We already saw build in functions like len(), divmod().

## Defining a function¶

We use def keyword to define a function. General syntax is like

```def functionname(params):
statement1
statement2
```

Let us write a function which will take two integers as input and then return the sum.

```>>> def sum(a, b):
...     return a + b
```

In the second line with the return keyword, we are sending back the value of a + b to the caller. You must call it like

```>>> res = sum(234234, 34453546464)
>>> res
34453780698L
```

Remember the palindrome program we wrote in the last chapter. Let us write a function which will check if a given string is palindrome or not, then return True or False.

```#!/usr/bin/env python
def palindrome(s):
return s == s[::-1]
if __name__ == '__main__':
s = raw_input("Enter a string: ")
if palindrome(s):
print "Yay a palindrome"
else:
print "Oh no, not a palindrome"
```

Now run the code :)

## Local and global variables¶

To understand local and global variables we will go through two examples.

```#!/usr/bin/env python
def change(b):
a = 90
print a
a = 9
print "Before the function call ", a
print "inside change function",
change(a)
print "After the function call ", a
```

The output

```\$ ./local.py
Before the function call  9
inside change function 90
After the function call  9
```

First we are assigning 9 to a, then calling change function, inside of that we are assigning 90 to a and printing a. After the function call we are again printing the value of a. When we are writing a = 90 inside the function, it is actually creating a new variable called a, which is only available inside the function and will be destroyed after the function finished. So though the name is same for the variable a but they are different in and out side of the function.

```#!/usr/bin/env python
def change(b):
global a
a = 90
print a
a = 9
print "Before the function call ", a
print "inside change function",
change(a)
print "After the function call ", a
```

Here by using global keyword we are telling that a is globally defined, so when we are changing a’s value inside the function it is actually changing for the a outside of the function also.

## Default argument value¶

In a function variables may have default argument values, that means if we don’t give any value for that particular variable it will assigned automatically.

```>>> def test(a , b=-99):
...     if a > b:
...         return True
...     else:
...         return False
```

In the above example we have written b = -99 in the function parameter list. That means of no value for b is given then b’s value is -99. This is a very simple example of default arguments. You can test the code by

```>>> test(12, 23)
False
>>> test(12)
True
```

Important

Important

Remember that you can not have an argument without default argument if you already have one argument with default values before it. Like f(a, b=90, c) is illegal as b is having a default value but after that c is not having any default value.

Also remember that default value is evaluated only once, so if you have any mutable object like list it will make a difference. See the next example

```>>> def f(a, data=[]):
...     data.append(a)
...     return data
...
>>> print f(1)

>>> print f(2)
[1, 2]
>>> print f(3)
[1, 2, 3]
```

To avoid this you can write more idiomatic Python, like the following

```>>> def f(a, data=None):
...     if data is None:
...         data = []
...         data.append(a)
...         return data
...
>>> print f(1)

>>> print f(2)

```

Note

## Keyword arguments¶

```>>> def func(a, b=5, c=10):
...     print 'a is', a, 'and b is', b, 'and c is', c
...
>>> func(12, 24)
a is 12 and b is 24 and c is 10
>>> func(12, c = 24)
a is 12 and b is 5 and c is 24
>>> func(b=12, c = 24, a = -1)
a is -1 and b is 12 and c is 24
```

In the above example you can see we are calling the function with variable names, like func(12, c = 24), by that we are assigning 24 to c and b is getting its default value. Also remember that you can not have without keyword based argument after a keyword based argument. like

```>>> def func(a, b=13, v):
...     print a, b, v
...
File "<stdin>", line 1
SyntaxError: non-default argument follows default argument
```

## Docstrings¶

In Python we use docstrings to explain how to use the code, it will be useful in interactive mode and to create auto-documentation. Below we see an example of the docstring for a function called longest_side.

```#!/usr/bin/env python
import math

def longest_side(a, b):
"""
Function to find the length of the longest side of a right triangle.

:arg a: Side a of the triangle
:arg b: Side b of the triangle

:return: Length of the longest side c as float
"""
return math.sqrt(a*a + b*b)

if __name__ == '__main__':
print longest_side(4, 5)
```

We will learn more on docstrings in reStructuredText chapter.

## Higher-order function¶

Higher-order function or a functor is a function which does at least one of the following step inside:

• Takes one or more functions as argument.
• Returns another function as output.

In Python any function can act as higher order function.

```>>> def high(func, value):
...     return func(value)
...
>>> lst = high(dir, int)
>>> print lst[-3:]
['imag', 'numerator', 'real']
>>> print lst
```

Note

## map function¶

map is a very useful higher order function in Python. It takes one function and an iterator as input and then applies the function on each value of the iterator and returns a list of results.

Example:

```>>> lst = [1, 2, 3, 4, 5]
>>> def square(num):
...     "Returns the square of a given number."
...     return num * num
...
>>> print map(square, lst)
[1, 4, 9, 16, 25]
```