1 .. Objectives |
|
2 .. ---------- |
|
3 |
|
4 .. 8.1 LO: getting started with functions (3) |
|
5 |
|
6 .. At the end of this tutorial, you will be able to |
|
7 |
|
8 .. 1. define function |
|
9 .. #. define functions with arguments |
|
10 .. #. learn about docstrings |
|
11 .. #. learn about return values |
|
12 .. can return multiple values |
|
13 .. #. read code |
|
14 |
|
15 |
|
16 .. Prerequisites |
|
17 .. ------------- |
|
18 |
|
19 .. 1. should have ``ipython`` installed. |
|
20 .. #. getting started with ``ipython``. |
|
21 |
|
22 |
|
23 .. Author : Anoop Jacob Thomas <anoop@fossee.in> |
|
24 Internal Reviewer : |
|
25 External Reviewer : |
|
26 Language Reviewer : Bhanukiran |
|
27 Checklist OK? : <put date stamp here, not OK> [2010-10-05] |
|
28 |
|
29 |
|
30 ============================== |
|
31 Getting started with functions |
|
32 ============================== |
|
33 |
|
34 {{{ show welcome slide }}} |
|
35 |
|
36 Hello and welcome to the tutorial getting started with functions. |
|
37 |
|
38 {{{ switch to next slide, outline slide }}} |
|
39 |
|
40 In this tutorial we will learn about functions in python, how to |
|
41 define functions, arguments to functions, docstrings, and function |
|
42 return value. |
|
43 |
|
44 {{{ switch to next slide, Function }}} |
|
45 |
|
46 While writing code, we always want to reduce the number of lines of |
|
47 code and functions is a way of reusing the code. Thus the same lines |
|
48 of code can be used as many times as needed. A function is a portion of code |
|
49 within a larger program that performs a specific task and is |
|
50 relatively independent of the remaining code. Now let us get more |
|
51 familiar with functions, |
|
52 |
|
53 {{{ switch to next slide, f(x) a mathematical function }}} |
|
54 |
|
55 Consider a mathematical function f(x) = x square. Here x is a variable |
|
56 and with different values of x the value of function will change. When |
|
57 x is one f(1) will return the value 1 and f(2) will return us the |
|
58 value 4. Let us now see how to define the function f(x) in python. |
|
59 |
|
60 {{{ switch to next slide, define f(x) in Python }}} |
|
61 |
|
62 In your Ipython interpreter type the following, |
|
63 :: |
|
64 |
|
65 def f(x): |
|
66 return x*x |
|
67 |
|
68 Well that defined the function, so before learning what we did let us |
|
69 see if it returns the expected values, try, |
|
70 :: |
|
71 |
|
72 f(1) |
|
73 f(2) |
|
74 |
|
75 Yes, it returned 1 and 4 respectively. And now let us see what we did. |
|
76 We wrote two lines: The first line ``def f(x)`` is used to define the |
|
77 name and the parameters to the function and the second line is used to |
|
78 fix what the function is supposed to return. ``def`` is a keyword and |
|
79 ``f`` is the name of the function and ``x`` the parameter of the |
|
80 function. |
|
81 |
|
82 {{{ switch to next slide, problem statement 1 }}} |
|
83 |
|
84 %% 1 %% Write a python function named cube which computes the cube of |
|
85 a given number n. |
|
86 |
|
87 Pause here and try to solve the problem yourself. |
|
88 |
|
89 {{{ switch to next slide, solution }}} |
|
90 |
|
91 The problem can be solved as, |
|
92 :: |
|
93 |
|
94 def cube(n): |
|
95 return n**3 |
|
96 |
|
97 And now let us see how to write functions without arguments. |
|
98 |
|
99 {{{ switch to next slide, greet function }}} |
|
100 |
|
101 let us define a new function called ``greet`` which will print ``Hello |
|
102 World``. |
|
103 :: |
|
104 |
|
105 def greet(): |
|
106 print "Hello World!" |
|
107 |
|
108 now try calling the function, |
|
109 :: |
|
110 |
|
111 greet() |
|
112 |
|
113 Well that is a function which takes no arguments. Also note that it is |
|
114 not mandatory for a function to return values. The function ``greet`` |
|
115 neither takes any argument nor returns any value. |
|
116 |
|
117 Now let us see how to write functions with more than one argument. |
|
118 |
|
119 {{{ switch to next slide, exercise 2 }}} |
|
120 |
|
121 %% 2 %% Write a python function named ``avg`` which computes the |
|
122 average of ``a`` and ``b``. |
|
123 |
|
124 Pause here and try to solve the problem yourself. |
|
125 |
|
126 {{{ switch to next slide, solution 2 }}} |
|
127 |
|
128 The problem can be solved as, |
|
129 :: |
|
130 |
|
131 def avg(a,b): |
|
132 return (a + b)/2 |
|
133 |
|
134 Thus if we want a function to accept more arguments, we just list them |
|
135 separated with a comma between the parenthesis after the function's name |
|
136 in the ``def`` line. |
|
137 |
|
138 {{{ switch to next slide, docstring }}} |
|
139 |
|
140 It is always a good practice to document the code that we write, and |
|
141 for a function we define we should write an abstract of what the |
|
142 function does, and that is called a docstring. Let us modify the |
|
143 function ``avg`` and add docstring to it. Do the following, |
|
144 :: |
|
145 |
|
146 def avg(a,b): |
|
147 """ avg takes two numbers as input (a & b), and |
|
148 returns the average of a and b""" |
|
149 return (a+b)/2 |
|
150 |
|
151 Note that docstrings are entered in the immediate line after the |
|
152 function definition and put as a triple quoted string. And here as far |
|
153 as the code functionality is concerned, we didn't do anything. We just |
|
154 added an abstract of what the function does. |
|
155 |
|
156 Now try this in the ipython interpreter. |
|
157 :: |
|
158 |
|
159 avg? |
|
160 |
|
161 It displays the docstring as we gave it. Thus docstring is a good way |
|
162 of documenting the function we write. |
|
163 |
|
164 Try to do this, |
|
165 :: |
|
166 |
|
167 f? |
|
168 |
|
169 It doesn't have a docstring associated with it. Also we cannot infer |
|
170 anything from the function name, and thus we are forced to read the |
|
171 code to understand about the function. |
|
172 |
|
173 {{{ switch to next slide, exercise 3 }}} |
|
174 |
|
175 %% 3 %% Add docstring to the function f. |
|
176 |
|
177 Pause here and try to do it yourself. |
|
178 |
|
179 {{{ switch to next slide, solution }}} |
|
180 |
|
181 We need to define the function again to add docstring to the function |
|
182 ``f`` and we do it as, |
|
183 :: |
|
184 |
|
185 def f(x): |
|
186 """Accepts a number x as argument and, |
|
187 returns the square of the number x.""" |
|
188 return x*x |
|
189 |
|
190 {{{ switch to next slide, exercise 4 }}} |
|
191 |
|
192 %% 4 %% Write a python function named ``circle`` which returns the |
|
193 area and perimeter of a circle given radius ``r``. |
|
194 |
|
195 Pause here and try to solve the problem yourself. |
|
196 |
|
197 {{{ switch to next slide, solution 4 }}} |
|
198 |
|
199 The problem requires us to return two values instead of one which we |
|
200 were doing till now. We can solve the problem as, |
|
201 :: |
|
202 |
|
203 def circle(r): |
|
204 """returns area and perimeter of a circle given radius r""" |
|
205 pi = 3.14 |
|
206 area = pi * r * r |
|
207 perimeter = 2 * pi * r |
|
208 return area, perimeter |
|
209 |
|
210 A python function can return any number of values. There is no |
|
211 restriction for it. |
|
212 |
|
213 Let us call the function ``circle`` as, |
|
214 :: |
|
215 |
|
216 a, p = circle(6) |
|
217 print a |
|
218 print p |
|
219 |
|
220 Now we have done enough coding, let us do some code reading exercise, |
|
221 |
|
222 {{{ switch to next slide, what }}} |
|
223 |
|
224 What does the function ``what`` do? |
|
225 |
|
226 .. def what( n ): |
|
227 .. if n < 0: n = -n |
|
228 .. while n > 0: |
|
229 .. if n % 2 == 1: |
|
230 .. return False |
|
231 .. n /= 10 |
|
232 .. return True |
|
233 |
|
234 Pause here and try to figure out what the function ``what`` does. |
|
235 |
|
236 {{{ switch to next slide, even_digits }}} |
|
237 |
|
238 .. def even_digits( n ): |
|
239 .. """returns True if all the digits in the number n are even, |
|
240 .. returns False if all the digits in the number n are not even""" |
|
241 .. if n < 0: n = -n |
|
242 .. while n > 0: |
|
243 .. if n % 2 == 1: |
|
244 .. return False |
|
245 .. n /= 10 |
|
246 .. return True |
|
247 |
|
248 The function returns ``True`` if all the digits of the number ``n`` |
|
249 are even, otherwise it returns ``False``. |
|
250 |
|
251 Now one more code reading exercise, |
|
252 |
|
253 {{{ switch to next slide, what }}} |
|
254 |
|
255 What does the function ``what`` do? |
|
256 |
|
257 .. def what( n ): |
|
258 .. i = 1 |
|
259 .. while i * i < n: |
|
260 .. i += 1 |
|
261 .. return i * i == n, i |
|
262 |
|
263 Pause here and try to figure out what the function ``what`` does. |
|
264 |
|
265 {{{ switch to next slide, is_perfect_square }}} |
|
266 |
|
267 .. def is_perfect_square( n ): |
|
268 .. """returns True and square root of n, if n is a perfect square, |
|
269 .. otherwise returns False and the square root of the |
|
270 .. next perfect square""" |
|
271 .. i = 1 |
|
272 .. while i * i < n: |
|
273 .. i += 1 |
|
274 .. return i * i == n, i |
|
275 |
|
276 |
|
277 The function returns ``True`` and the square root of ``n`` if n is a |
|
278 perfect square, otherwise it returns ``False`` and the square root of |
|
279 the next perfect square. |
|
280 |
|
281 This brings us to the end of this tutorial, in this tutorial we covered |
|
282 |
|
283 {{{ switch to next slide, summary }}} |
|
284 |
|
285 - Functions in Python |
|
286 - Passing parameters to a function |
|
287 - Returning values from a function |
|
288 |
|
289 We also did few code reading exercises. |
|
290 |
|
291 {{{ switch to next slide, Thank you }}} |
|
292 |
|
293 Thank you! |
|