<a href="#id2813580">

        Functional Approach

         <a href="#id2864618">

          1. Function scope

         <a href="#id2864676">

          2. Default Arguments

         <a href="#id2864716">

          3. Keyword Arguments

         </a>

        </span>

       </dt>

       <dt>

        <span class="section">

         <a href="#id2864832">

          4. Parameter Packing and Unpacking

         </a>

        </span>

       </dt>

       <dt>

        <span class="section">

         <a href="#id2864932">

          5. Nested Functions and Scopes

         </a>

        </span>

       </dt>

       <dt>

        <span class="section">

         <a href="#id2864984">

          6. map, reduce and filter functions

           <a href="#id2865174">

            6.1. List Comprehensions

   <div class="article" title="Functional Approach">

       <h2 class="title">

        <a name="id2813580">

        </a>

        Functional Approach

        <a href="#id2864618">

         1. Function scope

        <a href="#id2864676">

         2. Default Arguments

        <a href="#id2864716">

         3. Keyword Arguments

        <a href="#id2864832">

         4. Parameter Packing and Unpacking

        <a href="#id2864932">

         5. Nested Functions and Scopes

        <a href="#id2864984">

         6. map, reduce and filter functions

          <a href="#id2865174">

           6.1. List Comprehensions

    <p id="ch5func_1">

     <span class="emphasis">

      <em>

       Functions

      </em>

     </span>

     allow us to enclose a set of statements and call the function again

and again instead of repeating the group of statements everytime. Functions also

allow us to isolate a piece of code from all the other code and provides the

convenience of not polluting the global variables.

    </p>

    <p id="ch5func_2">

     <span class="emphasis">

      <em>

       Function

      </em>

     </span>

     in python is defined with the keyword

     <span class="strong">

      <strong>

       def

      </strong>

     </span>

     followed by the name

of the function, in turn followed by a pair of parenthesis which encloses the

list of parameters to the function. The definition line ends with a ':'. The

definition line is followed by the body of the function intended by one block.

The

     <span class="emphasis">

      <em>

       Function

      </em>

     </span>

     must return a value:

    </p>

    <pre class="programlisting">

     def factorial(n):

  fact = 1

  for i in range(2, n):

    fact *= i

  return fact

    </pre>

    <p id="ch5func_3">

     The code snippet above defines a function with the name factorial, takes the

number for which the factorial must be computed, computes the factorial and

returns the value.

    </p>

    <p id="ch5func_4">

     A

     <span class="emphasis">

      <em>

       Function

      </em>

     </span>

     once defined can be used or called anywhere else in the program. We

call a fucntion with its name followed by a pair of parenthesis which encloses

the arguments to the function.

    </p>

    <p id="ch5func_5">

     The value that function returns can be assigned to a variable. Let's call the

above function and store the factorial in a variable:

    </p>

    <pre class="programlisting">

     fact5 = factorial(5)

    </pre>

    <p id="ch5func_6">

     The value of fact5 will now be 120, which is the factorial of 5. Note that we

passed 5 as the argument to the function.

    </p>

    <p id="ch5func_7">

     It may be necessary to document what the function does, for each of the function

to help the person who reads our code to understand it better. In order to do

this Python allows the first line of the function body to be a string. This

string is called as

     <span class="emphasis">

      <em>

       Documentation String

      </em>

     </span>

     or

     <span class="emphasis">

      <em>

       docstring

      </em>

     </span>

     .

     <span class="emphasis">

      <em>

       docstrings

      </em>

     </span>

     prove

to be very handy since there are number of tools which can pull out all the

docstrings from Python functions and generate the documentation automatically

from it.

     <span class="emphasis">

      <em>

       docstrings

      </em>

     </span>

     for functions can be written as follows:

    </p>

    <pre class="programlisting">

     def factorial(n):

  'Returns the factorial for the number n.'

  fact = 1

  for i in range(2, n):

    fact *= i

  return fact

    </pre>

    <p id="ch5func_8">

     An important point to note at this point is that, a function can return any

Python value or a Python object, which also includes a

     <span class="emphasis">

      <em>

       Tuple

      </em>

     </span>

     . A

     <span class="emphasis">

      <em>

       Tuple

      </em>

     </span>

     is

just a collection of values and those values themselves can be of any other

valid Python datatypes, including

     <span class="emphasis">

      <em>

       Lists

      </em>

     </span>

     ,

     <span class="emphasis">

      <em>

       Tuples

      </em>

     </span>

     ,

     <span class="emphasis">

      <em>

       Dictionaries

      </em>

     </span>

     among other

things. So effectively, if a function can return a tuple, it can return any

number of values through a tuple

    </p>

    <p id="ch5func_9">

     Let us write a small function to swap two values:

    </p>

    <pre class="programlisting">

     def swap(a, b):

  return b, a

c, d = swap(a, b)

    </pre>

    <div class="section" title="1.Function scope">

         <a name="id2864618">

         1.Function scope

     <p id="ch5func_a">

      The variables used inside the function are confined to the function's scope

and doesn't pollute the variables of the same name outside the scope of the

function. Also the arguments passed to the function are passed by-value if

it is of basic Python data type:

     </p>

     <pre class="programlisting">

      def cant_change(n):

  n = 10

n = 5

cant_change(n)

     </pre>

     <p id="ch5func_b">

      Upon running this code, what do you think would have happened to value of n

which was assigned 5 before the function call? If you have already tried out

that snippet on the interpreter you already know that the value of n is not

changed. This is true of any immutable types of Python like

      <span class="emphasis">

       <em>

        Numbers

       </em>

      </span>

      ,

      <span class="emphasis">

       <em>

        Strings

       </em>

      </span>

      and

      <span class="emphasis">

       <em>

        Tuples

       </em>

      </span>

      . But when you pass mutable objects like

      <span class="emphasis">

       <em>

        Lists

       </em>

      </span>

      and

      <span class="emphasis">

       <em>

        Dictionaries

       </em>

      </span>

      the values are manipulated even outside the function:

     </p>

     <pre class="programlisting">

      >>> def can_change(n):

...   n[1] = James

...

>>> name = ['Mr.', 'Steve', 'Gosling']

>>> can_change(name)

>>> name

['Mr.', 'James', 'Gosling']

     </pre>

     <p id="ch5func_c">

      If nothing is returned by the function explicitly, Python takes care to return

None when the funnction is called.

     </p>

    <div class="section" title="2.Default Arguments">

         <a name="id2864676">

         2.Default Arguments

     <p id="ch5func_d">

      There may be situations where we need to allow the functions to take the

arguments optionally. Python allows us to define function this way by providing

a facility called

      <span class="emphasis">

       <em>

        Default Arguments

       </em>

      </span>

      . For example, we need to write a function

that returns a list of fibonacci numbers. Since our function cannot generate an

infinite list of fibonacci numbers, we need to specify the number of elements

that the fibonacci sequence must contain. Suppose, additionally, we want to the

function to return 10 numbers in the sequence if no option is specified we can

define the function as follows:

      def fib(n=10):

  fib_list = [0, 1]

  for i in range(n - 2):

    next = fib_list[-2] + fib_list[-1]

    fib_list.append(next)

  return fib_list

     <p id="ch5func_e">

      When we call this function, we can optionally specify the value for the

parameter n, during the call as an argument. Calling with no argument and

argument with n=5 returns the following fibonacci sequences:

      fib()

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

fib(5)

[0, 1, 1, 2, 3]

    <div class="section" title="3.Keyword Arguments">

         <a name="id2864716">

         3.Keyword Arguments

     <p id="ch5func_f">

      When a function takes a large number of arguments, it may be difficult to

remember the order of the parameters in the function definition or it may

be necessary to pass values to only certain parameters since others take

the default value. In either of these cases, Python provides the facility

of passing arguments by specifying the name of the parameter as defined in

the function definition. This is known as

      <span class="emphasis">

       <em>

        Keyword Arguments

       </em>

      </span>

      .

     </p>

     <p id="ch5func_10">

      In a function call,

      <span class="emphasis">

       <em>

        Keyword arguments

       </em>

      </span>

      can be used for each argument, in the

following fashion:

     </p>

     <pre class="programlisting">

      argument_name=argument_value

Also denoted as: keyword=argument

def wish(name='World', greetings='Hello'):