Appendix

Example

<app-group>
  <app id="bk978-0-7503-3071-8AppA">
    <label>Appendix A</label>
    <title>Python tutorial</title>
    <sec id="bk978-0-7503-3071-8AppAs1">
      <title>Python tutorial</title>
      <sec id="bk978-0-7503-3071-8AppAs2">
        <title>For engineers, scientists and other people who just want a
      computer to do the work.</title>
        <p>The aim of this tutorial is to get you up to speed with Python
      programming. Besides the basics, it should teach you how to use it
      effectively for usual programming tasks, like creating dynamic
      arrays, iterating them, saving them as CSV, etc.</p>
        <p>It assumes a very basic understanding of programming languages—e.g.
      knowing what a variables and conditionals are. If you’ve written
      more than 100 lines of code in, say, MATLAB, you should be
      fine.</p>
      </sec>
    </sec>
    <sec id="bk978-0-7503-3071-8AppAsA-1">
      <label>A.1</label>
      <title>The Python programming language</title>
      <p>Python is a general-purpose, interpreted programming language that
      aims to be as simple and clear as possible. Its main design philosophy
      dictates: <italic toggle="yes">></italic>There should be one—and
    preferably only one—obvious way to do it.</p>
      <p>Indeed, the Python community and developers put a high premium on
      simplicity, sometimes even at the expense of computational efficiency.
      However, for this exact reason Python code is perhaps the easiest to
      read and understand, even for people without any specific knowledge of
      the language. This ease of expressing ideas as succintly as possible
      is also responsible for Python’s adoption as the <italic toggle="yes">de facto</italic> programming language for data science. There is
      a very active—and welcoming!—community developing an ecosystem of
      <italic toggle="yes">libraries</italic> that can help with almost
    any task at hand.</p>
      <p>Even in the field of scientific computing, which traditionally prefers
      more explicit lower-level languages such as Fortran and C++, almost
      all numerical code developed nowadays also includes at least a Python
      interface. As such, Python also found use as a powerful <italic toggle="yes">orchestrating</italic> language, gluing together
      external high-performance subroutines into cohesive scripts that are
      easy to develop, understand and extend. For example, the ubiquitous
      library for matrices and <italic toggle="yes">N</italic>-dimensional
      arrays, NumPy (short for <bold>Num</bold>erical <bold>Py</bold>thon),
    contains subroutines written in heavily-optimised, low-level C code,
    making array computing in a dynamic language like Python oftentimes
    faster than straightforward implementations in much more complex
    languages.</p>
      <p>Because it is an interpreted programming language, Python code can
      exist and run in a variety of environments:<list id="bk978-0-7503-3071-8AppAl1" list-type="bullet">
        <list-item id="bk978-0-7503-3071-8AppAl1.1">
          <label>•</label>
          <p>As a script.</p>
        </list-item>
        <list-item id="bk978-0-7503-3071-8AppAl1.2">
          <label>•</label>
          <p>As functions or classes grouped into packages.</p>
        </list-item>
        <list-item id="bk978-0-7503-3071-8AppAl1.3">
          <label>•</label>
          <p>As a command-line (or REPL—Read-Eval-Print-Loop).</p>
        </list-item>
        <list-item id="bk978-0-7503-3071-8AppAl1.4">
          <label>•</label>
          <p>As mixed text and code cells in a Jupyter Notebook (such as
        this one!).</p>
        </list-item>
      </list>
    </p>
      <sec id="bk978-0-7503-3071-8AppAsA-1-1">
        <label>A.1.1</label>
        <title>Some terminology</title>
        <p>Perhaps it would be useful to clear up some of the terms that are
        usually passed around when talking about programming in Python, and
        programming languages in general:<list id="bk978-0-7503-3071-8AppAl2" list-type="bullet">
          <list-item id="bk978-0-7503-3071-8AppAl2.1">
            <label>•</label>
            <p>
            <bold>Python</bold> is the programming <italic toggle="yes">language</italic> itself, containing a set
          of syntactic rules for expressing code (much like the
          grammar of a human language!)</p>
          </list-item>
          <list-item id="bk978-0-7503-3071-8AppAl2.2">
            <label>•</label>
            <p>
            <bold>CPython</bold> is the most popular Python <italic toggle="yes">interpreter</italic>, the actual program
          that takes code written following Python’s syntax rules,
          understands it, and executes whatever commands the program
          outlines. Indeed, you can have different interpreters for
          the same language!</p>
          </list-item>
          <list-item id="bk978-0-7503-3071-8AppAl2.3">
            <label>•</label>
            <p>
            <bold>IDE</bold>, or <bold>I</bold>ntegrated
            <bold>D</bold>evelopment <bold>E</bold>nvironment is,
            like the name suggests, a programming environment; at the
            minimum, it includes a text editor with programming syntax
            highlighting and the ability to execute the code written
            in it. <italic toggle="yes">Spyder</italic> is an example
          IDE specially tailored to Python programming.</p>
          </list-item>
          <list-item id="bk978-0-7503-3071-8AppAl2.4">
            <label>•</label>
            <p>
            <bold>Library</bold> in the context of programming, is a
            collection of pre-written code that often automates or
            simplifies a task. <italic toggle="yes">NumPy</italic> is
          such a library allowing simple expression of array
          operations without worrying about low-level computer
          details (e.g. adding two matrices without needing to think
          about requesting memory from the operating system, loading
          each value from the matrices, telling the computer
          processor to add them, then saving them in the requested
          memory—sounds pretty tedious put this way, doesn’t
          it?)</p>
          </list-item>
          <list-item id="bk978-0-7503-3071-8AppAl2.5">
            <label>•</label>
            <p>
            <bold>Jupyter Notebook</bold>—essentially what you are
            seeing here!—is a programming environment containing
            <italic toggle="yes">text cells</italic> and
            interactive <italic toggle="yes">code cells</italic> that
            can be executed. If a <italic toggle="yes">Jupyter
          Notebook</italic> is the file itself (normally ending
            in <italic toggle="yes">“.ipynb”</italic>), <italic toggle="yes">JupyterLab</italic> is the environment
          that opens and displays notebooks such as this one.</p>
          </list-item>
          <list-item id="bk978-0-7503-3071-8AppAl2.6">
            <label>•</label>
            <p>
            <bold>Anaconda</bold> is a ‘batteries included’
          programming environment bringing together CPython, the
          most important libraries for data science, Spyder, an IDE
          for Python development and JupyterLab, which can host
          mixed text and interactive code cells. If you would like
          to code in Python, downloading Anaconda is the easiest way
          to get started!</p>
          </list-item>
        </list>
      </p>
        <p>By the way, <italic toggle="yes">Python</italic> comes from the
      famous British comedy troupe Monty Python, not the snake!</p>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAsA-1-2">
        <label>A.1.2</label>
        <title>The ‘pip’ package manager</title>
        <p>It is a very good idea to encapsulate code into packages, modules,
      and the like. Thankfully, python has a pretty smart package manager
      called ‘pip’ that takes care of installing and updating different
      packages.</p>
        <p>Let’s install the Numerical Python (NumPy) package. It provides
      classic MATLAB-like array functionality to Python, while being a
      bit more extensible. It is simply the most important library in
      Python for numerical computing.</p>
        <p>Run the next cell. You will see the output right under it.</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf5_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAsA-1-3">
        <label>A.1.3</label>
        <title>Using modules</title>
        <p>Once you have a module installed, you can import it inside your
        Python code (be it script, function, sandwich toaster, etc.):<disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf6_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </p>
      </sec>
    </sec>
    <sec id="bk978-0-7503-3071-8AppAsA-2">
      <label>A.2</label>
      <title>Basic constructs</title>
      <p>Now we’ll start actually programming in Python!</p>
      <sec id="bk978-0-7503-3071-8AppAsA-2-1">
        <label>A.2.1</label>
        <title>Basic data structures</title>
        <p>The simplest (i.e. most usual) data types that you will use
        are:<list id="bk978-0-7503-3071-8AppAl3" list-type="bullet">
          <list-item id="bk978-0-7503-3071-8AppAl3.1">
            <label>•</label>
            <p>
            <monospace>int</monospace> : normal integers. Python
          integers have a variable size: they are as big as your
          memory permits!</p>
          </list-item>
          <list-item id="bk978-0-7503-3071-8AppAl3.2">
            <label>•</label>
            <p>
            <monospace>float</monospace> : real numbers. For the C++
          nerds: it is equivalent to a double-precision
          floating-point number.</p>
          </list-item>
          <list-item id="bk978-0-7503-3071-8AppAl3.3">
            <label>•</label>
            <p>
            <monospace>str</monospace> : character strings.</p>
          </list-item>
        </list>
      </p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf7_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <sec id="bk978-0-7503-3071-8AppAsA-2-1-1">
          <label>A.2.1.1</label>
          <title>Lists</title>
          <p>The <monospace>list</monospace> is a built-in data structure.
        Unlike a MATLAB array, it is a variable-length container. This
        makes it very handy when we are dynamically allocating/reading
        in data:</p>
          <disp-formula>
            <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf8_pr.gif" xlink:type="simple"/>
          </disp-formula>
        </sec>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAs11">
        <title>Conditionals and loops:</title>
        <p>In Python we have the usual <monospace>if</monospace>
        <monospace>/</monospace>
        <monospace>elif</monospace>
        <monospace>/</monospace>
        <monospace>else</monospace> statements and the
        <monospace>for</monospace>
        <monospace>/</monospace>
        <monospace>while</monospace> loops.</p>
        <p>Python is a whitespace-delimited language. This means that blocks
        of code are delimited by the indentation level, rather than curly
        braces or start/end statements.<disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf9_pr.gif" xlink:type="simple"/>
        </disp-formula>x is a float!<disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf10_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </p>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAsA-2-2">
        <label>A.2.2</label>
        <title>Functions</title>
        <p>Functions in Python have a few extra features: - Positional
      arguments. - Keyword arguments. - Default values.</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf11_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf12_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAsA-2-3">
        <label>A.2.3</label>
        <title>Classes</title>
        <p>A <monospace>class</monospace> is a powerful way to bundle data
      (called ‘properties’ and/or ‘attributes’) and functions that
      operate on it (called ‘methods’):</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf13_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <p>It’s important to note that there is nothing that classes can do
        that couldn’t also be achieved with functions! Don’t worry if you
        do not <italic toggle="yes">deeply</italic> grasp what a
        <monospace>class</monospace> is—it is a more advanced concept
      that only becomes useful once your project grows in size. The most
      important things to understand are: - A class is a container for
      properties and methods. - You ‘instantiate’ a class and it will
      remember the properties you set. - You access the properties and
      methods of instances of classes using a dot.</p>
        <p>So a class helps you ‘bundle’ together related properties and
        behaviours, which you don’t really need to do for smaller projects
        (say &lt; 1000 lines of code). Using classes and objects that
        encapsulate data and functions is commonly called <italic toggle="yes">Object-Oriented Programming</italic>, or <italic toggle="yes">OOP</italic>. Teaching OOP would take an entire
      tutorial on its own, and its usefulness would only become apparent
      for large codebases.</p>
        <p>If you do, however, find yourself writing more than 1000 lines of
        code for a single project, then you’re probably ready to learn and
        understand OOP. In that case we recommend the following tutorial—it
        is quite comprehensive but doesn’t bore you with all the
        theoretical aspects of OOP: <ext-link ext-link-type="uri" xlink:href="https://realpython.com/python3-object-oriented-programming/" xlink:type="simple">https://realpython.com/python3-object-oriented-programming/</ext-link>.</p>
      </sec>
    </sec>
    <sec id="bk978-0-7503-3071-8AppAsA-3">
      <label>A.3</label>
      <title>NumPy basics</title>
      <p>Now let’s extend our Python arsenal with some NumPy-fuelled
    mathematical power! The easiest way to explain it is by example:</p>
      <sec id="bk978-0-7503-3071-8AppAsA-3-1">
        <label>A.3.1</label>
        <title>NumPy array creation and basic properties</title>
        <p>Starting from lists:</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf14_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <p>Using NumPy functions:</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf15_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAsA-3-2">
        <label>A.3.2</label>
        <title>NumPy array indexing</title>
        <p>This part is very similar to MATLAB’s arrays.</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf16_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf17_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAsA-3-3">
        <label>A.3.3</label>
        <title>Operations on NumPy arrays</title>
        <p>Inspired by MATLAB, extended by NumPy (TM). Here are some basic
      operations:</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf18_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf19_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf20_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf21_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </sec>
    </sec>
    <sec id="bk978-0-7503-3071-8AppAsA-4">
      <label>A.4</label>
      <title>Matplotlib basics</title>
      <p>Now let’s create some simple plots using Matplotlib. The quickest way
    is using MATLAB-style ‘stateful’ plotting (stateful in the sense that
    Matplotlib saves a global figure for all plotting commands you
    run):</p>
      <disp-formula>
        <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf22_pr.gif" xlink:type="simple"/>
      </disp-formula>
      <disp-formula>
        <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf1_pr.gif" xlink:type="simple"/>
      </disp-formula>
      <p>A more programmatic way to plot data would be to use individual
    figures and axes in the object-oriented style:</p>
      <disp-formula>
        <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf23_pr.gif" xlink:type="simple"/>
      </disp-formula>
      <disp-formula>
        <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf2_pr.gif" xlink:type="simple"/>
      </disp-formula>
      <p>When using subplots, the object-oriented style becomes more
    useful:</p>
      <disp-formula>
        <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf24_pr.gif" xlink:type="simple"/>
      </disp-formula>
      <disp-formula>
        <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf3_pr.gif" xlink:type="simple"/>
      </disp-formula>
    </sec>
    <sec id="bk978-0-7503-3071-8AppAsA-5">
      <label>A.5</label>
      <title>Plotly basics</title>
      <p>Plotly is JavaScript-based plotting engine that creates beautiful
    figures. They can be exported as interactive webpages and can be more
    efficient than Matplotlib in handling big datasets.</p>
      <p>Plotly is not a ‘core’ package like NumPy or Matplotlib. Let’s install
      it using <monospace>pip</monospace>:</p>
      <disp-formula>
        <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf25_pr.gif" xlink:type="simple"/>
      </disp-formula>
      <p>Plotly is a high-level, declarative charting library. This means that
    every setting of the plot can be accessed and set as a property of the
    instance.</p>
      <disp-formula>
        <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf26_pr.gif" xlink:type="simple"/>
      </disp-formula>
      <disp-formula>
        <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf4_pr.gif" xlink:type="simple"/>
      </disp-formula>
    </sec>
    <sec id="bk978-0-7503-3071-8AppAsA-6">
      <label>A.6</label>
      <title>Extra</title>
      <p>This section is entirely optional. It shows some more advanced, but
    oftentimes useful features of Python. We recommend you skim through
    it, such that you are at least familiar with the concepts. If a need
    for them arises, you’ll know where to find them:</p>
      <sec id="bk978-0-7503-3071-8AppAsA-6-1">
        <label>A.6.1</label>
        <title>Other data structures</title>
        <p>Some other data structures are: - <monospace>tuple</monospace> : an
        ordered, immutable collection. - <monospace>dict</monospace> : a
        dictionary, mapping keys to values. - <monospace>set</monospace> :
      a set, like the mathematical definition—i.e. no repeating
      values.</p>
        <p>Also, <monospace>None</monospace> is a special value that signifies
      an undefined or unset variable. It can be used as a default
      function parameter.</p>
        <p>Each of them defines some special operations:</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf27_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf28_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAsA-6-2">
        <label>A.6.2</label>
        <title>Documentation</title>
        <p>The documentation of a function/class/module can be accessed in a
      couple of ways:</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf29a_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf29b_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <p>You can easily document your own code, and Python will
      automatically generate the documentation strings:</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf30_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAsA-6-3">
        <label>A.6.3</label>
        <title>Python virtual environments</title>
        <p>Once you start building larger applications, it is important to
      have a reliable programming environment. What happens if: - Your
      app only works on one version of the Python interpreter. - Your app
      only works with older versions of some modules.</p>
        <p>The set of Python and modules’ versions forms a ‘Virtual
      Environment’. You can ‘freeze’ the state of your Virtual
      Environment and know that what you are developing surely works on
      those versions.</p>
        <p>This is the main idea. There are quite a few ways of managing
        multiple virtual environments (but <monospace>conda</monospace> is
        probably the nicest <italic toggle="yes">virtualenv</italic>
      manager). I will let you read about them once the need for them
      arises.</p>
      </sec>
    </sec>
    <sec id="bk978-0-7503-3071-8AppAsA-7">
      <label>A.7</label>
      <title>Common <italic toggle="yes">how-to</italic>s</title>
      <p>This is the final chapter of this tutorial, congratulations!</p>
      <p>We will show you the ‘easy’ (or ‘right’, following Python’s
      philosophy) way of doing a few usual tasks. This should save you a few
      trips to <italic toggle="yes">StackOverflow</italic> and NumPy’s
    documentation.</p>
      <sec id="bk978-0-7503-3071-8AppAsA-7-1">
        <label>A.7.1</label>
        <title>Formatting strings</title>
        <p>We frequently need to output data in a pretty format. Thankfully,
      Python has some nice ways of printing stuff:</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf31_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAsA-7-2">
        <label>A.7.2</label>
        <title>Iteration + list comprehensions</title>
        <p>If you start using C++-style for/while loops, stop and think if
      there isn’t a more concise (i.e. better) way of doing what you
      want. Python has some nice features for different types of
      iteration:</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf32_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <p>List comprehensions provide a concise and powerful way of
      generating or accessing iterable data.</p>
        <p>The main syntax is:</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf33_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf34_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAsA-7-3">
        <label>A.7.3</label>
        <title>Dynamic array creation</title>
        <p>We frequently need to create arrays dynamically, without knowing
        how much data there will be (e.g. reading lines from a file).
        Python <monospace>list</monospace>s have variable size, but are not
        great for maths, while NumPy <monospace>ndarray</monospace>s are
      very powerful but are not resizable. How can we achieve the best of
      both worlds? Combining them, of course:</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf35_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAsA-7-4">
        <label>A.7.4</label>
        <title>Saving and loading data</title>
        <p>We frequently need to load data from a file, do something to it,
      then save it somewhere else. In engineering, we most often handle
      big piles of numerical data that is usually saved as in a CSV
      (comma-separated-values) format. Again, Python has a few tricks up
      its sleeve.</p>
        <p>Reading or writing files line by line is laborious and oftentimes
      slow. NumPy has some optimised functions for this:</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf36_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </sec>
      <sec id="bk978-0-7503-3071-8AppAsA-7-5">
        <label>A.7.5</label>
        <title>Sorting</title>
        <p>Sorting data is terribly common. NumPy has one of the best sorting
      functions available, called TimSort (read about it, it’s great).
      For example, we often want to sort the rows of an array based on
      one of the columns (e.g. time from a simulation):</p>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf37a_pr.gif" xlink:type="simple"/>
        </disp-formula>
        <disp-formula>
          <graphic orientation="portrait" position="float" xlink:href="bk978-0-7503-3071-8app1uf37b_pr.gif" xlink:type="simple"/>
        </disp-formula>
      </sec>
    </sec>
    <sec id="bk978-0-7503-3071-8AppAsA-8">
      <label>A.8</label>
      <title>The end</title>
      <p>If you reached this point, congratulations! You’re officially a Python
      programmer, ready to take on the beautiful, vast world of data
      science. We covered a lot of ground here, from introducing the
      <monospace>Python</monospace> interpreter, the
      <monospace>pip</monospace> package manager and basic programming
    constructs, all the way to using NumPy arrays and list comprehensions
    to slice and dice our data, be it nicely-formatted or not. Because
    that’s what data science is all about, right?</p>
      <p>Don’t forget that it’s perfectly fine to not remember everything in
      this tutorial by heart—all that matters is knowing where to get the
      information you need, using <monospace>help</monospace> or <italic toggle="yes">StackOverflow</italic> or your neighbour. From here
      on, the best way to learn is by practice: start coding a few projects
      you might be interested in (there are lots of examples on Google) and
      continue to develop your programming skills; the hardest, but most
      rewarding aspect isn’t knowing a programming language, but
      <bold>making the computer do the work</bold> using the right tools
    at your disposal—be they programming languages or libraries.</p>
    </sec>
  </app>
  <app id="bk978-0-7503-3071-8AppB">
    <title>Glossary</title>
    <def-list list-content="abbreviations">
      <def-item>
        <term>Activity:</term>
        <def>
          <p>The level of radioactivity possessed by a tracer. In the
          specific context of PEPT, this typically refers to the number of
          positrons and thus gamma photon <italic toggle="yes">pairs</italic>, as opposed to individual gamma photons,
        emitted per second</p>
        </def>
      </def-item>
      <def-item>
        <term>ASIC:</term>
        <def>
          <p>Application-specific integrated circuit—i.e. a chip that was
        specially designed for a given purpose, such as identifying
        single events in PET / PEPT systems.</p>
        </def>
      </def-item>
      <def-item>
        <term>Attenuation:</term>
        <def>
          <p>The decrease in the intensity of (i.e. number of photons in) a
        beam of electromagnetic radiation (e.g. x-rays or gamma-rays) as
        it passes through a given medium.</p>
        </def>
      </def-item>
      <def-item>
        <term>Becquerel (Bq):</term>
        <def>
          <p>The SI derived unit of measure characterising the number of
          nuclei undergoing radioactive decay in a quantity of radioactive
          material. For example, a PEPT tracer particle with an activity
          of 20 MBq undergoes 20 million radioactive disintegrations per
          second. Indeed, Becquerels represent frequency (being equivalent
          to s<sup>–1</sup> or Hz), but this special name was introduced
        to avoid potentially dangerous measurement mistakes.</p>
        </def>
      </def-item>
      <def-item>
        <term>Bidispersity:</term>
        <def>
          <p>A bidisperse or ‘binary’ granular system is one containing
        exactly two distinct ‘species’ of particle (see also
        Polydispersity).</p>
        </def>
      </def-item>
      <def-item>
        <term>Binary system:</term>
        <def>
          <p>See ‘Bidispersity’</p>
        </def>
      </def-item>
      <def-item>
        <term>Body force:</term>
        <def>
          <p>A force, such as that occurring due to a gravitational or
        electromagnetic field, that acts throughout the volume of a
        system (or a body, if you will).</p>
        </def>
      </def-item>
      <def-item>
        <term>Coincidence event:</term>
        <def>
          <p>The recording, by a gamma-camera system, of two photons within a
        time window short enough that said photons are likely to have
        been produced simultaneously, i.e. due to a positron
        annihilation.</p>
        </def>
      </def-item>
      <def-item>
        <term>Coincidence rate:</term>
        <def>
          <p>The number of coincidence events (see above) registered by a
        gamma camera per unit time.</p>
        </def>
      </def-item>
      <def-item>
        <term>Collimation:</term>
        <def>
          <p>The use of a collimator (see below) to ensure that a detector
        receives only photons travelling in or close to a specific
        direction (typically orthogonal to the detector face).</p>
        </def>
      </def-item>
      <def-item>
        <term>Collimator:</term>
        <def>
          <p>A device which filters a beam of x-rays or gamma rays such that
        all photon trajectories are approximately parallel, travelling
        in a single chosen direction (in the case of nuclear imaging,
        normally perpendicular to the face of a detector).</p>
        </def>
      </def-item>
      <def-item>
        <term>Cyclone:</term>
        <def>
          <p>A device which uses the centrifugal forces induced by cyclonic
        fluid flows for the separation of particulate solids from
        fluids.</p>
        </def>
      </def-item>
      <def-item>
        <term>Detector sensitivity:</term>
        <def>
          <p>The number of events detected per unit time per unit of activity
        (i.e. the fraction of photons emitted by a source that are
        successfully detected by a given camera).</p>
        </def>
      </def-item>
      <def-item>
        <term>Direct activation:</term>
        <def>
          <p>The introduction of radioactivity into a material via the direct
        conversion of stable nuclei in said material into radioactive
        nuclei.</p>
        </def>
      </def-item>
      <def-item>
        <term>Eddy (current):</term>
        <def>
          <p>In the context of fluid mechanics, an eddy current—often
        referred to simply as an eddy—is a current whose flow direction
        diverges from that of the general (i.e. ‘bulk’ or ‘net’) flow
        within a system.</p>
        </def>
      </def-item>
      <def-item>
        <term>Electrical Permittivity:</term>
        <def>
          <p>See ‘Permittivity’.</p>
        </def>
      </def-item>
      <def-item>
        <term>Ergodicity:</term>
        <def>
          <p>An ergodic system is one whose time-averaged statistical
        behaviour is equivalent to its ensemble-averaged behaviour. In
        our present context, it is more clear to explain it in terms of
        a system for which the average behaviour of a single particle
        over a suitably long time is representative of the behaviour of
        an entire system of identical particles.</p>
        </def>
      </def-item>
      <def-item>
        <term>False coincidence:</term>
        <def>
          <p>A coincidence event (see definition above) which does not
        correspond to a positron-electron annihilation pair, or
        otherwise does not yield a line of response passing through the
        point of annihilation of such a pair.</p>
        </def>
      </def-item>
      <def-item>
        <term>FoV:</term>
        <def>
          <p>Field of view, the experimental volume which is actively being
        imaged by a detector system.</p>
        </def>
      </def-item>
      <def-item>
        <term>FPGA:</term>
        <def>
          <p>Field-programmable gate array, a circuit that can be configured
        by end-users ‘in the field’.</p>
        </def>
      </def-item>
      <def-item>
        <term>FWHM:</term>
        <def>
          <p>Full-width at half-maximum, the width of a bell-like
        distribution at half the maximum probability.</p>
        </def>
      </def-item>
      <def-item>
        <term>Half-life:</term>
        <def>
          <p>The time taken for a sample of material to reduce to half of its
        initial quantity. In nuclear science, it represents the time
        needed for half of the radioactive nuclei in a sample to undergo
        radioactive decay.</p>
        </def>
      </def-item>
      <def-item>
        <term>Hysteretic:</term>
        <def>
          <p>A hysteretic material—granular media being prime examples—is one
        whose behaviour depends upon its history.</p>
        </def>
      </def-item>
      <def-item>
        <term>Indirect activation:</term>
        <def>
          <p>The application of radioactivity to a particle through the
        absorption (or otherwise application) of an already
        radioactively-labelled material.</p>
        </def>
      </def-item>
      <def-item>
        <term>Granular material:</term>
        <def>
          <p>A system composed of multiple, discrete, macroscopic solids.</p>
        </def>
      </def-item>
      <def-item>
        <term>Inverse square law:</term>
        <def>
          <p>The amount of x-ray or gamma radiation received from a
        point-like radiation source (e.g. a tracer particle) decreases
        as the square of the distance from the source to the receiving
        object.</p>
        </def>
      </def-item>
      <def-item>
        <term>Labelling:</term>
        <def>
          <p>Marking (either literally or figuratively) a particle or fluid
        such that its motion may be recorded. In the context of PEPT,
        this is usually achieved via the attachment of a radioactive
        substance (see also ‘Radiotracer’).</p>
        </def>
      </def-item>
      <def-item>
        <term>Line of Response (LoR):</term>
        <def>
          <p>The line, or vector, representing the path taken by a pair of
        back-to-back gamma photons emitted from a positron-electron
        annihilation event.</p>
        </def>
      </def-item>
      <def-item>
        <term>Mass absorption coefficient:</term>
        <def>
          <p>The rate at which a given form of radiation with a given initial
        energy is absorbed by a given material.</p>
        </def>
      </def-item>
      <def-item>
        <term>Monodispersity:</term>
        <def>
          <p>A monodisperse granular system is one which contains only one
        single ‘species’ of particle—i.e. a system of particles all of
        whose sizes, densities, geometries and other physical properties
        can be considered effectively identical.</p>
        </def>
      </def-item>
      <def-item>
        <term>Non-invasive:</term>
        <def>
          <p>In the context of an experimental measurement, a non-invasive
        reading is one which acquires data from a system without
        disrupting its usual behaviour. As an example, inserting a
        physical sensor into a flowstream is an example of an invasive
        measurement, while performing PEPT using a tracer that is
        physically identical to others in the system would be
        non-invasive.</p>
        </def>
      </def-item>
      <def-item>
        <term>Occlusion:</term>
        <def>
          <p>The ‘loss’ of one or more tracer particles during PEPT (or
        indeed other) imaging, for example when the count rate
        registered by a particle is too low for it to be successfully
        detected.</p>
        </def>
      </def-item>
      <def-item>
        <term>Permittivity:</term>
        <def>
          <p>The (electrical) permittivity of a material is a measure of how
        strongly said material is polarised by an applied electric
        field. It can, in essence, be thought of as a measure of how
        much energy can be stored by a material in an electric
        field.</p>
        </def>
      </def-item>
      <def-item>
        <term>Polydispersity:</term>
        <def>
          <p>Any granular system which is not monodisperse, i.e. which
        contains more than one distinct ‘species’ of particle, can be
        considered polydisperse. However, the term is typically only
        used for systems comprising more than two or three distinct
        species, the terms binary/bidisperse or ternary/tridisperse
        being more commonly used to describe systems with lower orders
        of polydispersity.</p>
        </def>
      </def-item>
      <def-item>
        <term>Positron camera:</term>
        <def>
          <p>A detector system designed to detect the interactions of gamma
        rays emitted from positron-electron annihilation events, and
        thus reconstruct their trajectories as required for PEPT (and
        indeed PET) imaging.</p>
        </def>
      </def-item>
      <def-item>
        <term>Powder characterisation:</term>
        <def>
          <p>The use of experimental measurements to extract information
          regarding the physical properties—typically <italic toggle="yes">bulk</italic> properties—of a powder or granulate. Examples
          of powder characterisation devices are provided in section <xref ref-type="sec" rid="bk978-0-7503-3071-8ch4s4-4">4.4</xref>.</p>
        </def>
      </def-item>
      <def-item>
        <term>Quasi-two-dimensional:</term>
        <def>
          <p>A system whose constituents themselves are three-dimensional
        (e.g. spheres as opposed to discs) but whose dimensions are
        constrained such that all, or at least a majority, of motion
        occurs in only two of three spatial dimensions.</p>
        </def>
      </def-item>
      <def-item>
        <term>Radioisotope:</term>
        <def>
          <p>A form (isotope) of a given element which undergoes radioactive
        decay.</p>
        </def>
      </def-item>
      <def-item>
        <term>Radiolabelling:</term>
        <def>
          <p>Attaching radioactivity to a particle or fluid such that it may
        be tracked using a suitable imaging technique. See also
        ‘labelling’.</p>
        </def>
      </def-item>
      <def-item>
        <term>Radiotracer:</term>
        <def>
          <p>A particle (or, in the case of PET, fluid) ‘labelled’ with a
        radioactive material such that its trajectory may be followed
        using a suitable imaging technique.</p>
        </def>
      </def-item>
      <def-item>
        <term>Secondary radiation:</term>
        <def>
          <p>Radiation emitted by a tracer or a system being imaged which
          does not arise from <inline-formula>
            <tex-math>
              <?CDATA ${\beta }^{+}$?>
            </tex-math>
            <mml:math overflow="scroll">
              <mml:msup>
                <mml:mrow>
                  <mml:mi>β</mml:mi>
                </mml:mrow>
                <mml:mrow>
                  <mml:mo form="prefix">+</mml:mo>
                </mml:mrow>
              </mml:msup>
            </mml:math>
            <inline-graphic xlink:href="bk978-0-7503-3071-8AppBieqn1.gif" xlink:type="simple"/>
          </inline-formula> annihilation, and thus cannot be used for the
        location of tracers. Note that this term can also be defined
        more broadly—the specific definition provided here is applicable
        only to positron imaging techniques such as PEPT.</p>
        </def>
      </def-item>
      <def-item>
        <term>Segregation:</term>
        <def>
          <p>The spontaneous separation of the individual components of a
        dynamic binary or polydisperse system based on differences in
        particles’ sizes, shapes, densities and/or other physical
        properties.</p>
        </def>
      </def-item>
      <def-item>
        <term>Sensitivity:</term>
        <def>
          <p>See <italic toggle="yes">detector sensitivity</italic>.</p>
        </def>
      </def-item>
      <def-item>
        <term>Slurry:</term>
        <def>
          <p>A semi-solid mixture of particles immersed/suspended in a
        fluid.</p>
        </def>
      </def-item>
      <def-item>
        <term>Steady state:</term>
        <def>
          <p>A state in which a system’s behaviour does not vary
        significantly with time—for example a stream of fluid
        circulating at a constant rate and in a consistent pattern
        within a stirred container.</p>
        </def>
      </def-item>
      <def-item>
        <term>Ternary system:</term>
        <def>
          <p>A ternary granular system is one containing exactly three
        distinct ‘species’ of particle.</p>
        </def>
      </def-item>
      <def-item>
        <term>Tomography:</term>
        <def>
          <p>From the Greek <italic toggle="yes">tomos</italic> meaning slice
        or section; the process of reconstructing a full
        three-dimensional image of an object from a series of
        two-dimensional projections of said object.</p>
        </def>
      </def-item>
      <def-item>
        <term>Tracer:</term>
        <def>
          <p>See ‘Radiotracer’.</p>
        </def>
      </def-item>
      <def-item>
        <term>Tracer activity:</term>
        <def>
          <p>In the context of PEPT, the level of <inline-formula>
            <tex-math>
              <?CDATA ${\beta }^{+}$?>
            </tex-math>
            <mml:math overflow="scroll">
              <mml:msup>
                <mml:mrow>
                  <mml:mi>β</mml:mi>
                </mml:mrow>
                <mml:mrow>
                  <mml:mo form="prefix">+</mml:mo>
                </mml:mrow>
              </mml:msup>
            </mml:math>
            <inline-graphic xlink:href="bk978-0-7503-3071-8AppBieqn2.gif" xlink:type="simple"/>
          </inline-formula> radioactivity possessed by a tracer
        particle—i.e. the number of positrons emitted per unit time.</p>
        </def>
      </def-item>
      <def-item>
        <term>
        <italic toggle="yes">Z</italic> number:</term>
        <def>
          <p>The number of protons in the nucleus of an atom.</p>
        </def>
      </def-item>
    </def-list>
  </app>
</app-group>