1 ========

     2  Script

     3 ========

     4 

     5 {{{ show the welcome slide }}}

     6 

     7 Welcome to the tutorial on advanced feature of functions. 

     8 

     9 {{{ show the outline slide }}}

    10 

    11 In this tutorial we shall be looking at specifying default arguments

    12 to functions when defining them and calling functions using keyword

    13 arguments. We shall also, look at some of the built-in functions

    14 available in the standard library of Python.

    15 

    16 {{{ switch to terminal }}}

    17 

    18 We have an ``ipython`` terminal open, which we shall be using through

    19 out this session. 

    20 

    21 Let's use the ``round`` function as an example to understand what a

    22 default value of an argument means. Let's type the following

    23 expressions in the terminal. 

    24 

    25 ::

    26 

    27   round(2.484)

    28 

    29   round(2.484, 2)

    30 

    31 Both the first expression and the second are calls to the ``round``

    32 function, but the first calls it with only one argument and the second

    33 calls it with two arguments. By observing the output, we can guess

    34 that the first one is equivalent to call with the second argument

    35 being 0. 0 is the default value of the argument. 

    36 

    37 {{{ show a slide with examples of functions showing default values }}}

    38 ::

    39 

    40   s.strip() # strips on spaces. 

    41   s.strip('@') # strips the string of '@' symbols.

    42 

    43   plot(x, y) # plots with x vs. y using default line style. 

    44   plot(x, y, 'o') # plots x vs. y with circle markers. 

    45 

    46   linspace(0, 2*pi, 100) # returns 100 points between 0 and 2pi

    47   linspace(0, 2*pi) # returns 50 points between 0 and 2pi

    48 

    49 #[punch: all above content goes on to a slide]

    50 

    51 {{{ switch back to ipython }}}

    52 

    53 Let's now define a simple function that uses default arguments. We

    54 define a simple function that prints a welcome message to a person,

    55 given a greeting and his/her name.

    56 

    57 ::

    58 

    59   def welcome(greet, name="World"):

    60       print greet, name

    61 

    62 Let us first call the function with two arguments, one for ``greet``

    63 and other for ``name``.

    64 

    65 ::

    66 

    67   welcome("Hi", "Guido")          

    68 

    69 We get the expected welcome message, "Hi Guido". 

    70 

    71 Now let us call the function with just one argument "Hello". 

    72 ::

    73 

    74   welcome("Hello")

    75 

    76 "Hello" is treated as the ``greet`` and we get "Hello World" as

    77 the output. "World" is the default value for the argument ``name``. 

    78 

    79 E%% %% Pause the video here and redefine the function ``welcome``, by

    80 interchanging it's arguments. Place the ``name`` argument with it's

    81 default value of "Hello" before the ``greet`` argument. Then, resume

    82 the video. 

    83 

    84 ::

    85 

    86   def welcome(name="World", greet):

    87       print greet, name

    88 

    89 We get an error that reads ``SyntaxError: non-default argument follows

    90 default argument``. When defining a function all the argument with

    91 default values should come at the end. 

    92 

    93 E%% %% Pause the video here and type ``linspace?`` to see the

    94 definition of the command and notice how all the arguments with

    95 default values are towards the end.

    96 

    97 ::

    98 

    99   linspace?

   100 

   101 E%% %% Pause the video here and redefine the function ``welcome`` with

   102 a default value of "Hello" to the ``greet`` argument. Then, call the

   103 function without any arguments. Then, resume the video. 

   104 

   105 ::

   106 

   107   def welcome(greet="Hello", name="World"):

   108       print greet, name

   109  

   110 

   111   welcome()

   112 

   113 

   114 Let us now learn what keyword arguments are. 

   115 

   116 {{{ show a slide with examples using keyword arguments. }}}

   117 ::

   118 

   119   legend(['sin(2y)'], loc = 'center')

   120 

   121   plot(y, sin(y), 'g', linewidth = 2)

   122 

   123   annotate('local max', xy = (1.5, 1))

   124 

   125   pie(science.values(), labels = science.keys())

   126 

   127 When you are calling functions in Python, you don't need to remember

   128 the order in which to pass the arguments. Instead, you can use the

   129 name of the argument to pass it a value. This slide shows a few

   130 function calls that use keyword arguments. ``loc``, ``linewidth``,

   131 ``xy`` and ``labels`` are being called with keyword arguments. 

   132 

   133 {{{ switch to ipython terminal }}}

   134 

   135 Let us try and understand this better using the ``welcome`` function

   136 that we have been using all along. Let us call it in different ways

   137 and observe the output to see how keyword arguments work. 

   138 

   139 ::

   140 

   141   welcome()

   142 

   143   welcome("Hello", "James")

   144 

   145   welcome("Hi", name="Guido")

   146 

   147 When no keyword is specified, the arguments are allotted based on

   148 their position. So, "Hi" is the value of the argument ``greet`` and

   149 name is passed the value "Guido". 

   150 ::

   151 

   152   welcome(name="Guido", greet="Hey! ")

   153 

   154 When keyword arguments are used, the arguments can be called in any

   155 order. 

   156 

   157 ::

   158 

   159   welcome(name="Guido", "Hey")

   160 

   161 This call returns an error that reads, ``non keyword arg after keyword

   162 arg``. Python expects all the keyword to be present towards the end. 

   163 

   164 That brings us to the end of what we wanted to learn about ``keyword``

   165 arguments. 

   166 

   167 {{{ switch to a slide showing variety of functions with uses }}}

   168 

   169 Before defining a function of your own, make sure that you check the

   170 standard library, for a similar function. Python is popularly called a

   171 "Batteries included" language, for the huge library that comes along

   172 with it. 

   173 

   174 ::

   175 

   176   Math functions - abs, sin, ....

   177 

   178 #[punch: Need to decide, exactly what to put here. Reviewer comments

   179  welcome.] 

   180   

   181 

   182 {{{ switch to slide showing classes of functions in pylab, scipy }}}

   183 

   184 Apart from the standard library there are other libraries like ``pylab``,

   185 ``scipy``, etc which have a huge collection of functions for scientific

   186 purposes. 

   187 ::

   188 

   189   pylab

   190     plot, bar, contour, boxplot, errorbar, log, polar, quiver, semilog

   191 

   192   scipy (modules)

   193     fftpack, stats, linalg, ndimage, signal, optimize, integrate

   194 

   195 {{{ switch slide to summary slide }}}

   196 

   197 That brings us to the end of this tutorial. In this tutorial we have

   198 learnt how to use functions with default values and keyword

   199 arguments. We also looked at the range of functions available in the

   200 Python standard library and the Scientific Computing related

   201 packages. 

   202 

   203 Thank You!