day1/Session-2.tex
changeset 5 838cedef5e9d
child 14 55fb6114cff9
equal deleted inserted replaced
4:e5047bcbb608 5:838cedef5e9d
       
     1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
     2 % Tutorial slides on Python.
       
     3 %
       
     4 % Author: Prabhu Ramachandran <prabhu at aero.iitb.ac.in>
       
     5 % Copyright (c) 2005-2008, Prabhu Ramachandran
       
     6 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
     7 
       
     8 \documentclass[14pt,compress]{beamer}
       
     9 %\documentclass[draft]{beamer}
       
    10 %\documentclass[compress,handout]{beamer}
       
    11 %\usepackage{pgfpages} 
       
    12 %\pgfpagesuselayout{2 on 1}[a4paper,border shrink=5mm]
       
    13 
       
    14 % Modified from: generic-ornate-15min-45min.de.tex
       
    15 \mode<presentation>
       
    16 {
       
    17   \usetheme{Warsaw}
       
    18   \useoutertheme{split}
       
    19   \setbeamercovered{transparent}
       
    20 }
       
    21 
       
    22 \usepackage[english]{babel}
       
    23 \usepackage[latin1]{inputenc}
       
    24 %\usepackage{times}
       
    25 \usepackage[T1]{fontenc}
       
    26 
       
    27 % Taken from Fernando's slides.
       
    28 \usepackage{ae,aecompl}
       
    29 \usepackage{mathpazo,courier,euler}
       
    30 \usepackage[scaled=.95]{helvet}
       
    31 
       
    32 \definecolor{darkgreen}{rgb}{0,0.5,0}
       
    33 
       
    34 \usepackage{listings}
       
    35 \lstset{language=Python,
       
    36     basicstyle=\ttfamily,
       
    37     commentstyle=\color{red}\itshape,
       
    38   stringstyle=\color{darkgreen},
       
    39   showstringspaces=false,
       
    40   keywordstyle=\color{blue}\bfseries}
       
    41 
       
    42 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
    43 % Macros
       
    44 \setbeamercolor{emphbar}{bg=blue!20, fg=black}
       
    45 \newcommand{\emphbar}[1]
       
    46 {\begin{beamercolorbox}[rounded=true]{emphbar} 
       
    47       {#1}
       
    48  \end{beamercolorbox}
       
    49 }
       
    50 \newcounter{time}
       
    51 \setcounter{time}{0}
       
    52 \newcommand{\inctime}[1]{\addtocounter{time}{#1}{\tiny \thetime\ m}}
       
    53 
       
    54 \newcommand{\typ}[1]{\texttt{#1}}
       
    55 
       
    56 \newcommand{\kwrd}[1]{ \texttt{\textbf{\color{blue}{#1}}}  }
       
    57 
       
    58 %%% This is from Fernando's setup.
       
    59 % \usepackage{color}
       
    60 % \definecolor{orange}{cmyk}{0,0.4,0.8,0.2}
       
    61 % % Use and configure listings package for nicely formatted code
       
    62 % \usepackage{listings}
       
    63 % \lstset{
       
    64 %    language=Python,
       
    65 %    basicstyle=\small\ttfamily,
       
    66 %    commentstyle=\ttfamily\color{blue},
       
    67 %    stringstyle=\ttfamily\color{orange},
       
    68 %    showstringspaces=false,
       
    69 %    breaklines=true,
       
    70 %    postbreak = \space\dots
       
    71 % }
       
    72 
       
    73 
       
    74 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
    75 % Title page
       
    76 \title[Basic Python]{Python:\\A great programming toolkit}
       
    77 
       
    78 \author[Asokan \& Prabhu] {Asokan Pichai\\Prabhu Ramachandran}
       
    79 
       
    80 \institute[IIT Bombay] {Department of Aerospace Engineering\\IIT Bombay}
       
    81 \date[] {25, July 2009}
       
    82 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
    83 
       
    84 %\pgfdeclareimage[height=0.75cm]{iitmlogo}{iitmlogo}
       
    85 %\logo{\pgfuseimage{iitmlogo}}
       
    86 
       
    87 
       
    88 %% Delete this, if you do not want the table of contents to pop up at
       
    89 %% the beginning of each subsection:
       
    90 \AtBeginSubsection[]
       
    91 {
       
    92   \begin{frame}<beamer>
       
    93     \frametitle{Outline}
       
    94     \tableofcontents[currentsection,currentsubsection]
       
    95   \end{frame}
       
    96 }
       
    97 
       
    98 
       
    99 % If you wish to uncover everything in a step-wise fashion, uncomment
       
   100 % the following command: 
       
   101 %\beamerdefaultoverlayspecification{<+->}
       
   102 
       
   103 %\includeonlyframes{current,current1,current2,current3,current4,current5,current6}
       
   104 
       
   105 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   106 % DOCUMENT STARTS
       
   107 \begin{document}
       
   108 
       
   109 \begin{frame}
       
   110   \titlepage
       
   111 \end{frame}
       
   112 \begin{frame}
       
   113   {Acknowledgements}
       
   114   \begin{center}
       
   115   This program is conducted by\\
       
   116   IIT, Bombay\\
       
   117   through CDEEP\\as part of  the open source initiatives\\
       
   118   under the aegis of\\
       
   119   \alert{National Mission on Education through ICT,} \\
       
   120   Ministry of HRD.
       
   121   \end{center}
       
   122 \end{frame}
       
   123 
       
   124 \begin{frame}
       
   125   \frametitle{Outline}
       
   126   \tableofcontents
       
   127   % You might wish to add the option [pausesections]
       
   128 \end{frame}
       
   129 
       
   130 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   131 % TODO
       
   132 %
       
   133 %  * Add slide on Python packages (modules)
       
   134 %  * Add slides on reference counting.
       
   135 
       
   136 \section{Agenda}
       
   137 \begin{frame}{About the Workshop}
       
   138   \begin{description}
       
   139 	\item[Session 1] Sat 14:00--15:55
       
   140 	\item[Session 2] Sat 16:05--18:00
       
   141 	\item[Session 3] Sun 14:00--15:55
       
   142 	\item[Session 4] Sun 16:05--18:00 
       
   143   \end{description}
       
   144 
       
   145   \begin{block}{Goal of the workshop}
       
   146 	At the end of this program, successful participants will be able to use python as their scripting and problem solving language. Aimed at Engg. students--focus on basic numerics and plotting-- but should serve a similar purpose for others. 
       
   147   \end{block}
       
   148 \end{frame}
       
   149 
       
   150 \begin{frame}{Checklist}
       
   151   Let us verify that all of us are having the same (similar) tools and environment
       
   152   \begin{description}
       
   153 	\item[python] Type python at the command line. Do you see version 2.5 or later?
       
   154 	\item[IPython] Is IPython available?
       
   155 	\item[Editor] Which editor? scite, vim, emacs, \ldots
       
   156   \end{description}
       
   157 \end{frame}
       
   158 
       
   159 \section{Overview}
       
   160 \begin{frame}{Session 1}
       
   161   \begin{itemize}
       
   162 	\item Introduction and motivation
       
   163 	\item Using the interpreter(s)
       
   164 	\item Basic data types: int, float, string
       
   165 	\item Basic data structures: list
       
   166 	\item Basic console IO: \texttt{raw\_input(), print}
       
   167     \item Basic control flow: \texttt{if, while}
       
   168 	\item Problem set 1
       
   169     \item Functions $\rightarrow$ Problem set 2
       
   170     \item lists, \texttt{for}  $\rightarrow$ Problem set 3
       
   171     \item IO, Modules $\rightarrow$ Problem sets 4,5, \ldots
       
   172   \end{itemize}
       
   173 \end{frame}
       
   174 
       
   175 \begin{frame}
       
   176   \frametitle{Introduction}
       
   177   \begin{itemize}
       
   178   \item Creator and BDFL: Guido van Rossum
       
   179   \item Conceived in December 1989
       
   180   \item ``Python'' as in Monty Python's Flying Circus
       
   181   \item Current stable version of Python is 2.6.x
       
   182   \item PSF license (like BSD: no strings attached)
       
   183   \item Highly cross platform
       
   184   \item Runs on the Nokia series 60!
       
   185   \item \alert{Philosophy:} Simple and complete by design
       
   186   \end{itemize}
       
   187 \end{frame}
       
   188 
       
   189 \begin{frame}
       
   190   \frametitle{Resources}
       
   191   \begin{itemize}
       
   192   \item Part of many GNU/Linux distributions
       
   193   \item Web: \url{http://www.python.org}
       
   194   \item Doc: \url{http://www.python.org/doc}
       
   195   \item Free Tutorials:
       
   196     \begin{itemize}
       
   197     \item Official Python tutorial: \url{http://docs.python.org/tut/tut.html}
       
   198     \item Byte of Python: \url{http://www.byteofpython.info/}
       
   199     \item Dive into Python: \url{http://diveintopython.org/}
       
   200     \end{itemize}
       
   201   \end{itemize}
       
   202 \end{frame}
       
   203 
       
   204 \begin{frame}
       
   205   \frametitle{Why Python?}
       
   206   \begin{itemize}
       
   207   \item Designed to be readable and easy to use
       
   208   \item High level, interpreted, modular, OO
       
   209   \item Much faster development cycle
       
   210   \item Powerful interactive environment
       
   211   \item Rapid application development
       
   212   \item Rich standard library and modules
       
   213   \item Interfaces well with C++, C and FORTRAN
       
   214   \item \alert{More than a math package $\Rightarrow$ some extra work compared to math packages}
       
   215   \end{itemize}
       
   216 \end{frame}
       
   217 
       
   218 \begin{frame}
       
   219   \frametitle{Use cases}
       
   220   \begin{itemize}
       
   221   \item NASA: Space Shuttle Mission Design
       
   222   \item AstraZeneca: Collaborative Drug Discovery
       
   223   \item ForecastWatch.com: Helps Meteorologists
       
   224   \item Industrial Light \& Magic: Runs on Python
       
   225   \item Zope: Commercial grade Toolkit
       
   226   \item Plone: Professional high feature CMS
       
   227   \item RedHat: install scripts, sys-admin tools
       
   228   \item Django: A great web application framework
       
   229   \item Google: A strong python shop
       
   230   \end{itemize}
       
   231 \end{frame}
       
   232 
       
   233 \begin{frame}
       
   234   \frametitle{To sum up, python is\ldots}
       
   235   \begin{itemize}
       
   236   \item dynamically typed, interpreted $\rightarrow$ rapid testing/prototyping
       
   237   \item powerful, very high level
       
   238   \item has full introspection 
       
   239   \item Did we mention powerful?
       
   240   \end{itemize}
       
   241   \begin{block}{But \ldots}
       
   242     may be wanting in performance. specialised resources such as SWIG, \alert{Cython} are available 
       
   243   \end{block}
       
   244   \inctime{15}
       
   245 \end{frame}
       
   246 
       
   247 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   248 % TIME: 15 m, running 15m
       
   249 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   250 
       
   251 \section{Python}
       
   252 
       
   253 \subsection{Getting Started}
       
   254 
       
   255 \begin{frame}[fragile]{At the prompt, type the following}
       
   256    \begin{lstlisting}
       
   257 >>> print 'Hello Python' 
       
   258 >>> print 3124 * 126789
       
   259 >>> 1786 % 12
       
   260 >>> 3124 * 126789
       
   261 >>> a = 3124 * 126789
       
   262 >>> big = 12345678901234567890 ** 3
       
   263 >>> verybig = big * big * big * big 
       
   264 >>> 12345**6, 12345**67, 12345**678
       
   265   \end{lstlisting}
       
   266 \end{frame}
       
   267 
       
   268 \begin{frame}[fragile]{At the prompt, type the following}
       
   269    \begin{lstlisting}
       
   270 >>> s = 'Hello '
       
   271 >>> p = 'World'
       
   272 >>> s + p 
       
   273 >>> s * 12 
       
   274 >>> s * s
       
   275 >>> s + p * 12, (s + p)* 12
       
   276 >>> s * 12 + p * 12
       
   277 >>> 12 * s 
       
   278     \end{lstlisting}
       
   279 \end{frame}
       
   280 
       
   281 \begin{frame}[fragile]{At the prompt, type the following}
       
   282   \begin{lstlisting}
       
   283 >>> 17/2
       
   284 >>> 17/2.0
       
   285 >>> 17.0/2
       
   286 >>> 17.0/8.5
       
   287 >>> int(17/2.0)
       
   288 >>> float(17/2)
       
   289 >>> str(17/2.0)
       
   290 >>> round( 7.5 )
       
   291   \end{lstlisting}
       
   292   \begin{block}{Mini exercise}
       
   293 	Round a float to the nearest integer, using \texttt{int()}?
       
   294   \end{block}
       
   295 \end{frame}
       
   296 
       
   297 \begin{frame}{Midi exercises}
       
   298   \begin{center}
       
   299     \begin{itemize}
       
   300       \item What does this do?
       
   301       \item \texttt{round(amount * 10) /10.0 }
       
   302     \end{itemize}
       
   303   \end{center}
       
   304 \end{frame}
       
   305 
       
   306 \begin{frame}{More exercises?}
       
   307   \begin{center}
       
   308     \begin{block}{Round sums}
       
   309       How to round a number to the nearest  5 paise?\\
       
   310       \begin{description}
       
   311         \item[Remember] 17.23 $\rightarrow$ 17.25,\\ while 17.22 $\rightarrow$ 17.20\\
       
   312       \end{description}
       
   313       How to round a number to the nearest 20 paise?
       
   314     \end{block}
       
   315   \end{center}
       
   316 \end{frame}
       
   317 
       
   318 \begin{frame}[fragile] {A question of good style}
       
   319   \begin{lstlisting}
       
   320     amount = 12.68
       
   321     denom = 0.05
       
   322     nCoins = round(amount/denom)
       
   323     rAmount = nCoins * denom
       
   324   \end{lstlisting}
       
   325   \pause
       
   326   \begin{block}{Style Rule \#1}
       
   327     Naming is 80\% of programming
       
   328   \end{block}
       
   329 \end{frame}
       
   330 
       
   331 
       
   332 \begin{frame}[fragile]
       
   333   \frametitle{Odds and ends}
       
   334   \begin{itemize}
       
   335     \item Case sensitive
       
   336     \item Dynamically typed $\Rightarrow$ need not specify a type
       
   337       \begin{lstlisting}
       
   338 a = 1
       
   339 a = 1.1
       
   340 a = "Now I am a string!"
       
   341       \end{lstlisting}
       
   342     \item Comments:
       
   343       \begin{lstlisting}
       
   344 a = 1  # In-line comments
       
   345 # Comment in a line to itself.
       
   346 a = "# This is not a comment!"
       
   347       \end{lstlisting}
       
   348   \end{itemize}
       
   349   \inctime{15}
       
   350 \end{frame}
       
   351 
       
   352 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   353 % TIME: 15 m, running 30m
       
   354 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   355 
       
   356 \subsection{Data types}
       
   357 \begin{frame}
       
   358   \frametitle{Basic types}
       
   359   \begin{itemize}
       
   360     \item numbers: float, int, long, complex
       
   361     \item strings
       
   362     \item boolean
       
   363   \end{itemize}
       
   364   \begin{block}{Also to be discussed later}
       
   365     tuples, lists, dictionaries, functions, objects\ldots
       
   366   \end{block}
       
   367 \end{frame}
       
   368 
       
   369 \begin{frame}[fragile]
       
   370   \frametitle{Numbers}
       
   371   \vspace*{-0.25in}
       
   372   \begin{lstlisting}
       
   373 >>> a = 1 # Int.
       
   374 >>> l = 1000000L # Long
       
   375 >>> e = 1.01325e5 # float
       
   376 >>> f = 3.14159 # float
       
   377 >>> c = 1+1j # Complex!
       
   378 >>> print f*c/a
       
   379 (3.14159+3.14159j)
       
   380 >>> print c.real, c.imag
       
   381 1.0 1.0
       
   382 >>> abs(c)
       
   383 1.4142135623730951
       
   384 >>> abs( 8 - 9.5 )
       
   385 1.5
       
   386   \end{lstlisting}
       
   387 \end{frame}
       
   388 
       
   389 \begin{frame}[fragile]
       
   390   \frametitle{Boolean}
       
   391   \begin{lstlisting}
       
   392 >>> t = True
       
   393 >>> f = not t
       
   394 False
       
   395 >>> f or t
       
   396 True
       
   397 >>> f and t
       
   398 False
       
   399   \end{lstlisting}
       
   400   \begin{block}{Try:}
       
   401   NOT True\\
       
   402   not TRUE
       
   403   \end{block}
       
   404 \end{frame}
       
   405 
       
   406 \begin{frame}[fragile]
       
   407   \frametitle{Relational and logical operators}
       
   408   \begin{lstlisting}
       
   409 >>> a, b, c = -1, 0, 1
       
   410 >>> a == b
       
   411 False
       
   412 >>> a <= b 
       
   413 True
       
   414 >>> a + b != c
       
   415 True
       
   416 >>> a < b < c
       
   417 True
       
   418 >>> c >= a + b
       
   419 True
       
   420   \end{lstlisting}
       
   421 \end{frame}
       
   422 
       
   423 \begin{frame}[fragile]
       
   424   \frametitle{Strings}
       
   425   \begin{lstlisting}
       
   426 s = 'this is a string'
       
   427 s = 'This one has "quotes" inside!'
       
   428 s = "I have 'single-quotes' inside!"
       
   429 l = "A string spanning many lines\
       
   430 one more line\
       
   431 yet another"
       
   432 t = """A triple quoted string does
       
   433 not need to be escaped at the end and 
       
   434 "can have nested quotes" etc."""
       
   435   \end{lstlisting}
       
   436 \end{frame}
       
   437 
       
   438 \begin{frame}[fragile]
       
   439   \frametitle{More Strings}
       
   440   \vspace*{-0.2in}
       
   441   \begin{lstlisting}
       
   442 >>> w = "hello"    
       
   443 >>> print w[0] + w[2] + w[-1]
       
   444 hlo
       
   445 >>> len(w) # guess what
       
   446 5
       
   447 >>> s = u'Unicode strings!'
       
   448 >>> # Raw strings (note the leading 'r')
       
   449 ... r_s = r'A string $\alpha \nu$'
       
   450   \end{lstlisting}
       
   451 \pause
       
   452   \begin{lstlisting}
       
   453 >>> w[0] = 'H' # Can't do that!
       
   454 Traceback (most recent call last):
       
   455   File "<stdin>", line 1, in ?
       
   456 TypeError: object does not support item assignment
       
   457   \end{lstlisting}
       
   458 \end{frame}
       
   459 
       
   460 \begin{frame}
       
   461   \frametitle{Let us switch to IPython}
       
   462   Why?
       
   463   \begin{block}
       
   464     {Better help (and a lot more)}
       
   465     Tab completion\\
       
   466     ?\\
       
   467     .?\\
       
   468     object.function?
       
   469   \end{block}
       
   470 \end{frame}
       
   471 
       
   472 \begin{frame}[fragile]
       
   473   \frametitle{More on strings}
       
   474   \begin{lstlisting}
       
   475 In [1]: a = 'hello world'
       
   476 In [2]: a.startswith('hell')
       
   477 Out[2]: True
       
   478 In [3]: a.endswith('ld')
       
   479 Out[3]: True
       
   480 In [4]: a.upper()
       
   481 Out[4]: 'HELLO WORLD'
       
   482 In [5]: a.upper().lower()
       
   483 Out[5]: 'hello world'
       
   484   \end{lstlisting}
       
   485 \end{frame}
       
   486 
       
   487 \begin{frame}[fragile]{Still with strings}
       
   488   \begin{lstlisting}
       
   489 In [6]: a.split()
       
   490 Out[6]: ['hello', 'world']
       
   491 In [7]: ''.join(['a', 'b', 'c'])
       
   492 Out[7]: 'abc'
       
   493 In [8] 'd' in ''.join( 'a', 'b', 'c')
       
   494 Out[8]: False
       
   495   \end{lstlisting}
       
   496   \begin{block}{Try:}
       
   497     \texttt{a.split( 'o' )}\\
       
   498     \texttt{'x'.join( a.split( 'o' ) )}
       
   499   \end{block}
       
   500 \end{frame}
       
   501 
       
   502 \begin{frame}[fragile]{Surprise! strings!!}
       
   503   \begin{lstlisting}
       
   504 In [11]: x, y = 1, 1.2
       
   505 In [12]: 'x is %s, y is %s' %(x, y)
       
   506 Out[12]: 'x is 1, y is 1.234'
       
   507   \end{lstlisting}
       
   508   \begin{block}{Try:}
       
   509     \texttt{'x is \%d, y is \%f' \%(x, y) }\\
       
   510     \texttt{'x is \%3d, y is \%4.2f' \%(x, y) }
       
   511   \end{block}
       
   512   \small
       
   513 \url{docs.python.org/lib/typesseq-strings.html}\\
       
   514 \end{frame}
       
   515 
       
   516 \begin{frame}
       
   517   {Interlude}
       
   518   \begin{block}
       
   519     {A classic problem}
       
   520     How to interchange values of two variables? Please note that the type of either variable is unknown and it is not necessary that both be of the same type even!
       
   521   \end{block}
       
   522   \inctime{30}
       
   523 \end{frame}
       
   524 
       
   525 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   526 % TIME: 25 m+ Interlude break 5 mins, running 60m 
       
   527 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   528 
       
   529 \subsection{Control flow}
       
   530 \begin{frame}
       
   531   \frametitle{Control flow constructs}  
       
   532   \begin{itemize}
       
   533   \item \kwrd{if/elif/else}: branching
       
   534   \item \kwrd{while}: looping
       
   535   \item \kwrd{for}: iterating 
       
   536   \item \kwrd{break, continue}: modify loop 
       
   537   \item \kwrd{pass}: syntactic filler
       
   538   \end{itemize}
       
   539 \end{frame}
       
   540 
       
   541 \begin{frame}[fragile]
       
   542   \frametitle{Basic conditional flow}
       
   543   \begin{lstlisting}
       
   544 In [21]: a = 7
       
   545 In [22]: b = 8
       
   546 In [23]: if a > b:
       
   547    ....:    print 'Hello'
       
   548    ....: else:
       
   549    ....:     print 'World'
       
   550    ....:
       
   551    ....:
       
   552 World
       
   553   \end{lstlisting}
       
   554   Let us switch to creating a file
       
   555 \end{frame}
       
   556 
       
   557 \begin{frame}
       
   558   {Creating python files}
       
   559   \begin{itemize}
       
   560     \item aka scripts
       
   561     \item use your editor
       
   562     \item Note that white space is the way to specify blocks!
       
   563     \item extension \typ{.py}
       
   564     \item run with \texttt{python hello.py} at the command line
       
   565     \item in IPython\ldots
       
   566   \end{itemize}
       
   567 \end{frame}
       
   568 
       
   569 \begin{frame}[fragile]
       
   570   \frametitle{\typ{If...elif...else} example}
       
   571 \begin{lstlisting}
       
   572 x = int(raw_input("Enter an integer:"))
       
   573 if x < 0:
       
   574      print 'Be positive!'
       
   575 elif x == 0:
       
   576      print 'Zero'
       
   577 elif x == 1:
       
   578      print 'Single'
       
   579 else:
       
   580      print 'More'
       
   581 \end{lstlisting}
       
   582 \end{frame}
       
   583 
       
   584 \begin{frame}{Simple IO}
       
   585   \begin{block}
       
   586     {Console Input}
       
   587     \texttt{raw\_input(}) waits for user input.\\Prompt string is optional.\\
       
   588     All keystrokes are Strings!\\\texttt{int()} converts string to int.
       
   589   \end{block}
       
   590   \begin{block}
       
   591     {Console output}
       
   592     \texttt{print} is straight forward. Major point to remember is the distinction between \texttt{print x} and \texttt{print x,}
       
   593   \end{block}
       
   594 \end{frame}
       
   595 
       
   596 \begin{frame}[fragile]
       
   597   \frametitle{Basic looping}
       
   598   \begin{lstlisting}
       
   599 # Fibonacci series:
       
   600 # the sum of two elements
       
   601 # defines the next
       
   602 a, b = 0, 1
       
   603 while b < 10:
       
   604     print b,
       
   605     a, b = b, a + b
       
   606  
       
   607 \end{lstlisting}
       
   608 \typ{1 1 2 3 5 8}\\  
       
   609 \alert{Recall it is easy to write infinite loops with \kwrd{while}}
       
   610   \inctime{20}
       
   611 \end{frame}
       
   612 
       
   613 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   614 % TIME: 20 m, running 80m 
       
   615 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   616 
       
   617 \begin{frame}
       
   618   \frametitle{Problem set 1}
       
   619   \begin{itemize}
       
   620     \item All the problems can be\\
       
   621       solved using \kwrd{if} and \kwrd{while} 
       
   622   \end{itemize}
       
   623 \end{frame}
       
   624 
       
   625 \begin{frame}{Problem 1.1}
       
   626   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$\\
       
   627 These are called $Armstrong$ numbers.
       
   628 \end{frame}
       
   629   
       
   630 \begin{frame}{Problem 1.2 - Collatz sequence}
       
   631 \begin{enumerate}
       
   632   \item Start with an arbitrary (positive) integer. 
       
   633   \item If the number is even, divide by 2; if the number is odd multiply by 3 and add 1.
       
   634   \item Repeat the procedure with the new number.
       
   635   \item It appears that for all starting values there is a cycle of 4, 2, 1 at which the procedure loops.
       
   636 \end{enumerate}
       
   637     Write a program that accepts the starting value and prints out the Collatz sequence.
       
   638 
       
   639 \end{frame}
       
   640 
       
   641 \begin{frame}{Problem 1.3 - Kaprekar's constant}
       
   642   \begin{enumerate}
       
   643     \item Take a four digit number--with at least two digits different.
       
   644     \item Arrange the digits in ascending and descending order, giving A and D respectively.
       
   645     \item Leave leading zeros in A!
       
   646     \item Subtract A from D.
       
   647     \item With the result, repeat from step 2.
       
   648   \end{enumerate}
       
   649   Write a program to accept a 4-digit number and display the progression to Kaprekar's constant.
       
   650 \end{frame}
       
   651 
       
   652 \begin{frame}[fragile]{Problem 1.4}
       
   653   Write a program that prints the following pyramid on the screen. 
       
   654   \begin{lstlisting}
       
   655 1
       
   656 2  2
       
   657 3  3  3
       
   658 4  4  4  4
       
   659   \end{lstlisting}
       
   660 The number of lines must be obtained from the user as input.\\
       
   661 \pause
       
   662 When can your code fail?
       
   663 \only<2->{\inctime{25}}
       
   664 \end{frame}
       
   665 
       
   666 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   667 % TIME: 25 m, running 105m 
       
   668 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   669 
       
   670 \subsection{Functions}
       
   671 \begin{frame}[fragile]
       
   672 \frametitle{Functions: examples}
       
   673   \begin{lstlisting}
       
   674 def signum( r ):
       
   675     """returns 0 if r is zero
       
   676     -1 if r is negative
       
   677     +1 if r is positive"""
       
   678     if r < 0:
       
   679         return -1
       
   680     elif r > 0:
       
   681         return 1
       
   682     else:
       
   683         return 0
       
   684   \end{lstlisting}
       
   685 \end{frame}
       
   686 
       
   687 \begin{frame}[fragile]
       
   688   \frametitle{Functions: examples}
       
   689   \begin{lstlisting}
       
   690 def pad( n, size ): 
       
   691     """pads integer n with spaces
       
   692     into a string of length size
       
   693     """
       
   694     SPACE = ' '
       
   695     s = str( n )
       
   696     padSize = size - len( s )
       
   697     return padSize * SPACE + s
       
   698   \end{lstlisting}
       
   699 \pause
       
   700 What about \%3d?
       
   701 \end{frame}
       
   702 
       
   703 \begin{frame}[fragile]
       
   704   {What does this function do?}
       
   705   \begin{lstlisting}
       
   706 def what( n ):
       
   707     if n < 0: n = -n
       
   708     while n > 0:
       
   709         if n % 2 == 1:
       
   710             return False
       
   711         n /= 10
       
   712     return True
       
   713   \end{lstlisting}
       
   714 \end{frame}
       
   715 
       
   716 \begin{frame}[fragile]
       
   717   {What does this function do?}
       
   718 \begin{lstlisting}
       
   719 def what( n ):
       
   720     i = 1    
       
   721     while i * i < n:
       
   722         i += 1
       
   723     return i * i == n, i
       
   724   \end{lstlisting}
       
   725 \end{frame}
       
   726 
       
   727 \begin{frame}[fragile]
       
   728   {What does this function do?}
       
   729   \begin{lstlisting}
       
   730 def what( n, x ):
       
   731     z = 1.0
       
   732     if n < 0:
       
   733         x = 1.0 / x
       
   734         n = -n
       
   735     while n > 0:
       
   736         if n % 2 == 1:
       
   737             z *= x
       
   738         n /= 2
       
   739         x *= x
       
   740     return z
       
   741   \end{lstlisting}
       
   742 \end{frame}
       
   743 
       
   744 \begin{frame}
       
   745   {Before writing a function}
       
   746   \begin{itemize}
       
   747       \item Builtin functions for various and sundry
       
   748       \item \typ{abs, any, all, len, max, min}
       
   749       \item \typ{pow, range, sum, type}
       
   750       \item Refer here:
       
   751           \url{http://docs.python.org/library/functions.html}
       
   752   \end{itemize}
       
   753   \inctime{15} 
       
   754 \end{frame}
       
   755 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   756 % TIME: 15 m, running 120m 
       
   757 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   758 
       
   759 \begin{frame}{Problem set 2}
       
   760   The focus is on writing functions and calling them.
       
   761 \end{frame}
       
   762 
       
   763 \begin{frame}{Problem 2.1}
       
   764   Write a function to return the gcd of two numbers.
       
   765 \end{frame}
       
   766 
       
   767 \begin{frame}{Problem 2.2}
       
   768 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. \\
       
   769 Write a program to print primitive pythagorean triads. The program should generate all triads with a, b values in the range 0---100
       
   770 \end{frame}
       
   771 
       
   772 \begin{frame}{Problem 2.3}
       
   773   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).
       
   774 \end{frame}
       
   775 
       
   776 \begin{frame}{Problem 2.4}
       
   777   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.\\
       
   778   Write a function that returns the aliquot number of a given number. 
       
   779 \end{frame}
       
   780 
       
   781 \begin{frame}{Problem 2.5}
       
   782   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.\\
       
   783   Example: \texttt{220, 284}\\
       
   784   Write a program that prints all five digit amicable pairs.
       
   785   \inctime{30}
       
   786 \end{frame}
       
   787 
       
   788 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   789 % TIME: 30 m, running 150m 
       
   790 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   791 
       
   792 \subsection{Lists}
       
   793 
       
   794 \begin{frame}[fragile]
       
   795   \frametitle{List creation and indexing}
       
   796 \begin{lstlisting}
       
   797 >>> a = [] # An empty list.
       
   798 >>> a = [1, 2, 3, 4] # More useful.
       
   799 >>> len(a) 
       
   800 4
       
   801 >>> a[0] + a[1] + a[2] + a[-1]
       
   802 10
       
   803 \end{lstlisting}
       
   804   \begin{itemize}
       
   805   \item Indices start with ?
       
   806   \item Negative indices indicate ?
       
   807   \end{itemize}
       
   808 \end{frame}
       
   809 
       
   810 \begin{frame}[fragile]
       
   811   \frametitle{List: slices}
       
   812   \begin{itemize}
       
   813   \item Slicing is a basic operation
       
   814   \item \typ{list[initial:final:step]}
       
   815   \item  The step is optional
       
   816   \end{itemize}
       
   817 \begin{lstlisting}
       
   818 >>> a[1:3] # A slice.
       
   819 [2, 3]
       
   820 >>> a[1:-1]
       
   821 [2, 3, 4]
       
   822 >>> a[1:] == a[1:-1]
       
   823 False  
       
   824 \end{lstlisting}
       
   825 Explain last result
       
   826 \end{frame}
       
   827 
       
   828 \begin{frame}[fragile]
       
   829   \frametitle{List: more slices}
       
   830 \begin{lstlisting}
       
   831 >>> a[0:-1:2] # Notice the step!
       
   832 [1, 3]
       
   833 >>> a[::2]
       
   834 [1, 3]
       
   835 >>> a[-1::-1]
       
   836 \end{lstlisting}
       
   837 What do you think the last one will do?
       
   838   \emphbar{Note: Strings also use same indexing and slicing.}
       
   839 \end{frame}
       
   840 
       
   841 \begin{frame}[fragile]
       
   842   \frametitle{List: examples}
       
   843 \begin{lstlisting}
       
   844 >>> a = [1, 2, 3, 4]
       
   845 >>> a[:2]
       
   846 [1, 3]
       
   847 >>> a[0:-1:2]
       
   848 [1, 3]
       
   849 \end{lstlisting}
       
   850 \pause
       
   851 \alert{Lists are mutable (unlike strings)}
       
   852 \begin{lstlisting}
       
   853 >>> a[1] = 20
       
   854 >>> a
       
   855 [1, 20, 3, 4]
       
   856 \end{lstlisting}
       
   857 \end{frame}
       
   858 
       
   859 \begin{frame}[fragile]
       
   860   \frametitle{Lists are mutable and heterogenous}
       
   861 \begin{lstlisting}
       
   862 >>> a = ['spam', 'eggs', 100, 1234]
       
   863 >>> a[2] = a[2] + 23
       
   864 >>> a
       
   865 ['spam', 'eggs', 123, 1234]
       
   866 >>> a[0:2] = [1, 12] # Replace items
       
   867 >>> a
       
   868 [1, 12, 123, 1234]
       
   869 >>> a[0:2] = [] # Remove items
       
   870 >>> a.append( 12345 )
       
   871 >>> a
       
   872 [123, 1234, 12345]
       
   873 \end{lstlisting}
       
   874 \end{frame}
       
   875 
       
   876 \begin{frame}[fragile]
       
   877   \frametitle{List methods}
       
   878 \begin{lstlisting}
       
   879 >>> a = ['spam', 'eggs', 1, 12]
       
   880 >>> a.reverse() # in situ
       
   881 >>> a
       
   882 [12, 1, 'eggs', 'spam']
       
   883 >>> a.append(['x', 1]) 
       
   884 >>> a
       
   885 [12, 1, 'eggs', 'spam', ['x', 1]]
       
   886 >>> a.extend([1,2]) # Extend the list.
       
   887 >>> a.remove( 'spam' )
       
   888 >>> a
       
   889 [12, 1, 'eggs', ['x', 1], 1, 2]
       
   890 \end{lstlisting}
       
   891 \end{frame}
       
   892 
       
   893 \begin{frame}[fragile]
       
   894   \frametitle{List containership}
       
   895   \begin{lstlisting}
       
   896 >>> a = ['cat', 'dog', 'rat', 'croc']
       
   897 >>> 'dog' in a
       
   898 True
       
   899 >>> 'snake' in a
       
   900 False
       
   901 >>> 'snake' not in a
       
   902 True
       
   903 >>> 'ell' in 'hello world'
       
   904 True
       
   905   \end{lstlisting}
       
   906 \end{frame}
       
   907 
       
   908 \begin{frame}[fragile]
       
   909   \frametitle{Tuples: immutable}
       
   910 \begin{lstlisting}
       
   911 >>> t = (0, 1, 2)
       
   912 >>> print t[0], t[1], t[2], t[-1] 
       
   913 0 1 2 2
       
   914 >>> t[0] = 1
       
   915 Traceback (most recent call last):
       
   916   File "<stdin>", line 1, in ?
       
   917 TypeError: object does not support item
       
   918            assignment
       
   919 \end{lstlisting}  
       
   920 \begin{itemize}
       
   921     \item Multiple return values are actually a tuple.
       
   922     \item Exchange is tuple (un)packing
       
   923 \end{itemize}
       
   924 
       
   925 \end{frame}
       
   926 
       
   927 \begin{frame}[fragile]
       
   928   \frametitle{\typ{range()} function}
       
   929   \begin{lstlisting}
       
   930 >>> range(7)
       
   931 [0, 1, 2, 3, 4, 5, 6]
       
   932 >>> range( 3, 9)
       
   933 [3, 4, 5, 6, 7, 8]
       
   934 >>> range( 4, 17, 3)
       
   935 [4, 7, 10, 13, 16]
       
   936 >>> range( 5, 1, -1)
       
   937 [5, 4, 3, 2]
       
   938 >>> range( 8, 12, -1)
       
   939 []
       
   940   \end{lstlisting}
       
   941 \end{frame}
       
   942 
       
   943 \begin{frame}[fragile]
       
   944   \frametitle{\typ{for\ldots range(\ldots)} idiom}
       
   945   \begin{lstlisting}
       
   946 In [83]: for i in range(5):
       
   947    ....:     print i, i * i
       
   948    ....:     
       
   949    ....:     
       
   950 0 0
       
   951 1 1
       
   952 2 4
       
   953 3 9
       
   954 4 16
       
   955 \end{lstlisting}
       
   956 \end{frame}
       
   957 
       
   958 \begin{frame}[fragile]
       
   959   \frametitle{\typ{for}: the list companion}
       
   960   
       
   961   \begin{lstlisting}
       
   962 In [84]: a = ['a', 'b', 'c']
       
   963 In [85]: for x in a:
       
   964    ....:    print x, chr( ord(x) + 10 )
       
   965    ....:
       
   966 a  k
       
   967 b  l
       
   968 c  m
       
   969   \end{lstlisting}
       
   970   Iterating over the list and not the index + reference\\
       
   971   what if you want the index?
       
   972 \end{frame}
       
   973 
       
   974 \begin{frame}[fragile]
       
   975   \frametitle{\typ{for}: the list companion}
       
   976   \begin{lstlisting}
       
   977 In [89]: for p, ch in enumerate( a ):
       
   978    ....:     print p, ch
       
   979    ....:     
       
   980    ....:     
       
   981 0 a
       
   982 1 b
       
   983 2 c
       
   984   \end{lstlisting}
       
   985 Try: \typ{print enumerate(a)}
       
   986 \inctime{20}
       
   987 \end{frame}
       
   988 
       
   989 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   990 % TIME: 20 m, running 170m 
       
   991 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
   992 
       
   993 \begin{frame}
       
   994   {Problem set 3}
       
   995   As you can guess, idea is to use \kwrd{for}!
       
   996 \end{frame}
       
   997 
       
   998 \begin{frame}{Problem 3.1}
       
   999   Which of the earlier problems is simpler when we use \kwrd{for} instead of \kwrd{while}? 
       
  1000 \end{frame}
       
  1001 
       
  1002 \begin{frame}{Problem 3.2}
       
  1003   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.
       
  1004 \end{frame}
       
  1005 
       
  1006 \begin{frame}[fragile]
       
  1007   \frametitle{Problem 3.3}
       
  1008 
       
  1009   Given two real numbers \typ{a, b}, and an integer \typ{N}, write a
       
  1010   function named \typ{linspace( a, b, N)} that returns an ordered list
       
  1011   of \typ{N} points starting with \typ{a} and ending in \typ{b} and
       
  1012   equally spaced.\\
       
  1013 
       
  1014   For example, \typ{linspace(0, 5, 11)}, should return, \\
       
  1015 \begin{lstlisting}
       
  1016 [ 0.0 ,  0.5,  1.0 ,  1.5,  2.0 ,  2.5,  
       
  1017   3.0 ,  3.5,  4.0 ,  4.5,  5.0 ]
       
  1018 \end{lstlisting}
       
  1019 \end{frame}
       
  1020 
       
  1021 \begin{frame}[fragile]
       
  1022   \frametitle{Problem 3.4a (optional)}
       
  1023 
       
  1024 Use the \typ{linspace} function and generate a list of N tuples of the form\\
       
  1025 \typ{[($x_1$,f($x_1$)),($x_2$,f($x_2$)),\ldots,($x_N$,f($x_N$))]}\\for the following functions,\begin{itemize}
       
  1026   \item \typ{f(x) = sin(x)}
       
  1027   \item \typ{f(x) = sin(x) + sin(10*x)}.
       
  1028 \end{itemize}
       
  1029 \end{frame}
       
  1030 
       
  1031 \begin{frame}[fragile]
       
  1032   \frametitle{Problem 3.4b (optional)}
       
  1033 
       
  1034   Using the tuples generated earlier, determine the intervals where the roots of the functions lie.
       
  1035 
       
  1036   \inctime{15}
       
  1037 \end{frame}
       
  1038 
       
  1039 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
  1040 % TIME: 15 m, running 185m 
       
  1041 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
  1042 
       
  1043 \subsection{IO}
       
  1044 
       
  1045 \begin{frame}[fragile]
       
  1046   \frametitle{Simple tokenizing and parsing}
       
  1047   \begin{lstlisting}
       
  1048 s = """The quick brown fox jumped
       
  1049        over the lazy dog"""
       
  1050 for word in s.split():
       
  1051     print word.capitalize()
       
  1052   \end{lstlisting}
       
  1053 \end{frame}
       
  1054 
       
  1055 \begin{frame}[fragile]
       
  1056   \frametitle{Problem 4.1}
       
  1057   Given a string like, ``1, 3-7, 12, 15, 18-21'', produce the list \\
       
  1058   \begin{lstlisting}
       
  1059     [1,3,4,5,6,7,12,15,18,19,20,21]
       
  1060   \end{lstlisting}
       
  1061 \end{frame}
       
  1062 
       
  1063 \begin{frame}[fragile]
       
  1064   \frametitle{File handling}
       
  1065 \begin{lstlisting}
       
  1066 >>> f = open('/path/to/file_name')
       
  1067 >>> data = f.read() # Read entire file.
       
  1068 >>> line = f.readline() # Read one line.
       
  1069 >>> f.close() # close the file.
       
  1070 \end{lstlisting}
       
  1071 Writing files
       
  1072 \begin{lstlisting}
       
  1073 >>> f = open('/path/to/file_name', 'w')
       
  1074 >>> f.write('hello world\n')
       
  1075 >>> f.close()
       
  1076 \end{lstlisting}
       
  1077 \begin{itemize}
       
  1078     \item Everything read or written is a string
       
  1079 \end{itemize}
       
  1080 \emphbar{Try \typ{file?} for more help}
       
  1081 \end{frame}
       
  1082 
       
  1083 \begin{frame}[fragile]
       
  1084     \frametitle{File and \kwrd{for}}
       
  1085 \begin{lstlisting}
       
  1086 >>> f = open('/path/to/file_name')
       
  1087 >>> for line in f:
       
  1088 ...     print line
       
  1089 ...
       
  1090 \end{lstlisting}
       
  1091 \end{frame}
       
  1092 
       
  1093 \begin{frame}{Problem 4.2}
       
  1094     The given file has lakhs of records in the form:\\
       
  1095     \typ{RGN;ID;NAME;MARK1;\ldots;MARK5;TOTAL;PFW}\\
       
  1096     Some entries may be empty.  Read the data from this file and print the
       
  1097     name of the student with the maximum total marks.
       
  1098 \end{frame}
       
  1099 
       
  1100 \begin{frame}{Problem 4.3}
       
  1101     For the same data file compute the average marks in different
       
  1102     subjects, the student with the maximum mark in each subject and also
       
  1103     the standard deviation of the marks.  Do this efficiently.
       
  1104 
       
  1105     \inctime{20}
       
  1106 \end{frame}
       
  1107 
       
  1108 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
  1109 % TIME: 20 m, running 205m 
       
  1110 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
  1111 
       
  1112 \subsection{Modules}
       
  1113 
       
  1114 \begin{frame}[fragile]
       
  1115     {Modules}
       
  1116 \begin{lstlisting}
       
  1117 >>> sqrt(2)
       
  1118 Traceback (most recent call last):
       
  1119   File "<stdin>", line 1, in <module>
       
  1120 NameError: name 'sqrt' is not defined
       
  1121 >>> import math        
       
  1122 >>> math.sqrt(2)
       
  1123 1.4142135623730951
       
  1124 \end{lstlisting}
       
  1125 \end{frame}
       
  1126 
       
  1127 \begin{frame}[fragile]
       
  1128     {Modules}
       
  1129   \begin{itemize}
       
  1130     \item The \kwrd{import} keyword ``loads'' a module
       
  1131     \item One can also use:
       
  1132       \begin{lstlisting}
       
  1133 >>> from math import sqrt
       
  1134 >>> from math import *
       
  1135       \end{lstlisting}    
       
  1136     \item What is the difference?
       
  1137     \item \alert{Use the later only in interactive mode}
       
  1138     \end{itemize}
       
  1139   \emphbar{Package hierarchies}
       
  1140       \begin{lstlisting}
       
  1141 >>> from os.path import exists
       
  1142       \end{lstlisting}
       
  1143 \end{frame}
       
  1144 
       
  1145 \begin{frame}
       
  1146   \frametitle{Modules: Standard library}
       
  1147   \begin{itemize}
       
  1148   \item Very powerful, ``Batteries included''
       
  1149   \item Some standard modules:
       
  1150     \begin{itemize}
       
  1151     \item Math: \typ{math}, \typ{random}
       
  1152     \item Internet access: \typ{urllib2}, \typ{smtplib}
       
  1153     \item System, Command line arguments: \typ{sys}
       
  1154     \item Operating system interface: \typ{os}
       
  1155     \item Regular expressions: \typ{re}
       
  1156     \item Compression: \typ{gzip}, \typ{zipfile}, and \typ{tarfile}
       
  1157     \item And a whole lot more!
       
  1158     \end{itemize}
       
  1159   \item Check out the Python Library reference:
       
  1160     \url{http://docs.python.org/library/}
       
  1161   \end{itemize}
       
  1162 \end{frame}
       
  1163 
       
  1164 \begin{frame}[fragile]
       
  1165     {Modules of special interest}
       
  1166     \begin{description}[matplotlibfor2d]
       
  1167 
       
  1168         \item[\typ{numpy}] Efficient, powerful numeric arrays
       
  1169 
       
  1170         \item[\typ{matplotlib}] Easy, interactive, 2D plotting
       
  1171 
       
  1172         \item[\typ{scipy}] statistics, optimization, integration, linear
       
  1173             algebra, Fourier transforms, signal and image processing,
       
  1174             genetic algorithms, ODE solvers, special functions, and more
       
  1175 
       
  1176         \item[Mayavi] Easy, interactive, 3D plotting
       
  1177 
       
  1178     \end{description}
       
  1179 \end{frame}
       
  1180 
       
  1181 \begin{frame}[fragile]
       
  1182     {Creating your own modules}
       
  1183   \begin{itemize}
       
  1184   \item Define variables, functions and classes in a file with a
       
  1185     \typ{.py} extension
       
  1186   \item This file becomes a module!
       
  1187   \item Accessible when in the current directory
       
  1188   \item Use \typ{cd} in IPython to change directory
       
  1189 
       
  1190   \item Naming your module
       
  1191       \end{itemize}
       
  1192 \end{frame}
       
  1193 
       
  1194 \begin{frame}[fragile]
       
  1195   \frametitle{Modules: example}
       
  1196   \begin{lstlisting}
       
  1197 # --- arith.py ---
       
  1198 def gcd(a, b):
       
  1199     if a%b == 0: return b
       
  1200     return gcd(b, a%b)
       
  1201 def lcm(a, b):
       
  1202     return a*b/gcd(a, b)
       
  1203 # ------------------
       
  1204 >>> import arith
       
  1205 >>> arith.gcd(26, 65)
       
  1206 13
       
  1207 >>> arith.lcm(26, 65)
       
  1208 130
       
  1209   \end{lstlisting}
       
  1210 \end{frame}
       
  1211 
       
  1212 \begin{frame}[fragile]
       
  1213   \frametitle{Problem 5.1}
       
  1214 
       
  1215   Put all the functions you have written so far as part of the problems
       
  1216   into one module called \typ{iitb.py} and use this module from IPython.
       
  1217 
       
  1218 \inctime{20}
       
  1219 \end{frame}
       
  1220 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
  1221 % TIME: 20 m, running 225m 
       
  1222 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
  1223 
       
  1224 \begin{frame}
       
  1225   \frametitle{Did we meet the goal?}
       
  1226   \tableofcontents
       
  1227   % You might wish to add the option [pausesections]
       
  1228   \end{frame}
       
  1229 
       
  1230   \begin{frame}
       
  1231     {Tomorrow}
       
  1232     \begin{itemize}
       
  1233       \item Plotting: 2D, 3D
       
  1234       \item NumPy, SciPy
       
  1235       \item Dictionary, Set
       
  1236       \item Debugging
       
  1237       \item Testing
       
  1238       \item \ldots
       
  1239     \end{itemize}
       
  1240     11:30--13:00 Discussion of answers to problems OPTIONAL
       
  1241   \end{frame}
       
  1242 \end{document}
       
  1243 
       
  1244 
       
  1245 \begin{frame}[fragile]
       
  1246   \frametitle{More on functions}
       
  1247   \begin{itemize}
       
  1248   \item Support default and keyword arguments
       
  1249   \item Scope of variables in the function is local
       
  1250   \item Mutable items are \alert{passed by reference}
       
  1251   \item First line after definition may be a documentation string
       
  1252     (\alert{recommended!})
       
  1253   \item Function definition and execution defines a name bound to the
       
  1254     function
       
  1255   \item You \emph{can} assign a variable to a function!
       
  1256   \end{itemize}
       
  1257 \end{frame}
       
  1258 
       
  1259 
       
  1260 \begin{frame}[fragile]
       
  1261   \frametitle{Functions: default arguments}
       
  1262   \begin{lstlisting}
       
  1263 def ask_ok(prompt, retries=4, complaint='Yes or no!'):
       
  1264     while True:
       
  1265         ok = raw_input(prompt)
       
  1266         if ok in ('y', 'ye', 'yes'): 
       
  1267             return True
       
  1268         if ok in ('n', 'no', 'nop', 'nope'): 
       
  1269             return False
       
  1270         retries = retries - 1
       
  1271         if retries < 0: 
       
  1272             raise IOError, 'bad user'
       
  1273         print complaint
       
  1274   \end{lstlisting}
       
  1275 \end{frame}
       
  1276 
       
  1277 \begin{frame}[fragile]
       
  1278   \frametitle{Functions: keyword arguments}
       
  1279   \begin{lstlisting}
       
  1280 def parrot(voltage, state='a stiff', 
       
  1281            action='voom', type='Norwegian Blue'):
       
  1282     print "-- This parrot wouldn't", action,
       
  1283     print "if you put", voltage, "Volts through it."
       
  1284     print "-- Lovely plumage, the", type
       
  1285     print "-- It's", state, "!"
       
  1286 
       
  1287 parrot(1000)
       
  1288 parrot(action = 'VOOOOOM', voltage = 1000000)
       
  1289 parrot('a thousand', state = 'pushing up the daisies')
       
  1290 parrot('a million', 'bereft of life', 'jump')
       
  1291 \end{lstlisting}
       
  1292 \end{frame}
       
  1293 
       
  1294 \begin{frame}[fragile]
       
  1295   \frametitle{Functions: arbitrary argument lists}
       
  1296   \begin{itemize}
       
  1297   \item Arbitrary number of arguments using \verb+*args+ or
       
  1298     \verb+*whatever+
       
  1299   \item Keyword arguments using \verb+**kw+
       
  1300   \item Given a tuple/dict how do you call a function?
       
  1301     \begin{itemize}
       
  1302     \item Using argument unpacking
       
  1303     \item For positional arguments: \verb+foo(*[5, 10])+
       
  1304     \item For keyword args: \verb+foo(**{'a':5, 'b':10})+
       
  1305     \end{itemize}
       
  1306   \end{itemize}
       
  1307 \begin{lstlisting}
       
  1308 def foo(a=10, b=100):
       
  1309     print a, b
       
  1310 def func(*args, **keyword):
       
  1311     print args, keyword
       
  1312 # Unpacking:
       
  1313 args = [5, 10]
       
  1314 foo(*args)
       
  1315 kw = {'a':5, 'b':10}
       
  1316 foo(**kw)
       
  1317 \end{lstlisting}
       
  1318 \end{frame}
       
  1319 
       
  1320 \subsection{Modules, exceptions, classes}
       
  1321 
       
  1322 \begin{frame}
       
  1323   \frametitle{Modules}
       
  1324   \begin{itemize}
       
  1325   \item Define variables, functions and classes in a file with a
       
  1326     \typ{.py} extension
       
  1327   \item This file becomes a module!
       
  1328   \item Modules are searched in the following:
       
  1329     \begin{itemize}
       
  1330     \item Current directory
       
  1331     \item Standard: \typ{/usr/lib/python2.3/site-packages/} etc.
       
  1332     \item Directories specified in PYTHONPATH
       
  1333     \item \typ{sys.path}: current path settings (from the \typ{sys}
       
  1334       module)
       
  1335     \end{itemize}
       
  1336   \item The \typ{import} keyword ``loads'' a module
       
  1337   \item One can also use:
       
  1338     \mbox{\typ{from module import name1, name2, name2}}\\
       
  1339     where \typ{name1} etc. are names in the module, ``module''
       
  1340   \item \typ{from module import *} \ --- imports everything from module,
       
  1341     \alert{use only in interactive mode}
       
  1342   \end{itemize}
       
  1343 \end{frame}
       
  1344 
       
  1345 \begin{frame}[fragile]
       
  1346   \frametitle{Modules: example}
       
  1347   \begin{lstlisting}
       
  1348 # --- foo.py ---
       
  1349 some_var = 1
       
  1350 def fib(n): # write Fibonacci series up to n
       
  1351     """Print a Fibonacci series up to n."""
       
  1352     a, b = 0, 1
       
  1353     while b < n:
       
  1354         print b,
       
  1355         a, b = b, a+b
       
  1356 # EOF
       
  1357 
       
  1358 >>> import foo
       
  1359 >>> foo.fib(10)
       
  1360 1 1 2 3 5 8 
       
  1361 >>> foo.some_var
       
  1362 1
       
  1363   \end{lstlisting}
       
  1364 \end{frame}
       
  1365 
       
  1366 \begin{frame}[fragile]
       
  1367   \frametitle{Namespaces}
       
  1368   \begin{itemize}
       
  1369   \item A mapping from names to objects
       
  1370   \item Modules introduce a namespace 
       
  1371   \item So do classes
       
  1372   \item The running script's namespace is \verb+__main__+
       
  1373   \item A modules namespace is identified by its name
       
  1374   \item The standard functions (like \typ{len}) are in the
       
  1375     \verb+__builtin__+ namespace
       
  1376   \item Namespaces help organize different names and their bindings to
       
  1377     different objects
       
  1378   \end{itemize}
       
  1379 \end{frame}
       
  1380 
       
  1381 \begin{frame}
       
  1382   \frametitle{Exceptions}
       
  1383   \begin{itemize}
       
  1384   \item Python's way of notifying you of errors
       
  1385   \item Several standard exceptions: \typ{SyntaxError}, \typ{IOError}
       
  1386     etc.
       
  1387   \item Users can also \typ{raise} errors
       
  1388   \item Users can create their own exceptions
       
  1389   \item Exceptions can be ``caught'' via \typ{try/except} blocks
       
  1390   \end{itemize}
       
  1391 \end{frame}
       
  1392 
       
  1393 \begin{frame}[fragile]
       
  1394   \frametitle{Exception: examples}
       
  1395 \begin{lstlisting}
       
  1396 >>> 10 * (1/0)
       
  1397 Traceback (most recent call last):
       
  1398   File "<stdin>", line 1, in ?
       
  1399 ZeroDivisionError: integer division or modulo by zero
       
  1400 >>> 4 + spam*3
       
  1401 Traceback (most recent call last):
       
  1402   File "<stdin>", line 1, in ?
       
  1403 NameError: name 'spam' is not defined
       
  1404 >>> '2' + 2
       
  1405 Traceback (most recent call last):
       
  1406   File "<stdin>", line 1, in ?
       
  1407 TypeError: cannot concatenate 'str' and 'int' objects
       
  1408 \end{lstlisting}
       
  1409 \end{frame}
       
  1410 
       
  1411 \begin{frame}[fragile]
       
  1412   \frametitle{Exception: examples}
       
  1413 \begin{lstlisting}
       
  1414 >>> while True:
       
  1415 ...     try:
       
  1416 ...         x = int(raw_input("Enter a number: "))
       
  1417 ...         break
       
  1418 ...     except ValueError:
       
  1419 ...         print "Invalid number, try again..."
       
  1420 ...
       
  1421 >>> # To raise exceptions
       
  1422 ... raise ValueError, "your error message"
       
  1423 Traceback (most recent call last):
       
  1424   File "<stdin>", line 2, in ?
       
  1425 ValueError: your error message
       
  1426 \end{lstlisting}
       
  1427 \end{frame}
       
  1428 
       
  1429 \begin{frame}[fragile]
       
  1430   \frametitle{Classes: the big picture}
       
  1431   \begin{itemize}
       
  1432   \item Lets you create new data types
       
  1433   \item Class is a template for an object belonging to that class
       
  1434   \item Note: in Python a class is also an object
       
  1435   \item Instantiating a class creates an instance (an object)
       
  1436   \item An instance encapsulates the state (data) and behavior
       
  1437     (methods)
       
  1438   \item Allows you to define an inheritance hierarchy
       
  1439     \begin{itemize}
       
  1440     \item ``A Honda car \alert{is a} car.''
       
  1441     \item ``A car \alert{is an} automobile.''
       
  1442     \item ``A Python \alert{is a} reptile.''
       
  1443     \end{itemize}
       
  1444   \item Programmers need to think OO
       
  1445   \end{itemize}
       
  1446 \end{frame}
       
  1447 
       
  1448 \begin{frame}[fragile]
       
  1449   \frametitle{Classes: what's the big deal?}
       
  1450   \begin{itemize}
       
  1451   \item Lets you create objects that mimic a real problem being
       
  1452     simulated
       
  1453   \item Makes problem solving more natural and elegant
       
  1454   \item Easier to create code
       
  1455   \item Allows for code-reuse
       
  1456   \item Polymorphism
       
  1457   \end{itemize}
       
  1458 \end{frame}
       
  1459 
       
  1460 \begin{frame}[fragile]
       
  1461   \frametitle{Class definition and instantiation}
       
  1462   \begin{itemize}
       
  1463   \item Class definitions when executed create class objects
       
  1464   \item Instantiating the class object creates an instance of the
       
  1465     class
       
  1466   \end{itemize}
       
  1467 \footnotesize
       
  1468 \begin{lstlisting}
       
  1469 class Foo(object):
       
  1470     pass
       
  1471 # class object created.
       
  1472 # Create an instance of Foo.
       
  1473 f = Foo()
       
  1474 # Can assign an attribute to the instance
       
  1475 f.a = 100
       
  1476 print f.a
       
  1477 100
       
  1478 \end{lstlisting}
       
  1479 \end{frame}
       
  1480 
       
  1481 \begin{frame}[fragile]
       
  1482   \frametitle{Classes \ldots}
       
  1483   \begin{itemize}
       
  1484   \item All attributes are accessed via the \typ{object.attribute}
       
  1485     syntax
       
  1486   \item Both class and instance attributes are supported
       
  1487   \item \emph{Methods} represent the behavior of an object: crudely
       
  1488     think of them as functions ``belonging'' to the object
       
  1489   \item All methods in Python are ``virtual''
       
  1490   \item Inheritance through subclassing
       
  1491   \item Multiple inheritance is supported
       
  1492   \item No special public and private attributes: only good
       
  1493     conventions
       
  1494     \begin{itemize}
       
  1495     \item \verb+object.public()+: public
       
  1496     \item \verb+object._private()+ \& \verb+object.__priv()+: 
       
  1497       non-public
       
  1498     \end{itemize}
       
  1499   \end{itemize}
       
  1500 \end{frame}
       
  1501 
       
  1502 \begin{frame}[fragile]
       
  1503   \frametitle{Classes: examples}
       
  1504 \begin{lstlisting}
       
  1505 class MyClass(object):
       
  1506     """Example class (this is the class docstring)."""
       
  1507     i = 12345 # A class attribute
       
  1508     def f(self):
       
  1509         """This is the method docstring"""
       
  1510         return 'hello world'
       
  1511 
       
  1512 >>> a = MyClass() # creates an instance
       
  1513 >>> a.f()
       
  1514 'hello world'
       
  1515 >>> # a.f() is equivalent to MyClass.f(a)
       
  1516 ... # This also explains why f has a 'self' argument.
       
  1517 ... MyClass.f(a)
       
  1518 'hello world'
       
  1519 \end{lstlisting}
       
  1520 \end{frame}
       
  1521 
       
  1522 \begin{frame}[fragile]
       
  1523   \frametitle{Classes (continued)}
       
  1524   \begin{itemize}
       
  1525   \item \typ{self} is \alert{conventionally} the first argument for a
       
  1526     method
       
  1527   \item In previous example, \typ{a.f} is a method object
       
  1528   \item When \typ{a.f} is called, it is passed the instance \typ{a} as
       
  1529     the first argument
       
  1530   \item If a method called \verb+__init__+ exists, it is called when
       
  1531     the object is created
       
  1532   \item If a method called \verb+__del__+ exists, it is called before
       
  1533     the object is garbage collected
       
  1534   \item Instance attributes are set by simply ``setting'' them in
       
  1535     \typ{self}
       
  1536   \item Other special methods (by convention) like \verb+__add__+ let
       
  1537     you define numeric types:
       
  1538     {\footnotesize \url{http://docs.python.org/ref/specialnames.html}
       
  1539       \\ \url{http://docs.python.org/ref/numeric-types.html}
       
  1540     }
       
  1541   \end{itemize}
       
  1542 \end{frame}
       
  1543 
       
  1544 \begin{frame}[fragile]
       
  1545   \frametitle{Classes: examples}
       
  1546 \begin{lstlisting}
       
  1547 class Bag(MyClass): # Shows how to derive classes
       
  1548     def __init__(self): # called on object creation.
       
  1549         self.data = [] # an instance attribute
       
  1550     def add(self, x):
       
  1551         self.data.append(x)
       
  1552     def addtwice(self, x):
       
  1553         self.add(x)
       
  1554         self.add(x)
       
  1555 >>> a = Bag()
       
  1556 >>> a.f() # Inherited method
       
  1557 'hello world'
       
  1558 >>> a.add(1); a.addtwice(2)
       
  1559 >>> a.data
       
  1560 [1, 2, 2]
       
  1561 \end{lstlisting}
       
  1562 \end{frame}
       
  1563 
       
  1564 \begin{frame}[fragile]
       
  1565   \frametitle{Derived classes}
       
  1566   \begin{itemize}
       
  1567   \item Call the parent's \verb+__init__+ if needed
       
  1568   \item If you don't need a new constructor, no need to define it in subclass
       
  1569   \item Can also use the \verb+super+ built-in function
       
  1570   \end{itemize}
       
  1571 \begin{lstlisting}
       
  1572 class AnotherBag(Bag):
       
  1573     def __init__(self):
       
  1574         # Must call parent's __init__ explicitly
       
  1575         Bag.__init__(self)
       
  1576         # Alternatively use this:
       
  1577         super(AnotherBag, self).__init__()
       
  1578         # Now setup any more data.
       
  1579         self.more_data = []
       
  1580 \end{lstlisting}
       
  1581 \end{frame}
       
  1582 
       
  1583 \begin{frame}[fragile]
       
  1584   \frametitle{Classes: polymorphism}
       
  1585 \begin{lstlisting}
       
  1586 class Drawable(object):
       
  1587     def draw(self):
       
  1588         # Just a specification.
       
  1589         pass
       
  1590 \end{lstlisting}
       
  1591 \mode<presentation>{\pause}
       
  1592 \begin{lstlisting}
       
  1593 class Square(Drawable):
       
  1594     def draw(self):
       
  1595         # draw a square.
       
  1596 class Circle(Drawable):
       
  1597     def draw(self):
       
  1598         # draw a circle.
       
  1599 \end{lstlisting}
       
  1600 \mode<presentation>{\pause}
       
  1601 \begin{lstlisting}
       
  1602 class Artist(Drawable):
       
  1603     def draw(self):
       
  1604         for obj in self.drawables:
       
  1605             obj.draw()
       
  1606 \end{lstlisting}
       
  1607 \end{frame}
       
  1608 
       
  1609 \subsection{Miscellaneous}
       
  1610 
       
  1611 \begin{frame}[fragile]
       
  1612   \frametitle{Stand-alone scripts}
       
  1613 Consider a file \typ{f.py}:
       
  1614 \begin{lstlisting}
       
  1615 #!/usr/bin/env python
       
  1616 """Module level documentation."""
       
  1617 # First line tells the shell that it should use Python
       
  1618 # to interpret the code in the file.
       
  1619 def f():
       
  1620     print "f"
       
  1621 
       
  1622 # Check if we are running standalone or as module.
       
  1623 # When imported, __name__ will not be '__main__'
       
  1624 if __name__ == '__main__':
       
  1625     # This is not executed when f.py is imported.
       
  1626     f() 
       
  1627 \end{lstlisting}
       
  1628 \end{frame}
       
  1629 
       
  1630 \begin{frame}[fragile]
       
  1631   \frametitle{List comprehensions}
       
  1632 \begin{lstlisting}
       
  1633 >>> veg = ['tomato', 'cabbage', 'carrot', 'potato']
       
  1634 >>> [x.upper() for x in veg]
       
  1635 ['TOMATO', 'CABBAGE', 'CARROT', 'POTATO']
       
  1636 >>> vec = range(0, 8)
       
  1637 >>> even = [x for x in vec if x%2 == 0]
       
  1638 >>> even
       
  1639 [0, 2, 4, 6]
       
  1640 >>> [x*x for x in even]
       
  1641 [0, 4, 16, 36]
       
  1642 >>> odd = [x for x in vec if x%2 == 1]
       
  1643 >>> odd
       
  1644 [1, 3, 5, 7]
       
  1645 >>> [x*y for x in even for y in odd]
       
  1646 [0, 0, 0, 0, 2, 6, 10, 14, 4, 12, 20, 28, 6, 18,30,42]
       
  1647 \end{lstlisting}
       
  1648 \end{frame}
       
  1649 
       
  1650 \begin{frame}[fragile]
       
  1651   \frametitle{More IPython features}
       
  1652   \begin{itemize}
       
  1653   \item Input and output caching:
       
  1654     \begin{itemize}
       
  1655     \item \verb+In+: a list of all entered input
       
  1656     \item \verb+Out+: a dict of all output
       
  1657     \item \verb+_+, \verb+__+, \verb+__+ are the last three results as
       
  1658       is \verb+_N+
       
  1659     \item \verb+%hist [-n]+ macro shows previous history, \verb+-n+
       
  1660       suppresses line number information
       
  1661     \end{itemize}
       
  1662   \item Log the session using \verb+%logstart+, \verb+%logon+ and
       
  1663     \verb+%logoff+
       
  1664   \item \verb+%run [options] file[.py]+ -- running Python code
       
  1665     \begin{itemize}
       
  1666     \item \verb+%run -d [-b<N>]+: debug script with pdb
       
  1667           \verb+N+ is the line number to break at (defaults to 1)
       
  1668     \item \verb+%run -t+: time the script
       
  1669     \item \verb+%run -p+: Profile the script
       
  1670     \end{itemize}
       
  1671   \item \verb+%prun+ runs a statement/expression under the profiler
       
  1672   \item \verb+%macro [options] macro_name n1-n2 n3-n4 n6+ save specified
       
  1673     lines to a macro with name \verb+macro_name+
       
  1674   \end{itemize}
       
  1675 \end{frame}
       
  1676 
       
  1677 \begin{frame}[fragile]
       
  1678   \frametitle{More IPython features \ldots}
       
  1679   \begin{itemize}
       
  1680   \item \verb+%edit [options] [args]+: edit lines of code or file
       
  1681     specified in editor (configure editor via \verb+$EDITOR+)
       
  1682   \item \verb+%cd+ changes directory, see also \verb+%pushd, %popd, %dhist+
       
  1683   \item Shell access
       
  1684     \begin{itemize}
       
  1685     \item \verb+!command+ runs a shell command and returns its output
       
  1686     \item \verb+files = %sx ls+ or \verb+files = !ls+ sets
       
  1687       \verb+files+ to all result of the \verb+ls+ command
       
  1688     \item \verb+%sx+ is quiet
       
  1689     \item \verb+!ls $files+ passes the \verb+files+ variable to the
       
  1690       shell command
       
  1691     \item \verb+%alias alias_name cmd+ creates an alias for a system
       
  1692       command
       
  1693     \end{itemize}
       
  1694   \item \verb+%colors+ lets you change the color scheme to
       
  1695     \verb+NoColor, Linux, LightBG+
       
  1696   \end{itemize}
       
  1697 \end{frame}
       
  1698 
       
  1699 \begin{frame}[fragile]
       
  1700   \frametitle{More IPython features \ldots}
       
  1701   \begin{itemize}
       
  1702   \item Use \verb+;+ at the end of a statement to suppress printing
       
  1703     output
       
  1704   \item \verb+%bookmark+: store a bookmarked location, for use with \verb+%cd+
       
  1705   \item \verb+%who, %whos+: print information on variables
       
  1706   \item \verb+%save [options] filename n1-n2 n3-n4+: save lines to a
       
  1707     file
       
  1708   \item \verb+%time statement+: Time execution of a Python statement or
       
  1709     expression
       
  1710   \item \verb+%timeit [-n<N> -r<R> [-t|-c]] statement+: time execution
       
  1711     using Python's timeit module
       
  1712   \item Can define and use profiles to setup IPython differently:
       
  1713     \verb+math, scipy, numeric, pysh+ etc.
       
  1714   \item \verb+%magic+: \alert{Show help on all magics}
       
  1715   \end{itemize}
       
  1716 \end{frame}
       
  1717 
       
  1718 \begin{frame}[fragile]
       
  1719   \frametitle{File handling}
       
  1720 \begin{lstlisting}
       
  1721 >>> # Reading files:
       
  1722 ... f = open('/path/to/file_name')
       
  1723 >>> data = f.read() # Read entire file.
       
  1724 >>> line = f.readline() # Read one line.
       
  1725 >>> # Read entire file appending each line into a list
       
  1726 ... lines = f.readlines()
       
  1727 >>> f.close() # close the file.
       
  1728 >>> # Writing files:
       
  1729 ... f = open('/path/to/file_name', 'w')
       
  1730 >>> f.write('hello world\n')
       
  1731 \end{lstlisting}
       
  1732   \begin{itemize}
       
  1733   \item \typ{tell()}: returns int of current position
       
  1734   \item \typ{seek(pos)}: moves current position to specified byte
       
  1735   \item Call \typ{close()} when done using a file
       
  1736   \end{itemize}
       
  1737 \end{frame}
       
  1738 
       
  1739 \begin{frame}[fragile]
       
  1740   \frametitle{Math}
       
  1741   \begin{itemize}
       
  1742   \item \typ{math} module provides basic math routines for
       
  1743     floats
       
  1744   \item \typ{cmath} module provides math routies for complex
       
  1745     numbers
       
  1746   \item \typ{random}: provides pseudo-random number generators
       
  1747     for various distributions
       
  1748   \item These are always available and part of the standard library
       
  1749   \item More serious math is provided by the NumPy/SciPy modules --
       
  1750     these are not standard and need to be installed separately
       
  1751   \end{itemize}
       
  1752 \end{frame}
       
  1753 
       
  1754 \begin{frame}[fragile]
       
  1755   \frametitle{Timing and profiling}
       
  1756   \begin{itemize}
       
  1757   \item Timing code: use the \typ{time} module
       
  1758   \item Read up on \typ{time.time()} and \typ{time.clock()}
       
  1759   \item \typ{timeit}: is a better way of doing timing
       
  1760   \item IPython has handy \typ{time} and \typ{timeit} macros (type
       
  1761     \typ{timeit?} for help)
       
  1762   \item IPython lets you debug and profile code via the \typ{run}
       
  1763     macro (type \typ{run?} on the prompt to learn more)
       
  1764   \end{itemize}
       
  1765 \end{frame}
       
  1766 
       
  1767 \begin{frame}[fragile]
       
  1768   \frametitle{Odds and ends}
       
  1769   \begin{itemize}
       
  1770   \item \typ{dir([object])} function: attributes of given object
       
  1771   \item \typ{type(object)}: returns type information
       
  1772   \item \typ{str(), repr()}: convert object to string representation
       
  1773   \item \typ{isinstance, issubclass}
       
  1774   \item \typ{assert} statements let you do debugging assertions in
       
  1775     code
       
  1776   \item \typ{csv} module: reading and writing CSV files
       
  1777   \item \typ{pickle}: lets you save and load Python objects
       
  1778     (\alert{serialization})
       
  1779   \item \typ{sys.argv}: command line arguments
       
  1780   \item \typ{os.path}: common path manipulations
       
  1781   \item Check out the Python Library reference:
       
  1782     \url{http://docs.python.org/lib/lib.html}
       
  1783   \end{itemize}
       
  1784 \end{frame}
       
  1785 
       
  1786 \begin{frame}[fragile]
       
  1787   \frametitle{Test driven development (TDD)}
       
  1788   \begin{itemize}
       
  1789       \item Why?
       
  1790           \begin{itemize}
       
  1791 
       
  1792             \item Forces you to write reusable code!
       
  1793 
       
  1794             \item Think about the API
       
  1795 
       
  1796             \item More robust
       
  1797 
       
  1798             \item Makes refactoring very easy
       
  1799 
       
  1800           \end{itemize}
       
  1801       \item How?  Python offers three major ways of doing this
       
  1802           \begin{itemize}
       
  1803               \item doctest
       
  1804               \item unittest
       
  1805               \item nosetest (and similar like py.test)
       
  1806           \end{itemize}
       
  1807 
       
  1808       \item Test every piece of functionality you offer
       
  1809 
       
  1810       \item This isn't a formal introduction but more a practical one
       
  1811 
       
  1812   \end{itemize}
       
  1813 \end{frame}
       
  1814 
       
  1815 \begin{frame}[fragile]
       
  1816   \frametitle{Unit test}
       
  1817 \begin{lstlisting}
       
  1818 import unittest
       
  1819 
       
  1820 class MyTestCase(unittest.TestCase):
       
  1821     def setUp(self):
       
  1822         # Called *before* each test_* 
       
  1823     def tearDown(self):
       
  1824         # Called *after* each test_* 
       
  1825     def test_something(self):
       
  1826         "docstring"
       
  1827         #  Test code.
       
  1828         self.assertEqual(x, y)
       
  1829         self.assertRaises(ValueError, func, arg1, arg2 ...)
       
  1830 
       
  1831 if __name__ == '__main__':
       
  1832     unittest.main() 
       
  1833 \end{lstlisting}
       
  1834 \end{frame}
       
  1835 
       
  1836 \begin{frame}[fragile]
       
  1837     \frametitle{Nosetest}
       
  1838 \begin{lstlisting}
       
  1839 import particle
       
  1840 def test_particle():
       
  1841     # Use asserts here.
       
  1842     p = particle.Particle(1.0)
       
  1843     assert p.property[0] == 1.0
       
  1844     assert p.property[2] == 0.0
       
  1845 
       
  1846 if __name__ == '__main__':
       
  1847     import nose
       
  1848     nose.main()
       
  1849 \end{lstlisting}
       
  1850 \end{frame}
       
  1851 
       
  1852 \begin{frame}[fragile]
       
  1853   \frametitle{Testing}
       
  1854   \begin{itemize}
       
  1855       \item More details: see library reference and search for nosetest
       
  1856   \end{itemize}
       
  1857 \end{frame}
       
  1858 
       
  1859 \section{Numerics \& Plotting}
       
  1860 
       
  1861 \subsection{NumPy Arrays}
       
  1862 
       
  1863 \newcommand{\num}{\texttt{numpy}}
       
  1864 
       
  1865 \begin{frame}
       
  1866   \frametitle{The \num\ module}
       
  1867   \begin{itemize}
       
  1868   \item Manipulating large Python lists for scientific computing is
       
  1869     \alert{slow}
       
  1870   \item Most complex computations can be reduced to a few standard
       
  1871     operations
       
  1872   \item The \num\ module provides:
       
  1873     \begin{itemize}
       
  1874     \item An efficient and powerful array type for various common data
       
  1875       types
       
  1876     \item Abstracts out the most commonly used standard operations on
       
  1877       arrays
       
  1878     \end{itemize}
       
  1879   \item Numeric was the first, then came \texttt{numarray}.
       
  1880     \texttt{numpy} is the latest and is the future
       
  1881   \item This course uses \num\ and only covers the absolute basics
       
  1882   \end{itemize}
       
  1883 \end{frame}
       
  1884 
       
  1885 \begin{frame}
       
  1886   \frametitle{Basic concepts}
       
  1887   \begin{itemize}
       
  1888   \item \num\ arrays are of a fixed size (\typ{arr.size}) and have the
       
  1889     same type (\typ{arr.dtype})
       
  1890   \item \num\ arrays may have arbitrary dimensionality
       
  1891   \item The \typ{shape} of an array is the extent (length) of the
       
  1892     array along each dimension
       
  1893   \item The \typ{rank(arr)} of an array is the ``dimensionality'' of the
       
  1894     array
       
  1895   \item The \typ{arr.itemsize} is the number of bytes (8-bits) used for
       
  1896     each element of the array
       
  1897   \item \alert{Note:} The \typ{shape} and \typ{rank} may change as
       
  1898     long as the \typ{size} of the array is fixed
       
  1899   \item \alert{Note:} \typ{len(arr) != arr.size} in general
       
  1900   \item \alert{Note:} By default array operations are performed
       
  1901     \alert{elementwise}
       
  1902   \item Indices start from 0
       
  1903   \end{itemize}
       
  1904 \end{frame}
       
  1905 
       
  1906 \begin{frame}[fragile]
       
  1907   \frametitle{Examples of \num}
       
  1908 \begin{lstlisting}
       
  1909 # Simple array math example
       
  1910 >>> from numpy import *
       
  1911 >>> a = array([1,2,3,4])
       
  1912 >>> b = array([2,3,4,5])
       
  1913 >>> a + b # Element wise addition!
       
  1914 array([3, 5, 7, 9])
       
  1915 
       
  1916 >>> print pi, e  # Pi and e are defined.
       
  1917 3.14159265359 2.71828182846
       
  1918 # Create array from 0 to 10
       
  1919 >>> x = arange(0.0, 10.0, 0.05)
       
  1920 >>> x *= 2*pi/10 # multiply array by scalar value
       
  1921 array([ 0.,0.0314,...,6.252])
       
  1922 # apply functions to array.
       
  1923 >>> y = sin(x)
       
  1924 \end{lstlisting}
       
  1925 \end{frame}
       
  1926 
       
  1927 \begin{frame}[fragile]
       
  1928   \frametitle{More examples of \num}
       
  1929 \vspace*{-8pt}
       
  1930 \begin{lstlisting}
       
  1931 # Size, shape, rank, type etc.
       
  1932 >>> x = array([1., 2, 3, 4])
       
  1933 >>> size(x)
       
  1934 4
       
  1935 >>> x.dtype # or x.dtype.char
       
  1936 'd'
       
  1937 >>> x.shape
       
  1938 (4,)
       
  1939 >>> print rank(x), x.itemsize
       
  1940 1 8
       
  1941 >>> x.tolist()
       
  1942 [1.0, 2.0, 3.0, 4.0]
       
  1943 # Array indexing
       
  1944 >>> x[0] = 10
       
  1945 >>> print x[0], x[-1]
       
  1946 10.0 4.0
       
  1947 \end{lstlisting}
       
  1948 \end{frame}
       
  1949 
       
  1950 \begin{frame}[fragile]
       
  1951   \frametitle{Multi-dimensional arrays}
       
  1952 \begin{lstlisting}
       
  1953 >>> a = array([[ 0, 1, 2, 3],
       
  1954 ...            [10,11,12,13]])
       
  1955 >>> a.shape # (rows, columns)
       
  1956 (2, 4)
       
  1957 # Accessing and setting values
       
  1958 >>> a[1,3] 
       
  1959 13
       
  1960 >>> a[1,3] = -1
       
  1961 >>> a[1] # The second row
       
  1962 array([10,11,12,-1])
       
  1963 
       
  1964 # Flatten/ravel arrays to 1D arrays
       
  1965 >>> a.flat  # or ravel(a)
       
  1966 array([0,1,2,3,10,11,12,-1])
       
  1967 # Note: flat references original memory
       
  1968 \end{lstlisting}
       
  1969 \end{frame}
       
  1970 
       
  1971 \begin{frame}[fragile]
       
  1972   \frametitle{Slicing arrays}
       
  1973 \begin{lstlisting}
       
  1974 >>> a = array([[1,2,3], [4,5,6], [7,8,9]])
       
  1975 >>> a[0,1:3]
       
  1976 array([2, 3])
       
  1977 >>> a[1:,1:]
       
  1978 array([[5, 6],
       
  1979        [8, 9]])
       
  1980 >>> a[:,2]
       
  1981 array([3, 6, 9])
       
  1982 # Striding...
       
  1983 >>> a[0::2,0::2]
       
  1984 array([[1, 3],
       
  1985        [7, 9]])
       
  1986 # All these slices are references to the same memory!
       
  1987 \end{lstlisting}
       
  1988 \end{frame}
       
  1989 
       
  1990 % \begin{frame}[fragile]
       
  1991 %   \frametitle{Array types and typecodes}
       
  1992 %   \begin{tabular}[c]{|c|c|p{2.75in}|}
       
  1993 %     \hline
       
  1994 %     Character & Bits (bytes) & Type name \\
       
  1995 %     \hline
       
  1996 %     D & 128 (16) & \typ{Complex, Complex64}\\
       
  1997 %     F & 64   (8) & \typ{Complex0, Complex8, Complex16} \\
       
  1998 %     d & 64   (8) & \typ{Float, Float64} \\
       
  1999 %     f & 32   (4) & \typ{Float0, Float8, Float16} \\
       
  2000 %     i & 32   (4) & \typ{Int32} \\
       
  2001 %     l & 32   (4) & \typ{Int} \\
       
  2002 %     O & 4    (1) & \typ{PyObject} \\
       
  2003 %     %b 8     (1) UnsignedInt8
       
  2004 %     %1 (one) 8     (1) Int8
       
  2005 %     %s 16   (2) Int16
       
  2006 %     \hline
       
  2007 %   \end{tabular}
       
  2008 % \begin{lstlisting}
       
  2009 % # Examples
       
  2010 % >>> f = array([1,2,3], Float32)
       
  2011 % >>> c = array([1,2,3], Complex32)
       
  2012 % >>> print f, c
       
  2013 % [ 1.  2.  3.] [ 1.+0.j  2.+0.j  3.+0.j]
       
  2014 % \end{lstlisting}
       
  2015 % \end{frame}
       
  2016 
       
  2017 \begin{frame}[fragile]
       
  2018   \frametitle{Array creation functions}
       
  2019   \begin{itemize}
       
  2020   \item \typ{array(object, dtype=None, copy=1,order=None, subok=0,ndmin=0)}
       
  2021   \item \typ{arange(start, stop=None, step=1, dtype=None)}
       
  2022   \item \typ{linspace(start, stop, num=50, endpoint=True, retstep=False)}
       
  2023   \item \typ{ones(shape, dtype=None, order='C')}
       
  2024   \item \typ{zeros((d1,...,dn),dtype=float,order='C')}
       
  2025   \item \typ{identity(n)}
       
  2026   \item \typ{empty((d1,...,dn),dtype=float,order='C')}
       
  2027   \item \typ{ones\_like(x)}, \typ{zeros\_like(x)}, \typ{empty\_like(x)}
       
  2028   \end{itemize}
       
  2029 \end{frame}
       
  2030 
       
  2031 \begin{frame}[fragile]
       
  2032   \frametitle{Array math}
       
  2033   \begin{itemize}
       
  2034   \item Basic \alert{elementwise} math (given two arrays \typ{a, b}):
       
  2035     \begin{itemize}
       
  2036     \item \typ{a + b $\rightarrow$ add(a, b)} 
       
  2037     \item \typ{a - b, $\rightarrow$ subtract(a, b)} 
       
  2038     \item \typ{a * b, $\rightarrow$ multiply(a, b)} 
       
  2039     \item \typ{a / b, $\rightarrow$ divide(a, b)} 
       
  2040     \item \typ{a \% b, $\rightarrow$ remainder(a, b)} 
       
  2041     \item \typ{a ** b, $\rightarrow$ power(a, b)}
       
  2042     \end{itemize}
       
  2043   \item Inplace operators: \typ{a += b}, or \typ{add(a, b,
       
  2044       a)} etc.
       
  2045   \item Logical operations: \typ{equal (==)}, \typ{not\_equal (!=)},
       
  2046     \typ{less (<)}, \typ{greater (>)} etc.
       
  2047   \item Trig and other functions: \typ{sin(x), arcsin(x), sinh(x),
       
  2048       exp(x), sqrt(x)} etc.
       
  2049   \item \typ{sum(x, axis=0), product(x, axis=0)}: sum and product of array elements 
       
  2050   \item \typ{dot(a, b)}
       
  2051   \end{itemize}
       
  2052 \end{frame}
       
  2053 
       
  2054 \begin{frame}[fragile]
       
  2055   \frametitle{Advanced}
       
  2056   \begin{itemize}
       
  2057   \item Only scratched the surface of \num
       
  2058   \item Ufunc methods: \typ{reduce, accumulate, outer, reduceat}
       
  2059   \item Typecasting
       
  2060   \item More functions: \typ{take, choose, where, compress,
       
  2061       concatenate}
       
  2062   \item Array broadcasting and \typ{None}
       
  2063   \end{itemize}
       
  2064 \end{frame}
       
  2065 
       
  2066 \subsection{Plotting: Matplotlib}
       
  2067 
       
  2068 \begin{frame}
       
  2069   \frametitle{About \texttt{matplotlib}}
       
  2070   \begin{itemize}
       
  2071   \item Easy to use, scriptable, ``Matlab-like'' 2D plotting
       
  2072   \item Publication quality figures and interactive capabilities
       
  2073   \item Plots, histograms, power spectra, bar charts, errorcharts,
       
  2074     scatterplots, etc.
       
  2075   \item Also does polar plots, maps, contours
       
  2076   \item Support for simple \TeX\ markup
       
  2077   \item Multiple output backends (images, EPS, SVG, wx, Agg, Tk, GTK)
       
  2078   \item Cross-platform: Linux, Win32, Mac OS X
       
  2079   \item Good idea to use via IPython:  \typ{ipython -pylab}
       
  2080   \item From scripts use: \typ{import pylab}
       
  2081   \end{itemize}
       
  2082 \end{frame}
       
  2083 
       
  2084 \begin{frame}
       
  2085   \frametitle{More information}
       
  2086   \begin{itemize}
       
  2087   \item More information here: \url{http://matplotlib.sf.net}
       
  2088   \item \url{http://matplotlib.sf.net/tutorial.html}
       
  2089   \item \url{http://matplotlib.sf.net/screenshots.html}
       
  2090   \end{itemize}
       
  2091 \end{frame}
       
  2092 
       
  2093 \begin{frame}[fragile]
       
  2094   \frametitle{Basic plotting with \texttt{matplotlib}}
       
  2095 \begin{lstlisting}
       
  2096 >>> x = arange(0, 2*pi, 0.05)
       
  2097 >>> plot(x, sin(x)) # Same as plot(x, sin(x), 'b-') 
       
  2098 >>> plot(x, sin(x), 'ro')
       
  2099 >>> axis([0,2*pi, -1,1])
       
  2100 >>> xlabel(r'$\chi$', color='g')
       
  2101 >>> ylabel(r'sin($\chi$)', color='r')
       
  2102 >>> title('A simple figure', fontsize=20)
       
  2103 >>> savefig('/tmp/test.eps')
       
  2104 # Multiple plots in one figure
       
  2105 >>> t = arange(0.0, 5.2, 0.2)
       
  2106 # red dashes, blue squares and green triangles
       
  2107 >>> plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
       
  2108 \end{lstlisting}
       
  2109 \end{frame}
       
  2110 
       
  2111 \begin{frame}[fragile]
       
  2112   \frametitle{Basic plotting \ldots}
       
  2113 \begin{lstlisting}
       
  2114 # Set properties of objects:
       
  2115 >>> plot(x, sin(x), linewidth=2.0, color='r')
       
  2116 >>> l, = plot(x, sin(x))
       
  2117 >>> setp(l, linewidth=2.0, color='r')
       
  2118 >>> l.set_linewidth(2.0); l.set_color('r')
       
  2119 >>> draw() # Redraws current figure.
       
  2120 >>> setp(l) # Prints available properties
       
  2121 >>> close() # Closes the figure.
       
  2122 # Multiple figures:
       
  2123 >>> figure(1); plot(x, sin(x))
       
  2124 >>> figure(2); plot(x, tanh(x))
       
  2125 >>> figure(1); title('Easy as 1,2,3')
       
  2126 \end{lstlisting}
       
  2127 \end{frame}
       
  2128 
       
  2129 \begin{frame}[fragile]
       
  2130   \frametitle{Basic plotting \ldots}
       
  2131 \begin{lstlisting}
       
  2132 >>> figure(1)
       
  2133 >>> subplot(211) # Same as subplot(2, 1, 1)
       
  2134 >>> plot(x, cos(5*x)*exp(-x))
       
  2135 >>> subplot(2, 1, 2)
       
  2136 >>> plot(x, cos(5*x), 'r--', label='cosine')
       
  2137 >>> plot(x, sin(5*x), 'g--', label='sine')
       
  2138 >>> legend() # Or legend(['cosine', 'sine'])
       
  2139 >>> text(1,0, '(1,0)')
       
  2140 >>> axes = gca() # Current axis
       
  2141 >>> fig = gcf() # Current figure
       
  2142 \end{lstlisting}
       
  2143 \end{frame}
       
  2144 
       
  2145 \begin{frame}[fragile]
       
  2146   \frametitle{X-Y plot}
       
  2147   \begin{columns}
       
  2148     \column{0.5\textwidth}
       
  2149     \hspace*{-0.5in}
       
  2150     \includegraphics[height=2in, interpolate=true]{data/xyplot}
       
  2151     \column{0.45\textwidth}
       
  2152     \begin{block}{Example code}
       
  2153     \tiny
       
  2154 \begin{lstlisting}
       
  2155 t1 = arange(0.0, 5.0, 0.1)
       
  2156 t2 = arange(0.0, 5.0, 0.02)
       
  2157 t3 = arange(0.0, 2.0, 0.01)
       
  2158 subplot(211)
       
  2159 plot(t1, cos(2*pi*t1)*exp(-t1), 'bo', 
       
  2160      t2, cos(2*pi*t2)*exp(-t2), 'k')
       
  2161 grid(True)
       
  2162 title('A tale of 2 subplots')
       
  2163 ylabel('Damped')
       
  2164 subplot(212)
       
  2165 plot(t3, cos(2*pi*t3), 'r--')
       
  2166 grid(True)
       
  2167 xlabel('time (s)')
       
  2168 ylabel('Undamped')
       
  2169 \end{lstlisting}
       
  2170     \end{block}
       
  2171   \end{columns}
       
  2172 \end{frame}
       
  2173 
       
  2174 \begin{frame}[fragile] \frametitle{Errorbar}
       
  2175   \begin{columns}
       
  2176     \column{0.5\textwidth}
       
  2177     \hspace*{-0.5in}
       
  2178   \includegraphics[height=2in, interpolate=true]{data/errorbar}  
       
  2179     \column{0.45\textwidth}
       
  2180     \begin{block}{Example code}
       
  2181     \tiny
       
  2182 \begin{lstlisting}
       
  2183 t = arange(0.1, 4, 0.1)
       
  2184 s = exp(-t)
       
  2185 e = 0.1*abs(randn(len(s)))
       
  2186 f = 0.1*abs(randn(len(s)))
       
  2187 g = 2*e
       
  2188 h = 2*f
       
  2189 errorbar(t, s, [e,g], f, fmt='o')
       
  2190 xlabel('Distance (m)')
       
  2191 ylabel('Height (m)')
       
  2192 title('Mean and standard error '\
       
  2193       'as a function of distance')
       
  2194 \end{lstlisting}
       
  2195   \end{block}
       
  2196 \end{columns}
       
  2197 \end{frame}
       
  2198 
       
  2199 \begin{frame}[fragile] \frametitle{Semi-log and log-log plots}
       
  2200   \begin{columns}
       
  2201     \column{0.5\textwidth}
       
  2202     \hspace*{-0.5in}
       
  2203   \includegraphics[height=2in, interpolate=true]{data/log}  
       
  2204     \column{0.45\textwidth}
       
  2205     \begin{block}{Example code}
       
  2206     \tiny
       
  2207 \begin{lstlisting}
       
  2208 dt = 0.01
       
  2209 t = arange(dt, 20.0, dt)
       
  2210 subplot(311)
       
  2211 semilogy(t, exp(-t/5.0))
       
  2212 ylabel('semilogy')
       
  2213 grid(True)
       
  2214 subplot(312)
       
  2215 semilogx(t, sin(2*pi*t))
       
  2216 ylabel('semilogx')
       
  2217 grid(True)
       
  2218 # minor grid on too
       
  2219 gca().xaxis.grid(True, which='minor')  
       
  2220 subplot(313)
       
  2221 loglog(t, 20*exp(-t/10.0), basex=4)
       
  2222 grid(True)
       
  2223 ylabel('loglog base 4 on x')
       
  2224 \end{lstlisting}
       
  2225   \end{block}
       
  2226 \end{columns}
       
  2227 \end{frame}
       
  2228 
       
  2229 \begin{frame}[fragile] \frametitle{Histogram}
       
  2230   \begin{columns}
       
  2231     \column{0.5\textwidth}
       
  2232     \hspace*{-0.5in}
       
  2233   \includegraphics[height=2in, interpolate=true]{data/histogram}  
       
  2234     \column{0.45\textwidth}
       
  2235     \begin{block}{Example code}
       
  2236     \tiny
       
  2237 \begin{lstlisting}
       
  2238 mu, sigma = 100, 15
       
  2239 x = mu + sigma*randn(10000)
       
  2240 # the histogram of the data
       
  2241 n, bins, patches = hist(x, 100, normed=1)
       
  2242 # add a 'best fit' line
       
  2243 y = normpdf( bins, mu, sigma)
       
  2244 l = plot(bins, y, 'r--', linewidth=2)
       
  2245 xlim(40, 160)
       
  2246 xlabel('Smarts')
       
  2247 ylabel('P')
       
  2248 title(r'$\rm{IQ:}\/ \mu=100,\/ \sigma=15$')
       
  2249 \end{lstlisting}
       
  2250   \end{block}
       
  2251 \end{columns}
       
  2252 \end{frame}
       
  2253 
       
  2254 \begin{frame}[fragile] \frametitle{Bar charts}
       
  2255   \begin{columns}
       
  2256     \column{0.5\textwidth}
       
  2257     \hspace*{-0.5in}
       
  2258   \includegraphics[height=2in, interpolate=true]{data/barchart}  
       
  2259     \column{0.45\textwidth}
       
  2260     \begin{block}{Example code}
       
  2261     \tiny
       
  2262 \begin{lstlisting}
       
  2263 N = 5
       
  2264 menMeans = (20, 35, 30, 35, 27)
       
  2265 menStd =   ( 2,  3,  4,  1,  2)
       
  2266 # the x locations for the groups
       
  2267 ind = arange(N) 
       
  2268 # the width of the bars
       
  2269 width = 0.35       
       
  2270 p1 = bar(ind, menMeans, width, 
       
  2271          color='r', yerr=menStd)
       
  2272 womenMeans = (25, 32, 34, 20, 25)
       
  2273 womenStd =   ( 3,  5,  2,  3,  3)
       
  2274 p2 = bar(ind+width, womenMeans, width, 
       
  2275          color='y', yerr=womenStd)
       
  2276 ylabel('Scores')
       
  2277 title('Scores by group and gender')
       
  2278 xticks(ind+width, 
       
  2279        ('G1', 'G2', 'G3', 'G4', 'G5'))
       
  2280 xlim(-width,len(ind))
       
  2281 yticks(arange(0,41,10))
       
  2282 legend((p1[0], p2[0]), 
       
  2283        ('Men', 'Women'), shadow=True)
       
  2284 \end{lstlisting}
       
  2285   \end{block}
       
  2286 \end{columns}
       
  2287 \end{frame}
       
  2288 
       
  2289 \begin{frame}[fragile] \frametitle{Pie charts}
       
  2290   \begin{columns}
       
  2291     \column{0.5\textwidth}
       
  2292     \hspace*{-0.4in}
       
  2293   \includegraphics[height=2.0in, interpolate=true]{data/piechart}  
       
  2294     \column{0.45\textwidth}
       
  2295     \begin{block}{Example code}
       
  2296     \tiny
       
  2297 \begin{lstlisting}
       
  2298 # make a square figure and axes
       
  2299 figure(1, figsize=(8,8))
       
  2300 ax = axes([0.1, 0.1, 0.8, 0.8])
       
  2301 labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
       
  2302 fracs = [15,30,45, 10]
       
  2303 explode=(0, 0.05, 0, 0)
       
  2304 pie(fracs, explode=explode, labels=labels, 
       
  2305     autopct='%1.1f%%', shadow=True)
       
  2306 title('Raining Hogs and Dogs', 
       
  2307       bbox={'facecolor':'0.8', 'pad':5})
       
  2308 \end{lstlisting}
       
  2309   \end{block}
       
  2310 \end{columns}
       
  2311 \end{frame}
       
  2312 
       
  2313 \begin{frame}[fragile] \frametitle{Scatter plots}
       
  2314   \begin{columns}
       
  2315     \column{0.5\textwidth}
       
  2316     \hspace*{-0.4in}
       
  2317   \includegraphics[height=2in, interpolate=true]{data/scatter}  
       
  2318     \column{0.45\textwidth}
       
  2319     \begin{block}{Example code}
       
  2320     \tiny
       
  2321 \begin{lstlisting}
       
  2322 N = 30
       
  2323 x = 0.9*rand(N)
       
  2324 y = 0.9*rand(N)
       
  2325 # 0 to 10 point radiuses
       
  2326 area = pi*(10 * rand(N))**2 
       
  2327 volume = 400 + rand(N)*450
       
  2328 scatter(x,y,s=area, marker='o', c=volume, 
       
  2329         alpha=0.75)
       
  2330 xlabel(r'$\Delta_i$', size='x-large')
       
  2331 ylabel(r'$\Delta_{i+1}$', size='x-large')
       
  2332 title(r'Volume and percent change')
       
  2333 grid(True)
       
  2334 colorbar()
       
  2335 savefig('scatter')
       
  2336 \end{lstlisting}
       
  2337   \end{block}
       
  2338 \end{columns}
       
  2339 \end{frame}
       
  2340 
       
  2341 \begin{frame}[fragile] \frametitle{Polar}
       
  2342   \begin{columns}
       
  2343     \column{0.5\textwidth}
       
  2344     \hspace*{-0.5in}
       
  2345   \includegraphics[height=2in, interpolate=true]{data/polar}  
       
  2346     \column{0.45\textwidth}
       
  2347     \begin{block}{Example code}
       
  2348     \tiny
       
  2349 \begin{lstlisting}
       
  2350 figure(figsize=(8,8))
       
  2351 ax = axes([0.1, 0.1, 0.8, 0.8], polar=True, 
       
  2352           axisbg='#d5de9c')
       
  2353 r = arange(0,1,0.001)
       
  2354 theta = 2*2*pi*r
       
  2355 polar(theta, r, color='#ee8d18', lw=3)
       
  2356 # the radius of the grid labels
       
  2357 setp(ax.thetagridlabels, y=1.075) 
       
  2358 title(r"$\theta=4\pi r", fontsize=20)
       
  2359 \end{lstlisting}
       
  2360   \end{block}
       
  2361 \end{columns}
       
  2362 \end{frame}
       
  2363 
       
  2364 \begin{frame}[fragile] \frametitle{Contours}
       
  2365   \begin{columns}
       
  2366     \column{0.45\textwidth}
       
  2367     \hspace*{-0.5in}
       
  2368   \includegraphics[height=2in, interpolate=true]{data/contour}  
       
  2369     \column{0.525\textwidth}
       
  2370     \begin{block}{Example code}
       
  2371     \tiny
       
  2372 \begin{lstlisting}
       
  2373 x = arange(-3.0, 3.0, 0.025)
       
  2374 y = arange(-2.0, 2.0, 0.025)
       
  2375 X, Y = meshgrid(x, y)
       
  2376 Z1 = bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0)
       
  2377 Z2 = bivariate_normal(X, Y, 1.5, 0.5, 1, 1)
       
  2378 # difference of Gaussians
       
  2379 Z = 10.0 * (Z2 - Z1)
       
  2380 im = imshow(Z, interpolation='bilinear', 
       
  2381             origin='lower',
       
  2382             cmap=cm.gray, extent=(-3,3,-2,2))
       
  2383 levels = arange(-1.2, 1.6, 0.2)
       
  2384 # label every second level
       
  2385 clabel(CS, levels[1::2],  inline=1,
       
  2386        fmt='%1.1f', fontsize=14)
       
  2387 CS = contour(Z, levels,
       
  2388              origin='lower',
       
  2389              linewidths=2,
       
  2390              extent=(-3,3,-2,2))
       
  2391 # make a colorbar for the contour lines
       
  2392 CB = colorbar(CS, shrink=0.8, extend='both')
       
  2393 title('Lines with colorbar')
       
  2394 hot(); flag()
       
  2395 \end{lstlisting}
       
  2396   \end{block}
       
  2397 \end{columns}
       
  2398 \end{frame}
       
  2399 
       
  2400 \begin{frame}[fragile] \frametitle{Velocity vectors}
       
  2401   \begin{columns}
       
  2402     \column{0.5\textwidth}
       
  2403     \hspace*{-0.5in}
       
  2404   \includegraphics[height=2in, interpolate=true]{data/quiver}  
       
  2405     \column{0.45\textwidth}
       
  2406     \begin{block}{Example code}
       
  2407     \tiny
       
  2408 \begin{lstlisting}
       
  2409 X,Y = meshgrid(arange(0,2*pi,.2),
       
  2410                arange(0,2*pi,.2) )
       
  2411 U = cos(X)
       
  2412 V = sin(Y)
       
  2413 Q = quiver(X[::3, ::3], Y[::3, ::3], 
       
  2414            U[::3, ::3], V[::3, ::3],
       
  2415            color='r', units='x', 
       
  2416            linewidths=(2,), 
       
  2417            edgecolors=('k'), 
       
  2418            headaxislength=5 )
       
  2419 qk = quiverkey(Q, 0.5, 0.03, 1, '1 m/s', 
       
  2420                fontproperties=
       
  2421                {'weight': 'bold'})
       
  2422 axis([-1, 7, -1, 7])
       
  2423 title('triangular head; scale '\
       
  2424       'with x view; black edges')
       
  2425 \end{lstlisting}
       
  2426   \end{block}
       
  2427 \end{columns}
       
  2428 \end{frame}
       
  2429 
       
  2430 \begin{frame}[fragile] \frametitle{Maps}
       
  2431   \includegraphics[height=2.5in, interpolate=true]{data/plotmap}  
       
  2432   \begin{center}
       
  2433     \tiny
       
  2434     For details see \url{http://matplotlib.sourceforge.net/screenshots/plotmap.py}
       
  2435   \end{center}
       
  2436 \end{frame}
       
  2437 
       
  2438 
       
  2439 \subsection{SciPy}
       
  2440 
       
  2441 \begin{frame}
       
  2442   \frametitle{Using \texttt{SciPy}}
       
  2443   \begin{itemize}
       
  2444   \item SciPy is Open Source software for mathematics, science, and
       
  2445     engineering
       
  2446   \item \typ{import scipy}
       
  2447   \item Built on NumPy
       
  2448   \item Provides modules for statistics, optimization, integration,
       
  2449     linear algebra, Fourier transforms, signal and image processing,
       
  2450     genetic algorithms, ODE solvers, special functions, and more
       
  2451   \item Used widely by scientists world over
       
  2452   \item Details are beyond the scope of this tutorial
       
  2453   \end{itemize}
       
  2454 \end{frame}
       
  2455 
       
  2456 \section{Standard library}
       
  2457 
       
  2458 \subsection{Quick Tour}
       
  2459 
       
  2460 \begin{frame}
       
  2461   \frametitle{Standard library}
       
  2462   \begin{itemize}
       
  2463   \item Very powerful
       
  2464   \item ``Batteries included''
       
  2465   \item Example standard modules taken from the tutorial
       
  2466     \begin{itemize}
       
  2467     \item Operating system interface: \typ{os}
       
  2468     \item System, Command line arguments: \typ{sys}
       
  2469     \item Regular expressions: \typ{re}
       
  2470     \item Math: \typ{math}, \typ{random}
       
  2471     \item Internet access: \typ{urllib2}, \typ{smtplib}
       
  2472     \item Data compression: \typ{zlib}, \typ{gzip}, \typ{bz2},
       
  2473       \typ{zipfile}, and \typ{tarfile}
       
  2474     \item Unit testing: \typ{doctest} and \typ{unittest}
       
  2475     \item And a whole lot more!
       
  2476     \end{itemize}
       
  2477   \item Check out the Python Library reference:
       
  2478     \url{http://docs.python.org/lib/lib.html}
       
  2479   \end{itemize}
       
  2480 \end{frame}
       
  2481 
       
  2482 \begin{frame}[fragile]
       
  2483   \frametitle{Stdlib: examples}
       
  2484 \begin{lstlisting}
       
  2485 >>> import os
       
  2486 >>> os.system('date')
       
  2487 Fri Jun 10 22:13:09 IST 2005
       
  2488 0
       
  2489 >>> os.getcwd()
       
  2490 '/home/prabhu'
       
  2491 >>> os.chdir('/tmp')
       
  2492 >>> import os
       
  2493 >>> dir(os)
       
  2494 <returns a list of all module functions>
       
  2495 >>> help(os)
       
  2496 <extensive manual page from module's docstrings>
       
  2497 \end{lstlisting}
       
  2498 \end{frame}
       
  2499 
       
  2500 \begin{frame}[fragile]
       
  2501   \frametitle{Stdlib: examples}
       
  2502 \begin{lstlisting}
       
  2503 >>> import sys
       
  2504 >>> # Print the list of command line args to Python
       
  2505 ... print sys.argv 
       
  2506 ['']
       
  2507 >>> import re # Regular expressions
       
  2508 >>> re.findall(r'\bf[a-z]*', 
       
  2509 ... 'which foot or hand fell fastest')
       
  2510 ['foot', 'fell', 'fastest']
       
  2511 >>> re.sub(r'(\b[a-z]+) \1', r'\1', 
       
  2512 ... 'cat in the the hat')
       
  2513 'cat in the hat'
       
  2514 \end{lstlisting}
       
  2515 \end{frame}
       
  2516 
       
  2517 \begin{frame}[fragile]
       
  2518   \frametitle{Stdlib: examples}
       
  2519 \begin{lstlisting}
       
  2520 >>> import math
       
  2521 >>> math.cos(math.pi / 4.0)
       
  2522 0.70710678118654757
       
  2523 >>> math.log(1024, 2)
       
  2524 10.0
       
  2525 >>> import random
       
  2526 >>> random.choice(['apple', 'pear', 'banana'])
       
  2527 'pear'
       
  2528 \end{lstlisting}
       
  2529 \end{frame}
       
  2530 
       
  2531 \begin{frame}[fragile]
       
  2532   \frametitle{Stdlib: examples}
       
  2533 \begin{lstlisting}
       
  2534 >>> import urllib2
       
  2535 >>> f = urllib2.urlopen('http://www.python.org/')
       
  2536 >>> print f.read(100)
       
  2537 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
       
  2538 <?xml-stylesheet href="./css/ht2html
       
  2539 \end{lstlisting}
       
  2540 \end{frame}
       
  2541 
       
  2542 \begin{frame}[fragile]
       
  2543   \frametitle{Stdlib: examples}
       
  2544 \begin{lstlisting}
       
  2545 >>> import zlib
       
  2546 >>> s = 'witch which has which witches wrist watch'
       
  2547 >>> len(s)
       
  2548 41
       
  2549 >>> t = zlib.compress(s)
       
  2550 >>> len(t)
       
  2551 37
       
  2552 >>> zlib.decompress(t)
       
  2553 'witch which has which witches wrist watch'
       
  2554 >>> zlib.crc32(t)
       
  2555 -1438085031
       
  2556 \end{lstlisting}
       
  2557 \end{frame}
       
  2558 
       
  2559 \begin{frame}
       
  2560   \frametitle{Summary}
       
  2561   \begin{itemize}
       
  2562   \item Introduced Python
       
  2563   \item Basic syntax
       
  2564   \item Basic types and data structures
       
  2565   \item Control flow
       
  2566   \item Functions
       
  2567   \item Modules
       
  2568   \item Exceptions
       
  2569   \item Classes
       
  2570   \item Standard library
       
  2571   \end{itemize}
       
  2572 \end{frame}
       
  2573 
       
  2574 \end{document}
       
  2575 
       
  2576 \subsection{Basic data structures}
       
  2577 \begin{frame}{Lists}
       
  2578   \begin{itemize}
       
  2579     \item \texttt{species = [ 'humans', 'orcs', 'elves', 'dwarves' ]}
       
  2580     \item \texttt{ ids = [ 107, 109, 124, 141, 142, 144 ]}
       
  2581     \item \texttt{ oneliners = [ 'I will be back', 'Do or do not! No try!!', 42 ] }
       
  2582   \end{itemize}
       
  2583 
       
  2584   \begin{block}{List operations}
       
  2585     ids + [ 100, 102 ]\\
       
  2586     species.append( 'unicorns')\\
       
  2587     print oneliners[ 1 ]\\
       
  2588     look up \alert{docs.python.org/tutorial/datastructures.html}
       
  2589   \end{block}
       
  2590 \end{frame}
       
  2591 \end{document}
       
  2592 \section{Python Tutorial}
       
  2593 \subsection{Preliminaries}
       
  2594 \begin{frame}
       
  2595   \frametitle{Using the interpreter}
       
  2596   \begin{itemize}
       
  2597   \item Starting up: \typ{python} or \typ{ipython}
       
  2598   \item Quitting: \typ{Control-D} or \typ{Control-Z} (on Win32)
       
  2599   \item Can use it like a calculator
       
  2600   \item Can execute one-liners via the \typ{-c} option:
       
  2601     \typ{python -c "print 'hello world'"}
       
  2602   \item Other options via \typ{python -h}
       
  2603   \end{itemize}
       
  2604 \end{frame}
       
  2605 
       
  2606 \begin{frame}
       
  2607   \frametitle{IPython}
       
  2608   \begin{itemize}
       
  2609   \item Recommended interpreter, IPython:
       
  2610     \url{http://ipython.scipy.org}
       
  2611   \item Better than the default Python shell
       
  2612   \item Supports tab completion by default
       
  2613   \item Easier object introspection
       
  2614   \item Shell access!
       
  2615   \item Command system to allow extending its own behavior
       
  2616   \item Supports history (across sessions) and logging
       
  2617   \item Can be embedded in your own Python code
       
  2618   \item Support for macros
       
  2619   \item A flexible framework for your own custom interpreter
       
  2620   \item Other miscellaneous conveniences
       
  2621   \item We'll get back to this later
       
  2622   \end{itemize}
       
  2623 \end{frame}
       
  2624 
       
  2625 \begin{frame}[fragile]
       
  2626   \frametitle{Basic IPython features}
       
  2627   \begin{itemize}
       
  2628   \item Startup: \verb+ipython [options] files+
       
  2629     \begin{itemize}
       
  2630     \item \verb+ipython [-wthread|-gthread|-qthread]+:
       
  2631       Threading modes to support wxPython, pyGTK and Qt
       
  2632     \item \verb+ipython -pylab+: Support for matplotlib
       
  2633     \end{itemize}
       
  2634   \item TAB completion:
       
  2635     \begin{itemize}
       
  2636     \item Type \verb+object_name.<TAB>+ to see list of options
       
  2637     \item Also completes on file and directory names
       
  2638     \end{itemize}
       
  2639   \item \verb+object?+ shows docstring/help for any Python object
       
  2640   \item \verb+object??+ presents more docs (and source if possible)
       
  2641   \item Debugging with \verb+%pdb+ magic: pops up pdb on errors
       
  2642   \item Access history (saved over earlier sessions also)
       
  2643     \begin{itemize}
       
  2644     \item Use \texttt{<UpArrow>}: move up history
       
  2645     \item Use \texttt{<Ctrl-r> string}: search history backwards
       
  2646     \item Use \texttt{Esc >}: get back to end of history
       
  2647     \end{itemize}
       
  2648   \item \verb+%run [options] file[.py]+ lets you run Python code
       
  2649   \end{itemize}
       
  2650 \end{frame}
       
  2651 % LocalWords:  BDFL Guido Rossum PSF Nokia OO Zope CMS RedHat SciPy MayaVi spam
       
  2652 % LocalWords:  IPython ipython stdin TypeError dict int elif PYTHONPATH IOError
       
  2653 % LocalWords:  namespace Namespaces SyntaxError ZeroDivisionError NameError str
       
  2654 % LocalWords:  ValueError subclassed def
       
  2655 
       
  2656 
       
  2657   \item Types are of two kinds: \alert{mutable} and \alert{immutable}
       
  2658   \item Immutable types: numbers, strings, \typ{None} and tuples
       
  2659   \item Immutables cannot be changed ``in-place''
       
  2660   \item Mutable types: lists, dictionaries, instances, etc.
       
  2661   \item Mutable objects can be ``changed''
       
  2662   \end{itemize}
       
  2663 
       
  2664 
       
  2665 \begin{frame}
       
  2666   \frametitle{Important!}
       
  2667   \begin{itemize}
       
  2668     \item Assignment to an object is by reference
       
  2669     \item Essentially, \alert{names are bound to objects}
       
  2670   \end{itemize}
       
  2671 \end{frame}
       
  2672 
       
  2673 
       
  2674 \end{document}
       
  2675 \begin{frame}[fragile]
       
  2676   \frametitle{Dictionaries}
       
  2677   \begin{itemize}
       
  2678   \item Associative arrays/mappings
       
  2679   \item Indexed by ``keys'' (keys must be immutable)
       
  2680   \item \typ{dict[key] = value}
       
  2681   \item \typ{keys()} returns all keys of the dict
       
  2682   \item \typ{values()} returns the values of the dict
       
  2683   \item \verb+has_key(key)+ returns if \typ{key} is in the dict
       
  2684   \end{itemize}
       
  2685 \end{frame}
       
  2686 
       
  2687 \begin{frame}[fragile]
       
  2688   \frametitle{Dictionaries: example}
       
  2689   \begin{lstlisting}
       
  2690 >>> tel = {'jack': 4098, 'sape': 4139}
       
  2691 >>> tel['guido'] = 4127
       
  2692 >>> tel
       
  2693 {'sape': 4139, 'guido': 4127, 'jack': 4098}
       
  2694 >>> tel['jack']
       
  2695 4098
       
  2696 >>> del tel['sape']
       
  2697 >>> tel['irv'] = 4127
       
  2698 >>> tel
       
  2699 {'guido': 4127, 'irv': 4127, 'jack': 4098}
       
  2700 >>> tel.keys()
       
  2701 ['guido', 'irv', 'jack']
       
  2702 >>> tel.has_key('guido')
       
  2703 True
       
  2704   \end{lstlisting}
       
  2705 \end{frame}
       
  2706 
       
  2707 \subsection{Control flow, functions}
       
  2708 
       
  2709 
       
  2710 
       
  2711 \begin{frame}[fragile]
       
  2712   \frametitle{\typ{If} example}
       
  2713   \begin{lstlisting}
       
  2714 >>> a = ['cat', 'window', 'defenestrate']
       
  2715 >>> if 'cat' in a:
       
  2716 ...    print "meaw"
       
  2717 ...
       
  2718 meaw
       
  2719 >>> pets = {'cat': 1, 'dog':2, 'croc': 10}
       
  2720 >>> if 'croc' in pets:
       
  2721 ...    print pets['croc']
       
  2722 ...
       
  2723 10
       
  2724   \end{lstlisting}
       
  2725 \end{frame}
       
  2726 
       
  2727 \begin{frame}[fragile]
       
  2728   \frametitle{\typ{for} example}
       
  2729   \begin{lstlisting}
       
  2730 >>> a = ['cat', 'window', 'defenestrate']
       
  2731 >>> for x in a:
       
  2732 ...     print x, len(x)
       
  2733 ...
       
  2734 cat 3
       
  2735 window 6
       
  2736 defenestrate 12
       
  2737 >>> knights = {'gallahad': 'the pure', 
       
  2738 ... 'robin': 'the brave'}
       
  2739 >>> for k, v in knights.iteritems():
       
  2740 ...     print k, v
       
  2741 ...
       
  2742 gallahad the pure
       
  2743 robin the brave
       
  2744 \end{lstlisting}
       
  2745 \end{frame}