Updated HTML docs

2026-03-20 14:56:30 +01:00 · 2021-10-26 21:41:11 +02:00 · 2021-10-26 21:41:11 +02:00 · 7900aad365
commit 7900aad365
parent 66d0ad0bc9
2073 changed files with 32986 additions and 41197 deletions
--- a/docs/1.0-dev/Howto/Starting/Part1/Python-classes-and-objects.html
+++ b/docs/1.0-dev/Howto/Starting/Part1/Python-classes-and-objects.html
@ -14,6 +14,8 @@
    <script src="../../../_static/underscore.js"></script>
    <script src="../../../_static/doctools.js"></script>
    <script src="../../../_static/language_data.js"></script>
+    <script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"processClass": "tex2jax_process|mathjax_process|math|output_area"}})</script>
    <link rel="shortcut icon" href="../../../_static/favicon.ico"/>
    <link rel="index" title="Index" href="../../../genindex.html" />
    <link rel="search" title="Search" href="../../../search.html" />
@ -47,7 +49,7 @@
        <div class="bodywrapper">
          <div class="body" role="main">
            
-  <section id="python-classes-and-objects">
+  <section class="tex2jax_ignore mathjax_ignore" id="python-classes-and-objects">
 <h1>Python Classes and objects<a class="headerlink" href="#python-classes-and-objects" title="Permalink to this headline">¶</a></h1>
 <p>We have now learned how to run some simple Python code from inside (and outside) your game server.
 We have also taken a look at what our game dir looks and what is where. Now we’ll start to use it.</p>
@ -63,23 +65,23 @@ it much easier to find errors and to know what code is good and which has issues
 and it will import and use it (often instead of its defaults).</p>
 </div></blockquote>
 <p>We have already successfully imported things, for example:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>&gt; py import world.test ; world.test.hello_world(me)
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>&gt; py import world.test ; world.test.hello_world(me)
 Hello World!
 </pre></div>
 </div>
 <p>In this example, on your hard drive, the files looks like this:</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">mygame</span><span class="o">/</span>
-    <span class="n">world</span><span class="o">/</span> 
+    <span class="n">world</span><span class="o">/</span>
        <span class="n">test</span><span class="o">.</span><span class="n">py</span>    <span class="o">&lt;-</span> <span class="n">inside</span> <span class="n">this</span> <span class="n">file</span> <span class="ow">is</span> <span class="n">a</span> <span class="n">function</span> <span class="n">hello_world</span>
+
 </pre></div>
 </div>
 <p>If you followed earlier tutorial lessons, the <code class="docutils literal notranslate"><span class="pre">mygame/world/test.py</span></code> file should look like this (if
 not, make it so):</p>
-<div class="highlight-python notranslate"><table class="highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre><span class="normal">1</span>
-<span class="normal">2</span></pre></div></td><td class="code"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">hello_world</span><span class="p">(</span><span class="n">who</span><span class="p">):</span>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">hello_world</span><span class="p">(</span><span class="n">who</span><span class="p">):</span>
    <span class="n">who</span><span class="o">.</span><span class="n">msg</span><span class="p">(</span><span class="s2">&quot;Hello World!&quot;</span><span class="p">)</span>
 </pre></div>
-</td></tr></table></div>
+</div>
 <aside class="sidebar">
 <p class="sidebar-title">Remember:</p>
 <ul class="simple">
@ -94,43 +96,43 @@ not, make it so):</p>
 Python <em>modules</em> (that is, files ending with .py). A python-path separates each part of the
 path <code class="docutils literal notranslate"><span class="pre">.</span></code> and always skips the <code class="docutils literal notranslate"><span class="pre">.py</span></code> file endings. Also, Evennia already knows to start looking
 for python resources inside <code class="docutils literal notranslate"><span class="pre">mygame/</span></code> so this should never be specified. Hence</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">world.test</span> 
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>import world.test
 </pre></div>
 </div>
 <p>The <code class="docutils literal notranslate"><span class="pre">import</span></code> Python instruction loads <code class="docutils literal notranslate"><span class="pre">world.test</span></code> so you have it available. You can now go “into”
 this module to get to the function you want:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">world</span><span class="o">.</span><span class="n">test</span><span class="o">.</span><span class="n">hello_world</span><span class="p">(</span><span class="n">me</span><span class="p">)</span>
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>world.test.hello_world(me)
 </pre></div>
 </div>
 <p>Using <code class="docutils literal notranslate"><span class="pre">import</span></code> like this means that you have to specify the full <code class="docutils literal notranslate"><span class="pre">world.test</span></code> every time you want
 to get to your function. Here’s a more powerful form of import:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">world.test</span> <span class="kn">import</span> <span class="n">hello_world</span>
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>from world.test import hello_world
 </pre></div>
 </div>
 <p>The <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">...</span> <span class="pre">import</span> <span class="pre">...</span></code> is very, very common as long as you want to get something with a longer
 python path. It imports <code class="docutils literal notranslate"><span class="pre">hello_world</span></code> directly, so you can use it right away!</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> &gt; py from world.test import hello_world ; hello_world(me)
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span> &gt; py from world.test import hello_world ; hello_world(me)
 Hello World!
 </pre></div>
 </div>
 <p>Let’s say your <code class="docutils literal notranslate"><span class="pre">test.py</span></code> module had a bunch of interesting functions. You could then import them
 all one by one:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">world.test</span> <span class="kn">import</span> <span class="n">hello_world</span><span class="p">,</span> <span class="n">my_func</span><span class="p">,</span> <span class="n">awesome_func</span>
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>from world.test import hello_world, my_func, awesome_func
 </pre></div>
 </div>
 <p>If there were <em>a lot</em> of functions, you could instead just import <code class="docutils literal notranslate"><span class="pre">test</span></code> and get the function
 from there when you need (without having to give the full <code class="docutils literal notranslate"><span class="pre">world.test</span></code> every time):</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>&gt; from world import test ; test.hello_world(me
-Hello World! 
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>&gt; from world import test ; test.hello_world(me
+Hello World!
 </pre></div>
 </div>
 <p>You can also <em>rename</em> stuff you import. Say for example that the module you import to already
 has a function <code class="docutils literal notranslate"><span class="pre">hello_world</span></code> but we also want to use the one from <code class="docutils literal notranslate"><span class="pre">world/test.py</span></code>:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">world.test</span> <span class="kn">import</span> <span class="n">hello_world</span> <span class="k">as</span> <span class="n">test_hello_world</span>
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>from world.test import hello_world as test_hello_world
 </pre></div>
 </div>
 <p>The form <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">...</span> <span class="pre">import</span> <span class="pre">...</span> <span class="pre">as</span> <span class="pre">...</span></code> renames the import.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>&gt; from world.test import hello_world as hw ; hw(me)
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>&gt; from world.test import hello_world as hw ; hw(me)
 Hello World!
 </pre></div>
 </div>
@ -138,17 +140,17 @@ Hello World!
 <div><p>Avoid renaming unless it’s to avoid a name-collistion like above - you want to make things as
 easy to read as possible, and renaming adds another layer of potential confusion.</p>
 </div></blockquote>
-<p>In <a class="reference internal" href="Python-basic-introduction.html"><span class="doc">the basic intro to Python</span></a> we learned how to open the in-game
+<p>In <a class="reference internal" href="Python-basic-introduction.html"><span class="doc std std-doc">the basic intro to Python</span></a> we learned how to open the in-game
 multi-line interpreter.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o">&gt;</span> <span class="n">py</span> 
-<span class="n">Evennia</span> <span class="n">Interactive</span> <span class="n">Python</span> <span class="n">mode</span>
-<span class="n">Python</span> <span class="mf">3.7.1</span> <span class="p">(</span><span class="n">default</span><span class="p">,</span> <span class="n">Oct</span> <span class="mi">22</span> <span class="mi">2018</span><span class="p">,</span> <span class="mi">11</span><span class="p">:</span><span class="mi">21</span><span class="p">:</span><span class="mi">55</span><span class="p">)</span>
-<span class="p">[</span><span class="n">GCC</span> <span class="mf">8.2.0</span><span class="p">]</span> <span class="n">on</span> <span class="n">Linux</span>
-<span class="p">[</span><span class="n">py</span> <span class="n">mode</span> <span class="o">-</span> <span class="n">quit</span><span class="p">()</span> <span class="n">to</span> <span class="n">exit</span><span class="p">]</span> 
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>&gt; py
+Evennia Interactive Python mode
+Python 3.7.1 (default, Oct 22 2018, 11:21:55)
+[GCC 8.2.0] on Linux
+[py mode - quit() to exit]
 </pre></div>
 </div>
 <p>You now only need to import once to use the imported function over and over.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>&gt; from world.test import hello_world
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>&gt; from world.test import hello_world
 &gt; hello_world()
 Hello World!
 &gt; hello_world()
@ -166,16 +168,7 @@ imports at the top, resources that are then used by all code in that module.</p>
 <h2>On classes and objects<a class="headerlink" href="#on-classes-and-objects" title="Permalink to this headline">¶</a></h2>
 <p>Now that we know about imports, let look at a real Evennia module and try to understand it.</p>
 <p>Open <code class="docutils literal notranslate"><span class="pre">mygame/typeclasses/objects.py</span></code> in your text editor of choice.</p>
-<div class="highlight-python notranslate"><table class="highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre><span class="normal"> 1</span>
-<span class="normal"> 2</span>
-<span class="normal"> 3</span>
-<span class="normal"> 4</span>
-<span class="normal"> 5</span>
-<span class="normal"> 6</span>
-<span class="normal"> 7</span>
-<span class="normal"> 8</span>
-<span class="normal"> 9</span>
-<span class="normal">10</span></pre></div></td><td class="code"><div class="highlight"><pre><span></span><span class="sd">&quot;&quot;&quot;</span>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">module docstring</span>
 <span class="sd">&quot;&quot;&quot;</span>
 <span class="kn">from</span> <span class="nn">evennia</span> <span class="kn">import</span> <span class="n">DefaultObject</span>
@ -186,12 +179,14 @@ imports at the top, resources that are then used by all code in that module.</p>
 <span class="sd">    &quot;&quot;&quot;</span>
    <span class="k">pass</span>
 </pre></div>
-</td></tr></table></div>
+</div>
 <aside class="sidebar">
 <p class="sidebar-title">Docstrings vs Comments</p>
-<p>A docstring is not the same as a comment (created by <cite>#</cite>). A
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>A docstring is not the same as a comment (created by `#`). A
 docstring is not ignored by Python but is an integral part of the thing
-it is documenting (the module and the class in this case).</p>
+it is documenting (the module and the class in this case).
+</pre></div>
+</div>
 </aside>
 <p>The real file is much longer but we can ignore the multi-line strings (<code class="docutils literal notranslate"><span class="pre">&quot;&quot;&quot;</span> <span class="pre">...</span> <span class="pre">&quot;&quot;&quot;</span></code>). These serve
 as documentation-strings, or <em>docstrings</em> for the module (at the top) and the <code class="docutils literal notranslate"><span class="pre">class</span></code> below.</p>
@ -201,13 +196,15 @@ as a black box.</p>
 <p>Next we have a <code class="docutils literal notranslate"><span class="pre">class</span></code> named <code class="docutils literal notranslate"><span class="pre">Object</span></code>, which <em>inherits</em> from <code class="docutils literal notranslate"><span class="pre">DefaultObject</span></code>. This class doesn’t
 actually do anything on its own, its only code (except the docstring) is <code class="docutils literal notranslate"><span class="pre">pass</span></code> which means,
 well, to pass and don’t do anything.</p>
-<p>We will get back to this module in the <a class="reference internal" href="Learning-Typeclasses.html"><span class="doc">next lesson</span></a>. First we need to do a
+<p>We will get back to this module in the <a class="reference internal" href="Learning-Typeclasses.html"><span class="doc std std-doc">next lesson</span></a>. First we need to do a
 little detour to understand what a ‘class’, an ‘object’ or ‘instance’ is. These are fundamental
 things to understand before you can use Evennia efficiently.</p>
 <aside class="sidebar">
 <p class="sidebar-title">OOP</p>
-<p>Classes, objects, instances and inheritance are fundamental to Python. This and some
-other concepts are often clumped together under the term Object-Oriented-Programming (OOP).</p>
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>Classes, objects, instances and inheritance are fundamental to Python. This and some
+other concepts are often clumped together under the term Object-Oriented-Programming (OOP).
+</pre></div>
+</div>
 </aside>
 <section id="classes-and-instances">
 <h3>Classes and instances<a class="headerlink" href="#classes-and-instances" title="Permalink to this headline">¶</a></h3>
@ -215,21 +212,16 @@ other concepts are often clumped together under the term Object-Oriented-Program
 of everyone of that class. For example, we could have a class <code class="docutils literal notranslate"><span class="pre">Monster</span></code> which has resources for moving itself
 from room to room.</p>
 <p>Open a new file <code class="docutils literal notranslate"><span class="pre">mygame/typeclasses/monsters.py</span></code>. Add the following simple class:</p>
-<div class="highlight-python notranslate"><table class="highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre><span class="normal">1</span>
-<span class="normal">2</span>
-<span class="normal">3</span>
-<span class="normal">4</span>
-<span class="normal">5</span>
-<span class="normal">6</span>
-<span class="normal">7</span></pre></div></td><td class="code"><div class="highlight"><pre><span></span>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span>
 <span class="k">class</span> <span class="nc">Monster</span><span class="p">:</span>

    <span class="n">key</span> <span class="o">=</span> <span class="s2">&quot;Monster&quot;</span>

    <span class="k">def</span> <span class="nf">move_around</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&quot;</span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="n">key</span><span class="si">}</span><span class="s2"> is moving!&quot;</span><span class="p">)</span>
+
 </pre></div>
-</td></tr></table></div>
+</div>
 <p>Above we have defined a <code class="docutils literal notranslate"><span class="pre">Monster</span></code> class with one variable <code class="docutils literal notranslate"><span class="pre">key</span></code> (that is, the name) and one
 <em>method</em> on it. A method is like a function except it sits “on” the class. It also always has
 at least one argument (almost always written as <code class="docutils literal notranslate"><span class="pre">self</span></code> although you could in principle use
@ -245,11 +237,11 @@ back to the <code class="docutils literal notranslate"><span class="pre">key</sp
 <p>A class is just a template. Before it can be used, we must create an <em>instance</em> of the class. If
 <code class="docutils literal notranslate"><span class="pre">Monster</span></code> is a class, then an instance is Fluffy, the individual red dragon. You instantiate
 by <em>calling</em> the class, much like you would a function:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">fluffy</span> <span class="o">=</span> <span class="n">Monster</span><span class="p">()</span>
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>fluffy = Monster()
 </pre></div>
 </div>
 <p>Let’s try it in-game (we use multi-line mode, it’s easier)</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>&gt; py 
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>&gt; py
 &gt; from typeclasses.monsters import Monster
 &gt; fluffy = Monster()
 &gt; fluffy.move_around()
@ -264,78 +256,73 @@ there when defining the method, we <em>never</em> add it explicitly when we call
 will add the correct <code class="docutils literal notranslate"><span class="pre">self</span></code> for us automatically behind the scenes).</p>
 </div></blockquote>
 <p>Let’s create the sibling of Fluffy, Cuddly:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>&gt; cuddly = Monster()
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>&gt; cuddly = Monster()
 &gt; cuddly.move_around()
-Monster is moving!  
+Monster is moving!
 </pre></div>
 </div>
 <p>We now have two dragons and they’ll hang around until with call <code class="docutils literal notranslate"><span class="pre">quit()</span></code> to exit this Python
 instance. We can have them move as many times as we want. But no matter how many dragons we
 create, they will all show the same printout since <code class="docutils literal notranslate"><span class="pre">key</span></code> is always fixed as “Monster”.</p>
 <p>Let’s make the class a little more flexible:</p>
-<div class="highlight-python notranslate"><table class="highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre><span class="normal">1</span>
-<span class="normal">2</span>
-<span class="normal">3</span>
-<span class="normal">4</span>
-<span class="normal">5</span>
-<span class="normal">6</span>
-<span class="normal">7</span>
-<span class="normal">8</span></pre></div></td><td class="code"><div class="highlight"><pre><span></span>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span>
 <span class="k">class</span> <span class="nc">Monster</span><span class="p">:</span>
- 
+
    <span class="k">def</span> <span class="fm">__init__</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="bp">self</span><span class="o">.</span><span class="n">key</span> <span class="o">=</span> <span class="n">key</span> 
+        <span class="bp">self</span><span class="o">.</span><span class="n">key</span> <span class="o">=</span> <span class="n">key</span>

    <span class="k">def</span> <span class="nf">move_around</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&quot;</span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="n">key</span><span class="si">}</span><span class="s2"> is moving!&quot;</span><span class="p">)</span>
+
 </pre></div>
-</td></tr></table></div>
+</div>
 <p>The <code class="docutils literal notranslate"><span class="pre">__init__</span></code> is a special method that Python recognizes. If given, this handles extra arguments
 when you instantiate a new Monster. We have it add an argument <code class="docutils literal notranslate"><span class="pre">key</span></code> that we store on <code class="docutils literal notranslate"><span class="pre">self</span></code>.</p>
 <p>Now, for Evennia to see this code change, we need to reload the server. You can either do it this
 way:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o">&gt;</span> <span class="n">quit</span><span class="p">()</span>
-<span class="n">Python</span> <span class="n">Console</span> <span class="ow">is</span> <span class="n">closing</span><span class="o">.</span>
-<span class="o">&gt;</span> <span class="n">reload</span>
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>&gt; quit()
+Python Console is closing.
+&gt; reload
 </pre></div>
 </div>
 <p>Or you can use a separate terminal and restart from outside the game:</p>
 <aside class="sidebar">
 <p class="sidebar-title">On reloading</p>
-<p>Reloading with the python mode gets a little annoying since you need to redo everything
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>Reloading with the python mode gets a little annoying since you need to redo everything
 after every reload. Just keep in mind that during regular development you will not be
 working this way. The in-game python mode is practical for quick fixes and experiments like
-this, but actual code is normally written externally, in python modules.</p>
+this, but actual code is normally written externally, in python modules.
+</pre></div>
+</div>
 </aside>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>$ evennia reload   (or restart)
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>$ evennia reload   (or restart)
 </pre></div>
 </div>
 <p>Either way you’ll need to go into <code class="docutils literal notranslate"><span class="pre">py</span></code> again:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>&gt; py 
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>&gt; py
 &gt; from typeclasses.monsters import Monster
 fluffy = Monster(&quot;Fluffy&quot;)
 fluffy.move_around()
-Fluffy is moving! 
+Fluffy is moving!
 </pre></div>
 </div>
 <p>Now we passed <code class="docutils literal notranslate"><span class="pre">&quot;Fluffy&quot;</span></code> as an argument to the class. This went into <code class="docutils literal notranslate"><span class="pre">__init__</span></code> and set <code class="docutils literal notranslate"><span class="pre">self.key</span></code>, which we
 later used to print with the right name! Again, note that we didn’t include <code class="docutils literal notranslate"><span class="pre">self</span></code> when calling.</p>
 </section>
-<section id="what-s-so-good-about-objects">
-<h3>What’s so good about objects?<a class="headerlink" href="#what-s-so-good-about-objects" title="Permalink to this headline">¶</a></h3>
+<section id="whats-so-good-about-objects">
+<h3>What’s so good about objects?<a class="headerlink" href="#whats-so-good-about-objects" title="Permalink to this headline">¶</a></h3>
 <p>So far all we’ve seen a class do is to behave our first <code class="docutils literal notranslate"><span class="pre">hello_world</span></code> function but more complex. We
 could just have made a function:</p>
-<div class="highlight-python notranslate"><table class="highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre><span class="normal">1</span>
-<span class="normal">2</span></pre></div></td><td class="code"><div class="highlight"><pre><span></span>     <span class="k">def</span> <span class="nf">monster_move_around</span><span class="p">(</span><span class="n">key</span><span class="p">):</span>
-        <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&quot;</span><span class="si">{</span><span class="n">key</span><span class="si">}</span><span class="s2"> is moving!&quot;</span><span class="p">)</span>      
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span>     <span class="k">def</span> <span class="nf">monster_move_around</span><span class="p">(</span><span class="n">key</span><span class="p">):</span>
+        <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&quot;</span><span class="si">{</span><span class="n">key</span><span class="si">}</span><span class="s2"> is moving!&quot;</span><span class="p">)</span>
 </pre></div>
-</td></tr></table></div>
+</div>
 <p>The difference between the function and an instance of a class (the object), is that the
 object retains <em>state</em>. Once you called the function it forgets everything about what you called
 it with last time. The object, on the other hand, remembers changes:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>&gt; fluffy.key = &quot;Cuddly&quot;
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>&gt; fluffy.key = &quot;Cuddly&quot;
 &gt; fluffy.move_around()
-Cuddly is moving! 
+Cuddly is moving!
 </pre></div>
 </div>
 <p>The <code class="docutils literal notranslate"><span class="pre">fluffy</span></code> object’s <code class="docutils literal notranslate"><span class="pre">key</span></code> was changed to “Cuddly” for as long as it’s around. This makes objects
@ -357,39 +344,14 @@ objects in turn:</p>
 <p>Classes can <em>inherit</em> from each other. A “child” class will inherit everything from its “parent” class. But if
 the child adds something with the same name as its parent, it will <em>override</em> whatever it got from its parent.</p>
 <p>Let’s expand <code class="docutils literal notranslate"><span class="pre">mygame/typeclasses/monsters.py</span></code> with another class:</p>
-<div class="highlight-python notranslate"><table class="highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre><span class="normal"> 1</span>
-<span class="normal"> 2</span>
-<span class="normal"> 3</span>
-<span class="normal"> 4</span>
-<span class="normal"> 5</span>
-<span class="normal"> 6</span>
-<span class="normal"> 7</span>
-<span class="normal"> 8</span>
-<span class="normal"> 9</span>
-<span class="normal">10</span>
-<span class="normal">11</span>
-<span class="normal">12</span>
-<span class="normal">13</span>
-<span class="normal">14</span>
-<span class="normal">15</span>
-<span class="normal">16</span>
-<span class="normal">17</span>
-<span class="normal">18</span>
-<span class="normal">19</span>
-<span class="normal">20</span>
-<span class="normal">21</span>
-<span class="normal">22</span>
-<span class="normal">23</span>
-<span class="normal">24</span>
-<span class="normal">25</span>
-<span class="normal">26</span></pre></div></td><td class="code"><div class="highlight"><pre><span></span>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span>
 <span class="k">class</span> <span class="nc">Monster</span><span class="p">:</span>
    <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    This is a base class for Monster.</span>
 <span class="sd">    &quot;&quot;&quot;</span>
- 
+
    <span class="k">def</span> <span class="fm">__init__</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="bp">self</span><span class="o">.</span><span class="n">key</span> <span class="o">=</span> <span class="n">key</span> 
+        <span class="bp">self</span><span class="o">.</span><span class="n">key</span> <span class="o">=</span> <span class="n">key</span>

    <span class="k">def</span> <span class="nf">move_around</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&quot;</span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="n">key</span><span class="si">}</span><span class="s2"> is moving!&quot;</span><span class="p">)</span>
@ -404,30 +366,33 @@ the child adds something with the same name as its parent, it will <em>override<
        <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&quot;</span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="n">key</span><span class="si">}</span><span class="s2"> flies through the air high above!&quot;</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">firebreath</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
-        <span class="sd">&quot;&quot;&quot; </span>
+        <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">        Let our dragon breathe fire.</span>
 <span class="sd">        &quot;&quot;&quot;</span>
        <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&quot;</span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="n">key</span><span class="si">}</span><span class="s2"> breathes fire!&quot;</span><span class="p">)</span>
+
 </pre></div>
-</td></tr></table></div>
+</div>
 <p>We added some docstrings for clarity. It’s always a good idea to add doc strings; you can do so also for methods,
 as exemplified for the new <code class="docutils literal notranslate"><span class="pre">firebreath</span></code> method.</p>
 <p>We created the new class <code class="docutils literal notranslate"><span class="pre">Dragon</span></code> but we also specified that <code class="docutils literal notranslate"><span class="pre">Monster</span></code> is the <em>parent</em> of <code class="docutils literal notranslate"><span class="pre">Dragon</span></code> but adding
 the parent in parenthesis. <code class="docutils literal notranslate"><span class="pre">class</span> <span class="pre">Classname(Parent)</span></code> is the way to do this.</p>
 <aside class="sidebar">
 <p class="sidebar-title">Multi-inheritance</p>
-<p>It’s possible to add more comma-separated parents to a class. You should usually avoid
-this until you <cite>really</cite> know what you are doing. A single parent will be enough for almost
-every case you’ll need.</p>
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>It&#39;s possible to add more comma-separated parents to a class. You should usually avoid
+this until you `really` know what you are doing. A single parent will be enough for almost
+every case you&#39;ll need.
+</pre></div>
+</div>
 </aside>
 <p>Let’s try out our new class. First <code class="docutils literal notranslate"><span class="pre">reload</span></code> the server and the do</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>&gt; py 
-&gt; from typeclasses.monsters import Dragon 
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>&gt; py
+&gt; from typeclasses.monsters import Dragon
 &gt; smaug = Dragon(&quot;Smaug&quot;)
 &gt; smaug.move_around()
 Smaug flies through the air high above!
 &gt; smaug.firebreath()
-Smaug breathes fire! 
+Smaug breathes fire!
 </pre></div>
 </div>
 <p>Because we didn’t implement <code class="docutils literal notranslate"><span class="pre">__init__</span></code> in <code class="docutils literal notranslate"><span class="pre">Dragon</span></code>, we got the one from <code class="docutils literal notranslate"><span class="pre">Monster</span></code> instead. But since we
@ -436,33 +401,25 @@ available for <code class="docutils literal notranslate"><span class="pre">Drago
 can breathe fire.</p>
 <p>One can also force a class to use resources from the parent even if you are overriding some of it. This is done
 with the <code class="docutils literal notranslate"><span class="pre">super()</span></code> method. Modify your <code class="docutils literal notranslate"><span class="pre">Dragon</span></code> class as follows:</p>
-<div class="highlight-python notranslate"><table class="highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre><span class="normal">1</span>
-<span class="normal">2</span>
-<span class="normal">3</span>
-<span class="normal">4</span>
-<span class="normal">5</span>
-<span class="normal">6</span>
-<span class="normal">7</span>
-<span class="normal">8</span>
-<span class="normal">9</span></pre></div></td><td class="code"><div class="highlight"><pre><span></span><span class="c1"># ... </span>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># ...</span>

 <span class="k">class</span> <span class="nc">Dragon</span><span class="p">(</span><span class="n">Monster</span><span class="p">):</span>

    <span class="k">def</span> <span class="nf">move_around</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">move_around</span><span class="p">()</span>
        <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;The world trembles.&quot;</span><span class="p">)</span>
-    
+
    <span class="c1"># ...</span>
 </pre></div>
-</td></tr></table></div>
+</div>
 <blockquote>
 <div><p>Keep <code class="docutils literal notranslate"><span class="pre">Monster</span></code> and the <code class="docutils literal notranslate"><span class="pre">firebreath</span></code> method, <code class="docutils literal notranslate"><span class="pre">#</span> <span class="pre">...</span></code> indicates the rest of the code is untouched.</p>
 </div></blockquote>
 <p>The <code class="docutils literal notranslate"><span class="pre">super().move_around()</span></code> line means that we are calling <code class="docutils literal notranslate"><span class="pre">move_around()</span></code> on the parent of the class. So in this
 case, we will call <code class="docutils literal notranslate"><span class="pre">Monster.move_around</span></code> first, before doing our own thing.</p>
 <p>Now <code class="docutils literal notranslate"><span class="pre">reload</span></code> the server and then:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>&gt; py 
-&gt; from typeclasses.monsters import Dragon 
+<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>&gt; py
+&gt; from typeclasses.monsters import Dragon
 &gt; smaug = Dragon(&quot;Smaug&quot;)
 &gt; smaug.move_around()
 Smaug is moving!
@ -511,7 +468,7 @@ provides. But first we need to learn just where to find everything.</p>
 <li><a class="reference internal" href="#importing-things">Importing things</a></li>
 <li><a class="reference internal" href="#on-classes-and-objects">On classes and objects</a><ul>
 <li><a class="reference internal" href="#classes-and-instances">Classes and instances</a></li>
-<li><a class="reference internal" href="#what-s-so-good-about-objects">What’s so good about objects?</a></li>
+<li><a class="reference internal" href="#whats-so-good-about-objects">What’s so good about objects?</a></li>
 <li><a class="reference internal" href="#classes-can-have-children">Classes can have children</a></li>
 </ul>
 </li>
@ -546,7 +503,7 @@ provides. But first we need to learn just where to find everything.</p>
 <h3>Versions</h3>
 <ul>
  <li><a href="Python-classes-and-objects.html">1.0-dev (develop branch)</a></li>
-  <li><a href="../../../../0.9.5/index.html">0.9.5 (v0.9.5 branch)</a></li>
+  <li><a href="../../../../0.95/index.html">0.95 (v0.9.5 branch)</a></li>
 </ul>

        </div>