Website build

Author: dham

0_introduction.html

@@ -285,7 +285,7 @@ <h3><span class="section-number">2.3.2. </span>Other forms of import<a class="he
 between to end points is now accessible as <a class="reference external" href="https://numpy.org/doc/stable/reference/generated/numpy.linspace.html#numpy.linspace" title="(in NumPy v1.19)"><code class="xref py py-func docutils literal notranslate"><span class="pre">np.linspace</span></code></a>.</p>
 <p>A second option is to import particular names from a module directly
 into the current namespace. For example, if we planned to use the
-fuctions <a class="reference external" href="https://docs.python.org/3/library/math.html#math.sin" title="(in Python v3.9)"><code class="xref py py-func docutils literal notranslate"><span class="pre">math.sin()</span></code></a> and <a class="reference external" href="https://docs.python.org/3/library/math.html#math.cos" title="(in Python v3.9)"><code class="xref py py-func docutils literal notranslate"><span class="pre">math.cos()</span></code></a> a lot in our script, we
+functions <a class="reference external" href="https://docs.python.org/3/library/math.html#math.sin" title="(in Python v3.9)"><code class="xref py py-func docutils literal notranslate"><span class="pre">math.sin()</span></code></a> and <a class="reference external" href="https://docs.python.org/3/library/math.html#math.cos" title="(in Python v3.9)"><code class="xref py py-func docutils literal notranslate"><span class="pre">math.cos()</span></code></a> a lot in our script, we
 might use the following import statement:</p>
 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">math</span> <span class="kn">import</span> <span class="n">sin</span><span class="p">,</span> <span class="n">cos</span>
 </pre></div>
@@ -620,7 +620,7 @@ <h2><span class="section-number">2.7. </span>Testing frameworks<a class="headerl
 the practical details of including tests in your code here.</p>
 <p>There are a number of Python packages which support code testing. The
 concepts are largely similar so rather than get bogged down in the
-details of multiple frameworks, we will introduce <a class="reference external" href="https://docs.pytest.org/en/latest/index.html" title="(in pytest v0.1.dev280+gf453460)"><span class="xref std std-doc">pytest</span></a>, which is one of the most widely used.</p>
+details of multiple frameworks, we will introduce <a class="reference external" href="https://docs.pytest.org/en/latest/index.html" title="(in pytest v0.1.dev285+ge8504e0)"><span class="xref std std-doc">pytest</span></a>, which is one of the most widely used.</p>
 <div class="section" id="pytest-tests">
 <h3><span class="section-number">2.7.1. </span>Pytest tests<a class="headerlink" href="#pytest-tests" title="Permalink to this headline">¶</a></h3>
 <p>A Pytest test is simply a function whose name starts with <code class="xref py py-obj docutils literal notranslate"><span class="pre">test_</span></code>. In

1_programs_in_files.html

@@ -277,7 +277,7 @@ <h2><span class="section-number">4.4. </span>Names<a class="headerlink" href="#n
 to use capitals, when underscores and so on. This is covered by PEP 8
 and we reproduce some of the important rules below. The second aspect
 is the choice of the letter, word, or words that make up a name. This
-is much more a matter of judgment, though there are guiding principles
+is much more a matter of judgement, though there are guiding principles
 that greatly help with clarity.</p>
 <div class="section" id="pep-8-name-conventions">
 <h3><span class="section-number">4.4.1. </span>PEP 8 name conventions<a class="headerlink" href="#pep-8-name-conventions" title="Permalink to this headline">¶</a></h3>

3_style.html

@@ -513,7 +513,7 @@ <h3><span class="section-number">5.3.1. </span>Amortised complexity and worst ca
 only occurs when the list has to be extended. How often is that?
 Suppose the list has just been reallocated (at a cost of
 <span class="math notranslate nohighlight">\(O(n)\)</span>). The new memory allocation is <span class="math notranslate nohighlight">\(kn\)</span> large, but we’ve
-aready used <span class="math notranslate nohighlight">\(n\)</span> locations so we get <span class="math notranslate nohighlight">\((k-1)n\)</span> more cheap
+already used <span class="math notranslate nohighlight">\(n\)</span> locations so we get <span class="math notranslate nohighlight">\((k-1)n\)</span> more cheap
 <span class="math notranslate nohighlight">\(O(1)\)</span> append operations before we have to reallocate
 again. <span class="math notranslate nohighlight">\((k-1)n = O(n)\)</span> so this means that adding <span class="math notranslate nohighlight">\(O(n)\)</span>
 items to the list costs:</p>

4_abstract_data_types.html

@@ -308,7 +308,7 @@ <h3><span class="section-number">6.3.2. </span>Interpreting tracebacks<a class="
 <p>This shows information about a <a class="reference internal" href="#term-call-stack"><span class="xref std std-term">call stack</span></a> comprising three
 <a class="reference internal" href="#term-stack-frame"><span class="xref std std-term">stack frames</span></a>. Look first at the bottom-most
 frame, which corresponds to the function in which the exception
-occured. The traceback for this frame starts:</p>
+occurred. The traceback for this frame starts:</p>
 <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span><span class="o">~/</span><span class="n">docs</span><span class="o">/</span><span class="nb">object</span><span class="o">-</span><span class="n">oriented</span><span class="o">-</span><span class="n">programming</span><span class="o">/</span><span class="n">src</span><span class="o">/</span><span class="n">polynomial</span><span class="o">.</span><span class="n">py</span> <span class="ow">in</span> <span class="fm">__add__</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>
 </div>
@@ -363,7 +363,7 @@ <h3><span class="section-number">6.3.2. </span>Interpreting tracebacks<a class="
 <a class="reference internal" href="#typesafe-fib"><span class="std std-numref">Listing 6.1</span></a>, we inform the user that we were expecting an
 integer rather than the type actually provided.</p>
 <div class="literal-block-wrapper docutils container" id="id5">
-<span id="typesafe-fib"></span><div class="code-block-caption"><span class="caption-number">Listing 6.1 </span><span class="caption-text">A version of the Fibbonacci function which raises an
+<span id="typesafe-fib"></span><div class="code-block-caption"><span class="caption-number">Listing 6.1 </span><span class="caption-text">A version of the Fibonacci function which raises an
 exception if a non-integer type is passed as the
 argument.</span><a class="headerlink" href="#id5" title="Permalink to this code">¶</a></div>
 <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">numbers</span> <span class="kn">import</span> <span class="n">Integral</span>
@@ -406,8 +406,8 @@ <h3><span class="section-number">6.3.2. </span>Interpreting tracebacks<a class="
 between this and the previous errors we have seen is that the bottom
 <a class="reference internal" href="#term-stack-frame"><span class="xref std std-term">stack frame</span></a> explicitly shows the exception being raised, while
 previously the stack showed a piece of code where an error had
-occured. This minor difference has to do with whether the particular
-piece of code where the exception occured is written in Python, or is
+occurred. This minor difference has to do with whether the particular
+piece of code where the exception occurred is written in Python, or is
 written in a language such as C and called from Python. This
 distinction is of negligible importance for our current purposes.</p>
 <div class="admonition note">
@@ -530,7 +530,7 @@ <h3><span class="section-number">6.5.3. </span>Exception handling and the call s
 point which is ultimately inside several <a class="reference external" href="https://docs.python.org/3/reference/compound_stmts.html#try" title="(in Python v3.9)"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">try</span></code></a> blocks.</p>
 <p>The <a class="reference internal" href="1_programs_in_files.html#term-Python-interpreter"><span class="xref std std-term">Python interpreter</span></a> deals with this situation by starting
 from the current <a class="reference internal" href="#term-stack-frame"><span class="xref std std-term">stack frame</span></a> and working upwards, a process
-known as <em>unwinding the stack</em>. In pseudocode, the alogrithm is:</p>
+known as <em>unwinding the stack</em>. In pseudocode, the algorithm is:</p>
 <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">while</span> <span class="n">call</span> <span class="n">stack</span> <span class="ow">not</span> <span class="n">empty</span><span class="p">:</span>
     <span class="k">if</span> <span class="n">current</span> <span class="n">execution</span> <span class="n">point</span> <span class="ow">is</span> <span class="ow">in</span> <span class="n">a</span> <span class="k">try</span> <span class="n">block</span> \
             <span class="k">with</span> <span class="n">an</span> <span class="k">except</span> <span class="n">matching</span> <span class="n">the</span> <span class="n">current</span> <span class="n">exception</span><span class="p">:</span>
@@ -551,9 +551,9 @@ <h2><span class="section-number">6.6. </span>Exceptions are not always errors<a
 concepts. While user errors and bugs in programs typically result in
 an exception being raised, it is not the case that all exceptions
 result from errors. The name “exception” means what it says, it is an
-event whose occurance requires an exception to the normal sequence of
+event whose occurrence requires an exception to the normal sequence of
 execution.</p>
-<p>The <a class="reference external" href="https://docs.python.org/3/library/exceptions.html#StopIteration" title="(in Python v3.9)"><code class="xref py py-class docutils literal notranslate"><span class="pre">StopIteration</span></code></a> exception which we encoutered in
+<p>The <a class="reference external" href="https://docs.python.org/3/library/exceptions.html#StopIteration" title="(in Python v3.9)"><code class="xref py py-class docutils literal notranslate"><span class="pre">StopIteration</span></code></a> exception which we encountered in
 <a class="reference internal" href="4_abstract_data_types.html#iterator-protocol"><span class="std std-numref">Section 5.5</span></a> is a good example of an <a class="reference internal" href="#term-exception"><span class="xref std std-term">exception</span></a>
 which does not indicate an error. The end of the set of things to be
 iterated over does not indicate that something has gone wrong, but it
@@ -575,12 +575,12 @@ <h2><span class="section-number">6.7. </span>Glossary<a class="headerlink" href=
 exception is <a class="reference internal" href="#raising-exceptions"><span class="std std-ref">raised</span></a> the
 <a class="reference internal" href="1_programs_in_files.html#term-Python-interpreter"><span class="xref std std-term">Python interpreter</span></a> doesn’t continue to execute the
 following line of code. Instead, the exception is either
-<a class="reference internal" href="#handling-exceptions"><span class="std std-ref">handled</span></a> or execution stips and a
+<a class="reference internal" href="#handling-exceptions"><span class="std std-ref">handled</span></a> or execution stops and a
 <a class="reference internal" href="#term-traceback"><span class="xref std std-term">traceback</span></a> is printed.</p>
 </dd>
 <dt id="term-stack-frame">stack frame</dt><dd><p>An object encapsulating the set of variables which define the
 execution of a Python script or function. This information
-includes the code being executed, all the local and gobal
+includes the code being executed, all the local and global
 names which are visible, the last instruction that was
 executed, and a reference to the stack frame which called this
 function.</p>