Website build

Author: dham

1_programs_in_files.html

@@ -372,6 +372,22 @@ <h2><span class="section-number">4.5. </span>Parsimony and modularity<a class="h
 <p class="admonition-title">Note</p>
 <p>Put in an example here of some horrific code that can be radically simplified.</p>
 </div>
+<div class="badcode docutils container">
+<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">result</span> <span class="o">=</span> <span class="p">[]</span>
+
+<span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">9999</span><span class="p">):</span>
+   <span class="k">if</span> <span class="n">_</span> <span class="o">%</span> <span class="mi">1</span> <span class="o">==</span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">_</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">_</span> <span class="o">%</span> <span class="mi">3</span> <span class="o">==</span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">_</span> <span class="o">%</span> <span class="mi">4</span> <span class="o">==</span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">_</span> <span class="o">%</span> <span class="mi">5</span> <span class="o">==</span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">_</span> <span class="o">%</span> <span class="mi">6</span> <span class="o">==</span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">_</span> <span class="o">%</span> <span class="mi">7</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
+      <span class="n">result</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">_</span><span class="p">)</span>
+<span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="goodcode docutils container">
+<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">result</span> <span class="o">=</span> <span class="p">[</span><span class="n">num</span> <span class="k">for</span> <span class="n">num</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">9999</span><span class="p">)</span> <span class="k">if</span> <span class="nb">all</span><span class="p">(</span><span class="n">num</span> <span class="o">%</span> <span class="n">x</span> <span class="o">==</span> <span class="mi">0</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">8</span><span class="p">))]</span>
+<span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
 <div class="section" id="use-comprehensions">
 <h3><span class="section-number">4.5.1. </span>Use comprehensions<a class="headerlink" href="#use-comprehensions" title="Permalink to this headline">¶</a></h3>
 <p>It is very common to write loops to populate collection objects with
@@ -386,7 +402,7 @@ <h3><span class="section-number">4.5.1. </span>Use comprehensions<a class="heade
 </div>
 <p>This is a fairly typical, if simple, example. It takes three lines of
 code: one to initialise the list, one to loop, and one to add the
-values to the list. Alternatively, if we had used a <a class="reference external" href="https://docs.python.org/3/tutorial/datastructures.html#tut-listcomps" title="(in Python v3.8)"><span class="xref std std-ref">list
+values to the list. Alternatively, if we had used a <a class="reference external" href="https://docs.python.org/3/tutorial/datastructures.html#tut-listcomps" title="(in Python v3.9)"><span class="xref std std-ref">list
 comprehension</span></a>, all three steps would have been subsumed into a single
 operation:</p>
 <div class="goodcode docutils container">
@@ -396,8 +412,8 @@ <h3><span class="section-number">4.5.1. </span>Use comprehensions<a class="heade
 </div>
 <p>At least for fairly simple operations, comprehensions are almost
 always easier for the reader to understand than loops. In addition to
-lists, comprehensions are also available for <a class="reference external" href="https://docs.python.org/3/tutorial/datastructures.html#tut-sets" title="(in Python v3.8)"><span class="xref std std-ref">sets</span></a>
-and <a class="reference external" href="https://docs.python.org/3/tutorial/datastructures.html#tut-dictionaries" title="(in Python v3.8)"><span class="xref std std-ref">dictionaries</span></a>.</p>
+lists, comprehensions are also available for <a class="reference external" href="https://docs.python.org/3/tutorial/datastructures.html#tut-sets" title="(in Python v3.9)"><span class="xref std std-ref">sets</span></a>
+and <a class="reference external" href="https://docs.python.org/3/tutorial/datastructures.html#tut-dictionaries" title="(in Python v3.9)"><span class="xref std std-ref">dictionaries</span></a>.</p>
 </div>
 <div class="section" id="redundant-logical-expressions">
 <h3><span class="section-number">4.5.2. </span>Redundant logical expressions<a class="headerlink" href="#redundant-logical-expressions" title="Permalink to this headline">¶</a></h3>
@@ -408,7 +424,7 @@ <h3><span class="section-number">4.5.2. </span>Redundant logical expressions<a c
 </div>
 </div>
 <p>To see the problem with this statement, let’s write out its truth table:</p>
-<table class="docutils align-default">
+<table class="center-align-center-col docutils align-default">
 <colgroup>
 <col style="width: 28%" />
 <col style="width: 72%" />
@@ -428,7 +444,7 @@ <h3><span class="section-number">4.5.2. </span>Redundant logical expressions<a c
 </tbody>
 </table>
 <p>In other words, the expressions <code class="xref py py-obj docutils literal notranslate"><span class="pre">var</span></code> and <code class="xref py py-obj docutils literal notranslate"><span class="pre">var</span> <span class="pre">==</span> <span class="pre">True</span></code> are logically
-equivalent (at least assuming <code class="xref py py-obj docutils literal notranslate"><span class="pre">var</span></code> is a <a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#bltin-boolean-values" title="(in Python v3.8)"><span class="xref std std-ref">boolean value</span></a>), so it would
+equivalent (at least assuming <code class="xref py py-obj docutils literal notranslate"><span class="pre">var</span></code> is a <a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#bltin-boolean-values" title="(in Python v3.9)"><span class="xref std std-ref">boolean value</span></a>), so it would
 have been more parsimonious to write:</p>
 <div class="goodcode docutils container">
 <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">var</span><span class="p">:</span>
@@ -447,7 +463,7 @@ <h3><span class="section-number">4.5.2. </span>Redundant logical expressions<a c
 </pre></div>
 </div>
 </div>
-<p>Finally, the use of <a class="reference external" href="https://docs.python.org/3/reference/compound_stmts.html#else" title="(in Python v3.8)"><span class="xref std std-ref">else</span></a> (or <a class="reference external" href="https://docs.python.org/3/reference/compound_stmts.html#elif" title="(in Python v3.8)"><span class="xref std std-ref">elif</span></a>) can reduce the number
+<p>Finally, the use of <a class="reference external" href="https://docs.python.org/3/reference/compound_stmts.html#else" title="(in Python v3.9)"><span class="xref std std-ref">else</span></a> (or <a class="reference external" href="https://docs.python.org/3/reference/compound_stmts.html#elif" title="(in Python v3.9)"><span class="xref std std-ref">elif</span></a>) can reduce the number
 of logical expressions that the reader has to read and
 understand. This means that:</p>
 <div class="badcode docutils container">
@@ -474,7 +490,7 @@ <h3><span class="section-number">4.5.2. </span>Redundant logical expressions<a c
 </div>
 <div class="section" id="use-the-fact-that-every-object-is-true-or-false">
 <h3><span class="section-number">4.5.3. </span>Use the fact that every object is True or False<a class="headerlink" href="#use-the-fact-that-every-object-is-true-or-false" title="Permalink to this headline">¶</a></h3>
-<p>Every Python object is logically either <a class="reference external" href="https://docs.python.org/3/library/constants.html#True" title="(in Python v3.8)"><code class="xref py py-data docutils literal notranslate"><span class="pre">True</span></code></a> or <a class="reference external" href="https://docs.python.org/3/library/constants.html#False" title="(in Python v3.8)"><code class="xref py py-data docutils literal notranslate"><span class="pre">False</span></code></a> according to the
+<p>Every Python object is logically either <a class="reference external" href="https://docs.python.org/3/library/constants.html#True" title="(in Python v3.9)"><code class="xref py py-data docutils literal notranslate"><span class="pre">True</span></code></a> or <a class="reference external" href="https://docs.python.org/3/library/constants.html#False" title="(in Python v3.9)"><code class="xref py py-data docutils literal notranslate"><span class="pre">False</span></code></a> according to the
 following rules:</p>
 <ol class="arabic simple">
 <li><p>None is False.</p></li>
@@ -484,16 +500,16 @@ <h3><span class="section-number">4.5.3. </span>Use the fact that every object is
 <li><p>The null string <code class="xref py py-obj docutils literal notranslate"><span class="pre">&quot;&quot;</span></code> is False, a string containing any characters is True.</p></li>
 <li><p>A user-defined class is True unless:</p>
 <ol class="loweralpha simple">
-<li><p>It defines the <a class="reference external" href="https://docs.python.org/3/reference/datamodel.html#object.__bool__" title="(in Python v3.8)"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__bool__()</span></code></a> <a class="reference internal" href="2_objects.html#term-special-method"><span class="xref std std-term">special
+<li><p>It defines the <a class="reference external" href="https://docs.python.org/3/reference/datamodel.html#object.__bool__" title="(in Python v3.9)"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__bool__()</span></code></a> <a class="reference internal" href="2_objects.html#term-special-method"><span class="xref std std-term">special
 method</span></a>. In this case the truth value is whatever this method
 returns.</p></li>
-<li><p>It doesn’t define <a class="reference external" href="https://docs.python.org/3/reference/datamodel.html#object.__bool__" title="(in Python v3.8)"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__bool__()</span></code></a> but does define
-<a class="reference external" href="https://docs.python.org/3/reference/datamodel.html#object.__len__" title="(in Python v3.8)"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__len__()</span></code></a>. In this case the object is False if the
+<li><p>It doesn’t define <a class="reference external" href="https://docs.python.org/3/reference/datamodel.html#object.__bool__" title="(in Python v3.9)"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__bool__()</span></code></a> but does define
+<a class="reference external" href="https://docs.python.org/3/reference/datamodel.html#object.__len__" title="(in Python v3.9)"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__len__()</span></code></a>. In this case the object is False if the
 length is zero, and True otherwise.</p></li>
 </ol>
 </li>
 </ol>
-<p>These rules are laid out formally in <a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#truth" title="(in Python v3.8)"><span class="xref std std-ref">the Python documentation</span></a>. One way that they can be used to write simpler, clearer code
+<p>These rules are laid out formally in <a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#truth" title="(in Python v3.9)"><span class="xref std std-ref">the Python documentation</span></a>. One way that they can be used to write simpler, clearer code
 is in the very common case of code that should only execute if a
 collection object actually contains something. In that case, this form
 of test is to be preferred:</p>

2_objects.html

@@ -425,7 +425,7 @@ internal module structure of a package in a logical way while still
 providing users with direct access to the most important or most
 frequently used features.
 
-The eagle-eyed reader will have noticed the extra `.` in front of
+The eagle-eyed reader will have noticed the extra . in front of
 `.module_1`. This marks this import as a *relative import*. In other
 words, in looking for `module_1.py`, Python should look for files in
 the same folder as the module where the import statement occurs,
@@ -444,15 +444,14 @@ reader that the import is from the current package.
 Making packages installable
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-In order for the :ref:`import statement <python:import>` to work,
-Python needs to know about the package being imported. This is
-achieved by installing the package. In order to make a package
-installable, we need to provide Python with a bit more information
-about the package. This information is contained in a Python module
-which must be called `setup.py`. This file isn't part of the package
-and does not go in the package folder. Instead, it should be placed in
-the top-level folder of your git repository, so that the Python
-package installer will be able to find it.
+In order for the :ref:`import statement <python:import>` to work, Python needs
+to know that the package being imported exists, and where to find it. This is
+achieved by *installing* the package. In order to make a package installable, we
+need to provide Python with a bit more information about the package. This
+information is contained in a Python module which must be called `setup.py`.
+This file isn't part of the package and does not go in the package folder.
+Instead, it should be placed in the top-level folder of your git repository, so
+that the Python package installer will be able to find it.
 
 At the very least, `setup.py` should contain the following:
 

3_style.html

@@ -341,6 +341,24 @@ function or method is small enough for a reader to understand.
 
    Put in an example here of some horrific code that can be radically simplified.
 
+.. container:: badcode
+
+   .. code-block:: python3
+
+         result = []
+
+         for _ in range(1, 9999):
+            if _ % 1 == 0 and _ % 2 == 0 and _ % 3 == 0 and _ % 4 == 0 and _ % 5 == 0 and _ % 6 == 0 and _ % 7 == 0:
+               result.append(_)
+         print(result)
+
+.. container:: goodcode
+
+    .. code-block:: python3
+
+         result = [num for num in range(1, 9999) if all(num % x == 0 for x in range(1, 8))]
+         print(result)
+
 Use comprehensions
 ..................
 
@@ -386,12 +404,14 @@ One exceptionally common failure of parsimony is to write expressions of the fol
 
 To see the problem with this statement, let's write out its truth table:
 
-===== =============
-`var` `var == True`
-===== =============
-T     T
-F     F
-===== =============
+.. rst-class:: center-align-center-col
+      
+   ===== =============
+   `var` `var == True`
+   ===== =============
+   T     T
+   F     F
+   ===== =============
 
 In other words, the expressions `var` and `var == True` are logically
 equivalent (at least assuming `var` is a :ref:`boolean value <bltin-boolean-values>`), so it would

_sources/1_programs_in_files.rst.txt

@@ -371,6 +371,11 @@ table.imagegrid td{
     text-align: center;
 }
 
+table.center-align-center-col td:last-child {
+    text-align: center;
+    width: 200%;
+}
+
 table.docutils {
     margin: auto;
 }