1 <html> |
|
2 <head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> |
|
3 <title>Chapter 9. Finding and fixing mistakes</title> |
|
4 <link rel="stylesheet" href="/support/styles.css" type="text/css"> |
|
5 <meta name="generator" content="DocBook XSL Stylesheets V1.74.3"><link rel="home" href="index.html" title="Mercurial: The Definitive Guide"> |
|
6 <link rel="up" href="index.html" title="Mercurial: The Definitive Guide"> |
|
7 <link rel="prev" href="managing-releases-and-branchy-development.html" title="Chapter 8. Managing releases and branchy development"> |
|
8 <link rel="next" href="handling-repository-events-with-hooks.html" title="Chapter 10. Handling repository events with hooks"><link rel="alternate" type="application/atom+xml" title="Comments" href="/feeds/comments/"> |
|
9 <link rel="shortcut icon" type="image/png" href="/support/figs/favicon.png"> |
|
10 <script type="text/javascript" src="/support/jquery-min.js"></script> |
|
11 <script type="text/javascript" src="/support/form.js"></script> |
|
12 <script type="text/javascript" src="/support/hsbook.js"></script></head> |
|
13 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> |
|
14 <!--<div class="navheader"> |
|
15 <table width="100%" summary="Navigation header"> |
|
16 <tr><th colspan="3" align="center">Chapter 14. Adding functionality with extensions</th></tr> |
|
17 <tr> |
|
18 <td width="20%" align="left"> |
|
19 <a accesskey="p" href="advanced-uses-of-mercurial-queues.html">Prev</a> </td> |
|
20 <th width="60%" align="center"> </th> |
|
21 <td width="20%" align="right"> <a accesskey="n" href="migrating-to-mercurial.html">Next</a> |
|
22 </td> |
|
23 </tr> |
|
24 </table> |
|
25 <hr> |
|
26 </div> --> |
|
27 <div class="chapter" title="Chapter 14. Adding functionality with extensions"> |
|
28 <div class="titlepage"><div><div><h2 class="title"> |
|
29 <a name="chap:hgext"></a>Chapter 14. Adding functionality with extensions</h2></div></div></div> |
|
30 <div class="toc"> |
|
31 <p><b>Table of Contents</b></p> |
|
32 <dl> |
|
33 <dt><span class="sect1"><a href="adding-functionality-with-extensions.html#sec:hgext:inotify">14.1. Improve performance with the <code class="literal">inotify</code> extension</a></span></dt> |
|
34 <dt><span class="sect1"><a href="adding-functionality-with-extensions.html#sec:hgext:extdiff">14.2. Flexible diff support with the <code class="literal">extdiff</code> extension</a></span></dt> |
|
35 <dd><dl><dt><span class="sect2"><a href="adding-functionality-with-extensions.html#id3071699">14.2.1. Defining command aliases</a></span></dt></dl></dd> |
|
36 <dt><span class="sect1"><a href="adding-functionality-with-extensions.html#sec:hgext:transplant">14.3. Cherrypicking changes with the <code class="literal">transplant</code> extension</a></span></dt> |
|
37 <dt><span class="sect1"><a href="adding-functionality-with-extensions.html#sec:hgext:patchbomb">14.4. Send changes via email with the <code class="literal">patchbomb</code> extension</a></span></dt> |
|
38 <dd><dl><dt><span class="sect2"><a href="adding-functionality-with-extensions.html#id3072184">14.4.1. Changing the behavior of patchbombs</a></span></dt></dl></dd> |
|
39 </dl> |
|
40 </div> |
|
41 <p><b>Table of Contents</b></p> |
|
42 <dl> |
|
43 <dt><span class="section"><a href="#default-arguments">1. Default Arguments</a></span></dt> |
|
44 <dt><span class="section"><a href="#keyword-arguments">2. Keyword Arguments</a></span></dt> |
|
45 <dt><span class="section"><a href="#parameter-packing-and-unpacking">3. Parameter Packing and Unpacking</a></span></dt> |
|
46 <dt><span class="section"><a href="#nested-functions-and-scopes">4. Nested Functions and Scopes</a></span></dt> |
|
47 <dt><span class="section"><a href="#map-reduce-and-filter-functions">5. map, reduce and filter functions</a></span></dt> |
|
48 <dd><dl><dt><span class="section"><a href="#list-comprehensions">5.1. List Comprehensions</a></span></dt></dl></dd> |
|
49 </dl> |
|
50 |
|
51 <p id="x_74b"> |
|
52 <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. |
|
53 </p> |
|
54 <p id="x_74c"<a name="x_74c"></a> |
|
55 <span class="emphasis"><em>Function</em></span> in python is defined with the keyword |
|
56 <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 |
|
57 <span class="emphasis"><em>Function</em></span> must return a value: |
|
58 </p> |
|
59 <pre class="programlisting">def factorial(n): |
|
60 fact = 1 |
|
61 for i in range(2, n): |
|
62 fact *= i |
|
63 |
|
64 return fact |
|
65 |
|
66 </pre> |
|
67 <p><a name="x_74d"></a>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> |
|
68 <p><a name="x_74e"></a>A |
|
69 <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. |
|
70 </p> |
|
71 <p><a name="x_74f"></a>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> |
|
72 <pre class="programlisting">fact5 = factorial(5) |
|
73 |
|
74 </pre> |
|
75 <p><a name="x_750"></a>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> |
|
76 <p><a name="x_751"></a>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 |
|
77 <span class="emphasis"><em>Documentation String</em></span> or |
|
78 <span class="emphasis"><em>docstring</em></span>. |
|
79 <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. |
|
80 <span class="emphasis"><em>docstrings</em></span> for functions can be written as follows: |
|
81 </p> |
|
82 <pre class="programlisting">def factorial(n): |
|
83 'Returns the factorial for the number n.' |
|
84 fact = 1 |
|
85 for i in range(2, n): |
|
86 fact *= i |
|
87 |
|
88 return fact |
|
89 |
|
90 </pre> |
|
91 <p><a name="x_752"></a>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 |
|
92 <span class="emphasis"><em>Tuple</em></span>. A |
|
93 <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 |
|
94 <span class="emphasis"><em>Lists</em></span>, |
|
95 <span class="emphasis"><em>Tuples</em></span>, |
|
96 <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 |
|
97 </p> |
|
98 <p><a name="x_753"></a>Let us write a small function to swap two values:</p> |
|
99 <pre class="programlisting">def swap(a, b): |
|
100 return b, a |
|
101 |
|
102 c, d = swap(a, b) |
|
103 |
|
104 </pre> |
|
105 <p><a name="x_754"></a>Function scope --------------- 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> |
|
106 <pre class="programlisting">def cant_change(n): |
|
107 n = 10 |
|
108 |
|
109 n = 5 |
|
110 cant_change(n) |
|
111 |
|
112 </pre> |
|
113 <p><a name="x_755"></a>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 |
|
114 <span class="emphasis"><em>Numbers</em></span>, |
|
115 <span class="emphasis"><em>Strings</em></span> and |
|
116 <span class="emphasis"><em>Tuples</em></span>. But when you pass mutable objects like |
|
117 <span class="emphasis"><em>Lists</em></span> and |
|
118 <span class="emphasis"><em>Dictionaries</em></span> the values are manipulated even outside the function: |
|
119 </p> |
|
120 <pre class="programlisting">>>> def can_change(n): |
|
121 ... n[1] = James |
|
122 ... |
|
123 |
|
124 >>> name = ['Mr.', 'Steve', 'Gosling'] |
|
125 >>> can_change(name) |
|
126 >>> name |
|
127 ['Mr.', 'James', 'Gosling'] |
|
128 |
|
129 </pre> |
|
130 <p><a name="x_756"></a>If nothing is returned by the function explicitly, Python takes care to return None when the funnction is called.</p> |
|
131 <div class="section" title="1. Default Arguments"> |
|
132 <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
|
133 <a name="default-arguments"></a>1. Default Arguments</h2></div></div></div> |
|
134 <p><a name="x_757"></a>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 |
|
135 <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: |
|
136 </p> |
|
137 <pre class="programlisting">def fib(n=10): |
|
138 fib_list = [0, 1] |
|
139 for i in range(n - 2): |
|
140 next = fib_list[-2] + fib_list[-1] |
|
141 fib_list.append(next) |
|
142 return fib_list |
|
143 |
|
144 </pre> |
|
145 <p><a name="x_758"></a>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:</p> |
|
146 <pre class="programlisting">fib() |
|
147 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34] |
|
148 fib(5) |
|
149 [0, 1, 1, 2, 3] |
|
150 |
|
151 </pre> |
|
152 </div> |
|
153 <div class="section" title="2. Keyword Arguments"> |
|
154 <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
|
155 <a name="keyword-arguments"></a>2. Keyword Arguments</h2></div></div></div> |
|
156 <p><a name="x_759"></a>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 |
|
157 <span class="emphasis"><em>Keyword Arguments</em></span>. |
|
158 </p> |
|
159 <p><a name="x_75a"></a>In a function call, |
|
160 <span class="emphasis"><em>Keyword arguments</em></span> can be used for each argument, in the following fashion: |
|
161 </p> |
|
162 <pre class="programlisting">argument_name=argument_value |
|
163 Also denoted as: keyword=argument |
|
164 |
|
165 def wish(name='World', greetings='Hello'): |
|
166 print "%s, %s!" % (greetings, name) |
|
167 |
|
168 </pre> |
|
169 <p><a name="x_75b"></a>This function can be called in one of the following ways. It is important to note that no restriction is imposed in the order in which |
|
170 <span class="emphasis"><em>Keyword arguments</em></span> can be specified. Also note, that we have combined |
|
171 <span class="emphasis"><em>Keyword arguments</em></span> with |
|
172 <span class="emphasis"><em>Default arguments</em></span> in this example, however it is not necessary: |
|
173 </p> |
|
174 <pre class="programlisting">wish(name='Guido', greetings='Hey') |
|
175 wish(greetings='Hey', name='Guido') |
|
176 |
|
177 </pre> |
|
178 <p><a name="x_75c"></a>Calling functions by specifying arguments in the order of parameters specified in the function definition is called as |
|
179 <span class="emphasis"><em>Positional arguments</em></span>, as opposed to |
|
180 <span class="emphasis"><em>Keyword arguments</em></span>. It is possible to use both |
|
181 <span class="emphasis"><em>Positional arguments</em></span> and |
|
182 <span class="emphasis"><em>Keyword arguments</em></span> in a single function call. But Python doesn't allow us to bungle up both of them. The arguments to the function, in the call, must always start with |
|
183 <span class="emphasis"><em>Positional arguments</em></span> which is in turn followed by |
|
184 <span class="emphasis"><em>Keyword arguments</em></span>: |
|
185 </p> |
|
186 <pre class="programlisting">def my_func(x, y, z, u, v, w): |
|
187 # initialize variables. |
|
188 ... |
|
189 # do some stuff |
|
190 ... |
|
191 # return the value |
|
192 |
|
193 </pre> |
|
194 <p><a name="x_75d"></a>It is valid to call the above functions in the following ways:</p> |
|
195 <pre class="programlisting">my_func(10, 20, 30, u=1.0, v=2.0, w=3.0) |
|
196 my_func(10, 20, 30, 1.0, 2.0, w=3.0) |
|
197 my_func(10, 20, z=30, u=1.0, v=2.0, w=3.0) |
|
198 my_func(x=10, y=20, z=30, u=1.0, v=2.0, w=3.0) |
|
199 |
|
200 </pre> |
|
201 <p><a name="x_75e"></a>Following lists some of the invalid calls:</p> |
|
202 <pre class="programlisting">my_func(10, 20, z=30, 1.0, 2.0, 3.0) |
|
203 my_func(x=10, 20, z=30, 1.0, 2.0, 3.0) |
|
204 my_func(x=10, y=20, z=30, u=1.0, v=2.0, 3.0) |
|
205 |
|
206 </pre> |
|
207 </div> |
|
208 <div class="section" title="3. Parameter Packing and Unpacking"> |
|
209 <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
|
210 <a name="parameter-packing-and-unpacking"></a>3. Parameter Packing and Unpacking</h2></div></div></div> |
|
211 <p><a name="x_75f"></a>The positional arguments passed to a function can be collected in a tuple parameter and keyword arguments can be collected in a dictionary. Since keyword arguments must always be the last set of arguments passed to a function, the keyword dictionary parameter must be the last parameter. The function definition must include a list explicit parameters, followed by tuple paramter collecting parameter, whose name is preceded by a *****, for collecting positional parameters, in turn followed by the dictionary collecting parameter, whose name is preceded by a ****** :</p> |
|
212 <pre class="programlisting">def print_report(title, *args, **name): |
|
213 """Structure of *args* |
|
214 (age, email-id) |
|
215 Structure of *name* |
|
216 { |
|
217 'first': First Name |
|
218 'middle': Middle Name |
|
219 'last': Last Name |
|
220 } |
|
221 """ |
|
222 |
|
223 print "Title: %s" % (title) |
|
224 print "Full name: %(first)s %(middle)s %(last)s" % name |
|
225 print "Age: %d\nEmail-ID: %s" % args |
|
226 |
|
227 </pre> |
|
228 <p><a name="x_760"></a>The above function can be called as. Note, the order of keyword parameters can be interchanged:</p> |
|
229 <pre class="programlisting">>>> print_report('Employee Report', 29, 'johny@example.com', first='Johny', |
|
230 last='Charles', middle='Douglas') |
|
231 Title: Employee Report |
|
232 Full name: Johny Douglas Charles |
|
233 Age: 29 |
|
234 Email-ID: johny@example.com |
|
235 |
|
236 </pre> |
|
237 <p><a name="x_761"></a>The reverse of this can also be achieved by using a very identical syntax while calling the function. A tuple or a dictionary can be passed as arguments in place of a list of *Positional arguments* or *Keyword arguments* respectively using ***** or ****** :</p> |
|
238 <pre class="programlisting">def print_report(title, age, email, first, middle, last): |
|
239 print "Title: %s" % (title) |
|
240 print "Full name: %s %s %s" % (first, middle, last) |
|
241 print "Age: %d\nEmail-ID: %s" % (age, email) |
|
242 |
|
243 >>> args = (29, 'johny@example.com') |
|
244 >>> name = { |
|
245 'first': 'Johny', |
|
246 'middle': 'Charles', |
|
247 'last': 'Douglas' |
|
248 } |
|
249 >>> print_report('Employee Report', *args, **name) |
|
250 Title: Employee Report |
|
251 Full name: Johny Charles Douglas |
|
252 Age: 29 |
|
253 Email-ID: johny@example.com |
|
254 |
|
255 </pre> |
|
256 </div> |
|
257 <div class="section" title="4. Nested Functions and Scopes"> |
|
258 <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
|
259 <a name="nested-functions-and-scopes"></a>4. Nested Functions and Scopes</h2></div></div></div> |
|
260 <p><a name="x_762"></a>Python allows nesting one function inside another. This style of programming turns out to be extremely flexible and powerful features when we use |
|
261 <span class="emphasis"><em>Python decorators</em></span>. We will not talk about decorators is beyond the scope of this course. If you are interested in knowing more about |
|
262 <span class="emphasis"><em>decorator programming</em></span> in Python you are suggested to read: |
|
263 </p> |
|
264 <div class="literallayout"><p><br> |
|
265 <a class="ulink" href="http://avinashv.net/2008/04/python-decorators-syntactic-sugar" target="_top">http://avinashv.net/2008/04/python-decorators-syntactic-sugar</a>/<br> |
|
266 <a class="ulink" href="http://personalpages.tds.net" target="_top">http://personalpages.tds.net</a>/~kent37/kk/00001.html<br> |
|
267 </p></div> |
|
268 <p><a name="x_763"></a>However, the following is an example for nested functions in Python:</p> |
|
269 <pre class="programlisting">def outer(): |
|
270 print "Outer..." |
|
271 def inner(): |
|
272 print "Inner..." |
|
273 print "Outer..." |
|
274 inner() |
|
275 |
|
276 >>> outer() |
|
277 |
|
278 </pre> |
|
279 </div> |
|
280 <div class="section" title="5. map, reduce and filter functions"> |
|
281 <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
|
282 <a name="map-reduce-and-filter-functions"></a>5. map, reduce and filter functions</h2></div></div></div> |
|
283 <p><a name="x_764"></a>Python provides several built-in functions for convenience. The |
|
284 <span class="strong"><strong>map()</strong></span>, |
|
285 <span class="strong"><strong>reduce()</strong></span> and |
|
286 <span class="strong"><strong>filter()</strong></span> functions prove to be very useful with sequences like |
|
287 <span class="emphasis"><em>Lists</em></span>. |
|
288 </p> |
|
289 <p><a name="x_765"></a>The |
|
290 <span class="strong"><strong>map</strong></span> ( |
|
291 <span class="emphasis"><em>function</em></span>, |
|
292 <span class="emphasis"><em>sequence</em></span>) function takes two arguments: |
|
293 <span class="emphasis"><em>function</em></span> and a |
|
294 <span class="emphasis"><em>sequence</em></span> argument. The |
|
295 <span class="emphasis"><em>function</em></span> argument must be the name of the function which in turn takes a single argument, the individual element of the |
|
296 <span class="emphasis"><em>sequence</em></span>. The |
|
297 <span class="strong"><strong>map</strong></span> function calls |
|
298 <span class="emphasis"><em>function(item)</em></span>, for each item in the sequence and returns a list of values, where each value is the value returned by each call to |
|
299 <span class="emphasis"><em>function(item)</em></span>. |
|
300 <span class="strong"><strong>map()</strong></span> function allows to pass more than one sequence. In this case, the first argument, |
|
301 <span class="emphasis"><em>function</em></span> must take as many arguments as the number of sequences passed. This function is called with each corresponding element in the each of the sequences, or |
|
302 <span class="strong"><strong>None</strong></span> if one of the sequence is exhausted: |
|
303 </p> |
|
304 <pre class="programlisting">def square(x): |
|
305 return x*x |
|
306 |
|
307 >>> map(square, [1, 2, 3, 4]) |
|
308 [1, 4, 9, 16] |
|
309 |
|
310 def mul(x, y): |
|
311 return x*y |
|
312 |
|
313 >>> map(mul, [1, 2, 3, 4], [6, 7, 8, 9]) |
|
314 |
|
315 </pre> |
|
316 <p><a name="x_766"></a>The |
|
317 <span class="strong"><strong>filter</strong></span> ( |
|
318 <span class="emphasis"><em>function</em></span>, |
|
319 <span class="emphasis"><em>sequence</em></span>) function takes two arguments, similar to the |
|
320 <span class="strong"><strong>map()</strong></span> function. The |
|
321 <span class="strong"><strong>filter</strong></span> function calls |
|
322 <span class="emphasis"><em>function(item)</em></span>, for each item in the sequence and returns all the elements in the sequence for which |
|
323 <span class="emphasis"><em>function(item)</em></span> returned True: |
|
324 </p> |
|
325 <pre class="programlisting">def even(x): |
|
326 if x % 2: |
|
327 return True |
|
328 else: |
|
329 return False |
|
330 |
|
331 >>> filter(even, range(1, 10)) |
|
332 [1, 3, 5, 7, 9] |
|
333 |
|
334 </pre> |
|
335 <p><a name="x_767"></a>The |
|
336 <span class="strong"><strong>reduce</strong></span> ( |
|
337 <span class="emphasis"><em>function</em></span>, |
|
338 <span class="emphasis"><em>sequence</em></span>) function takes two arguments, similar to |
|
339 <span class="strong"><strong>map</strong></span> function, however multiple sequences are not allowed. The |
|
340 <span class="strong"><strong>reduce</strong></span> function calls |
|
341 <span class="emphasis"><em>function</em></span> with first two consecutive elements in the sequence, obtains the result, calls |
|
342 <span class="emphasis"><em>function</em></span> with the result and the subsequent element in the sequence and so on until the end of the list and returns the final result: |
|
343 </p> |
|
344 <pre class="programlisting">def mul(x, y): |
|
345 return x*y |
|
346 |
|
347 >>> reduce(mul, [1, 2, 3, 4]) |
|
348 24 |
|
349 |
|
350 </pre> |
|
351 <div class="section" title="5.1. List Comprehensions"> |
|
352 <div class="titlepage"><div><div><h3 class="title"> |
|
353 <a name="list-comprehensions"></a>5.1. List Comprehensions</h3></div></div></div> |
|
354 <p><a name="x_768"></a>List Comprehension is a convenvience utility provided by Python. It is a syntatic sugar to create |
|
355 <span class="emphasis"><em>Lists</em></span>. Using |
|
356 <span class="emphasis"><em>List Comprehensions</em></span> one can create |
|
357 <span class="emphasis"><em>Lists</em></span> from other type of sequential data structures or other |
|
358 <span class="emphasis"><em>Lists</em></span> itself. The syntax of |
|
359 <span class="emphasis"><em>List Comprehensions</em></span> consists of a square brackets to indicate the result is a |
|
360 <span class="emphasis"><em>List</em></span> within which we include at least one |
|
361 <span class="strong"><strong>for</strong></span> clause and multiple |
|
362 <span class="strong"><strong>if</strong></span> clauses. It will be more clear with an example: |
|
363 </p> |
|
364 <pre class="programlisting">>>> num = [1, 2, 3] |
|
365 >>> sq = [x*x for x in num] |
|
366 >>> sq |
|
367 [1, 4, 9] |
|
368 >>> all_num = [1, 2, 3, 4, 5, 6, 7, 8, 9] |
|
369 >>> even = [x for x in all_num if x%2 == 0] |
|
370 |
|
371 </pre> |
|
372 <p><a name="x_769"></a>The syntax used here is very clear from the way it is written. It can be translated into english as, "for each element x in the list all_num, if remainder of x divided by 2 is 0, add x to the list."</p> |
|
373 </div> |
|
374 </div> |
|
375 </div></body> |
|
376 </html> |
|
377 <html> |
|
378 <head> |
|
379 <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> |
|
380 <title>Functional Approach</title> |
|
381 <link rel="stylesheet" href="hgbook.css" type="text/css"> |
|
382 <meta name="generator" content="DocBook XSL Stylesheets V1.75.1"> |
|
383 </head> |
|
384 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="article" title="Functional Approach"> |
|
385 <div class="titlepage"> |
|
386 <div><div><h2 class="title"> |
|
387 <a name="id2760558"></a>Functional Approach</h2></div></div> |
|
388 <hr> |
|
389 </div> |
|
390 <div class="toc"> |
|
391 <p><b>Table of Contents</b></p> |
|
392 <dl> |
|
393 <dt><span class="section"><a href="#default-arguments">1. Default Arguments</a></span></dt> |
|
394 <dt><span class="section"><a href="#keyword-arguments">2. Keyword Arguments</a></span></dt> |
|
395 <dt><span class="section"><a href="#parameter-packing-and-unpacking">3. Parameter Packing and Unpacking</a></span></dt> |
|
396 <dt><span class="section"><a href="#nested-functions-and-scopes">4. Nested Functions and Scopes</a></span></dt> |
|
397 <dt><span class="section"><a href="#map-reduce-and-filter-functions">5. map, reduce and filter functions</a></span></dt> |
|
398 <dd><dl><dt><span class="section"><a href="#list-comprehensions">5.1. List Comprehensions</a></span></dt></dl></dd> |
|
399 </dl> |
|
400 </div> |
|
401 <p><a name="x_74b"></a> |
|
402 <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. |
|
403 </p> |
|
404 <p><a name="x_74c"></a> |
|
405 <span class="emphasis"><em>Function</em></span> in python is defined with the keyword |
|
406 <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 |
|
407 <span class="emphasis"><em>Function</em></span> must return a value: |
|
408 </p> |
|
409 <pre class="programlisting">def factorial(n): |
|
410 fact = 1 |
|
411 for i in range(2, n): |
|
412 fact *= i |
|
413 |
|
414 return fact |
|
415 |
|
416 </pre> |
|
417 <p><a name="x_74d"></a>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> |
|
418 <p><a name="x_74e"></a>A |
|
419 <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. |
|
420 </p> |
|
421 <p><a name="x_74f"></a>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> |
|
422 <pre class="programlisting">fact5 = factorial(5) |
|
423 |
|
424 </pre> |
|
425 <p><a name="x_750"></a>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> |
|
426 <p><a name="x_751"></a>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 |
|
427 <span class="emphasis"><em>Documentation String</em></span> or |
|
428 <span class="emphasis"><em>docstring</em></span>. |
|
429 <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. |
|
430 <span class="emphasis"><em>docstrings</em></span> for functions can be written as follows: |
|
431 </p> |
|
432 <pre class="programlisting">def factorial(n): |
|
433 'Returns the factorial for the number n.' |
|
434 fact = 1 |
|
435 for i in range(2, n): |
|
436 fact *= i |
|
437 |
|
438 return fact |
|
439 |
|
440 </pre> |
|
441 <p><a name="x_752"></a>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 |
|
442 <span class="emphasis"><em>Tuple</em></span>. A |
|
443 <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 |
|
444 <span class="emphasis"><em>Lists</em></span>, |
|
445 <span class="emphasis"><em>Tuples</em></span>, |
|
446 <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 |
|
447 </p> |
|
448 <p><a name="x_753"></a>Let us write a small function to swap two values:</p> |
|
449 <pre class="programlisting">def swap(a, b): |
|
450 return b, a |
|
451 |
|
452 c, d = swap(a, b) |
|
453 |
|
454 </pre> |
|
455 <p><a name="x_754"></a>Function scope --------------- 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> |
|
456 <pre class="programlisting">def cant_change(n): |
|
457 n = 10 |
|
458 |
|
459 n = 5 |
|
460 cant_change(n) |
|
461 |
|
462 </pre> |
|
463 <p><a name="x_755"></a>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 |
|
464 <span class="emphasis"><em>Numbers</em></span>, |
|
465 <span class="emphasis"><em>Strings</em></span> and |
|
466 <span class="emphasis"><em>Tuples</em></span>. But when you pass mutable objects like |
|
467 <span class="emphasis"><em>Lists</em></span> and |
|
468 <span class="emphasis"><em>Dictionaries</em></span> the values are manipulated even outside the function: |
|
469 </p> |
|
470 <pre class="programlisting">>>> def can_change(n): |
|
471 ... n[1] = James |
|
472 ... |
|
473 |
|
474 >>> name = ['Mr.', 'Steve', 'Gosling'] |
|
475 >>> can_change(name) |
|
476 >>> name |
|
477 ['Mr.', 'James', 'Gosling'] |
|
478 |
|
479 </pre> |
|
480 <p><a name="x_756"></a>If nothing is returned by the function explicitly, Python takes care to return None when the funnction is called.</p> |
|
481 <div class="section" title="1. Default Arguments"> |
|
482 <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
|
483 <a name="default-arguments"></a>1. Default Arguments</h2></div></div></div> |
|
484 <p><a name="x_757"></a>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 |
|
485 <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: |
|
486 </p> |
|
487 <pre class="programlisting">def fib(n=10): |
|
488 fib_list = [0, 1] |
|
489 for i in range(n - 2): |
|
490 next = fib_list[-2] + fib_list[-1] |
|
491 fib_list.append(next) |
|
492 return fib_list |
|
493 |
|
494 </pre> |
|
495 <p><a name="x_758"></a>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:</p> |
|
496 <pre class="programlisting">fib() |
|
497 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34] |
|
498 fib(5) |
|
499 [0, 1, 1, 2, 3] |
|
500 |
|
501 </pre> |
|
502 </div> |
|
503 <div class="section" title="2. Keyword Arguments"> |
|
504 <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
|
505 <a name="keyword-arguments"></a>2. Keyword Arguments</h2></div></div></div> |
|
506 <p><a name="x_759"></a>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 |
|
507 <span class="emphasis"><em>Keyword Arguments</em></span>. |
|
508 </p> |
|
509 <p><a name="x_75a"></a>In a function call, |
|
510 <span class="emphasis"><em>Keyword arguments</em></span> can be used for each argument, in the following fashion: |
|
511 </p> |
|
512 <pre class="programlisting">argument_name=argument_value |
|
513 Also denoted as: keyword=argument |
|
514 |
|
515 def wish(name='World', greetings='Hello'): |
|
516 print "%s, %s!" % (greetings, name) |
|
517 |
|
518 </pre> |
|
519 <p><a name="x_75b"></a>This function can be called in one of the following ways. It is important to note that no restriction is imposed in the order in which |
|
520 <span class="emphasis"><em>Keyword arguments</em></span> can be specified. Also note, that we have combined |
|
521 <span class="emphasis"><em>Keyword arguments</em></span> with |
|
522 <span class="emphasis"><em>Default arguments</em></span> in this example, however it is not necessary: |
|
523 </p> |
|
524 <pre class="programlisting">wish(name='Guido', greetings='Hey') |
|
525 wish(greetings='Hey', name='Guido') |
|
526 |
|
527 </pre> |
|
528 <p><a name="x_75c"></a>Calling functions by specifying arguments in the order of parameters specified in the function definition is called as |
|
529 <span class="emphasis"><em>Positional arguments</em></span>, as opposed to |
|
530 <span class="emphasis"><em>Keyword arguments</em></span>. It is possible to use both |
|
531 <span class="emphasis"><em>Positional arguments</em></span> and |
|
532 <span class="emphasis"><em>Keyword arguments</em></span> in a single function call. But Python doesn't allow us to bungle up both of them. The arguments to the function, in the call, must always start with |
|
533 <span class="emphasis"><em>Positional arguments</em></span> which is in turn followed by |
|
534 <span class="emphasis"><em>Keyword arguments</em></span>: |
|
535 </p> |
|
536 <pre class="programlisting">def my_func(x, y, z, u, v, w): |
|
537 # initialize variables. |
|
538 ... |
|
539 # do some stuff |
|
540 ... |
|
541 # return the value |
|
542 |
|
543 </pre> |
|
544 <p><a name="x_75d"></a>It is valid to call the above functions in the following ways:</p> |
|
545 <pre class="programlisting">my_func(10, 20, 30, u=1.0, v=2.0, w=3.0) |
|
546 my_func(10, 20, 30, 1.0, 2.0, w=3.0) |
|
547 my_func(10, 20, z=30, u=1.0, v=2.0, w=3.0) |
|
548 my_func(x=10, y=20, z=30, u=1.0, v=2.0, w=3.0) |
|
549 |
|
550 </pre> |
|
551 <p><a name="x_75e"></a>Following lists some of the invalid calls:</p> |
|
552 <pre class="programlisting">my_func(10, 20, z=30, 1.0, 2.0, 3.0) |
|
553 my_func(x=10, 20, z=30, 1.0, 2.0, 3.0) |
|
554 my_func(x=10, y=20, z=30, u=1.0, v=2.0, 3.0) |
|
555 |
|
556 </pre> |
|
557 </div> |
|
558 <div class="section" title="3. Parameter Packing and Unpacking"> |
|
559 <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
|
560 <a name="parameter-packing-and-unpacking"></a>3. Parameter Packing and Unpacking</h2></div></div></div> |
|
561 <p><a name="x_75f"></a>The positional arguments passed to a function can be collected in a tuple parameter and keyword arguments can be collected in a dictionary. Since keyword arguments must always be the last set of arguments passed to a function, the keyword dictionary parameter must be the last parameter. The function definition must include a list explicit parameters, followed by tuple paramter collecting parameter, whose name is preceded by a *****, for collecting positional parameters, in turn followed by the dictionary collecting parameter, whose name is preceded by a ****** :</p> |
|
562 <pre class="programlisting">def print_report(title, *args, **name): |
|
563 """Structure of *args* |
|
564 (age, email-id) |
|
565 Structure of *name* |
|
566 { |
|
567 'first': First Name |
|
568 'middle': Middle Name |
|
569 'last': Last Name |
|
570 } |
|
571 """ |
|
572 |
|
573 print "Title: %s" % (title) |
|
574 print "Full name: %(first)s %(middle)s %(last)s" % name |
|
575 print "Age: %d\nEmail-ID: %s" % args |
|
576 |
|
577 </pre> |
|
578 <p><a name="x_760"></a>The above function can be called as. Note, the order of keyword parameters can be interchanged:</p> |
|
579 <pre class="programlisting">>>> print_report('Employee Report', 29, 'johny@example.com', first='Johny', |
|
580 last='Charles', middle='Douglas') |
|
581 Title: Employee Report |
|
582 Full name: Johny Douglas Charles |
|
583 Age: 29 |
|
584 Email-ID: johny@example.com |
|
585 |
|
586 </pre> |
|
587 <p><a name="x_761"></a>The reverse of this can also be achieved by using a very identical syntax while calling the function. A tuple or a dictionary can be passed as arguments in place of a list of *Positional arguments* or *Keyword arguments* respectively using ***** or ****** :</p> |
|
588 <pre class="programlisting">def print_report(title, age, email, first, middle, last): |
|
589 print "Title: %s" % (title) |
|
590 print "Full name: %s %s %s" % (first, middle, last) |
|
591 print "Age: %d\nEmail-ID: %s" % (age, email) |
|
592 |
|
593 >>> args = (29, 'johny@example.com') |
|
594 >>> name = { |
|
595 'first': 'Johny', |
|
596 'middle': 'Charles', |
|
597 'last': 'Douglas' |
|
598 } |
|
599 >>> print_report('Employee Report', *args, **name) |
|
600 Title: Employee Report |
|
601 Full name: Johny Charles Douglas |
|
602 Age: 29 |
|
603 Email-ID: johny@example.com |
|
604 |
|
605 </pre> |
|
606 </div> |
|
607 <div class="section" title="4. Nested Functions and Scopes"> |
|
608 <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
|
609 <a name="nested-functions-and-scopes"></a>4. Nested Functions and Scopes</h2></div></div></div> |
|
610 <p><a name="x_762"></a>Python allows nesting one function inside another. This style of programming turns out to be extremely flexible and powerful features when we use |
|
611 <span class="emphasis"><em>Python decorators</em></span>. We will not talk about decorators is beyond the scope of this course. If you are interested in knowing more about |
|
612 <span class="emphasis"><em>decorator programming</em></span> in Python you are suggested to read: |
|
613 </p> |
|
614 <div class="literallayout"><p><br> |
|
615 <a class="ulink" href="http://avinashv.net/2008/04/python-decorators-syntactic-sugar" target="_top">http://avinashv.net/2008/04/python-decorators-syntactic-sugar</a>/<br> |
|
616 <a class="ulink" href="http://personalpages.tds.net" target="_top">http://personalpages.tds.net</a>/~kent37/kk/00001.html<br> |
|
617 </p></div> |
|
618 <p><a name="x_763"></a>However, the following is an example for nested functions in Python:</p> |
|
619 <pre class="programlisting">def outer(): |
|
620 print "Outer..." |
|
621 def inner(): |
|
622 print "Inner..." |
|
623 print "Outer..." |
|
624 inner() |
|
625 |
|
626 >>> outer() |
|
627 |
|
628 </pre> |
|
629 </div> |
|
630 <div class="section" title="5. map, reduce and filter functions"> |
|
631 <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
|
632 <a name="map-reduce-and-filter-functions"></a>5. map, reduce and filter functions</h2></div></div></div> |
|
633 <p><a name="x_764"></a>Python provides several built-in functions for convenience. The |
|
634 <span class="strong"><strong>map()</strong></span>, |
|
635 <span class="strong"><strong>reduce()</strong></span> and |
|
636 <span class="strong"><strong>filter()</strong></span> functions prove to be very useful with sequences like |
|
637 <span class="emphasis"><em>Lists</em></span>. |
|
638 </p> |
|
639 <p><a name="x_765"></a>The |
|
640 <span class="strong"><strong>map</strong></span> ( |
|
641 <span class="emphasis"><em>function</em></span>, |
|
642 <span class="emphasis"><em>sequence</em></span>) function takes two arguments: |
|
643 <span class="emphasis"><em>function</em></span> and a |
|
644 <span class="emphasis"><em>sequence</em></span> argument. The |
|
645 <span class="emphasis"><em>function</em></span> argument must be the name of the function which in turn takes a single argument, the individual element of the |
|
646 <span class="emphasis"><em>sequence</em></span>. The |
|
647 <span class="strong"><strong>map</strong></span> function calls |
|
648 <span class="emphasis"><em>function(item)</em></span>, for each item in the sequence and returns a list of values, where each value is the value returned by each call to |
|
649 <span class="emphasis"><em>function(item)</em></span>. |
|
650 <span class="strong"><strong>map()</strong></span> function allows to pass more than one sequence. In this case, the first argument, |
|
651 <span class="emphasis"><em>function</em></span> must take as many arguments as the number of sequences passed. This function is called with each corresponding element in the each of the sequences, or |
|
652 <span class="strong"><strong>None</strong></span> if one of the sequence is exhausted: |
|
653 </p> |
|
654 <pre class="programlisting">def square(x): |
|
655 return x*x |
|
656 |
|
657 >>> map(square, [1, 2, 3, 4]) |
|
658 [1, 4, 9, 16] |
|
659 |
|
660 def mul(x, y): |
|
661 return x*y |
|
662 |
|
663 >>> map(mul, [1, 2, 3, 4], [6, 7, 8, 9]) |
|
664 |
|
665 </pre> |
|
666 <p><a name="x_766"></a>The |
|
667 <span class="strong"><strong>filter</strong></span> ( |
|
668 <span class="emphasis"><em>function</em></span>, |
|
669 <span class="emphasis"><em>sequence</em></span>) function takes two arguments, similar to the |
|
670 <span class="strong"><strong>map()</strong></span> function. The |
|
671 <span class="strong"><strong>filter</strong></span> function calls |
|
672 <span class="emphasis"><em>function(item)</em></span>, for each item in the sequence and returns all the elements in the sequence for which |
|
673 <span class="emphasis"><em>function(item)</em></span> returned True: |
|
674 </p> |
|
675 <pre class="programlisting">def even(x): |
|
676 if x % 2: |
|
677 return True |
|
678 else: |
|
679 return False |
|
680 |
|
681 >>> filter(even, range(1, 10)) |
|
682 [1, 3, 5, 7, 9] |
|
683 |
|
684 </pre> |
|
685 <p><a name="x_767"></a>The |
|
686 <span class="strong"><strong>reduce</strong></span> ( |
|
687 <span class="emphasis"><em>function</em></span>, |
|
688 <span class="emphasis"><em>sequence</em></span>) function takes two arguments, similar to |
|
689 <span class="strong"><strong>map</strong></span> function, however multiple sequences are not allowed. The |
|
690 <span class="strong"><strong>reduce</strong></span> function calls |
|
691 <span class="emphasis"><em>function</em></span> with first two consecutive elements in the sequence, obtains the result, calls |
|
692 <span class="emphasis"><em>function</em></span> with the result and the subsequent element in the sequence and so on until the end of the list and returns the final result: |
|
693 </p> |
|
694 <pre class="programlisting">def mul(x, y): |
|
695 return x*y |
|
696 |
|
697 >>> reduce(mul, [1, 2, 3, 4]) |
|
698 24 |
|
699 |
|
700 </pre> |
|
701 <div class="section" title="5.1. List Comprehensions"> |
|
702 <div class="titlepage"><div><div><h3 class="title"> |
|
703 <a name="list-comprehensions"></a>5.1. List Comprehensions</h3></div></div></div> |
|
704 <p><a name="x_768"></a>List Comprehension is a convenvience utility provided by Python. It is a syntatic sugar to create |
|
705 <span class="emphasis"><em>Lists</em></span>. Using |
|
706 <span class="emphasis"><em>List Comprehensions</em></span> one can create |
|
707 <span class="emphasis"><em>Lists</em></span> from other type of sequential data structures or other |
|
708 <span class="emphasis"><em>Lists</em></span> itself. The syntax of |
|
709 <span class="emphasis"><em>List Comprehensions</em></span> consists of a square brackets to indicate the result is a |
|
710 <span class="emphasis"><em>List</em></span> within which we include at least one |
|
711 <span class="strong"><strong>for</strong></span> clause and multiple |
|
712 <span class="strong"><strong>if</strong></span> clauses. It will be more clear with an example: |
|
713 </p> |
|
714 <pre class="programlisting">>>> num = [1, 2, 3] |
|
715 >>> sq = [x*x for x in num] |
|
716 >>> sq |
|
717 [1, 4, 9] |
|
718 >>> all_num = [1, 2, 3, 4, 5, 6, 7, 8, 9] |
|
719 >>> even = [x for x in all_num if x%2 == 0] |
|
720 |
|
721 </pre> |
|
722 <p><a name="x_769"></a>The syntax used here is very clear from the way it is written. It can be translated into english as, "for each element x in the list all_num, if remainder of x divided by 2 is 0, add x to the list."</p> |
|
723 </div> |
|
724 </div> |
|
725 </div></body> |
|
726 </html> |
|