iframe-proxy | Sunbelt Computer Software

822 lines (712 loc) · 53.9 KB
<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Session Eight: More OO: Properties, Special methods. &mdash; Introduction To Python 1.3 documentation</title>
    <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
    <link rel="top" title="Introduction To Python 1.3 documentation" href="index.html"/>
        <link rel="next" title="Session Nine: Iterators, Iterables, and Generators" href="session09.html"/>
        <link rel="prev" title="Object Oriented Programming" href="session07.html"/> 
  <script src="_static/js/modernizr.min.js"></script>
<body class="wy-body-for-nav" role="document">
  <div class="wy-grid-for-nav">
    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
      <div class="wy-side-scroll">
        <div class="wy-side-nav-search">
            <a href="index.html" class="icon icon-home"> Introduction To Python
          </a>
              <div class="version">
              </div>
<div role="search">
  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
    <input type="text" name="q" placeholder="Search docs" />
    <input type="hidden" name="check_keywords" value="yes" />
    <input type="hidden" name="area" value="default" />
        </div>
        <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
                <ul class="current">
<li class="toctree-l1"><a class="reference internal" href="session01.html">Session One: Introductions</a></li>
<li class="toctree-l1"><a class="reference internal" href="session02.html">Session Two: gitHub, Functions, Booleans and Modules</a></li>
<li class="toctree-l1"><a class="reference internal" href="session03.html">Session Three: Sequences, Iteration and String Formatting</a></li>
<li class="toctree-l1"><a class="reference internal" href="session04.html">Session Four: Dictionaries, Sets, and Files</a></li>
<li class="toctree-l1"><a class="reference internal" href="session05.html">Session Five: Exceptions, Testing, Comprehensions</a></li>
<li class="toctree-l1"><a class="reference internal" href="session06.html">Session Six: Advanced Argument Passing, lambda, functions as objects</a></li>
<li class="toctree-l1"><a class="reference internal" href="session07.html">Object Oriented Programming</a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="">Session Eight: More OO: Properties, Special methods.</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#review-questions">Review/Questions</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#review-of-previous-class">Review of Previous Class</a></li>
<li class="toctree-l3"><a class="reference internal" href="#lightning-talks-today">Lightning Talks Today:</a></li>
<li class="toctree-l3"><a class="reference internal" href="#personal-project">Personal Project</a></li>
<li class="toctree-l3"><a class="reference internal" href="#homework-review">Homework review</a></li>
<li class="toctree-l3"><a class="reference internal" href="#homework-notes">Homework Notes:</a></li>
<li class="toctree-l2"><a class="reference internal" href="#properties">Properties</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#getter-and-setters">Getter and Setters?</a></li>
<li class="toctree-l3"><a class="reference internal" href="#id1">properties</a></li>
<li class="toctree-l3"><a class="reference internal" href="#read-only-attributes">&#8220;Read Only&#8221; Attributes</a></li>
<li class="toctree-l3"><a class="reference internal" href="#deleters">Deleters</a></li>
<li class="toctree-l2"><a class="reference internal" href="#lab">LAB</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#lightning-talks">Lightning talks:</a></li>
<li class="toctree-l2"><a class="reference internal" href="#static-and-class-methods">Static and Class Methods</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#static-methods">Static Methods</a></li>
<li class="toctree-l3"><a class="reference internal" href="#class-methods">Class Methods</a></li>
<li class="toctree-l3"><a class="reference internal" href="#why">Why?</a></li>
<li class="toctree-l3"><a class="reference internal" href="#alternate-constructors">Alternate Constructors</a></li>
<li class="toctree-l2"><a class="reference internal" href="#special-methods">Special Methods</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#what-s-in-a-name">What&#8217;s in a Name?</a></li>
<li class="toctree-l3"><a class="reference internal" href="#protocols">Protocols</a></li>
<li class="toctree-l2"><a class="reference internal" href="#id2">LAB</a></li>
<li class="toctree-l2"><a class="reference internal" href="#emulating-standard-types">Emulating Standard types</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#callable-classes">Callable classes</a></li>
<li class="toctree-l3"><a class="reference internal" href="#callables">&#8220;Callables&#8221;</a></li>
<li class="toctree-l3"><a class="reference internal" href="#custom-callable-objects">Custom callable objects</a></li>
<li class="toctree-l3"><a class="reference internal" href="#writing-your-own-sequence-type">Writing your own sequence type</a></li>
<li class="toctree-l3"><a class="reference internal" href="#a-sparse-array">A Sparse array</a></li>
<li class="toctree-l3"><a class="reference internal" href="#the-sequence-protocol">The Sequence protocol</a></li>
<li class="toctree-l2"><a class="reference internal" href="#id3">LAB</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#id4">Callables:</a></li>
<li class="toctree-l3"><a class="reference internal" href="#sparse-array">Sparse Array:</a></li>
<li class="toctree-l2"><a class="reference internal" href="#homework">Homework</a></li>
<li class="toctree-l1"><a class="reference internal" href="session09.html">Session Nine: Iterators, Iterables, and Generators</a></li>
<li class="toctree-l1"><a class="reference internal" href="session10.html">Session Ten: Decorators and Context Managers &#8211; Wrap Up</a></li>
<li class="toctree-l1"><a class="reference internal" href="exercises/index.html">Exercises</a></li>
<li class="toctree-l1"><a class="reference internal" href="supplements/index.html">Supplemental Materials</a></li>
        </div>
      </div>
    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
      <nav class="wy-nav-top" role="navigation" aria-label="top navigation">
        <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
        <a href="index.html">Introduction To Python</a>
      </nav>
      <div class="wy-nav-content">
        <div class="rst-content">
<div role="navigation" aria-label="breadcrumbs navigation">
  <ul class="wy-breadcrumbs">
    <li><a href="index.html">Docs</a> &raquo;</li>
    <li>Session Eight: More OO: Properties, Special methods.</li>
      <li class="wy-breadcrumbs-aside">
            <a href="_sources/session08.txt" rel="nofollow"> View page source</a>
      </li>
          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
           <div itemprop="articleBody">
  <div class="section" id="session-eight-more-oo-properties-special-methods">
<h1>Session Eight: More OO: Properties, Special methods.<a class="headerlink" href="#session-eight-more-oo-properties-special-methods" title="Permalink to this headline">¶</a></h1>
<div class="section" id="review-questions">
<h2>Review/Questions<a class="headerlink" href="#review-questions" title="Permalink to this headline">¶</a></h2>
<div class="section" id="review-of-previous-class">
<h3>Review of Previous Class<a class="headerlink" href="#review-of-previous-class" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li>Basic OO Concepts<ul>
<li>Classes</li>
<li>class vs. instance attributes</li>
<li>subclassing</li>
<li>overriding methods / attributes</li>
<div class="section" id="lightning-talks-today">
<h3>Lightning Talks Today:<a class="headerlink" href="#lightning-talks-today" title="Permalink to this headline">¶</a></h3>
<p class="medium">Robert Ryan Leslie</p>
<p class="medium">Ryan Morin</p>
<div class="section" id="personal-project">
<h3>Personal Project<a class="headerlink" href="#personal-project" title="Permalink to this headline">¶</a></h3>
<p>The bulk of the homework for the rest of the class will be a personal project:</p>
<ul class="simple">
<li>It can be for fun, or something you need for your job.</li>
<li>It should be large enough to take a few weeks homework time to do.</li>
<li><strong>It should demostrate that you can do something useful with python.</strong></li>
<li>It should follow PEP8 (<a class="reference external" href="https://www.python.org/dev/peps/pep-0008">https://www.python.org/dev/peps/pep-0008</a>)</li>
<li>It should have unit tests!</li>
<li>Ideally, it will be in version control (gitHub)</li>
<li>I don&#8217;t require any specific python features (i.e. classes): use
what is appropriate for your project</li>
<li>Due the Friday after the last class (December 11)</li>
<div class="line-block">
<div class="line"><br /></div>
<div class="line-block">
<div class="line">By next week, send me a project proposal: short and sweet.</div>
<div class="line"><br /></div>
<div class="section" id="homework-review">
<h3>Homework review<a class="headerlink" href="#homework-review" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li>html renderer</li>
<li>Test-driven development</li>
<div class="section" id="homework-notes">
<h3>Homework Notes:<a class="headerlink" href="#homework-notes" title="Permalink to this headline">¶</a></h3>
<p><code class="docutils literal"><span class="pre">**kwargs</span></code> will always define a <code class="docutils literal"><span class="pre">kwargs</span></code> dict: it just may be empty.</p>
<p>And there is no need to check if it&#8217;s empty before trying to loop through it.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span> <span class="o">!=</span> <span class="p">{}:</span>
    <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">atts</span> <span class="o">+=</span> <span class="s">&#39; {}=&quot;{}&quot;&#39;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
</pre></div>
<p>no need for <code class="docutils literal"><span class="pre">!=</span> <span class="pre">{}</span></code> &#8211; an empty dict is &#8220;Falsey&#8221;</p>
<p><strong>but</strong> no need for that check at all. If the dict (or ist, or tuple) is
empty, then the loop is a do-nothing operation:</p>
<ul class="simple">
<li>notes on Duck Typing: <a class="reference internal" href="exercises/html_renderer.html#exercise-html-renderer"><span>HTML Renderer Exercise</span></a> and  code review</li>
<li>anyone stuck that wants to work through your code?</li>
<div class="section" id="properties">
<h2>Properties<a class="headerlink" href="#properties" title="Permalink to this headline">¶</a></h2>
<div class="left container">
<p>One of the strengths of Python is lack of clutter.</p>
<p>Attributes are simple and concise:</p>
<div class="highlight-ipython"><div class="highlight"><pre><span class="gp">In [5]: </span><span class="k">class</span> <span class="nc">C</span><span class="p">:</span>
<span class="go">        def __init__(self):</span>
<span class="go">                self.x = 5</span>
<span class="gp">In [6]: </span><span class="n">c</span> <span class="o">=</span> <span class="n">C</span><span class="p">()</span>
<span class="gp">In [7]: </span><span class="n">c</span><span class="o">.</span><span class="n">x</span>
<span class="gh">Out[7]: </span><span class="go">5</span>
<span class="gp">In [8]: </span><span class="n">c</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="mi">8</span>
<span class="gp">In [9]: </span><span class="n">c</span><span class="o">.</span><span class="n">x</span>
<span class="gh">Out[9]: </span><span class="go">8</span>
</pre></div>
<div class="section" id="getter-and-setters">
<h3>Getter and Setters?<a class="headerlink" href="#getter-and-setters" title="Permalink to this headline">¶</a></h3>
<p>But what if you need to add behavior later?</p>
<ul class="build simple">
<li>do some calculation</li>
<li>check data validity</li>
<li>keep things in sync</li>
<div class="highlight-ipython"><div class="highlight"><pre><span class="gp">In [5]: </span><span class="k">class</span> <span class="nc">C</span><span class="p">:</span>
<span class="gp">   ...: </span>    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="gp">   ...: </span>        <span class="bp">self</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="mi">5</span>
<span class="gp">   ...: </span>    <span class="k">def</span> <span class="nf">get_x</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="gp">   ...: </span>        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">x</span>
<span class="gp">   ...: </span>    <span class="k">def</span> <span class="nf">set_x</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
<span class="gp">   ...: </span>        <span class="bp">self</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="n">x</span>
<span class="gp">   ...:</span>
<span class="gp">In [6]: </span><span class="n">c</span> <span class="o">=</span> <span class="n">C</span><span class="p">()</span>
<span class="gp">In [7]: </span><span class="n">c</span><span class="o">.</span><span class="n">get_x</span><span class="p">()</span>
<span class="gh">Out[7]: </span><span class="go">5</span>
<span class="gp">In [8]: </span><span class="n">c</span><span class="o">.</span><span class="n">set_x</span><span class="p">(</span><span class="mi">8</span><span class="p">)</span>
<span class="gp">In [9]: </span><span class="n">c</span><span class="o">.</span><span class="n">get_x</span><span class="p">()</span>
<span class="gh">Out[9]: </span><span class="go">8</span>
</pre></div>
<p>&lt;shudder&gt; This is ugly and verbose &#8211; <a class="reference external" href="http://dirtsimple.org/2004/12/python-is-not-java.html">Java</a>?</p>
<div class="section" id="id1">
<h3>properties<a class="headerlink" href="#id1" title="Permalink to this headline">¶</a></h3>
<div class="highlight-ipython"><div class="highlight"><pre><span class="go">class C:</span>
<span class="go">    _x = None</span>
<span class="go">    @property</span>
<span class="go">    def x(self):</span>
<span class="go">        return self._x</span>
<span class="go">    @x.setter</span>
<span class="go">    def x(self, value):</span>
<span class="go">        self._x = value</span>
<span class="gp">In [28]: </span><span class="n">c</span> <span class="o">=</span> <span class="n">C</span><span class="p">()</span>
<span class="gp">In [30]: </span><span class="n">c</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="mi">5</span>
<span class="gp">In [31]: </span><span class="k">print</span><span class="p">(</span><span class="n">c</span><span class="o">.</span><span class="n">x</span><span class="p">)</span>
<span class="go">5</span>
</pre></div>
<p>Now the interface is like simple attribute access!</p>
<p>What&#8217;s up with the &#8220;&#64;&#8221; symbols?</p>
<p>Those are &#8220;decorations&#8221; it&#8217;s a syntax for wrapping functions up with something special.</p>
<p>We&#8217;ll cover that in detail in a couple weeks, but for now &#8211; just copy the syntax.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nd">@property</span>
<span class="k">def</span> <span class="nf">x</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
</pre></div>
<p>means: make a property called x with this as the &#8220;getter&#8221;.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nd">@x.setter</span>
<span class="k">def</span> <span class="nf">x</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
</pre></div>
<p>means: make the &#8220;setter&#8221; of the &#8216;x&#8217; property this new function</p>
<div class="section" id="read-only-attributes">
<h3>&#8220;Read Only&#8221; Attributes<a class="headerlink" href="#read-only-attributes" title="Permalink to this headline">¶</a></h3>
<p>You do not need to define a setter. If you don&#8217;t, you get a &#8220;read only&#8221; attribute:</p>
<div class="highlight-ipython"><div class="highlight"><pre><span class="gp">In [11]: </span><span class="k">class</span> <span class="nc">D</span><span class="p">():</span>
<span class="gp">   ....: </span>    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="mi">5</span><span class="p">):</span>
<span class="gp">   ....: </span>        <span class="bp">self</span><span class="o">.</span><span class="n">_x</span> <span class="o">=</span> <span class="mi">5</span>
<span class="gp">   ....: </span>    <span class="nd">@property</span>
<span class="gp">   ....: </span>    <span class="k">def</span> <span class="nf">getx</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="gp">   ....: </span>    <span class="sd">&quot;&quot;&quot;I am read only&quot;&quot;&quot;</span>
<span class="gp">   ....: </span>        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_x</span>
<span class="gp">   ....:</span>
<span class="gp">In [12]: </span><span class="n">d</span> <span class="o">=</span> <span class="n">D</span><span class="p">()</span>
<span class="gp">In [13]: </span><span class="n">d</span><span class="o">.</span><span class="n">x</span>
<span class="gh">Out[13]: </span><span class="go">5</span>
<span class="gp">In [14]: </span><span class="n">d</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="mi">6</span>
<span class="gt">---------------------------------------------------------------------------</span>
<span class="ne">AttributeError</span><span class="g-Whitespace">                            </span>Traceback (most recent call last)
<span class="nn">&lt;ipython-input-14-c83386d97be3&gt;</span> in <span class="ni">&lt;module&gt;</span><span class="nt">()</span>
<span class="ne">----&gt; </span><span class="mi">1</span> <span class="n">d</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="mi">6</span>
<span class="ne">AttributeError</span>: can&#39;t set attribute
</pre></div>
<div class="section" id="deleters">
<h3>Deleters<a class="headerlink" href="#deleters" title="Permalink to this headline">¶</a></h3>
<p>If you want to do something special when a property is deleted, you can define
a deleter is well:</p>
<div class="highlight-ipython"><div class="highlight"><pre><span class="gp">In [11]: </span><span class="k">class</span> <span class="nc">D</span><span class="p">():</span>
<span class="gp">   ....: </span>    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="mi">5</span><span class="p">):</span>
<span class="gp">   ....: </span>        <span class="bp">self</span><span class="o">.</span><span class="n">_x</span> <span class="o">=</span> <span class="mi">5</span>
<span class="gp">   ....: </span>    <span class="nd">@property</span>
<span class="gp">   ....: </span>    <span class="k">def</span> <span class="nf">x</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="gp">   ....: </span>        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_x</span>
<span class="gp">   ....: </span>    <span class="nd">@x.deleter</span>
<span class="gp">   ....: </span>    <span class="k">def</span> <span class="nf">x</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="gp">   ....: </span>        <span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">_x</span>
</pre></div>
<p>If you leave this out, the property can&#8217;t be deleted, which is usually
what you want.</p>
<p class="centered">[demo: <a class="reference download internal" href="_downloads/properties_example.py"><code class="xref download docutils literal"><span class="pre">properties_example.py</span></code></a>]</p>
<div class="section" id="lab">
<h2>LAB<a class="headerlink" href="#lab" title="Permalink to this headline">¶</a></h2>
<p>Let&#8217;s use some of this to build a nice class to represent a Circle.</p>
<p>For now, Let&#8217;s do steps 1-4 of:</p>
<p><a class="reference internal" href="exercises/circle_class.html#exercise-circle-class"><span>Circle Class Excercise</span></a></p>
<div class="section" id="lightning-talks">
<h3>Lightning talks:<a class="headerlink" href="#lightning-talks" title="Permalink to this headline">¶</a></h3>
<p class="medium">Robert Ryan Leslie</p>
<p class="medium">Ryan Morin</p>
<div class="section" id="static-and-class-methods">
<h2>Static and Class Methods<a class="headerlink" href="#static-and-class-methods" title="Permalink to this headline">¶</a></h2>
<div class="left build container">
<p>You&#8217;ve seen how methods of a class are <em>bound</em> to an instance when it is
created.</p>
<p>And you&#8217;ve seen how the argument <code class="docutils literal"><span class="pre">self</span></code> is then automatically passed to
the method when it is called.</p>
<p>And you&#8217;ve seen how you can call <em>unbound</em> methods on a class object so
long as you pass an instance of that class as the first argument.</p>
<div class="line-block">
<div class="line"><br /></div>
<p class="centered"><strong>But what if you don&#8217;t want or need an instance?</strong></p>
<div class="section" id="static-methods">
<h3>Static Methods<a class="headerlink" href="#static-methods" title="Permalink to this headline">¶</a></h3>
<p>A <em>static method</em> is a method that doesn&#8217;t get self:</p>
<div class="highlight-ipython"><div class="highlight"><pre><span class="gp">In [36]: </span><span class="k">class</span> <span class="nc">StaticAdder</span><span class="p">:</span>
<span class="gp">   ....: </span>    <span class="nd">@staticmethod</span>
<span class="gp">   ....: </span>    <span class="k">def</span> <span class="nf">add</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
<span class="gp">   ....: </span>        <span class="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span>
<span class="gp">   ....:</span>
<span class="gp">In [37]: </span><span class="n">StaticAdder</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">6</span><span class="p">)</span>
<span class="gh">Out[37]: </span><span class="go">9</span>
</pre></div>
<p class="centered">[demo: <a class="reference download internal" href="_downloads/static_method.py"><code class="xref download docutils literal"><span class="pre">static_method.py</span></code></a>]</p>
<div class="build container">
<p>Where are static methods useful?</p>
<p>Usually they aren&#8217;t</p>
<p>99% of the time, it&#8217;s better just to write a module-level function</p>
<p>An example from the Standard Library (tarfile.py):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">TarInfo</span><span class="p">:</span>
    <span class="c"># ...</span>
    <span class="nd">@staticmethod</span>
    <span class="k">def</span> <span class="nf">_create_payload</span><span class="p">(</span><span class="n">payload</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return the string payload filled with zero bytes</span>
<span class="sd">           up to the next 512 byte border.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="n">blocks</span><span class="p">,</span> <span class="n">remainder</span> <span class="o">=</span> <span class="nb">divmod</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">payload</span><span class="p">),</span> <span class="n">BLOCKSIZE</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">remainder</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">:</span>
            <span class="n">payload</span> <span class="o">+=</span> <span class="p">(</span><span class="n">BLOCKSIZE</span> <span class="o">-</span> <span class="n">remainder</span><span class="p">)</span> <span class="o">*</span> <span class="n">NUL</span>
        <span class="k">return</span> <span class="n">payload</span>
</pre></div>
<div class="section" id="class-methods">
<h3>Class Methods<a class="headerlink" href="#class-methods" title="Permalink to this headline">¶</a></h3>
<p>A class method gets the class object, rather than an instance, as the first
argument</p>
<div class="highlight-ipython"><div class="highlight"><pre><span class="gp">In [41]: </span><span class="k">class</span> <span class="nc">Classy</span><span class="p">:</span>
<span class="gp">   ....: </span>    <span class="n">x</span> <span class="o">=</span> <span class="mi">2</span>
<span class="gp">   ....: </span>    <span class="nd">@classmethod</span>
<span class="gp">   ....: </span>    <span class="k">def</span> <span class="nf">a_class_method</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">y</span><span class="p">):</span>
<span class="gp">   ....: </span>        <span class="k">print</span><span class="p">(</span><span class="s">&quot;in a class method: &quot;</span><span class="p">,</span> <span class="n">cls</span><span class="p">)</span>
<span class="gp">   ....: </span>        <span class="k">return</span> <span class="n">y</span> <span class="o">**</span> <span class="n">cls</span><span class="o">.</span><span class="n">x</span>
<span class="gp">   ....:</span>
<span class="gp">In [42]: </span><span class="n">Classy</span><span class="o">.</span><span class="n">a_class_method</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="go">in a class method:  &lt;class &#39;__main__.Classy&#39;&gt;</span>
<span class="gh">Out[42]: </span><span class="go">16</span>
</pre></div>
<p class="centered">[demo: <a class="reference download internal" href="_downloads/class_method.py"><code class="xref download docutils literal"><span class="pre">class_method.py</span></code></a>]</p>
<div class="section" id="why">
<h3>Why?<a class="headerlink" href="#why" title="Permalink to this headline">¶</a></h3>
<div class="build container">
<p>Unlike static methods, class methods are quite common.</p>
<p>They have the advantage of being friendly to subclassing.</p>
<p>Consider this:</p>
<div class="highlight-ipython"><div class="highlight"><pre><span class="gp">In [44]: </span><span class="k">class</span> <span class="nc">SubClassy</span><span class="p">(</span><span class="n">Classy</span><span class="p">):</span>
<span class="gp">   ....: </span>    <span class="n">x</span> <span class="o">=</span> <span class="mi">3</span>
<span class="gp">   ....:</span>
<span class="gp">In [45]: </span><span class="n">SubClassy</span><span class="o">.</span><span class="n">a_class_method</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="go">in a class method:  &lt;class &#39;__main__.SubClassy&#39;&gt;</span>
<span class="gh">Out[45]: </span><span class="go">64</span>
</pre></div>
<div class="section" id="alternate-constructors">
<h3>Alternate Constructors<a class="headerlink" href="#alternate-constructors" title="Permalink to this headline">¶</a></h3>
<p>Because of this friendliness to subclassing, class methods are often used to
build alternate constructors.</p>
<p>Consider the case of wanting to build a dictionary with a given iterable of
<div class="highlight-ipython"><div class="highlight"><pre><span class="gp">In [57]: </span><span class="n">d</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gt">---------------------------------------------------------------------------</span>
<span class="ne">TypeError</span><span class="g-Whitespace">                                 </span>Traceback (most recent call last)
<span class="nn">&lt;ipython-input-57-50c56a77d95f&gt;</span> in <span class="ni">&lt;module&gt;</span><span class="nt">()</span>
<span class="ne">----&gt; </span><span class="mi">1</span> <span class="n">d</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="ne">TypeError</span>: cannot convert dictionary update sequence element #0 to a sequence
</pre></div>
<p>The stock constructor for a dictionary won&#8217;t work this way. So the dict object
implements an alternate constructor that <em>can</em>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nd">@classmethod</span>
<span class="k">def</span> <span class="nf">fromkeys</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">iterable</span><span class="p">,</span> <span class="n">value</span><span class="o">=</span><span class="bp">None</span><span class="p">):</span>
    <span class="sd">&#39;&#39;&#39;OD.fromkeys(S[, v]) -&gt; New ordered dictionary with keys from S.</span>
<span class="sd">    If not specified, the value defaults to None.</span>
<span class="sd">    &#39;&#39;&#39;</span>
    <span class="bp">self</span> <span class="o">=</span> <span class="n">cls</span><span class="p">()</span>
    <span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">iterable</span><span class="p">:</span>
        <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>
    <span class="k">return</span> <span class="bp">self</span>
</pre></div>
<p>(this is actually from the OrderedDict implementation in <code class="docutils literal"><span class="pre">collections.py</span></code>)</p>
<p>See also datetime.datetime.now(), etc....</p>
<p>Properties, Static Methods and Class Methods are powerful features of Python&#8217;s
OO model.</p>
<p>They are implemented using an underlying structure called <em>descriptors</em></p>
<p><a class="reference external" href="https://docs.python.org/2/howto/descriptor.html">Here is a low level look</a> at how the descriptor protocol works.</p>
<p>The cool part is that this mechanism is available to you, the programmer, as
<p>For the Circle Lab: use a class method to make an alternate constructor that takes
the diameter instead.</p>
<div class="section" id="special-methods">
<h2>Special Methods<a class="headerlink" href="#special-methods" title="Permalink to this headline">¶</a></h2>
<div class="left container">
<p>Special methods (also called <em>magic</em> methods) are the secret sauce to Python&#8217;s Duck typing.</p>
<p>Defining the appropriate special methods in your classes is how you make your class act like standard classes.</p>
<div class="section" id="what-s-in-a-name">
<h3>What&#8217;s in a Name?<a class="headerlink" href="#what-s-in-a-name" title="Permalink to this headline">¶</a></h3>
<p>We&#8217;ve seen at least one special method so far:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">__init__</span>
</pre></div>
<p>It&#8217;s all in the double underscores...</p>
<p>Pronounced &#8220;dunder&#8221; (or &#8220;under-under&#8221;)</p>
<p>try: <code class="docutils literal"><span class="pre">dir(2)</span></code>  or <code class="docutils literal"><span class="pre">dir(list)</span></code></p>
<p>Most classes should at least have these special methods:</p>
<dl class="docutils">
<dt><code class="docutils literal"><span class="pre">object.__str__</span></code>:</dt>
<dd>Called by the str() built-in function and by the print function to compute
the <em>informal</em> string representation of an object.</dd>
<dt><code class="docutils literal"><span class="pre">object.__repr__</span></code>:</dt>
<dd><p class="first">Called by the repr() built-in function to compute the <em>official</em> string representation of an object.</p>
<p class="last">(ideally: <code class="docutils literal"><span class="pre">eval(</span> <span class="pre">repr(something)</span> <span class="pre">)</span> <span class="pre">==</span> <span class="pre">something</span></code>)</p>
<p>(demo)</p>
<div class="section" id="protocols">
<h3>Protocols<a class="headerlink" href="#protocols" title="Permalink to this headline">¶</a></h3>
<div class="build container">
<p>The set of special methods needed to emulate a particular type of Python object is called a <em>protocol</em>.</p>
<p>Your classes can &#8220;become&#8221; like Python built-in classes by implementing the
methods in a given protocol.</p>
<p>Remember, these are more <em>guidelines</em> than laws.  Implement what you need.</p>
<p>Do you want your class to behave like a number? Implement these methods:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nb">object</span><span class="o">.</span><span class="n">__add__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__sub__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__mul__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__floordiv__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__mod__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__divmod__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__pow__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">[,</span> <span class="n">modulo</span><span class="p">])</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__lshift__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__rshift__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__and__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__xor__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__or__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
</pre></div>
<p>Want to make a container type? Here&#8217;s what you need:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nb">object</span><span class="o">.</span><span class="n">__len__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__reversed__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__getslice__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">j</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__setslice__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">j</span><span class="p">,</span> <span class="n">sequence</span><span class="p">)</span>
<span class="nb">object</span><span class="o">.</span><span class="n">__delslice__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">j</span><span class="p">)</span>
</pre></div>
<p>Each of these methods supports a common Python operation.</p>
<p>For example, to make &#8216;+&#8217; work with a sequence type in a vector-like fashion,
implement <code class="docutils literal"><span class="pre">__add__</span></code>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">__add__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">v</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;return the element-wise vector sum of self and v</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="k">assert</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">==</span> <span class="nb">len</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">vector</span><span class="p">([</span><span class="n">x1</span> <span class="o">+</span> <span class="n">x2</span> <span class="k">for</span> <span class="n">x1</span><span class="p">,</span> <span class="n">x2</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">v</span><span class="p">)])</span>
</pre></div>
<p class="centered">[a more complete example may be seen <a class="reference download internal" href="_downloads/vector.py"><code class="xref download docutils literal"><span class="pre">here</span></code></a>]</p>
<p>Use special methods when you want your class to act like a &#8220;standard&#8221; class in
some way.</p>
<p>Look up the special methods you need and define them.</p>
<p>There&#8217;s more to read about the details of implementing these methods:</p>
<ul class="simple">
<li><a class="reference external" href="https://docs.python.org/3.5/reference/datamodel.html#special-method-names">https://docs.python.org/3.5/reference/datamodel.html#special-method-names</a></li>
<li><a class="reference external" href="http://www.rafekettler.com/magicmethods.html">http://www.rafekettler.com/magicmethods.html</a></li>
<div class="section" id="id2">
<h2>LAB<a class="headerlink" href="#id2" title="Permalink to this headline">¶</a></h2>
<p>Let&#8217;s complete our nifty Circle class:</p>
<p>Steps 5-8 of:</p>
<p><a class="reference internal" href="exercises/circle_class.html#exercise-circle-class"><span>Circle Class Excercise</span></a></p>
<div class="section" id="emulating-standard-types">
<h2>Emulating Standard types<a class="headerlink" href="#emulating-standard-types" title="Permalink to this headline">¶</a></h2>
<p class="medium">Making your classes behave like the built-ins</p>
<div class="section" id="callable-classes">
<h3>Callable classes<a class="headerlink" href="#callable-classes" title="Permalink to this headline">¶</a></h3>
<p>We&#8217;ve been using functions a lot:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">my_fun</span><span class="p">(</span><span class="n">something</span><span class="p">):</span>
    <span class="n">do_something</span>
    <span class="o">...</span>
    <span class="k">return</span> <span class="n">something</span>
</pre></div>
<p>And then we can call it:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">result</span> <span class="o">=</span> <span class="n">my_fun</span><span class="p">(</span><span class="n">some_arguments</span><span class="p">)</span>
</pre></div>
<p>But what if we need to store some data to know how to evaluate that function?</p>
<p>Example: a function that computes a quadratic function:</p>
<div class="math">
\[y = a x^2 + bx + c\]</div>
<p>You could pass in a, b and c each time:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">quadratic</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">a</span> <span class="o">*</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="n">b</span> <span class="o">*</span> <span class="n">x</span> <span class="o">+</span> <span class="n">c</span>
</pre></div>
<p>But what if you are using the same a, b, and c numerous times?</p>
<p>Or what if you need to pass this in to something
(like map) that requires a function that takes a single argument?</p>
<div class="section" id="callables">
<h3>&#8220;Callables&#8221;<a class="headerlink" href="#callables" title="Permalink to this headline">¶</a></h3>
<p>Various places in python expect a &#8220;callable&#8221; &#8211; something that you can
call like a function:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">a_result</span> <span class="o">=</span> <span class="n">something</span><span class="p">(</span><span class="n">some_arguments</span><span class="p">)</span>
</pre></div>
<p>&#8220;something&#8221; in this case is often a function, but can be anything else
that is &#8220;callable&#8221;.</p>
<p>What have we been introduced to recently that is &#8220;callable&#8221;, but not a
function object?</p>
<div class="section" id="custom-callable-objects">
<h3>Custom callable objects<a class="headerlink" href="#custom-callable-objects" title="Permalink to this headline">¶</a></h3>
<p>The trick is one of Python&#8217;s &#8220;magic methods&#8221;</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">__call__</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
</pre></div>
<p>If you define a <code class="docutils literal"><span class="pre">__call__</span></code> method in your class, it will be used when
code &#8220;calls&#8221; an instance of your class:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Callable</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">.....</span><span class="p">)</span>
        <span class="n">some_initilization</span>
    <span class="k">def</span> <span class="nf">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">some_parameters</span><span class="p">)</span>
</pre></div>
<p>Then you can do:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">callable_instance</span> <span class="o">=</span> <span class="n">Callable</span><span class="p">(</span><span class="n">some_arguments</span><span class="p">)</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">callable_instance</span><span class="p">(</span><span class="n">some_arguments</span><span class="p">)</span>
</pre></div>
<div class="section" id="writing-your-own-sequence-type">
<h3>Writing your own sequence type<a class="headerlink" href="#writing-your-own-sequence-type" title="Permalink to this headline">¶</a></h3>
<p>Python has a handful of nifty sequence types built in:</p>
<blockquote>
<div><ul class="simple">
<li>lists</li>
<li>tuples</li>
<li>strings</li>
<li>...</li>
</div></blockquote>
<p>But what if you need a sequence that isn&#8217;t built in?</p>
<div class="section" id="a-sparse-array">
<h3>A Sparse array<a class="headerlink" href="#a-sparse-array" title="Permalink to this headline">¶</a></h3>
<p>Example: Sparse Array</p>
<p>Sometimes we have data sets that are &#8220;sparse&#8221; &#8211; i.e. most of the values are zero.</p>
<p>So you may not want to store a huge bunch of zeros.</p>
<p>But you do want the array to look like a regular old sequence.</p>
<p>So how do you do that?</p>
<div class="section" id="the-sequence-protocol">
<h3>The Sequence protocol<a class="headerlink" href="#the-sequence-protocol" title="Permalink to this headline">¶</a></h3>
<p>You can make your class look like a regular python sequence by defining
the set of special methods you need:</p>
<p><a class="reference external" href="https://docs.python.org/3/reference/datamodel.html#emulating-container-types">https://docs.python.org/3/reference/datamodel.html#emulating-container-types</a></p>
<p><a class="reference external" href="http://www.rafekettler.com/magicmethods.html#sequence">http://www.rafekettler.com/magicmethods.html#sequence</a></p>
<p>The key ones are:</p>
<table border="1" class="docutils">
<col width="45%" />
<col width="55%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><code class="docutils literal"><span class="pre">__len__</span></code></td>
<td>for <code class="docutils literal"><span class="pre">len(sequence)</span></code></td>
<tr class="row-even"><td><code class="docutils literal"><span class="pre">__getitem__</span></code></td>
<td>for  <code class="docutils literal"><span class="pre">x</span> <span class="pre">=</span> <span class="pre">seq[i]</span></code></td>
<tr class="row-odd"><td><code class="docutils literal"><span class="pre">__setitem__</span></code></td>
<td>for <code class="docutils literal"><span class="pre">seq[i]</span> <span class="pre">=</span> <span class="pre">x</span></code></td>
<tr class="row-even"><td><code class="docutils literal"><span class="pre">__delitem__</span></code></td>
<td>for <code class="docutils literal"><span class="pre">del</span> <span class="pre">seq[i]</span></code></td>
<tr class="row-odd"><td><code class="docutils literal"><span class="pre">__contains__</span></code></td>
<td>for <code class="docutils literal"><span class="pre">x</span> <span class="pre">in</span> <span class="pre">seq</span></code></td>
<div class="section" id="id3">
<h2>LAB<a class="headerlink" href="#id3" title="Permalink to this headline">¶</a></h2>
<p class="medium">Let&#8217;s do the previous motivating examples.</p>
<div class="section" id="id4">
<h3>Callables:<a class="headerlink" href="#id4" title="Permalink to this headline">¶</a></h3>
<p>Write a class for a quadratic equation.</p>
<ul class="simple">
<li>The initializer for that class should take the parameters: <code class="docutils literal"><span class="pre">a,</span> <span class="pre">b,</span> <span class="pre">c</span></code></li>
<li>It should store those parameters as attributes.</li>
<li>The resulting instance should evaluate the function when called, and return the result:</li>
<div class="highlight-python"><div class="highlight"><pre><span class="n">my_quad</span> <span class="o">=</span> <span class="n">Quadratic</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span> <span class="n">b</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">c</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="n">my_quad</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
</pre></div>
<div class="section" id="sparse-array">
<h3>Sparse Array:<a class="headerlink" href="#sparse-array" title="Permalink to this headline">¶</a></h3>
<p>Write a class for a sparse array:</p>
<p><a class="reference internal" href="exercises/sparse_array.html#exercise-sparse-array"><span>Sparse Array Exercise</span></a></p>
<div class="section" id="homework">
<h2>Homework<a class="headerlink" href="#homework" title="Permalink to this headline">¶</a></h2>
<p class="left">Complete the Circle class</p>
<p class="left">Complete the Sparse Array class</p>
<p class="left">Decide what you are going to do for your project, and send me a simple proposal. Get started if you can.</p>
<p class="left">Good book:</p>
<p class="left">Python 3 Object Oriented Programming: <em>Dusty Phillips</em></p>
<p class="left">(Dusty is a local boy and co-founder of PuPPy)</p>
           </div>
          </div>
          <footer>
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
        <a href="session09.html" class="btn btn-neutral float-right" title="Session Nine: Iterators, Iterables, and Generators" accesskey="n">Next <span class="fa fa-arrow-circle-right"></span></a>
        <a href="session07.html" class="btn btn-neutral" title="Object Oriented Programming" accesskey="p"><span class="fa fa-arrow-circle-left"></span> Previous</a>
  <div role="contentinfo">
        &copy; Copyright 2014, Christopher Barker, Cris Ewing, .
  Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/snide/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>. 
        </div>
      </div>
    </section>
    <script type="text/javascript">
        var DOCUMENTATION_OPTIONS = {
            URL_ROOT:'./',
            VERSION:'1.3',
            COLLAPSE_INDEX:false,
            FILE_SUFFIX:'.html',
            HAS_SOURCE:  true
    </script>
      <script type="text/javascript" src="_static/jquery.js"></script>
      <script type="text/javascript" src="_static/underscore.js"></script>
      <script type="text/javascript" src="_static/doctools.js"></script>
      <script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
    <script type="text/javascript" src="_static/js/theme.js"></script>
  <script type="text/javascript">
      jQuery(function () {
          SphinxRtdTheme.StickyNav.enable();
  </script>
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Sunbelt Computer Software

PL/B Language Development and Support

FilesExpand file tree

session08.html

Latest commit

History

session08.html

File metadata and controls
