IntroToPython/session07.html at gh-pages · reecel/IntroToPython

905 lines (825 loc) · 69.3 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 Seven: Testing, More OO &mdash; Introduction To Python 1.3 documentation</title>
  <link href='https://fonts.googleapis.com/css?family=Lato:400,700|Roboto+Slab:400,700|Inconsolata:400,700' rel='stylesheet' type='text/css'>
    <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 Eight: Generators, Iterators, Decorators, and Context Managers" href="session08.html"/>
        <link rel="prev" title="Session Six: Object oriented programming: Classes, instances, attributes, and subclassing" href="session06.html"/> 
  <script src="https://cdnjs.cloudflare.com/ajax/libs/modernizr/2.6.2/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-nav-search">
        <a href="index.html" class="fa fa-home"> Introduction To Python</a>
        <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><ul>
<li class="toctree-l2"><a class="reference internal" href="session01.html#introductions">Introductions</a></li>
<li class="toctree-l2"><a class="reference internal" href="session01.html#introduction-to-this-class">Introduction to This Class</a></li>
<li class="toctree-l2"><a class="reference internal" href="session01.html#introduction-to-your-environment">Introduction to Your Environment</a></li>
<li class="toctree-l2"><a class="reference internal" href="session01.html#setting-up-your-environment">Setting Up Your Environment</a></li>
<li class="toctree-l2"><a class="reference internal" href="session01.html#introduction-to-ipython">Introduction to iPython</a></li>
<li class="toctree-l2"><a class="reference internal" href="session01.html#basic-python-syntax">Basic Python Syntax</a></li>
<li class="toctree-l2"><a class="reference internal" href="session01.html#id2">Homework</a></li>
<li class="toctree-l2"><a class="reference internal" href="session01.html#next-class">Next Class</a></li>
<li class="toctree-l1"><a class="reference internal" href="session02.html">Session Two: Functions, Booleans and Modules</a><ul>
<li class="toctree-l2"><a class="reference internal" href="session02.html#review-questions">Review/Questions</a></li>
<li class="toctree-l2"><a class="reference internal" href="session02.html#git-work">Git Work</a></li>
<li class="toctree-l2"><a class="reference internal" href="session02.html#quick-intro-to-basics">Quick Intro to Basics</a></li>
<li class="toctree-l2"><a class="reference internal" href="session02.html#functions">Functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="session02.html#in-class-lab">In-Class Lab:</a></li>
<li class="toctree-l2"><a class="reference internal" href="session02.html#boolean-expressions">Boolean Expressions</a></li>
<li class="toctree-l2"><a class="reference internal" href="session02.html#id1">In-Class Lab:</a></li>
<li class="toctree-l2"><a class="reference internal" href="session02.html#code-structure-modules-and-namespaces">Code Structure, Modules, and Namespaces</a></li>
<li class="toctree-l2"><a class="reference internal" href="session02.html#id4">In-Class Lab</a></li>
<li class="toctree-l2"><a class="reference internal" href="session02.html#homework">Homework</a></li>
<li class="toctree-l1"><a class="reference internal" href="session03.html">Session Three: Sequences, Iteration and String Formatting</a><ul>
<li class="toctree-l2"><a class="reference internal" href="session03.html#review-questions">Review/Questions</a></li>
<li class="toctree-l2"><a class="reference internal" href="session03.html#sequences">Sequences</a></li>
<li class="toctree-l2"><a class="reference internal" href="session03.html#lists-tuples">Lists, Tuples...</a></li>
<li class="toctree-l2"><a class="reference internal" href="session03.html#mutability">Mutability</a></li>
<li class="toctree-l2"><a class="reference internal" href="session03.html#mutable-sequence-methods">Mutable Sequence Methods</a></li>
<li class="toctree-l2"><a class="reference internal" href="session03.html#id1">Iteration</a></li>
<li class="toctree-l2"><a class="reference internal" href="session03.html#string-features">String Features</a></li>
<li class="toctree-l2"><a class="reference internal" href="session03.html#one-last-trick">One Last Trick</a></li>
<li class="toctree-l2"><a class="reference internal" href="session03.html#homework">Homework</a></li>
<li class="toctree-l1"><a class="reference internal" href="session04.html">Session Four: Dictionaries, Sets, Exceptions, and Files</a><ul>
<li class="toctree-l2"><a class="reference internal" href="session04.html#review-questions">Review/Questions</a></li>
<li class="toctree-l2"><a class="reference internal" href="session04.html#a-little-warm-up">A little warm up</a></li>
<li class="toctree-l2"><a class="reference internal" href="session04.html#dictionaries-and-sets">Dictionaries and Sets</a></li>
<li class="toctree-l2"><a class="reference internal" href="session04.html#exceptions">Exceptions</a></li>
<li class="toctree-l2"><a class="reference internal" href="session04.html#file-reading-and-writing">File Reading and Writing</a></li>
<li class="toctree-l2"><a class="reference internal" href="session04.html#paths-and-directories">Paths and Directories</a></li>
<li class="toctree-l2"><a class="reference internal" href="session04.html#homework">Homework</a></li>
<li class="toctree-l1"><a class="reference internal" href="session05.html">Session Five: Advanced Argument passing, List and Dict Comprehensions, Lambda and Functional programming</a><ul>
<li class="toctree-l2"><a class="reference internal" href="session05.html#review-questions">Review/Questions</a></li>
<li class="toctree-l2"><a class="reference internal" href="session05.html#advanced-argument-passing">Advanced Argument Passing</a></li>
<li class="toctree-l2"><a class="reference internal" href="session05.html#a-bit-more-on-mutability-and-copies">A bit more on mutability (and copies)</a></li>
<li class="toctree-l2"><a class="reference internal" href="session05.html#list-and-dict-comprehensions">List and Dict Comprehensions</a></li>
<li class="toctree-l2"><a class="reference internal" href="session05.html#anonymous-functions">Anonymous functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="session05.html#functional-programming">Functional Programming</a></li>
<li class="toctree-l2"><a class="reference internal" href="session05.html#homework">Homework</a></li>
<li class="toctree-l1"><a class="reference internal" href="session06.html">Session Six: Object oriented programming: Classes, instances, attributes, and subclassing</a><ul>
<li class="toctree-l2"><a class="reference internal" href="session06.html#review-questions">Review/Questions</a></li>
<li class="toctree-l2"><a class="reference internal" href="session06.html#object-oriented-programming">Object Oriented Programming</a></li>
<li class="toctree-l2"><a class="reference internal" href="session06.html#python-classes">Python Classes</a></li>
<li class="toctree-l2"><a class="reference internal" href="session06.html#subclassing-inheritance">Subclassing/Inheritance</a></li>
<li class="toctree-l2"><a class="reference internal" href="session06.html#more-on-subclassing">More on Subclassing</a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="">Session Seven: Testing, More OO</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#review-questions">Review/Questions</a></li>
<li class="toctree-l2"><a class="reference internal" href="#testing">Testing</a></li>
<li class="toctree-l2"><a class="reference internal" href="#more-on-subclassing">More on Subclassing</a></li>
<li class="toctree-l2"><a class="reference internal" href="#properties">Properties</a></li>
<li class="toctree-l2"><a class="reference internal" href="#static-and-class-methods">Static and Class Methods</a></li>
<li class="toctree-l2"><a class="reference internal" href="#special-methods">Special Methods</a></li>
<li class="toctree-l2"><a class="reference internal" href="#homework">Homework</a></li>
<li class="toctree-l1"><a class="reference internal" href="session08.html">Session Eight: Generators, Iterators, Decorators, and Context Managers</a><ul>
<li class="toctree-l2"><a class="reference internal" href="session08.html#review-questions">Review/Questions</a></li>
<li class="toctree-l2"><a class="reference internal" href="session08.html#decorators">Decorators</a></li>
<li class="toctree-l2"><a class="reference internal" href="session08.html#iterators-and-generators">Iterators and Generators</a></li>
<li class="toctree-l2"><a class="reference internal" href="session08.html#context-managers">Context Managers</a></li>
<li class="toctree-l2"><a class="reference internal" href="session08.html#homework">Homework</a></li>
<li class="toctree-l1"><a class="reference internal" href="homework/index.html">Homework Materials</a><ul>
<li class="toctree-l2"><a class="reference internal" href="homework/kata_fourteen.html">Kata Fourteen: Tom Swift Under Milk Wood</a></li>
<li class="toctree-l2"><a class="reference internal" href="homework/html_builder.html">HTML Renderer Homework Assignment</a></li>
<li class="toctree-l1"><a class="reference internal" href="supplements/index.html">Supplemental Materials</a><ul>
<li class="toctree-l2"><a class="reference internal" href="supplements/python_learning_resources.html">Useful Python Learning Resources</a></li>
<li class="toctree-l2"><a class="reference internal" href="supplements/python_for_mac.html">Setting up your Mac for Python and this class</a></li>
<li class="toctree-l2"><a class="reference internal" href="supplements/python_for_windows.html">Setting up Windows for Python and this class</a></li>
<li class="toctree-l2"><a class="reference internal" href="supplements/python_for_linux.html">Setting up Linux for Python and this class</a></li>
<li class="toctree-l2"><a class="reference internal" href="supplements/virtualenv.html">Working with Virtualenv</a></li>
<li class="toctree-l2"><a class="reference internal" href="supplements/sublime_as_ide.html">Turning Sublime Text Into a Lightweight Python IDE</a></li>
<li class="toctree-l2"><a class="reference internal" href="supplements/shell.html">Shell Customizations for Python Development</a></li>
<li class="toctree-l2"><a class="reference internal" href="supplements/unicode.html">Unicode in Python 2</a></li>
      </div>
      &nbsp;
    <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 Seven: Testing, More OO</li>
      <li class="wy-breadcrumbs-aside">
          <a href="_sources/session07.txt" rel="nofollow"> View page source</a>
      </li>
          <div role="main">
  <div class="section" id="session-seven-testing-more-oo">
<h1>Session Seven: Testing, More OO<a class="headerlink" href="#session-seven-testing-more-oo" title="Permalink to this headline">¶</a></h1>
<div class="large centered line-block">
<div class="line">Testing,</div>
<div class="line">Multiple Inheritance,</div>
<div class="line">Properties,</div>
<div class="line">Class and Static Methods,</div>
<div class="line">Special (Magic) Methods</div>
<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>Unicode</li>
<li>Object Oriented Programming</li>
<div class="section" id="homework-review">
<h3>Homework review<a class="headerlink" href="#homework-review" title="Permalink to this headline">¶</a></h3>
<p>Homework Questions?</p>
<p>How is progress going on the HTML Renderer?</p>
<div class="section" id="testing">
<h2>Testing<a class="headerlink" href="#testing" title="Permalink to this headline">¶</a></h2>
<div class="build left container">
<p>You&#8217;ve already seen some a very basic testing strategy.</p>
<p>You&#8217;ve written some tests using that strategy.</p>
<p>These tests were pretty basic, and a bit awkward in places (testing error
conditions in particular).</p>
<p class="centered"><strong>It gets better</strong></p>
<div class="section" id="test-runners">
<h3>Test Runners<a class="headerlink" href="#test-runners" title="Permalink to this headline">¶</a></h3>
<p>So far our tests have been limited to code in an <tt class="docutils literal"><span class="pre">if</span> <span class="pre">__name__</span> <span class="pre">==</span> <span class="pre">&quot;__main__&quot;:</span></tt>
<ul class="build simple">
<li>They are run only when the file is executed</li>
<li>They are always run when the file is executed</li>
<li>You can&#8217;t do anything else when the file is executed without running tests.</li>
<div class="build container">
<p>This is not optimal.</p>
<p>Python provides testing systems to help.</p>
<p>The original testing system in Python.</p>
<p>You write subclasses of the <tt class="docutils literal"><span class="pre">unittest.TestCase</span></tt> class:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># in test.py</span>
<span class="kn">import</span> <span class="nn">unittest</span>
<span class="k">class</span> <span class="nc">MyTests</span><span class="p">(</span><span class="n">unittest</span><span class="o">.</span><span class="n">TestCase</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">test_tautology</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">assertEquals</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
</pre></div>
<p>Then you run the tests by using the <tt class="docutils literal"><span class="pre">main</span></tt> function from the <tt class="docutils literal"><span class="pre">unittest</span></tt>
module:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># in test.py</span>
<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s">&#39;__main__&#39;</span><span class="p">:</span>
    <span class="n">unittest</span><span class="o">.</span><span class="n">main</span><span class="p">()</span>
</pre></div>
<p>This way, you can write your code in one file and test it from another:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># in my_mod.py</span>
<span class="k">def</span> <span class="nf">my_func</span><span class="p">(</span><span class="n">val1</span><span class="p">,</span> <span class="n">val2</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">val1</span> <span class="o">*</span> <span class="n">val2</span>
<span class="c"># in test_my_mod.py</span>
<span class="kn">import</span> <span class="nn">unittest</span>
<span class="kn">from</span> <span class="nn">my_mod</span> <span class="kn">import</span> <span class="n">my_func</span>
<span class="k">class</span> <span class="nc">MyFuncTestCase</span><span class="p">(</span><span class="n">unittest</span><span class="o">.</span><span class="n">TestCase</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">test_my_func</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="n">test_vals</span> <span class="o">=</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="n">expected</span> <span class="o">=</span> <span class="nb">reduce</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">:</span> <span class="n">x</span> <span class="o">*</span> <span class="n">y</span><span class="p">,</span> <span class="n">test_vals</span><span class="p">)</span>
        <span class="n">actual</span> <span class="o">=</span> <span class="n">my_func</span><span class="p">(</span><span class="o">*</span><span class="n">test_vals</span><span class="p">)</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">assertEquals</span><span class="p">(</span><span class="n">expected</span><span class="p">,</span> <span class="n">actual</span><span class="p">)</span>
<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s">&#39;__main__&#39;</span><span class="p">:</span>
    <span class="n">unittest</span><span class="o">.</span><span class="n">main</span><span class="p">()</span>
</pre></div>
<div class="build container">
<p>The <tt class="docutils literal"><span class="pre">unittest</span></tt> module is great.</p>
<p>It comes with the standard Python distribution, no installation required.</p>
<p>It provides a wide variety of assertions for testing all sorts of situations.</p>
<p>It allows for a setup and tear down workflow both before and after all tests
and before and after each test.</p>
<p>It&#8217;s well known and well understood.</p>
<div class="build container">
<p>It&#8217;s Object Oriented, and quite heavy.</p>
<p>It uses the framework design pattern, so knowing how to use the features
means learning what to override.</p>
<p>Needing to override means you have to be cautious.</p>
<p>Test discovery is both inflexible and brittle.</p>
<p>There are several other options for running tests in Python.</p>
<ul class="simple">
<li><a class="reference external" href="https://nose.readthedocs.org/">Nose</a></li>
<li><a class="reference external" href="http://pytest.org/latest/">pytest</a></li>
<li>... (many frameworks supply their own test runners)</li>
<p>We are going to play today with pytest</p>
<p>The first step is to install the package:</p>
<div class="highlight-bash"><div class="highlight"><pre><span class="nv">$ </span>workon cff2py
<span class="o">(</span>cff2py<span class="o">)</span><span class="nv">$ </span>pip install pytest
</pre></div>
<p>Once this is complete, you should have a <tt class="docutils literal"><span class="pre">py.test</span></tt> command you can run at the
command line:</p>
<div class="highlight-bash"><div class="highlight"><pre><span class="o">(</span>cff2py<span class="o">)</span><span class="nv">$ </span>py.test
</pre></div>
<p>If you have any tests in your repository, that will find and run them.</p>
<div class="build container">
<strong>Do you?</strong></div>
<p>I&#8217;ve added two files to the <tt class="docutils literal"><span class="pre">code/session07</span></tt> folder, along with a python
source code file called <tt class="docutils literal"><span class="pre">circle.py</span></tt>.</p>
<p>The results you should have seen when you ran <tt class="docutils literal"><span class="pre">py.test</span></tt> above come partly
from these files.</p>
<p>Let&#8217;s take a few minutes to look these files over.</p>
<p>[demo]</p>
<p>When you run the <tt class="docutils literal"><span class="pre">py.test</span></tt> command, <tt class="docutils literal"><span class="pre">pytest</span></tt> starts in your current working
directory and searches the filesystem for things that might be tests.</p>
<p>It follows some simple rules:</p>
<ul class="build simple">
<li>Any python file that starts with <tt class="docutils literal"><span class="pre">test_</span></tt> or <tt class="docutils literal"><span class="pre">_test</span></tt> is imported.</li>
<li>Any functions in them that start with <tt class="docutils literal"><span class="pre">test_</span></tt> are run as tests.</li>
<li>Any classes that start with <tt class="docutils literal"><span class="pre">Test</span></tt> are treated similarly, with methods that
begin with <tt class="docutils literal"><span class="pre">test_</span></tt> treated as tests.</li>
<p>This test running framework is simple, flexible and configurable.</p>
<p><a class="reference external" href="http://pytest.org/latest/getting-started.html#getstarted">Read the documentation</a> for more information.</p>
<p>What we&#8217;ve just done here is the first step in what is called <strong>Test Driven
Development</strong>.</p>
<p>A bunch of tests exist, but the code to make them pass does not yet exist.</p>
<p>The red we see in the terminal when we run our tests is a goad to us to write
the code that fixes these tests.</p>
<p>Let&#8217;s do that next!</p>
<div class="section" id="more-on-subclassing">
<h2>More on Subclassing<a class="headerlink" href="#more-on-subclassing" title="Permalink to this headline">¶</a></h2>
<p>Watch This Video:</p>
<p><a class="reference external" href="http://pyvideo.org/video/879/the-art-of-subclassing">http://pyvideo.org/video/879/the-art-of-subclassing</a></p>
<p class="left">Seriously, well worth the time.</p>
<div class="section" id="what-s-a-subclass-for">
<h3>What&#8217;s a Subclass For?<a class="headerlink" href="#what-s-a-subclass-for" title="Permalink to this headline">¶</a></h3>
<p>The most salient points from that video are as follows:</p>
<p><strong>Subclassing is not for Specialization</strong></p>
<p><strong>Subclassing is for Reusing Code</strong></p>
<p><strong>Bear in mind that the subclass is in charge</strong></p>
<div class="section" id="multiple-inheritance">
<h3>Multiple Inheritance<a class="headerlink" href="#multiple-inheritance" title="Permalink to this headline">¶</a></h3>
<p>Multiple inheritance: Inheriting from more than one class</p>
<p>Simply provide more than one parent.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Combined</span><span class="p">(</span><span class="n">Super1</span><span class="p">,</span> <span class="n">Super2</span><span class="p">,</span> <span class="n">Super3</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="n">something</span><span class="p">,</span> <span class="n">something</span> <span class="k">else</span><span class="p">):</span>
        <span class="c"># some custom initialization here.</span>
        <span class="n">Super1</span><span class="o">.</span><span class="n">__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">Super2</span><span class="o">.</span><span class="n">__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">Super3</span><span class="o">.</span><span class="n">__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="c"># possibly more custom initialization</span>
</pre></div>
<p>(calls to the super class <tt class="docutils literal"><span class="pre">__init__</span></tt>  are optional &#8211; case dependent)</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Combined</span><span class="p">(</span><span class="n">Super1</span><span class="p">,</span> <span class="n">Super2</span><span class="p">,</span> <span class="n">Super3</span><span class="p">)</span>
</pre></div>
<p>Attributes are located bottom-to-top, left-to-right</p>
<ul class="simple">
<li>Is it an instance attribute ?</li>
<li>Is it a class attribute ?</li>
<li>Is it a superclass attribute ?<ul>
<li>is the it an attribute of the left-most superclass?</li>
<li>is the it an attribute of the next superclass?</li>
<li>and so on up the hierarchy...</li>
<li>Is it a super-superclass attribute ?</li>
<li>... also left to right ...</li>
<p><a class="reference external" href="http://python-history.blogspot.com/2010/06/method-resolution-order.html">http://python-history.blogspot.com/2010/06/method-resolution-order.html</a></p>
<p>Provides an subset of expected functionality in a re-usable package.</p>
<p>Why would you want to do this?</p>
<p>Hierarchies are not always simple:</p>
<ul class="simple">
<li>Animal<ul>
<li>Mammal<ul>
<li>GiveBirth()</li>
<li>Bird<ul>
<li>LayEggs()</li>
<p>Where do you put a Platypus?</p>
<p>Real World Example: <a class="reference external" href="https://github.com/svn2github/wxPython/blob/master/3rdParty/FloatCanvas/floatcanvas/FloatCanvas.py#L485">FloatCanvas</a></p>
<p><strong>Careful About This Pattern</strong></p>
<p>All the class definitions we&#8217;ve been showing inherit from <tt class="docutils literal"><span class="pre">object</span></tt>.</p>
<p>This is referred to as a &#8220;new style&#8221; class.</p>
<p>They were introduced in python2.2 to better merge types and classes, and clean
up a few things.</p>
<p>There are differences in method resolution order and properties.</p>
<p><strong>Always Make New-Style Classes.</strong></p>
<p>The differences are subtle, and may not appear until they jump up to bite you.</p>
<p><tt class="docutils literal"><span class="pre">super()</span></tt>: use it to call a superclass method, rather than explicitly calling
the unbound method on the superclass.</p>
<p>instead of:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">A</span><span class="p">(</span><span class="n">B</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="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
        <span class="n">B</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">argw</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
        <span class="o">...</span>
</pre></div>
<p>You can do:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">A</span><span class="p">(</span><span class="n">B</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="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
        <span class="nb">super</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="o">*</span><span class="n">argw</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
        <span class="o">...</span>
</pre></div>
<p>Caution: There are some subtle differences with multiple inheritance.</p>
<p>You can use explicit calling to ensure that the &#8216;right&#8217; method is called.</p>
<p>Two seminal articles about <tt class="docutils literal"><span class="pre">super()</span></tt>:</p>
<p>&#8220;Super Considered Harmful&#8221; &#8211; James Knight</p>
<p><a class="reference external" href="https://fuhm.net/super-harmful/">https://fuhm.net/super-harmful/</a></p>
<p>&#8220;super() considered super!&#8221;  &#8211;  Raymond Hettinger</p>
<p><a class="reference external" href="http://rhettinger.wordpress.com/2011/05/26/super-considered-super/">http://rhettinger.wordpress.com/2011/05/26/super-considered-super/</a>}</p>
<p>(Both worth reading....)</p>
<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="nb">object</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="nb">object</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>
<p>When (and if) you need them:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">C</span><span class="p">(</span><span class="nb">object</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="n">x</span><span class="o">=</span><span class="mi">5</span><span class="p">):</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="k">def</span> <span class="nf">_getx</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_x</span>
    <span class="k">def</span> <span class="nf">_setx</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_x</span> <span class="o">=</span> <span class="n">value</span>
    <span class="k">def</span> <span class="nf">_delx</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">_x</span>
    <span class="n">x</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="n">_getx</span><span class="p">,</span> <span class="n">_setx</span><span class="p">,</span> <span class="n">_delx</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="s">&quot;docstring&quot;</span><span class="p">)</span>
</pre></div>
<p>Now the interface is still like simple attribute access!</p>
<p class="centered small">[demo: <a class="reference download internal" href="_downloads/properties_example.py"><tt class="xref download docutils literal"><span class="pre">properties_example.py</span></tt></a>]</p>
<p>Not all the arguments to <tt class="docutils literal"><span class="pre">property</span></tt> are required.</p>
<p>You can use this to create attributes that are &#8220;read only&#8221;:</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="nb">object</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="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="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_x</span>
<span class="gp">   ....: </span>    <span class="n">x</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="n">getx</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="s">&quot;I am read only&quot;</span><span class="p">)</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>
<p>This <em>imperative</em> style of adding a <tt class="docutils literal"><span class="pre">property</span></tt> to you class is clear, but
it&#8217;s still a little verbose.</p>
<p>It also has the effect of leaving all those defined method objects laying
around:</p>
<div class="highlight-ipython"><div class="highlight"><pre><span class="gp">In [19]: </span><span class="n">d</span><span class="o">.</span><span class="n">x</span>
<span class="gh">Out[19]: </span><span class="go">5</span>
<span class="gp">In [20]: </span><span class="n">d</span><span class="o">.</span><span class="n">getx</span>
<span class="gh">Out[20]: </span><span class="go">&lt;bound method D.getx of &lt;__main__.D object at 0x1043a4a10&gt;&gt;</span>
<span class="gp">In [21]: </span><span class="n">d</span><span class="o">.</span><span class="n">getx</span><span class="p">()</span>
<span class="gh">Out[21]: </span><span class="go">5</span>
</pre></div>
<p>Python provides us with a way to solve both these issues at once, using a
syntactic feature called <strong>decorators</strong> (more about these next session):</p>
<div class="highlight-ipython"><div class="highlight"><pre><span class="gp">In [22]: </span><span class="k">class</span> <span class="nc">E</span><span class="p">(</span><span class="nb">object</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="n">x</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.setter</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="n">value</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">value</span>
<span class="gp">   ....:</span>
<span class="gp">In [23]: </span><span class="n">e</span> <span class="o">=</span> <span class="n">E</span><span class="p">()</span>
<span class="gp">In [24]: </span><span class="n">e</span><span class="o">.</span><span class="n">x</span>
<span class="gh">Out[24]: </span><span class="go">5</span>
<span class="gp">In [25]: </span><span class="n">e</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="mi">6</span>
<span class="gp">In [26]: </span><span class="n">e</span><span class="o">.</span><span class="n">x</span>
<span class="gh">Out[26]: </span><span class="go">6</span>
</pre></div>
<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 <tt class="docutils literal"><span class="pre">self</span></tt> 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>
<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="nb">object</span><span class="p">):</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="n">add</span> <span class="o">=</span> <span class="nb">staticmethod</span><span class="p">(</span><span class="n">add</span><span class="p">)</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"><tt class="xref download docutils literal"><span class="pre">static_method.py</span></tt></a>]</p>
<p>Like <tt class="docutils literal"><span class="pre">properties</span></tt>, static methods can be written <em>declaratively</em> using the
<tt class="docutils literal"><span class="pre">staticmethod</span></tt> built-in as a <em>decorator</em>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">StaticAdder</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
    <span class="nd">@staticmethod</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="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span>
</pre></div>
<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="nb">object</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="nb">object</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="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="s">&quot;in a class method: &quot;</span><span class="p">,</span> <span class="n">cls</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="n">a_class_method</span> <span class="o">=</span> <span class="nb">classmethod</span><span class="p">(</span><span class="n">a_class_method</span><span class="p">)</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"><tt class="xref download docutils literal"><span class="pre">class_method.py</span></tt></a>]</p>
<p>Once again, the <tt class="docutils literal"><span class="pre">classmethod</span></tt> built-in can be used as a <em>decorator</em> for a
more declarative style of programming:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Classy</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
    <span class="n">x</span> <span class="o">=</span> <span class="mi">2</span>
    <span class="nd">@classmethod</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="k">print</span> <span class="s">&quot;in a class method: &quot;</span><span class="p">,</span> <span class="n">cls</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>
</pre></div>
<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>
<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 <tt class="docutils literal"><span class="pre">collections.py</span></tt>)</p>
<p>See also datetime.datetime.now(), etc....</p>
<p>Properties, Static Methods and Class Methods are powerful features of Pythons
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
<div class="section" id="kicking-the-tires">
<h3>Kicking the Tires<a class="headerlink" href="#kicking-the-tires" title="Permalink to this headline">¶</a></h3>
<p>Copy the file <tt class="docutils literal"><span class="pre">code/session07/circly.py</span></tt> to your student folder.</p>
<p>In it, write a simple &#8220;Circle&#8221; class:</p>
<div class="highlight-ipython"><div class="highlight"><pre><span class="gp">In [13]: </span><span class="n">c</span> <span class="o">=</span> <span class="n">Circle</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">In [15]: </span><span class="n">c</span><span class="o">.</span><span class="n">diameter</span>
<span class="gh">Out[15]: </span><span class="go">6.0</span>
<span class="gp">In [16]: </span><span class="n">c</span><span class="o">.</span><span class="n">diameter</span> <span class="o">=</span> <span class="mi">8</span>
<span class="gp">In [17]: </span><span class="n">c</span><span class="o">.</span><span class="n">radius</span>
<span class="gh">Out[17]: </span><span class="go">4.0</span>
<span class="gp">In [18]: </span><span class="n">c</span><span class="o">.</span><span class="n">area</span>
<span class="gh">Out[18]: </span><span class="go">50.26548245743669</span>
</pre></div>
<p>Use <tt class="docutils literal"><span class="pre">properties</span></tt> so you can keep the radius and diameter in sync, and the
area computed on the fly.</p>
<p>Extra Credit: use a class method to make an alternate constructor that takes
the diameter instead.</p>
<p>Also copy the file <tt class="docutils literal"><span class="pre">test_circle1.py</span></tt> to your student folder.</p>
<p>As you work, run the tests:</p>
<div class="highlight-bash"><div class="highlight"><pre><span class="o">(</span>cff2py<span class="o">)</span><span class="nv">$ </span>py.test test_circle1.py
</pre></div>
<p>As each of the requirements from above are fulfilled, you&#8217;ll see tests &#8216;turn
green&#8217;.</p>
<p>When all your tests are passing, you&#8217;ve completed the job.</p>
<p>(This clear finish line is another of the advantages of TDD)</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: <tt class="docutils literal"><span class="pre">dir(2)</span></tt>  or <tt class="docutils literal"><span class="pre">dir(list)</span></tt></p>
<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 <tt class="docutils literal"><span class="pre">__add__</span></tt>:</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"><tt class="xref download docutils literal"><span class="pre">here</span></tt></a>]</p>
<p>You only <em>need</em> to define the special methods that will be used by your class.</p>
<p>However, even in the absence of wanting to duck-type, you should almost always
define these:</p>
<dl class="docutils">
<dt><tt class="docutils literal"><span class="pre">object.__str__</span></tt>:</dt>
<dd>Called by the str() built-in function and by the print statement to compute
the <em>informal</em> string representation of an object.</dd>
<dt><tt class="docutils literal"><span class="pre">object.__unicode__</span></tt>:</dt>
<dd>Called by the unicode() built-in function.  This converts an object to an
<em>informal</em> unicode representation.</dd>
<dt><tt class="docutils literal"><span class="pre">object.__repr__</span></tt>:</dt>
<dd><p class="first">Called by the repr() built-in function and by string conversions (reverse
quotes) to compute the <em>official</em> string representation of an object.</p>
<p class="last">(ideally: <tt 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></tt>)</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/2/reference/datamodel.html#special-method-names">https://docs.python.org/2/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>
<p>Be a bit cautious about the code examples in that last one. It uses quite a bit
of old-style class definitions, which should not be emulated.</p>
<div class="section" id="id1">
<h3>Kicking the Tires<a class="headerlink" href="#id1" title="Permalink to this headline">¶</a></h3>
<p>Extend your &#8220;Circle&#8221; class:</p>
<ul class="simple">
<li>Add <tt class="docutils literal"><span class="pre">__str__</span></tt>  and <tt class="docutils literal"><span class="pre">__repr__</span></tt>  methods</li>
<li>Write an <tt class="docutils literal"><span class="pre">__add__</span></tt>  method so you can add two circles</li>
<li>Make it so you can multiply a circle by a number....</li>
<div class="highlight-ipython"><div class="highlight"><pre><span class="gp">In [22]: </span><span class="n">c1</span> <span class="o">=</span> <span class="n">Circle</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">In [23]: </span><span class="n">c2</span> <span class="o">=</span> <span class="n">Circle</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">In [24]: </span><span class="n">c3</span> <span class="o">=</span> <span class="n">c1</span><span class="o">+</span><span class="n">c2</span>
<span class="gp">In [25]: </span><span class="n">c3</span><span class="o">.</span><span class="n">radius</span>
<span class="gh">Out[25]: </span><span class="go">7</span>
<span class="gp">In [26]: </span><span class="n">c1</span><span class="o">*</span><span class="mi">3</span>
<span class="gh">Out[26]: </span><span class="go">Circle(9)</span>
</pre></div>
<p>If you have time: compare them... (<tt class="docutils literal"><span class="pre">c1</span> <span class="pre">&gt;</span> <span class="pre">c2</span></tt> , etc)</p>
<p>As you work, run the tests in <tt class="docutils literal"><span class="pre">test_circle2.py</span></tt>:</p>
<div class="highlight-bash"><div class="highlight"><pre><span class="o">(</span>cff2py<span class="o">)</span><span class="nv">$ </span>py.test test_circle2.py
</pre></div>
<p>As each of the requirements from above are fulfilled, you&#8217;ll see tests &#8216;turn
green&#8217;.</p>
<p>When all your tests are passing, you&#8217;ve completed the job.</p>
<div class="section" id="homework">
<h2>Homework<a class="headerlink" href="#homework" title="Permalink to this headline">¶</a></h2>
<p class="centered large">Testing, Testing, 1 2 3</p>
<div class="section" id="assignment">
<h3>Assignment<a class="headerlink" href="#assignment" title="Permalink to this headline">¶</a></h3>
<p>If you are not yet done, complete the <tt class="docutils literal"><span class="pre">Circle</span></tt> class so that all tests in
<tt class="docutils literal"><span class="pre">test_circle2.py</span></tt> pass.</p>
<p>Go back over some of your assignments from the last weeks.</p>
<p>Convert tests that are currently in the <tt class="docutils literal"><span class="pre">if</span> <span class="pre">__name__</span> <span class="pre">==</span> <span class="pre">'__main__':</span></tt> blocks
into standalone pytest files.</p>
<p>Name each test file so that it is clear with which source file it belongs:</p>
<div class="highlight-python"><div class="highlight"><pre>test_rot13.py -&gt; rot13.py
</pre></div>
<p>Add unit tests for the HTML Renderer that you are currently constructing.</p>
<p>Create at least 4 test files with tests that well exercise the features built
in each source file.</p>
          </div>
          <footer>
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
        <a href="session08.html" class="btn btn-neutral float-right" title="Session Eight: Generators, Iterators, Decorators, and Context Managers"/>Next <span class="fa fa-arrow-circle-right"></span></a>
        <a href="session06.html" class="btn btn-neutral" title="Session Six: Object oriented programming: Classes, instances, attributes, and subclassing"><span class="fa fa-arrow-circle-left"></span> Previous</a>
  <div role="contentinfo">
        &copy; Copyright 2014, Christopher Barker, Cris Ewing, .
  <a href="https://github.com/snide/sphinx_rtd_theme">Sphinx 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="_static/js/theme.js"></script>
  <script type="text/javascript">
      jQuery(function () {
          SphinxRtdTheme.StickyNav.enable();
  </script>
FilesExpand file tree

session07.html

Latest commit

History

session07.html

File metadata and controls
