636 

   637 \begin{frame}

   638   \frametitle{Problem set 1}

   639   \begin{itemize}

   640     \item All the problems can be\\

   641       solved using \kwrd{if} and \kwrd{while} 

   642   \end{itemize}

   643 \end{frame}

   644 

   645 \begin{frame}{Problem 1.1}

   646   Write a program that displays all three digit numbers that are equal to the sum of the cubes of their digits. That is, print numbers $abc$ that have the property $abc = a^3 + b^3 + c^3$\\

   647 These are called $Armstrong$ numbers.

   648 \end{frame}

   649   

   650 \begin{frame}{Problem 1.2 - Collatz sequence}

   651 \begin{enumerate}

   652   \item Start with an arbitrary (positive) integer. 

   653   \item If the number is even, divide by 2; if the number is odd multiply by 3 and add 1.

   654   \item Repeat the procedure with the new number.

   655   \item It appears that for all starting values there is a cycle of 4, 2, 1 at which the procedure loops.

   656 \end{enumerate}

   657     Write a program that accepts the starting value and prints out the Collatz sequence.

   658 

   659 \end{frame}

   660 

   661 \begin{frame}{Problem 1.3 - Kaprekar's constant}

   662   \begin{enumerate}

   663     \item Take a four digit number--with at least two digits different.

   664     \item Arrange the digits in ascending and descending order, giving A and D respectively.

   665     \item Leave leading zeros in A!

   666     \item Subtract A from D.

   667     \item With the result, repeat from step 2.

   668   \end{enumerate}

   669   Write a program to accept a 4-digit number and display the progression to Kaprekar's constant.

   670 \end{frame}

   671 

   672 \begin{frame}[fragile]{Problem 1.4}

   673   Write a program that prints the following pyramid on the screen. 

   674   \begin{lstlisting}

   675 1

   676 2  2

   677 3  3  3

   678 4  4  4  4

   679   \end{lstlisting}

   680 The number of lines must be obtained from the user as input.\\

   681 \pause

   682 When can your code fail?

   683 \only<2->{\inctime{25}}

   684 \end{frame}

   685 

   686 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

   687 % TIME: 25 m, running 105m 

   688 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

   689 

   690 \subsection{Functions}

   691 \begin{frame}[fragile]

   692 \frametitle{Functions: examples}

   693   \begin{lstlisting}

   694 def signum( r ):

   695     """returns 0 if r is zero

   696     -1 if r is negative

   697     +1 if r is positive"""

   698     if r < 0:

   699         return -1

   700     elif r > 0:

   701         return 1

   702     else:

   703         return 0

   704   \end{lstlisting}

   705 \end{frame}

   706 

   707 \begin{frame}[fragile]

   708   \frametitle{Functions: examples}

   709   \begin{lstlisting}

   710 def pad( n, size ): 

   711     """pads integer n with spaces

   712     into a string of length size

   713     """

   714     SPACE = ' '

   715     s = str( n )

   716     padSize = size - len( s )

   717     return padSize * SPACE + s

   718   \end{lstlisting}

   719 \pause

   720 What about \%3d?

   721 \end{frame}

   722 

   723 \begin{frame}[fragile]

   724   {What does this function do?}

   725   \begin{lstlisting}

   726 def what( n ):

   727     if n < 0: n = -n

   728     while n > 0:

   729         if n % 2 == 1:

   730             return False

   731         n /= 10

   732     return True

   733   \end{lstlisting}

   734 \end{frame}

   735 

   736 \begin{frame}[fragile]

   737   {What does this function do?}

   738 \begin{lstlisting}

   739 def what( n ):

   740     i = 1    

   741     while i * i < n:

   742         i += 1

   743     return i * i == n, i

   744   \end{lstlisting}

   745 \end{frame}

   746 

   747 \begin{frame}[fragile]

   748   {What does this function do?}

   749   \begin{lstlisting}

   750 def what( n, x ):

   751     z = 1.0

   752     if n < 0:

   753         x = 1.0 / x

   754         n = -n

   755     while n > 0:

   756         if n % 2 == 1:

   757             z *= x

   758         n /= 2

   759         x *= x

   760     return z

   761   \end{lstlisting}

   762 \end{frame}

   763 

   764 \begin{frame}

   765   {Before writing a function}

   766   \begin{itemize}

   767       \item Builtin functions for various and sundry

   768       \item \typ{abs, any, all, len, max, min}

   769       \item \typ{pow, range, sum, type}

   770       \item Refer here:

   771           \url{http://docs.python.org/library/functions.html}

   772   \end{itemize}

   773   \inctime{15} 

   774 \end{frame}

   775 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

   776 % TIME: 15 m, running 120m 

   777 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

   778 

   779 \begin{frame}{Problem set 2}

   780   The focus is on writing functions and calling them.

   781 \end{frame}

   782 

   783 \begin{frame}{Problem 2.1}

   784   Write a function to return the gcd of two numbers.

   785 \end{frame}

   786 

   787 \begin{frame}{Problem 2.2}

   788 A pythagorean triad $(a,b,c)$ has the property $a^2 + b^2 = c^2$.\\By primitive we mean triads that do not `depend' on others. For example, (4,3,5) is a variant of (3,4,5) and hence is not primitive. And (10,24,26) is easily derived from (5,12,13) and should not be displayed by our program. \\

   789 Write a program to print primitive pythagorean triads. The program should generate all triads with a, b values in the range 0---100

   790 \end{frame}

   791 

   792 \begin{frame}{Problem 2.3}

   793   Write a program that generates a list of all four digit numbers that have all their digits even and are perfect squares.\\For example, the output should include 6400 but not 8100 (one digit is odd) or 4248 (not a perfect square).

   794 \end{frame}

   795 

   796 \begin{frame}{Problem 2.4}

   797   The aliquot of a number is defined as: the sum of the \emph{proper} divisors of the number. For example, the aliquot(12) = 1 + 2 + 3 + 4 + 6 = 16.\\

   798   Write a function that returns the aliquot number of a given number. 

   799 \end{frame}

   800 

   801 \begin{frame}{Problem 2.5}

   802   A pair of numbers (a, b) is said to be \alert{amicable} if the aliquot number of a is b and the aliquot number of b is a.\\

   803   Example: \texttt{220, 284}\\

   804   Write a program that prints all five digit amicable pairs.

   805   \inctime{30}

   806 \end{frame}

   807 

   808 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

   809 % TIME: 30 m, running 150m 

   810 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

   811 

   812 \subsection{Lists}

   813 

   814 \begin{frame}[fragile]

   815   \frametitle{List creation and indexing}

   816 \begin{lstlisting}

   817 >>> a = [] # An empty list.

   818 >>> a = [1, 2, 3, 4] # More useful.

   819 >>> len(a) 

   820 4

   821 >>> a[0] + a[1] + a[2] + a[-1]

   822 10

   823 \end{lstlisting}

   824   \begin{itemize}

   825   \item Indices start with ?

   826   \item Negative indices indicate ?

   827   \end{itemize}

   828 \end{frame}

   829 

   830 \begin{frame}[fragile]

   831   \frametitle{List: slices}

   832   \begin{itemize}

   833   \item Slicing is a basic operation

   834   \item \typ{list[initial:final:step]}

   835   \item  The step is optional

   836   \end{itemize}

   837 \begin{lstlisting}

   838 >>> a[1:3] # A slice.

   839 [2, 3]

   840 >>> a[1:-1]

   841 [2, 3, 4]

   842 >>> a[1:] == a[1:-1]

   843 False  

   844 \end{lstlisting}

   845 Explain last result

   846 \end{frame}

   847 

   848 \begin{frame}[fragile]

   849   \frametitle{List: more slices}

   850 \begin{lstlisting}

   851 >>> a[0:-1:2] # Notice the step!

   852 [1, 3]

   853 >>> a[::2]

   854 [1, 3]

   855 >>> a[-1::-1]

   856 \end{lstlisting}

   857 What do you think the last one will do?

   858   \emphbar{Note: Strings also use same indexing and slicing.}

   859 \end{frame}

   860 

   861 \begin{frame}[fragile]

   862   \frametitle{List: examples}

   863 \begin{lstlisting}

   864 >>> a = [1, 2, 3, 4]

   865 >>> a[:2]

   866 [1, 3]

   867 >>> a[0:-1:2]

   868 [1, 3]

   869 \end{lstlisting}

   870 \pause

   871 \alert{Lists are mutable (unlike strings)}

   872 \begin{lstlisting}

   873 >>> a[1] = 20

   874 >>> a

   875 [1, 20, 3, 4]

   876 \end{lstlisting}

   877 \end{frame}

   878 

   879 \begin{frame}[fragile]

   880   \frametitle{Lists are mutable and heterogenous}

   881 \begin{lstlisting}

   882 >>> a = ['spam', 'eggs', 100, 1234]

   883 >>> a[2] = a[2] + 23

   884 >>> a

   885 ['spam', 'eggs', 123, 1234]

   886 >>> a[0:2] = [1, 12] # Replace items

   887 >>> a

   888 [1, 12, 123, 1234]

   889 >>> a[0:2] = [] # Remove items

   890 >>> a.append( 12345 )

   891 >>> a

   892 [123, 1234, 12345]

   893 \end{lstlisting}

   894 \end{frame}

   895 

   896 \begin{frame}[fragile]

   897   \frametitle{List methods}

   898 \begin{lstlisting}

   899 >>> a = ['spam', 'eggs', 1, 12]

   900 >>> a.reverse() # in situ

   901 >>> a

   902 [12, 1, 'eggs', 'spam']

   903 >>> a.append(['x', 1]) 

   904 >>> a

   905 [12, 1, 'eggs', 'spam', ['x', 1]]

   906 >>> a.extend([1,2]) # Extend the list.

   907 >>> a.remove( 'spam' )

   908 >>> a

   909 [12, 1, 'eggs', ['x', 1], 1, 2]

   910 \end{lstlisting}

   911 \end{frame}

   912 

   913 \begin{frame}[fragile]

   914   \frametitle{List containership}

   915   \begin{lstlisting}

   916 >>> a = ['cat', 'dog', 'rat', 'croc']

   917 >>> 'dog' in a

   918 True

   919 >>> 'snake' in a

   920 False

   921 >>> 'snake' not in a

   922 True

   923 >>> 'ell' in 'hello world'

   924 True

   925   \end{lstlisting}

   926 \end{frame}

   927 

   928 \begin{frame}[fragile]

   929   \frametitle{Tuples: immutable}

   930 \begin{lstlisting}

   931 >>> t = (0, 1, 2)

   932 >>> print t[0], t[1], t[2], t[-1] 

   933 0 1 2 2

   934 >>> t[0] = 1

   935 Traceback (most recent call last):

   936   File "<stdin>", line 1, in ?

   937 TypeError: object does not support item

   938            assignment

   939 \end{lstlisting}  

   940 \begin{itemize}

   941     \item Multiple return values are actually a tuple.

   942     \item Exchange is tuple (un)packing

   943 \end{itemize}

   944 

   945 \end{frame}

   946 

   947 \begin{frame}[fragile]

   948   \frametitle{\typ{range()} function}

   949   \begin{lstlisting}

   950 >>> range(7)

   951 [0, 1, 2, 3, 4, 5, 6]

   952 >>> range( 3, 9)

   953 [3, 4, 5, 6, 7, 8]

   954 >>> range( 4, 17, 3)

   955 [4, 7, 10, 13, 16]

   956 >>> range( 5, 1, -1)

   957 [5, 4, 3, 2]

   958 >>> range( 8, 12, -1)

   959 []

   960   \end{lstlisting}

   961 \end{frame}

   962 

   963 \begin{frame}[fragile]

   964   \frametitle{\typ{for\ldots range(\ldots)} idiom}

   965   \begin{lstlisting}

   966 In [83]: for i in range(5):

   967    ....:     print i, i * i

   968    ....:     

   969    ....:     

   970 0 0

   971 1 1

   972 2 4

   973 3 9

   974 4 16

   975 \end{lstlisting}

   976 \end{frame}

   977 

   978 \begin{frame}[fragile]

   979   \frametitle{\typ{for}: the list companion}

   980   

   981   \begin{lstlisting}

   982 In [84]: a = ['a', 'b', 'c']

   983 In [85]: for x in a:

   984    ....:    print x, chr( ord(x) + 10 )

   985    ....:

   986 a  k

   987 b  l

   988 c  m

   989   \end{lstlisting}

   990   Iterating over the list and not the index + reference\\

   991   what if you want the index?

   992 \end{frame}

   993 

   994 \begin{frame}[fragile]

   995   \frametitle{\typ{for}: the list companion}

   996   \begin{lstlisting}

   997 In [89]: for p, ch in enumerate( a ):

   998    ....:     print p, ch

   999    ....:     

  1000    ....:     

  1001 0 a

  1002 1 b

  1003 2 c

  1004   \end{lstlisting}

  1005 Try: \typ{print enumerate(a)}

  1006 \inctime{20}

  1007 \end{frame}

  1008 

  1009 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  1010 % TIME: 20 m, running 170m 

  1011 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  1012 

  1013 \begin{frame}

  1014   {Problem set 3}

  1015   As you can guess, idea is to use \kwrd{for}!

  1016 \end{frame}

  1017 

  1018 \begin{frame}{Problem 3.1}

  1019   Which of the earlier problems is simpler when we use \kwrd{for} instead of \kwrd{while}? 

  1020 \end{frame}

  1021 

  1022 \begin{frame}{Problem 3.2}

  1023   Given an empty chessboard and one Bishop placed in any square, say (r, c), generate the list of all squares the Bishop could move to.

  1024 \end{frame}

  1025 

  1026 \begin{frame}[fragile]

  1027   \frametitle{Problem 3.3}

  1028 

  1029   Given two real numbers \typ{a, b}, and an integer \typ{N}, write a

  1030   function named \typ{linspace( a, b, N)} that returns an ordered list

  1031   of \typ{N} points starting with \typ{a} and ending in \typ{b} and

  1032   equally spaced.\\

  1033 

  1034   For example, \typ{linspace(0, 5, 11)}, should return, \\

  1035 \begin{lstlisting}

  1036 [ 0.0 ,  0.5,  1.0 ,  1.5,  2.0 ,  2.5,  

  1037   3.0 ,  3.5,  4.0 ,  4.5,  5.0 ]

  1038 \end{lstlisting}

  1039 \end{frame}

  1040 

  1041 \begin{frame}[fragile]

  1042   \frametitle{Problem 3.4a (optional)}

  1043 

  1044 Use the \typ{linspace} function and generate a list of N tuples of the form\\

  1045 \typ{[($x_1$,f($x_1$)),($x_2$,f($x_2$)),\ldots,($x_N$,f($x_N$))]}\\for the following functions,\begin{itemize}

  1046   \item \typ{f(x) = sin(x)}

  1047   \item \typ{f(x) = sin(x) + sin(10*x)}.

  1048 \end{itemize}

  1049 \end{frame}

  1050 

  1051 \begin{frame}[fragile]

  1052   \frametitle{Problem 3.4b (optional)}

  1053 

  1054   Using the tuples generated earlier, determine the intervals where the roots of the functions lie.

  1055 

  1056   \inctime{15}

  1057 \end{frame}

  1058 

  1059 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  1060 % TIME: 15 m, running 185m 

  1061 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  1062 

  1063 \subsection{IO}

  1064 

  1065 \begin{frame}[fragile]

  1066   \frametitle{Simple tokenizing and parsing}

  1067   \begin{lstlisting}

  1068 s = """The quick brown fox jumped

  1069        over the lazy dog"""

  1070 for word in s.split():

  1071     print word.capitalize()

  1072   \end{lstlisting}

  1073 \end{frame}

  1074 

  1075 \begin{frame}[fragile]

  1076   \frametitle{Problem 4.1}

  1077   Given a string like, ``1, 3-7, 12, 15, 18-21'', produce the list \\

  1078   \begin{lstlisting}

  1079     [1,3,4,5,6,7,12,15,18,19,20,21]

  1080   \end{lstlisting}

  1081 \end{frame}

  1082 

  1083 \begin{frame}[fragile]

  1084   \frametitle{File handling}

  1085 \begin{lstlisting}

  1086 >>> f = open('/path/to/file_name')

  1087 >>> data = f.read() # Read entire file.

  1088 >>> line = f.readline() # Read one line.

  1089 >>> f.close() # close the file.

  1090 \end{lstlisting}

  1091 Writing files

  1092 \begin{lstlisting}

  1093 >>> f = open('/path/to/file_name', 'w')

  1094 >>> f.write('hello world\n')

  1095 >>> f.close()

  1096 \end{lstlisting}

  1097 \begin{itemize}

  1098     \item Everything read or written is a string

  1099 \end{itemize}

  1100 \emphbar{Try \typ{file?} for more help}

  1101 \end{frame}

  1102 

  1103 \begin{frame}[fragile]

  1104     \frametitle{File and \kwrd{for}}

  1105 \begin{lstlisting}

  1106 >>> f = open('/path/to/file_name')

  1107 >>> for line in f:

  1108 ...     print line

  1109 ...

  1110 \end{lstlisting}

  1111 \end{frame}

  1112 

  1113 \begin{frame}{Problem 4.2}

  1114     The given file has lakhs of records in the form:\\

  1115     \typ{RGN;ID;NAME;MARK1;\ldots;MARK5;TOTAL;PFW}\\

  1116     Some entries may be empty.  Read the data from this file and print the

  1117     name of the student with the maximum total marks.

  1118 \end{frame}

  1119 

  1120 \begin{frame}{Problem 4.3}

  1121     For the same data file compute the average marks in different

  1122     subjects, the student with the maximum mark in each subject and also

  1123     the standard deviation of the marks.  Do this efficiently.

  1124 

  1125     \inctime{20}

  1126 \end{frame}

  1127 

  1128 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  1129 % TIME: 20 m, running 205m 

  1130 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  1131 

  1132 \subsection{Modules}

  1133 

  1134 \begin{frame}[fragile]

  1135     {Modules}

  1136 \begin{lstlisting}

  1137 >>> sqrt(2)

  1138 Traceback (most recent call last):

  1139   File "<stdin>", line 1, in <module>

  1140 NameError: name 'sqrt' is not defined

  1141 >>> import math        

  1142 >>> math.sqrt(2)

  1143 1.4142135623730951

  1144 \end{lstlisting}

  1145 \end{frame}

  1146 

  1147 \begin{frame}[fragile]

  1148     {Modules}

  1149   \begin{itemize}

  1150     \item The \kwrd{import} keyword ``loads'' a module

  1151     \item One can also use:

  1152       \begin{lstlisting}

  1153 >>> from math import sqrt

  1154 >>> from math import *

  1155       \end{lstlisting}    

  1156     \item What is the difference?

  1157     \item \alert{Use the later only in interactive mode}

  1158     \end{itemize}

  1159   \emphbar{Package hierarchies}

  1160       \begin{lstlisting}

  1161 >>> from os.path import exists

  1162       \end{lstlisting}

  1163 \end{frame}

  1164 

  1165 \begin{frame}

  1166   \frametitle{Modules: Standard library}

  1167   \begin{itemize}

  1168   \item Very powerful, ``Batteries included''

  1169   \item Some standard modules:

  1170     \begin{itemize}

  1171     \item Math: \typ{math}, \typ{random}

  1172     \item Internet access: \typ{urllib2}, \typ{smtplib}

  1173     \item System, Command line arguments: \typ{sys}

  1174     \item Operating system interface: \typ{os}

  1175     \item Regular expressions: \typ{re}

  1176     \item Compression: \typ{gzip}, \typ{zipfile}, and \typ{tarfile}

  1177     \item And a whole lot more!

  1178     \end{itemize}

  1179   \item Check out the Python Library reference:

  1180     \url{http://docs.python.org/library/}

  1181   \end{itemize}

  1182 \end{frame}

  1183 

  1184 \begin{frame}[fragile]

  1185     {Modules of special interest}

  1186     \begin{description}[matplotlibfor2d]

  1187 

  1188         \item[\typ{numpy}] Efficient, powerful numeric arrays

  1189 

  1190         \item[\typ{matplotlib}] Easy, interactive, 2D plotting

  1191 

  1192         \item[\typ{scipy}] statistics, optimization, integration, linear

  1193             algebra, Fourier transforms, signal and image processing,

  1194             genetic algorithms, ODE solvers, special functions, and more

  1195 

  1196         \item[Mayavi] Easy, interactive, 3D plotting

  1197 

  1198     \end{description}

  1199 \end{frame}

  1200 

  1201 \begin{frame}[fragile]

  1202     {Creating your own modules}

  1203   \begin{itemize}

  1204   \item Define variables, functions and classes in a file with a

  1205     \typ{.py} extension

  1206   \item This file becomes a module!

  1207   \item Accessible when in the current directory

  1208   \item Use \typ{cd} in IPython to change directory

  1209 

  1210   \item Naming your module

  1211       \end{itemize}

  1212 \end{frame}

  1213 

  1214 \begin{frame}[fragile]

  1215   \frametitle{Modules: example}

  1216   \begin{lstlisting}

  1217 # --- arith.py ---

  1218 def gcd(a, b):

  1219     if a%b == 0: return b

  1220     return gcd(b, a%b)

  1221 def lcm(a, b):

  1222     return a*b/gcd(a, b)

  1223 # ------------------

  1224 >>> import arith

  1225 >>> arith.gcd(26, 65)

  1226 13

  1227 >>> arith.lcm(26, 65)

  1228 130

  1229   \end{lstlisting}

  1230 \end{frame}

  1231 

  1232 \begin{frame}[fragile]

  1233   \frametitle{Problem 5.1}

  1234 

  1235   Put all the functions you have written so far as part of the problems

  1236   into one module called \typ{iitb.py} and use this module from IPython.

  1237 

  1238 \inctime{20}

  1239 \end{frame}

  1240 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  1241 % TIME: 20 m, running 225m 

  1242 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  1243 

  1244 \begin{frame}

  1245   \frametitle{Did we meet the goal?}

  1246   \tableofcontents

  1247   % You might wish to add the option [pausesections]

  1248   \end{frame}

  1249 

  1250   \begin{frame}

  1251     {Tomorrow}

  1252     \begin{itemize}

  1253       \item Plotting: 2D, 3D

  1254       \item NumPy, SciPy

  1255       \item Dictionary, Set

  1256       \item Debugging

  1257       \item Testing

  1258       \item \ldots

  1259     \end{itemize}

  1260     11:30--13:00 Discussion of answers to problems OPTIONAL

  1261   \end{frame}

  1263 

  1264 

  1265 \begin{frame}[fragile]

  1266   \frametitle{More on functions}

  1267   \begin{itemize}

  1268   \item Support default and keyword arguments

  1269   \item Scope of variables in the function is local

  1270   \item Mutable items are \alert{passed by reference}

  1271   \item First line after definition may be a documentation string

  1272     (\alert{recommended!})

  1273   \item Function definition and execution defines a name bound to the

  1274     function

  1275   \item You \emph{can} assign a variable to a function!

  1276   \end{itemize}

  1277 \end{frame}

  1278 

  1279 

  1280 \begin{frame}[fragile]

  1281   \frametitle{Functions: default arguments}

  1282   \begin{lstlisting}

  1283 def ask_ok(prompt, retries=4, complaint='Yes or no!'):

  1284     while True:

  1285         ok = raw_input(prompt)

  1286         if ok in ('y', 'ye', 'yes'): 

  1287             return True

  1288         if ok in ('n', 'no', 'nop', 'nope'): 

  1289             return False

  1290         retries = retries - 1

  1291         if retries < 0: 

  1292             raise IOError, 'bad user'

  1293         print complaint

  1294   \end{lstlisting}

  1295 \end{frame}

  1296 

  1297 \begin{frame}[fragile]

  1298   \frametitle{Functions: keyword arguments}

  1299   \begin{lstlisting}

  1300 def parrot(voltage, state='a stiff', 

  1301            action='voom', type='Norwegian Blue'):

  1302     print "-- This parrot wouldn't", action,

  1303     print "if you put", voltage, "Volts through it."

  1304     print "-- Lovely plumage, the", type

  1305     print "-- It's", state, "!"

  1306 

  1307 parrot(1000)

  1308 parrot(action = 'VOOOOOM', voltage = 1000000)

  1309 parrot('a thousand', state = 'pushing up the daisies')

  1310 parrot('a million', 'bereft of life', 'jump')

  1311 \end{lstlisting}

  1312 \end{frame}

  1313 

  1314 \begin{frame}[fragile]

  1315   \frametitle{Functions: arbitrary argument lists}

  1316   \begin{itemize}

  1317   \item Arbitrary number of arguments using \verb+*args+ or

  1318     \verb+*whatever+

  1319   \item Keyword arguments using \verb+**kw+

  1320   \item Given a tuple/dict how do you call a function?

  1321     \begin{itemize}

  1322     \item Using argument unpacking

  1323     \item For positional arguments: \verb+foo(*[5, 10])+

  1324     \item For keyword args: \verb+foo(**{'a':5, 'b':10})+

  1325     \end{itemize}

  1326   \end{itemize}

  1327 \begin{lstlisting}

  1328 def foo(a=10, b=100):

  1329     print a, b

  1330 def func(*args, **keyword):

  1331     print args, keyword

  1332 # Unpacking:

  1333 args = [5, 10]

  1334 foo(*args)

  1335 kw = {'a':5, 'b':10}

  1336 foo(**kw)

  1337 \end{lstlisting}

  1338 \end{frame}

  1339 

  1340 \subsection{Modules, exceptions, classes}

  1341 

  1342 \begin{frame}

  1343   \frametitle{Modules}

  1344   \begin{itemize}

  1345   \item Define variables, functions and classes in a file with a

  1346     \typ{.py} extension

  1347   \item This file becomes a module!

  1348   \item Modules are searched in the following:

  1349     \begin{itemize}

  1350     \item Current directory

  1351     \item Standard: \typ{/usr/lib/python2.3/site-packages/} etc.

  1352     \item Directories specified in PYTHONPATH

  1353     \item \typ{sys.path}: current path settings (from the \typ{sys}

  1354       module)

  1355     \end{itemize}

  1356   \item The \typ{import} keyword ``loads'' a module

  1357   \item One can also use:

  1358     \mbox{\typ{from module import name1, name2, name2}}\\

  1359     where \typ{name1} etc. are names in the module, ``module''

  1360   \item \typ{from module import *} \ --- imports everything from module,

  1361     \alert{use only in interactive mode}

  1362   \end{itemize}

  1363 \end{frame}

  1364 

  1365 \begin{frame}[fragile]

  1366   \frametitle{Modules: example}

  1367   \begin{lstlisting}

  1368 # --- foo.py ---

  1369 some_var = 1

  1370 def fib(n): # write Fibonacci series up to n

  1371     """Print a Fibonacci series up to n."""

  1372     a, b = 0, 1

  1373     while b < n:

  1374         print b,

  1375         a, b = b, a+b

  1376 # EOF

  1377 

  1378 >>> import foo

  1379 >>> foo.fib(10)

  1380 1 1 2 3 5 8 

  1381 >>> foo.some_var

  1382 1

  1383   \end{lstlisting}

  1384 \end{frame}

  1385 

  1386 \begin{frame}[fragile]

  1387   \frametitle{Namespaces}

  1388   \begin{itemize}

  1389   \item A mapping from names to objects

  1390   \item Modules introduce a namespace 

  1391   \item So do classes

  1392   \item The running script's namespace is \verb+__main__+

  1393   \item A modules namespace is identified by its name

  1394   \item The standard functions (like \typ{len}) are in the

  1395     \verb+__builtin__+ namespace

  1396   \item Namespaces help organize different names and their bindings to

  1397     different objects

  1398   \end{itemize}

  1399 \end{frame}

  1400 

  1401 \begin{frame}

  1402   \frametitle{Exceptions}

  1403   \begin{itemize}

  1404   \item Python's way of notifying you of errors

  1405   \item Several standard exceptions: \typ{SyntaxError}, \typ{IOError}

  1406     etc.

  1407   \item Users can also \typ{raise} errors

  1408   \item Users can create their own exceptions

  1409   \item Exceptions can be ``caught'' via \typ{try/except} blocks

  1410   \end{itemize}

  1411 \end{frame}

  1412 

  1413 \begin{frame}[fragile]

  1414   \frametitle{Exception: examples}

  1415 \begin{lstlisting}

  1416 >>> 10 * (1/0)

  1417 Traceback (most recent call last):

  1418   File "<stdin>", line 1, in ?

  1419 ZeroDivisionError: integer division or modulo by zero

  1420 >>> 4 + spam*3

  1421 Traceback (most recent call last):

  1422   File "<stdin>", line 1, in ?

  1423 NameError: name 'spam' is not defined

  1424 >>> '2' + 2

  1425 Traceback (most recent call last):

  1426   File "<stdin>", line 1, in ?

  1427 TypeError: cannot concatenate 'str' and 'int' objects

  1428 \end{lstlisting}

  1429 \end{frame}

  1430 

  1431 \begin{frame}[fragile]

  1432   \frametitle{Exception: examples}

  1433 \begin{lstlisting}

  1434 >>> while True:

  1435 ...     try:

  1436 ...         x = int(raw_input("Enter a number: "))

  1437 ...         break

  1438 ...     except ValueError:

  1439 ...         print "Invalid number, try again..."

  1440 ...

  1441 >>> # To raise exceptions

  1442 ... raise ValueError, "your error message"

  1443 Traceback (most recent call last):

  1444   File "<stdin>", line 2, in ?

  1445 ValueError: your error message

  1446 \end{lstlisting}

  1447 \end{frame}

  1448 

  1449 \begin{frame}[fragile]

  1450   \frametitle{Classes: the big picture}

  1451   \begin{itemize}

  1452   \item Lets you create new data types

  1453   \item Class is a template for an object belonging to that class

  1454   \item Note: in Python a class is also an object

  1455   \item Instantiating a class creates an instance (an object)

  1456   \item An instance encapsulates the state (data) and behavior

  1457     (methods)

  1458   \item Allows you to define an inheritance hierarchy

  1459     \begin{itemize}

  1460     \item ``A Honda car \alert{is a} car.''

  1461     \item ``A car \alert{is an} automobile.''

  1462     \item ``A Python \alert{is a} reptile.''

  1463     \end{itemize}

  1464   \item Programmers need to think OO

  1465   \end{itemize}

  1466 \end{frame}

  1467 

  1468 \begin{frame}[fragile]

  1469   \frametitle{Classes: what's the big deal?}

  1470   \begin{itemize}

  1471   \item Lets you create objects that mimic a real problem being

  1472     simulated

  1473   \item Makes problem solving more natural and elegant

  1474   \item Easier to create code

  1475   \item Allows for code-reuse

  1476   \item Polymorphism

  1477   \end{itemize}

  1478 \end{frame}

  1479 

  1480 \begin{frame}[fragile]

  1481   \frametitle{Class definition and instantiation}

  1482   \begin{itemize}

  1483   \item Class definitions when executed create class objects

  1484   \item Instantiating the class object creates an instance of the

  1485     class

  1486   \end{itemize}

  1487 \footnotesize

  1488 \begin{lstlisting}

  1489 class Foo(object):

  1490     pass

  1491 # class object created.

  1492 # Create an instance of Foo.

  1493 f = Foo()

  1494 # Can assign an attribute to the instance

  1495 f.a = 100

  1496 print f.a

  1497 100

  1498 \end{lstlisting}

  1499 \end{frame}

  1500 

  1501 \begin{frame}[fragile]

  1502   \frametitle{Classes \ldots}

  1503   \begin{itemize}

  1504   \item All attributes are accessed via the \typ{object.attribute}

  1505     syntax

  1506   \item Both class and instance attributes are supported

  1507   \item \emph{Methods} represent the behavior of an object: crudely

  1508     think of them as functions ``belonging'' to the object

  1509   \item All methods in Python are ``virtual''

  1510   \item Inheritance through subclassing

  1511   \item Multiple inheritance is supported

  1512   \item No special public and private attributes: only good

  1513     conventions

  1514     \begin{itemize}

  1515     \item \verb+object.public()+: public

  1516     \item \verb+object._private()+ \& \verb+object.__priv()+: 

  1517       non-public

  1518     \end{itemize}

  1519   \end{itemize}

  1520 \end{frame}

  1521 

  1522 \begin{frame}[fragile]

  1523   \frametitle{Classes: examples}

  1524 \begin{lstlisting}

  1525 class MyClass(object):

  1526     """Example class (this is the class docstring)."""

  1527     i = 12345 # A class attribute

  1528     def f(self):

  1529         """This is the method docstring"""

  1530         return 'hello world'

  1531 

  1532 >>> a = MyClass() # creates an instance

  1533 >>> a.f()

  1534 'hello world'

  1535 >>> # a.f() is equivalent to MyClass.f(a)

  1536 ... # This also explains why f has a 'self' argument.

  1537 ... MyClass.f(a)

  1538 'hello world'

  1539 \end{lstlisting}

  1540 \end{frame}

  1541 

  1542 \begin{frame}[fragile]

  1543   \frametitle{Classes (continued)}

  1544   \begin{itemize}

  1545   \item \typ{self} is \alert{conventionally} the first argument for a

  1546     method

  1547   \item In previous example, \typ{a.f} is a method object

  1548   \item When \typ{a.f} is called, it is passed the instance \typ{a} as

  1549     the first argument

  1550   \item If a method called \verb+__init__+ exists, it is called when

  1551     the object is created

  1552   \item If a method called \verb+__del__+ exists, it is called before

  1553     the object is garbage collected

  1554   \item Instance attributes are set by simply ``setting'' them in

  1555     \typ{self}

  1556   \item Other special methods (by convention) like \verb+__add__+ let

  1557     you define numeric types:

  1558     {\footnotesize \url{http://docs.python.org/ref/specialnames.html}

  1559       \\ \url{http://docs.python.org/ref/numeric-types.html}

  1560     }

  1561   \end{itemize}

  1562 \end{frame}

  1563 

  1564 \begin{frame}[fragile]

  1565   \frametitle{Classes: examples}

  1566 \begin{lstlisting}

  1567 class Bag(MyClass): # Shows how to derive classes

  1568     def __init__(self): # called on object creation.

  1569         self.data = [] # an instance attribute

  1570     def add(self, x):

  1571         self.data.append(x)

  1572     def addtwice(self, x):

  1573         self.add(x)

  1574         self.add(x)

  1575 >>> a = Bag()

  1576 >>> a.f() # Inherited method

  1577 'hello world'

  1578 >>> a.add(1); a.addtwice(2)

  1579 >>> a.data

  1580 [1, 2, 2]

  1581 \end{lstlisting}

  1582 \end{frame}

  1583 

  1584 \begin{frame}[fragile]

  1585   \frametitle{Derived classes}

  1586   \begin{itemize}

  1587   \item Call the parent's \verb+__init__+ if needed

  1588   \item If you don't need a new constructor, no need to define it in subclass

  1589   \item Can also use the \verb+super+ built-in function

  1590   \end{itemize}

  1591 \begin{lstlisting}

  1592 class AnotherBag(Bag):

  1593     def __init__(self):

  1594         # Must call parent's __init__ explicitly

  1595         Bag.__init__(self)

  1596         # Alternatively use this:

  1597         super(AnotherBag, self).__init__()

  1598         # Now setup any more data.

  1599         self.more_data = []

  1600 \end{lstlisting}

  1601 \end{frame}

  1602 

  1603 \begin{frame}[fragile]

  1604   \frametitle{Classes: polymorphism}

  1605 \begin{lstlisting}

  1606 class Drawable(object):

  1607     def draw(self):

  1608         # Just a specification.

  1609         pass

  1610 \end{lstlisting}

  1611 \mode<presentation>{\pause}

  1612 \begin{lstlisting}

  1613 class Square(Drawable):

  1614     def draw(self):

  1615         # draw a square.

  1616 class Circle(Drawable):

  1617     def draw(self):

  1618         # draw a circle.

  1619 \end{lstlisting}

  1620 \mode<presentation>{\pause}

  1621 \begin{lstlisting}

  1622 class Artist(Drawable):

  1623     def draw(self):

  1624         for obj in self.drawables:

  1625             obj.draw()

  1626 \end{lstlisting}

  1627 \end{frame}

  1628 

  1629 \subsection{Miscellaneous}

  1630 

  1631 \begin{frame}[fragile]

  1632   \frametitle{Stand-alone scripts}

  1633 Consider a file \typ{f.py}:

  1634 \begin{lstlisting}

  1635 #!/usr/bin/env python

  1636 """Module level documentation."""

  1637 # First line tells the shell that it should use Python

  1638 # to interpret the code in the file.

  1639 def f():

  1640     print "f"

  1641 

  1642 # Check if we are running standalone or as module.

  1643 # When imported, __name__ will not be '__main__'

  1644 if __name__ == '__main__':

  1645     # This is not executed when f.py is imported.

  1646     f() 

  1647 \end{lstlisting}

  1648 \end{frame}

  1649 

  1650 \begin{frame}[fragile]

  1651   \frametitle{List comprehensions}

  1652 \begin{lstlisting}

  1653 >>> veg = ['tomato', 'cabbage', 'carrot', 'potato']

  1654 >>> [x.upper() for x in veg]

  1655 ['TOMATO', 'CABBAGE', 'CARROT', 'POTATO']

  1656 >>> vec = range(0, 8)

  1657 >>> even = [x for x in vec if x%2 == 0]

  1658 >>> even

  1659 [0, 2, 4, 6]

  1660 >>> [x*x for x in even]

  1661 [0, 4, 16, 36]

  1662 >>> odd = [x for x in vec if x%2 == 1]

  1663 >>> odd

  1664 [1, 3, 5, 7]

  1665 >>> [x*y for x in even for y in odd]

  1666 [0, 0, 0, 0, 2, 6, 10, 14, 4, 12, 20, 28, 6, 18,30,42]

  1667 \end{lstlisting}

  1668 \end{frame}

  1669 

  1670 \begin{frame}[fragile]

  1671   \frametitle{More IPython features}

  1672   \begin{itemize}

  1673   \item Input and output caching:

  1674     \begin{itemize}

  1675     \item \verb+In+: a list of all entered input

  1676     \item \verb+Out+: a dict of all output

  1677     \item \verb+_+, \verb+__+, \verb+__+ are the last three results as

  1678       is \verb+_N+

  1679     \item \verb+%hist [-n]+ macro shows previous history, \verb+-n+

  1680       suppresses line number information

  1681     \end{itemize}

  1682   \item Log the session using \verb+%logstart+, \verb+%logon+ and

  1683     \verb+%logoff+

  1684   \item \verb+%run [options] file[.py]+ -- running Python code

  1685     \begin{itemize}

  1686     \item \verb+%run -d [-b<N>]+: debug script with pdb

  1687           \verb+N+ is the line number to break at (defaults to 1)

  1688     \item \verb+%run -t+: time the script

  1689     \item \verb+%run -p+: Profile the script

  1690     \end{itemize}

  1691   \item \verb+%prun+ runs a statement/expression under the profiler

  1692   \item \verb+%macro [options] macro_name n1-n2 n3-n4 n6+ save specified

  1693     lines to a macro with name \verb+macro_name+

  1694   \end{itemize}

  1695 \end{frame}

  1696 

  1697 \begin{frame}[fragile]

  1698   \frametitle{More IPython features \ldots}

  1699   \begin{itemize}

  1700   \item \verb+%edit [options] [args]+: edit lines of code or file

  1701     specified in editor (configure editor via \verb+$EDITOR+)

  1702   \item \verb+%cd+ changes directory, see also \verb+%pushd, %popd, %dhist+

  1703   \item Shell access

  1704     \begin{itemize}

  1705     \item \verb+!command+ runs a shell command and returns its output

  1706     \item \verb+files = %sx ls+ or \verb+files = !ls+ sets

  1707       \verb+files+ to all result of the \verb+ls+ command

  1708     \item \verb+%sx+ is quiet

  1709     \item \verb+!ls $files+ passes the \verb+files+ variable to the

  1710       shell command

  1711     \item \verb+%alias alias_name cmd+ creates an alias for a system

  1712       command

  1713     \end{itemize}

  1714   \item \verb+%colors+ lets you change the color scheme to

  1715     \verb+NoColor, Linux, LightBG+

  1716   \end{itemize}

  1717 \end{frame}

  1718 

  1719 \begin{frame}[fragile]

  1720   \frametitle{More IPython features \ldots}

  1721   \begin{itemize}

  1722   \item Use \verb+;+ at the end of a statement to suppress printing

  1723     output

  1724   \item \verb+%bookmark+: store a bookmarked location, for use with \verb+%cd+

  1725   \item \verb+%who, %whos+: print information on variables

  1726   \item \verb+%save [options] filename n1-n2 n3-n4+: save lines to a

  1727     file

  1728   \item \verb+%time statement+: Time execution of a Python statement or

  1729     expression

  1730   \item \verb+%timeit [-n<N> -r<R> [-t|-c]] statement+: time execution

  1731     using Python's timeit module

  1732   \item Can define and use profiles to setup IPython differently:

  1733     \verb+math, scipy, numeric, pysh+ etc.

  1734   \item \verb+%magic+: \alert{Show help on all magics}

  1735   \end{itemize}

  1736 \end{frame}

  1737 

  1738 \begin{frame}[fragile]

  1739   \frametitle{File handling}

  1740 \begin{lstlisting}

  1741 >>> # Reading files:

  1742 ... f = open('/path/to/file_name')

  1743 >>> data = f.read() # Read entire file.

  1744 >>> line = f.readline() # Read one line.

  1745 >>> # Read entire file appending each line into a list

  1746 ... lines = f.readlines()

  1747 >>> f.close() # close the file.

  1748 >>> # Writing files:

  1749 ... f = open('/path/to/file_name', 'w')

  1750 >>> f.write('hello world\n')

  1751 \end{lstlisting}

  1752   \begin{itemize}

  1753   \item \typ{tell()}: returns int of current position