start of [presentation

Author: ChrisBarker-NOAA

week-07/presentation-week-07.tex

@@ -519,7 +519,7 @@ \section{Multiple Inheritance}
 \begin{verbatim}
 class A(B):
     def __init__(self, *args, **kwargs)
-        super(B, self).__init__(self, *argw, **kwargs)
+        super(A, self).__init__(self, *argw, **kwargs)
         ...
 \end{verbatim}
 

week-08/presentation-week-08.pdf

@@ -1,10 +1,10 @@
 \documentclass{beamer}
 %\usepackage[latin1]{inputenc}
 \usetheme{Warsaw}
-\title[Intro to Python: Week 1]{Introduction  to Python\\ Topics}
+\title[Intro to Python: Week 8]{Introduction  to Python\\ More OO}
 \author{Christopher Barker}
 \institute{UW Continuing Education}
-\date{October 15, 2013}
+\date{November 19, 2013}
 
 \usepackage{listings}
 \usepackage{hyperref}
@@ -73,18 +73,155 @@ \section{Review/Questions}
 
 \end{frame}
 
-%########################
-\section{First Section}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{Special Methods}
 
-\begin{frame}[fragile]{topic}
+\begin{frame}[fragile]{special methods}
 
-{\Large Some Stuff}
+{\Large Python's Duck typing:}
 
+\vfill
+{\Large Defining special (or magic) methods in your classes is how you make
+your class act like standard classes}
+
+\end{frame} 
+
+\begin{frame}[fragile]{special methods}
+
+{\Large We've seen at least one:}
+
+\begin{verbatim}
+__init__
+\end{verbatim}
+
+\vfill
+{\Large it's all in the double underscores...}
+
+\vfill
+{\Large Pronounced ``dunder'' (or ``under-under'') }
+
+\vfill
+{\Large try: \verb|dir(2)| or \verb|dir(list)|}
+
+\end{frame} 
+
+\begin{frame}[fragile]{special methods}
+
+{\Large Emulating Numeric types}
+
+\begin{verbatim}
+object.__add__(self, other)
+object.__sub__(self, other)
+object.__mul__(self, other)
+object.__floordiv__(self, other)
+object.__mod__(self, other)
+object.__divmod__(self, other)
+object.__pow__(self, other[, modulo])
+object.__lshift__(self, other)
+object.__rshift__(self, other)
+object.__and__(self, other)
+object.__xor__(self, other)
+object.__or__(self, other)¶
+\end{verbatim}
+
+\end{frame} 
+
+\begin{frame}[fragile]{special methods}
+
+{\Large Emulating container types:}
+
+\begin{verbatim}
+object.__len__(self)
+object.__getitem__(self, key)
+object.__setitem__(self, key, value)
+object.__delitem__(self, key)
+object.__iter__(self)
+object.__reversed__(self)
+object.__contains__(self, item)
+object.__getslice__(self, i, j)
+object.__setslice__(self, i, j, sequence)
+object.__delslice__(self, i, j)
+\end{verbatim}
+
+\end{frame} 
+
+\begin{frame}[fragile]{special methods}
+
+{\Large Example -- to define addition:}
+
+\begin{verbatim}
+def __add__(self, v):
+    """
+    redefine + as element-wise vector sum
+    """
+    assert len(self) == len(v)
+    return vector([x1 + x2 for x1, x2 in zip(self, v)])
+\end{verbatim}
+
+( from a nice complete example in \verb|code/vector.py| )
+
+\end{frame} 
+
+
+\begin{frame}[fragile]{special methods}
+
+{\Large You get the idea...}
+
+\vfill
+{\Large You only need to define the ones that are going to get used}
+
+\vfill
+{\Large But you probably want to define at least these:}
+
+\vfill
+\verb|object.__str__|: Called by the str() built-in function and by the print statement to compute the “informal” string representation of an object.
+
+\vfill
+\verb|object.__repr__|: Called by the repr() built-in function and by string conversions (reverse quotes) to compute the “official” string representation of an object.
+
+\end{frame} 
+
+\begin{frame}[fragile]{special methods}
+
+\vfill
+{\Large When you want your class to act like a "standard" class in some way:}
+
+\vfill
+{\Large Look up the magic methods you need and define them}
+
+\vfill
+\url{http://docs.python.org/reference/datamodel.html#special-method-names}
+
+\vfill
+\url{http://www.rafekettler.com/magicmethods.html}
+\end{frame} 
+
+\begin{frame}[fragile]{LAB}
+
+{\Large Write a ``Circle'' class:}
+
+
+\vfill
+{\large A Circle has a radius and can compute its area:}
 \begin{verbatim}
-sample code
+In [2]: c = Circle(3)
+In [3]: c.radius
+Out[3]: 3
+In [4]: c.get_area()
+Out[4]: 28.274333882308138
+In [5]: print c
+Circle Object with radius: 3.000000
 \end{verbatim}
+{\large Write an \verb|__add__| method so you can add two circles }
+
+\vfill
+{\large Have \verb|__str__| and \verb|__repr__| methods }
 
+\vfill
+{\large Extra credit: also compare them... (\verb|c1 > c2|, etc)}
 
+\vfill
+{\large \verb|code/circle.py| and \verb|code/test_circle.py|}
 \end{frame}
 
 
@@ -112,6 +249,70 @@ \section{First Section}
 \end{frame}
 
 
+
+%-------------------------------
+\begin{frame}[fragile]{Wrap Up}
+
+{\LARGE Thinking OO in Python:}
+
+\vfill
+{\large Think about what makes sense for your code:}
+\begin{itemize}
+  \item {\large Code re-use}
+  \item {\large Clean APIs}
+  \item {\large ... }
+\end{itemize}
+
+\vfill
+{\large Don't be a slave to what OO is \emph{supposed} to look like. }
+
+\vfill
+{\large Let OO work for you, not \emph{create} work for you}
+
+\end{frame}
+
+
+%-------------------------------
+\begin{frame}[fragile]{Wrap Up}
+
+{\Large OO in Python:}
+
+\vfill
+{\Large The Art of Subclassing}: Raymond Hettinger
+
+\vfill
+{\small \url{http://pyvideo.org/video/879/the-art-of-subclassing}}
+
+\vfill
+''classes are for code re-use -- not creating taxonomies''
+
+\vfill
+{\Large Stop Writing Classes}: Jack Diederich
+
+\vfill
+{\small \url{http://pyvideo.org/video/880/stop-writing-classes}}
+
+\vfill
+``If your class has only two methods -- and one of them is \verb|__init__|
+-- you don't need a class ''
+\end{frame}
+
+
+
+
+%-------------------------------
+\begin{frame}[fragile]{Homework}
+
+{\Large Finish the labs.}
+
+{\Large You should have a good start on your project by the end of this week}
+
+\end{frame}
+ 
+
+
+
+
 %-------------------------------
 \begin{frame}[fragile]{Homework}