|
1 .. Objectives |
|
2 .. ---------- |
|
3 |
|
4 .. At the end of this tutorial, you will be able to |
|
5 |
|
6 .. 1. Assign default values to arguments, when defining functions |
|
7 .. 2. Define and call functions with keyword arguments. |
|
8 .. 3. Also, you will get a glimpse of the plethora of functions |
|
9 .. available, in Python standard library and the scientific computing |
|
10 .. libraries. |
|
11 |
|
12 |
|
13 .. Prerequisites |
|
14 .. ------------- |
|
15 |
|
16 .. 1. getting started with ipython |
|
17 .. #. getting started with functions |
|
18 |
|
19 .. Author : Puneeth |
|
20 Internal Reviewer : Anoop Jacob Thomas<anoop@fossee.in> |
|
21 External Reviewer : |
|
22 Language Reviewer : Bhanukiran |
|
23 Checklist OK? : <put date stamp here, if OK> [2010-10-05] |
|
24 |
|
25 Script |
|
26 ------ |
|
27 |
|
28 {{{ Show the slide containing title }}} |
|
29 |
|
30 Welcome to the tutorial on advanced feature of functions. |
|
31 |
|
32 {{{ Show the outline slide }}} |
|
33 |
|
34 In this tutorial we shall be looking at specifying default arguments |
|
35 to functions when defining them and calling functions using keyword |
|
36 arguments. We shall also, look at some of the built-in functions |
|
37 available in the standard library of Python and the scientific |
|
38 computing libraries. |
|
39 |
|
40 {{{ switch to terminal }}} |
|
41 |
|
42 We have an ``ipython`` terminal open, which we shall be using through |
|
43 out this session. |
|
44 |
|
45 Let's use the ``round`` function as an example to understand what a |
|
46 default value of an argument means. Let's type the following |
|
47 expressions in the terminal. |
|
48 |
|
49 :: |
|
50 |
|
51 round(2.484) |
|
52 |
|
53 round(2.484, 2) |
|
54 |
|
55 Both the first expression and the second are calls to the ``round`` |
|
56 function, but the first calls it with only one argument and the second |
|
57 calls it with two arguments. By observing the output, we can guess |
|
58 that the first one is equivalent to call with the second argument |
|
59 being 0. 0 is the default value of the argument. |
|
60 |
|
61 .. #[[Anoop: It will be good if we show ``round??`` and tell them the |
|
62 optional argument ndigits, or it could be given as an |
|
63 exercise(solved) asking them to find the name of the argument in |
|
64 the function round]] |
|
65 |
|
66 {{{ show a slide with examples of functions showing default values }}} |
|
67 |
|
68 .. #[[Anoop: I think the slide is not there]] |
|
69 |
|
70 :: |
|
71 |
|
72 s.strip() # strips on spaces. |
|
73 s.strip('@') # strips the string of '@' symbols. |
|
74 |
|
75 plot(x, y) # plots with x vs. y using default line style. |
|
76 plot(x, y, 'o') # plots x vs. y with circle markers. |
|
77 |
|
78 linspace(0, 2*pi, 100) # returns 100 points between 0 and 2pi |
|
79 linspace(0, 2*pi) # returns 50 points between 0 and 2pi |
|
80 |
|
81 .. #[punch: all above content goes on to a slide] |
|
82 |
|
83 {{{ switch back to ipython }}} |
|
84 |
|
85 Let's now define a simple function that uses default arguments. We |
|
86 define a simple function that prints a welcome message to a person, |
|
87 given a greeting and his/her name. |
|
88 |
|
89 :: |
|
90 |
|
91 def welcome(greet, name="World"): |
|
92 print greet, name |
|
93 |
|
94 Let us first call the function with two arguments, one for ``greet`` |
|
95 and other for ``name``. |
|
96 |
|
97 :: |
|
98 |
|
99 welcome("Hi", "Guido") |
|
100 |
|
101 We get the expected welcome message, "Hi Guido". |
|
102 |
|
103 Now let us call the function with just one argument "Hello". |
|
104 :: |
|
105 |
|
106 welcome("Hello") |
|
107 |
|
108 "Hello" is treated as the ``greet`` and we get "Hello World" as |
|
109 the output. "World" is the default value for the argument ``name``. |
|
110 |
|
111 Following is an (are) exercise(s) that you must do. |
|
112 |
|
113 {{{ switch to next slide, containing problem statement of |
|
114 question 1 }}} |
|
115 |
|
116 %%1%% Redefine the function ``welcome``, by interchanging it's |
|
117 arguments. Place the ``name`` argument with it's default value of |
|
118 "World" before the ``greet`` argument. |
|
119 |
|
120 Please, pause the video here. Do the exercise and then continue. |
|
121 |
|
122 {{{ switch to next slide, containing the solution to problem 1 }}} |
|
123 |
|
124 :: |
|
125 |
|
126 def welcome(name="World", greet): |
|
127 print greet, name |
|
128 |
|
129 We get an error that reads ``SyntaxError: non-default argument follows |
|
130 default argument``. When defining a function all the argument with |
|
131 default values should come at the end. |
|
132 |
|
133 .. #[[Anoop: In the slide, "when defining a function all the default |
|
134 arguments must be defined at the end" has to be emphasized"]] |
|
135 |
|
136 Following is an exercise that you must do. |
|
137 |
|
138 {{{ switch to next slide, containing the problem statement of |
|
139 question 2 }}} |
|
140 |
|
141 %%2%% See the definition of linspace using ``?`` and observe how all |
|
142 the arguments with default values are towards the end. |
|
143 |
|
144 Please, pause the video here. Do the exercise and then continue. |
|
145 |
|
146 {{{ switch to next slide, containing solution to problem 2 }}} |
|
147 |
|
148 :: |
|
149 |
|
150 linspace? |
|
151 |
|
152 Following is an exercise that you must do. |
|
153 |
|
154 {{{ switch to next slide, problem statement }}} |
|
155 |
|
156 %%3%% Redefine the function ``welcome`` with a default value of |
|
157 "Hello" to the ``greet`` argument. Then, call the function without any |
|
158 arguments. |
|
159 |
|
160 Please, pause the video here. Do the exercise and then continue. |
|
161 |
|
162 {{{ switch to next slide, solution }}} |
|
163 |
|
164 :: |
|
165 |
|
166 def welcome(greet="Hello", name="World"): |
|
167 print greet, name |
|
168 |
|
169 |
|
170 welcome() |
|
171 |
|
172 |
|
173 Let us now learn what keyword arguments or named arguments are. We |
|
174 shall refer to them as keyword arguments, henceforth. |
|
175 |
|
176 {{{ show a slide with examples using keyword arguments. }}} |
|
177 |
|
178 .. #[[Anoop: slide is missing]] |
|
179 |
|
180 :: |
|
181 |
|
182 legend(['sin(2y)'], loc = 'center') |
|
183 |
|
184 plot(y, sin(y), 'g', linewidth = 2) |
|
185 |
|
186 annotate('local max', xy = (1.5, 1)) |
|
187 |
|
188 pie(science.values(), labels = science.keys()) |
|
189 |
|
190 When you are calling functions in Python, you don't need to remember |
|
191 the order in which to pass the arguments. Instead, you can use the |
|
192 name of the argument to pass it a value. This slide shows a few |
|
193 function calls that use keyword arguments. ``loc``, ``linewidth``, |
|
194 ``xy`` and ``labels`` are being called with keyword arguments. |
|
195 |
|
196 {{{ switch to ipython terminal }}} |
|
197 |
|
198 Let us try and understand this better using the ``welcome`` function |
|
199 that we have been using all along. Let us call it in different ways |
|
200 and observe the output to see how keyword arguments work. |
|
201 |
|
202 :: |
|
203 |
|
204 welcome() |
|
205 |
|
206 welcome("Hello", "James") |
|
207 |
|
208 welcome("Hi", name="Guido") |
|
209 |
|
210 When no keyword is specified, the arguments are allotted based on |
|
211 their position. So, "Hi" is the value of the argument ``greet`` and |
|
212 name is passed the value "Guido". |
|
213 :: |
|
214 |
|
215 welcome(name="Guido", greet="Hey! ") |
|
216 |
|
217 When keyword arguments are used, the arguments can be called in any |
|
218 order. |
|
219 |
|
220 :: |
|
221 |
|
222 welcome(name="Guido", "Hey") |
|
223 |
|
224 This call returns an error that reads, ``non keyword arg after keyword |
|
225 arg``. Python expects all the keyword to be present towards the end. |
|
226 |
|
227 That brings us to the end of what we wanted to learn about ``keyword`` |
|
228 arguments. |
|
229 |
|
230 {{{ switch to a slide showing variety of functions with uses }}} |
|
231 |
|
232 .. #[[Anoop: slide missing]] |
|
233 |
|
234 Before defining a function of your own, make sure that you check the |
|
235 standard library, for a similar function. Python is popularly called a |
|
236 "Batteries included" language, for the huge library that comes along |
|
237 with it. |
|
238 |
|
239 :: |
|
240 |
|
241 Math functions - abs, sin, .... |
|
242 |
|
243 .. #[punch: Need to decide, exactly what to put here. Reviewer comments |
|
244 .. welcome.] |
|
245 |
|
246 {{{ switch to slide showing classes of functions in pylab, scipy }}} |
|
247 |
|
248 .. #[[Anoop: slide missing]] |
|
249 |
|
250 Apart from the standard library there are other libraries like ``pylab``, |
|
251 ``scipy``, etc which have a huge collection of functions for scientific |
|
252 purposes. |
|
253 :: |
|
254 |
|
255 pylab |
|
256 plot, bar, contour, boxplot, errorbar, log, polar, quiver, semilog |
|
257 |
|
258 scipy (modules) |
|
259 fftpack, stats, linalg, ndimage, signal, optimize, integrate |
|
260 |
|
261 {{{ Show summary slide }}} |
|
262 |
|
263 .. #[[Anoop: add range of functions available in python standard |
|
264 library]] |
|
265 |
|
266 That brings us to the end of this tutorial. In this tutorial we have |
|
267 learnt how to use functions with default values and keyword |
|
268 arguments. We also looked at the range of functions available in the |
|
269 Python standard library and the Scientific Computing related |
|
270 packages. |
|
271 |
|
272 {{{ Show the "sponsored by FOSSEE" slide }}} |
|
273 |
|
274 This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India |
|
275 |
|
276 Hope you have enjoyed and found it useful. |
|
277 Thank you! |