diff --git a/.gitignore b/.gitignore
index 35008af..79eb637 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
+**/.ipynb_checkpoints/
.python-version
.venv/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..676b025
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,28 @@
+default_stages: [commit]
+fail_fast: true
+repos:
+- repo: local
+ hooks:
+ - id: doctests
+ name: Run the xdoctests in the source files
+ entry: poetry run nox -s doctests --
+ language: system
+ stages: [commit, merge-commit]
+ types: [python]
+ - id: fix-branch-references
+ name: Check for wrong branch references
+ entry: poetry run nox -s fix-branch-references --
+ language: system
+ stages: [commit, merge-commit]
+ types: [text]
+# Enable hooks provided by the pre-commit project to
+# enforce rules that local tools could not that easily.
+- repo: https://github.com/pre-commit/pre-commit-hooks
+ rev: v3.2.0
+ hooks:
+ - id: check-added-large-files
+ args: [--maxkb=250]
+ - id: check-merge-conflict
+ - id: no-commit-to-branch
+ args: [--branch, main]
+ - id: trailing-whitespace
diff --git a/00_intro/00_content.ipynb b/00_intro/00_content.ipynb
new file mode 100644
index 0000000..0b6ba58
--- /dev/null
+++ b/00_intro/00_content.ipynb
@@ -0,0 +1,873 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ![](\"../static/link/to_mb.png\")
](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/00_intro/00_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# An Introduction to Python and Programming"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This book is a *thorough* introduction to programming in [Python ![](\"../static/link/to_py.png\")
](https://www.python.org/).\n",
+ "\n",
+ "It teaches the concepts behind and the syntax of the core Python language as defined by the [Python Software Foundation ](https://www.python.org/psf/) in the official [language reference ](https://docs.python.org/3/reference/index.html). Furthermore, it introduces commonly used functionalities from the [standard library ](https://docs.python.org/3/library/index.html) and popular third-party libraries like [numpy ](https://www.numpy.org/), [pandas ](https://pandas.pydata.org/), [matplotlib ](https://matplotlib.org/), and others."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "-"
+ }
+ },
+ "source": [
+ "![](\"static/logo.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "## Prerequisites"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "There are *no* prerequisites for reading this book."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Objective"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The **main goal** of this introduction is to **prepare** the student **for further studies** in the \"field\" of **data science**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "### Why data science?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The term **[data science ![](\"../static/link/to_wiki.png\")
](https://en.wikipedia.org/wiki/Data_science)** is rather vague and does *not* refer to an academic discipline. Instead, the term was popularized by the tech industry, who also coined non-meaningful job titles such as \"[rockstar](https://www.quora.com/Why-are-engineers-called-rockstars-and-ninjas)\" or \"[ninja developers](https://www.quora.com/Why-are-engineers-called-rockstars-and-ninjas).\" Most *serious* definitions describe the field as being **multi-disciplinary** *integrating* scientific methods, algorithms, and systems thinking to extract knowledge from structured and unstructured data, *and* also emphasize the importance of **[domain knowledge ](https://en.wikipedia.org/wiki/Domain_knowledge)**.\n",
+ "\n",
+ "Recently, this integration aspect feeds back into the academic world. The [MIT](https://www.mit.edu/), for example, created the new [Stephen A. Schwarzman College of Computing](http://computing.mit.edu) for [artificial intelligence ](https://en.wikipedia.org/wiki/Artificial_intelligence) with a 1 billion dollar initial investment where students undergo a \"bilingual\" curriculum with half the classes in quantitative and method-centric fields and the other half in domains such as biology, business, chemistry, politics, (art) history, or linguistics (cf., the [official Q&As](http://computing.mit.edu/faq/) or this [NYT article](https://www.nytimes.com/2018/10/15/technology/mit-college-artificial-intelligence.html)). Their strategists see a future where programming skills are just as naturally embedded into students' curricula as are nowadays subjects like calculus, statistics, or academic writing. Then, programming literacy is not just another \"nice to have\" skill but a prerequisite, or an enabler, to understanding more advanced topics in the actual domains studied."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "## Installation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To \"read\" this book in the most meaningful way, a working installation of **Python 3.8** with [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) is needed.\n",
+ "\n",
+ "For a tutorial on how to install Python on your computer, follow the instructions in the [README.md](https://github.com/webartifex/intro-to-python/blob/main/README.md#installation) file in the project's [GitHub repository ![](\"../static/link/to_gh.png\")
](https://github.com/webartifex/intro-to-python). If you cannot install Python on your own machine, you may open the book interactively in the cloud with [Binder ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Jupyter Notebooks"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The document you are viewing is a so-called [Jupyter notebook](https://jupyter-notebook.readthedocs.io/en/stable/notebook.html), a file format introduced by the [Jupyter Project](https://jupyter.org/).\n",
+ "\n",
+ "\"Jupyter\" is an [acronym ](https://en.wikipedia.org/wiki/Acronym) derived from the names of the three major programming languages **[Julia](https://julialang.org/)**, **[Python ](https://www.python.org)**, and **[R](https://www.r-project.org/)**, all of which play significant roles in the world of data science. The Jupyter Project's idea is to serve as an integrating platform such that different programming languages and software packages can be used together within the same project.\n",
+ "\n",
+ "Jupyter notebooks have become a de-facto standard for communicating and exchanging results in the data science community - both in academia and business - and provide an alternative to command-line interface (CLI or \"terminal\") based ways of running Python code. As an example for the latter case, we could start the default [Python interpreter ](https://docs.python.org/3/tutorial/interpreter.html) that comes with every installation by typing the `python` command into a CLI (or `poetry run python` if the project is managed with the [poetry](https://python-poetry.org/docs/) CLI tool as explained in the [README.md](https://github.com/webartifex/intro-to-python/blob/main/README.md#alternative-installation-for-instructors) file). Then, as the screenshot below shows, we could execute Python code like `1 + 2` or `print(\"Hello World\")` line by line simply by typing it following the `>>>` **prompt** and pressing the **Enter** key. For an introductory course, however, this would be rather tedious and probably scare off many beginners."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "![](\"static/cli_example.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "One reason for the popularity of Jupyter notebooks is that they allow mixing text with code in the same document. Text may be formatted with the [Markdown ](https://guides.github.com/features/mastering-markdown/) language and mathematical formulas typeset with [LaTeX](https://www.overleaf.com/learn/latex/Free_online_introduction_to_LaTeX_%28part_1%29). Moreover, we may include pictures, plots, and even videos. Because of these features, the notebooks developed for this book come in a self-contained \"tutorial\" style enabling students to simply read them from top to bottom while executing the code snippets.\n",
+ "\n",
+ "Other ways of running Python code are to use the [IPython ](https://ipython.org/) CLI tool instead of the default interpreter or a full-fledged [Integrated Development Environment ](https://en.wikipedia.org/wiki/Integrated_development_environment) (e.g., the commercial [PyCharm](https://www.jetbrains.com/pycharm/) or the free [Spyder ](https://github.com/spyder-ide/spyder) that comes with the Anaconda Distribution)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "### Markdown Cells vs. Code Cells"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A Jupyter notebook consists of cells that have a type associated with them. So far, only cells of type \"Markdown\" have been used, which is the default way to present formatted text.\n",
+ "\n",
+ "The cells below are examples of \"Code\" cells containing actual Python code: They calculate the sum of `1` and `2` and print out `\"Hello World\"` when executed, respectively. To edit an existing code cell, enter into it with a mouse click. You are \"in\" a code cell if its frame is highlighted in blue. We call that the **edit mode**.\n",
+ "\n",
+ "There is also a **command mode** that you reach by hitting the **Escape** key. That un-highlights the frame. You are now \"out\" of but still \"on\" the cell. If you were already in command mode, hitting the Escape key does *nothing*.\n",
+ "\n",
+ "Using the **Enter** and **Escape** keys, you can now switch between the two modes.\n",
+ "\n",
+ "To **execute**, or \"run,\" a code cell, hold down the **Control** key and press **Enter**. Note how you do *not* go to the subsequent cell if you keep re-executing the cell you are on. Alternatively, you can hold the **Shift** key and press **Enter**, which executes a cell *and* places your focus on the subsequent cell or creates a new one if there is none."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 + 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hello World\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Hello World\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Similarly, a Markdown cell is also in either edit or command mode. For example, double-click on the text you are reading: This puts you into edit mode. Now, you could change the formatting (e.g., print a word in *italics* or **bold**) and \"execute\" the cell to render the text as specified.\n",
+ "\n",
+ "To change a cell's type, choose either \"Code\" or \"Markdown\" in the navigation bar at the top. Alternatively, you can press either the **Y** or **M** key in command mode.\n",
+ "\n",
+ "Sometimes, a code cell starts with an exclamation mark `!`. Then, the Jupyter notebook behaves as if the following command were typed directly into a terminal. The cell below asks the `python` CLI to show its version number and is *not* Python code but a command in the [Shell ](https://en.wikipedia.org/wiki/Shell_%28computing%29) language. The `!` is useful to execute short CLI commands without leaving a Jupyter notebook."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Python 3.12.2\n"
+ ]
+ }
+ ],
+ "source": [
+ "!python --version"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "## Programming vs. Computer Science vs. IT"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In this book, **programming** is defined as\n",
+ "- a *structured* way of *problem-solving*\n",
+ "- by *expressing* the steps of a *computation* or *process*\n",
+ "- and thereby *documenting* the process in a formal way.\n",
+ "\n",
+ "Programming is always *concrete* and based on a *particular case*. It exhibits elements of an *art* or a *craft* as we hear programmers call code \"beautiful\" or \"ugly\" or talk about the \"expressive\" power of an application."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "That is different from **computer science**, which is\n",
+ "- a field of study comparable to applied *mathematics* that\n",
+ "- asks *abstract* questions (e.g., \"Is something computable at all?\"),\n",
+ "- develops and analyses *algorithms* and *data structures*,\n",
+ "- and *proves* the *correctness* of a program.\n",
+ "\n",
+ "In a sense, a computer scientist does not need to know a programming language to work, and many computer scientists only know how to produce \"ugly\" looking code in the eyes of professional programmers."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**IT** or **information technology** is a term that has many meanings to different people. Often, it has something to do with hardware or physical devices, both of which are out of scope for programmers and computer scientists. Sometimes, it refers to a [support function](https://en.wikipedia.org/wiki/Value_chain#Support_activities) within a company. Many computer scientists and programmers are more than happy if their printer and internet connection work as they often do not know a lot more about that than \"non-technical\" people."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "## Why Python?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "### What is Python?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Here is a brief history of and some background on Python (cf., also this [TechRepublic article](https://www.techrepublic.com/article/python-is-eating-the-world-how-one-developers-side-project-became-the-hottest-programming-language-on-the-planet/) for a more elaborate story):\n",
+ "\n",
+ "- [Guido van Rossum ](https://en.wikipedia.org/wiki/Guido_van_Rossum) (Python’s **[Benevolent Dictator for Life ](https://en.wikipedia.org/wiki/Benevolent_dictator_for_life)**) was bored during a week around Christmas 1989 and started Python as a hobby project \"that would keep \\[him\\] occupied\" for some days\n",
+ "- the idea was to create a **general-purpose** scripting **language** that would allow fast *prototyping* and would *run on every operating system*\n",
+ "- Python grew through the 90s as van Rossum promoted it via his \"Computer Programming for Everybody\" initiative that had the *goal to encourage a basic level of coding literacy* as an equal knowledge alongside English literacy and math skills\n",
+ "- to become more independent from its creator, the next major version **Python 2** - released in 2000 and still in heavy use as of today - was **open-source** from the get-go which attracted a *large and global community of programmers* that *contributed* their expertise and best practices in their free time to make Python even better\n",
+ "- **Python 3** resulted from a significant overhaul of the language in 2008 taking into account the *learnings from almost two decades*, streamlining the language, and getting ready for the age of **big data**\n",
+ "- the language is named after the sketch comedy group [Monty Python ](https://en.wikipedia.org/wiki/Monty_Python)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "#### Summary"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Python is a **general-purpose** programming **language** that allows for *fast development*, is *easy to read*, **open-source**, long-established, unifies the knowledge of *hundreds of thousands of experts* around the world, runs on basically every machine, and can handle the complexities of applications involving **big data**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "### Why open-source?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Couldn't a company like Google, Facebook, or Microsoft come up with a better programming language? The following is an argument on why this can likely not be the case.\n",
+ "\n",
+ "Wouldn't it be weird if professors and scholars of English literature and language studies dictated how we'd have to speak in day-to-day casual conversations or how authors of poesy and novels should use language constructs to achieve a particular type of mood? If you agree with that premise, it makes sense to assume that even programming languages should evolve in a \"natural\" way as users *use* the language over time and in *new* and *unpredictable* contexts creating new conventions."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Loose *communities* are the primary building block around which open-source software projects are built. Someone - like Guido - starts a project and makes it free to use for anybody (e.g., on a code-sharing platform like [GitHub ](https://github.com/)). People find it useful enough to solve one of their daily problems and start using it. They see how a project could be improved and provide new use cases (e.g., via the popularized concept of a [pull request ](https://help.github.com/articles/about-pull-requests/)). The project grows both in lines of code and people using it. After a while, people start local user groups to share their same interests and meet regularly (e.g., this is a big market for companies like [Meetup](https://www.meetup.com/) or non-profits like [PyData ](https://pydata.org/)). Out of these local and usually monthly meetups grow yearly conferences on the country or even continental level (e.g., the original [PyCon ](https://us.pycon.org/) in the US, [EuroPython ](https://europython.eu/), or [PyCon.DE ](https://de.pycon.org/)). The content presented at these conferences is made publicly available via GitHub and YouTube (e.g., [PyCon 2019 ](https://www.youtube.com/channel/UCxs2IIVXaEHHA4BtTiWZ2mQ) or [EuroPython ](http://europython.tv/)) and serves as references on what people are working on and introductions to the endless number of specialized fields."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While these communities are somewhat loose and continuously changing, smaller in-groups, often democratically organized and elected (e.g., the [Python Software Foundation ](https://www.python.org/psf/)), take care of, for example, the development of the \"core\" Python language itself.\n",
+ "\n",
+ "Python itself is just a specification (i.e., a set of rules) as to what is allowed and what not: It must first be implemented (c.f., next section below). The current version of Python can always be looked up in the [Python Language Reference ](https://docs.python.org/3/reference/index.html). To make changes to that, anyone can make a so-called **[Python Enhancement Proposal ](https://www.python.org/dev/peps/)**, or **PEP** for short, where it needs to be specified what exact changes are to be made and argued why that is a good thing to do. These PEPs are reviewed by the [core developers ](https://devguide.python.org/coredev/) and interested people and are then either accepted, modified, or rejected if, for example, the change introduces internal inconsistencies. This process is similar to the **double-blind peer review** established in academia, just a lot more transparent. Many of the contributors even held or hold positions in academia, one more indicator of the high quality standards in the Python community. To learn more about PEPs, check out [PEP 1 ](https://www.python.org/dev/peps/pep-0001/) that describes the entire process.\n",
+ "\n",
+ "In total, no one single entity can control how the language evolves, and the users' needs and ideas always feed back to the language specification via a quality controlled and \"democratic\" process."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Besides being **free** as in \"free beer,\" a major benefit of open-source is that one can always *look up how something works in detail*: That is the literal meaning of *open* source and a difference to commercial languages (e.g., [MATLAB](https://www.mathworks.com/products/matlab.html)) as a programmer can always continue to *study best practices* or find out how things are implemented. Along this way, many *errors are uncovered*, as well. Furthermore, if one runs an open-source application, one can be reasonably sure that no bad people built in a \"backdoor.\" [Free software ](https://en.wikipedia.org/wiki/Free_software) is consequently free of charge but brings *many other freedoms* with it, most notably the freedom to change the code."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "### Isn't C a lot faster?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The default Python implementation is written in the C language and called CPython. This is also what the Anaconda Distribution uses.\n",
+ "\n",
+ "[C ](https://en.wikipedia.org/wiki/C_%28programming_language%29) and [C++ ](https://en.wikipedia.org/wiki/C%2B%2B) (cf., this [introduction](https://www.learncpp.com/)) are wide-spread and long-established (i.e., since the 1970s) programming languages employed in many mission-critical software systems (e.g., operating systems themselves, low latency databases and web servers, nuclear reactor control systems, airplanes, ...). They are fast, mainly because the programmer not only needs to come up with the **business logic** but also manage the computer's memory.\n",
+ "\n",
+ "In contrast, Python automatically manages the memory for the programmer. So, speed here is a trade-off between application run time and engineering/development time. Often, the program's run time is not that important: For example, what if C needs 0.001 seconds in a case where Python needs 0.1 seconds to do the same thing? When the requirements change and computing speed becomes an issue, the Python community offers many third-party libraries - usually also written in C - where specific problems can be solved in near-C time."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "#### Summary"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While it is true that a language like C is a lot faster than Python when it comes to *pure* **computation time**, this does not matter in many cases as the *significantly shorter* **development cycles** are the more significant cost factor in a rapidly changing world."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Who uses it?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "-"
+ }
+ },
+ "source": [
+ "![](\"static/example_python_users.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While ad-hominem arguments are usually not the best kind of reasoning, we briefly look at some examples of who uses Python and leave it up to the reader to decide if this is convincing or not:\n",
+ "\n",
+ "- **[Massachusetts Institute of Technology](https://www.mit.edu/)**\n",
+ " - teaches Python in its [introductory course](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-0001-introduction-to-computer-science-and-programming-in-python-fall-2016/) to computer science independent of the student's major\n",
+ " - replaced the infamous course on the [Scheme](https://groups.csail.mit.edu/mac/projects/scheme/) language (cf., [source ![](\"../static/link/to_hn.png\")
](https://news.ycombinator.com/item?id=602307))\n",
+ "- **[Google](https://www.google.com/)**\n",
+ " - used the strategy \"Python where we can, C++ where we must\" from its early days on to stay flexible in a rapidly changing environment (cf., [source ![](\"../static/link/to_so.png\")
](https://stackoverflow.com/questions/2560310/heavy-usage-of-python-at-google))\n",
+ " - the very first web-crawler was written in Java and so difficult to maintain that it was rewritten in Python right away (cf., [source](https://www.amazon.com/Plex-Google-Thinks-Works-Shapes/dp/1416596585/ref=sr_1_1?ie=UTF8&qid=1539101827&sr=8-1&keywords=in+the+plex))\n",
+ " - Guido van Rossom was hired by Google from 2005 to 2012 to advance the language there\n",
+ "- **[NASA](https://www.nasa.gov/)** open-sources many of its projects, often written in Python and regarding analyses with big data (cf., [source](https://code.nasa.gov/language/python/))\n",
+ "- **[Facebook](https://facebook.com/)** uses Python besides C++ and its legacy PHP (a language for building websites; the \"cool kid\" from the early 2000s)\n",
+ "- **[Instagram](https://instagram.com/)** operates the largest installation of the popular **web framework [Django](https://www.djangoproject.com/)** (cf., [source](https://instagram-engineering.com/web-service-efficiency-at-instagram-with-python-4976d078e366))\n",
+ "- **[Spotify](https://spotify.com/)** bases its data science on Python (cf., [source](https://labs.spotify.com/2013/03/20/how-we-use-python-at-spotify/))\n",
+ "- **[Netflix](https://netflix.com/)** also runs its predictive models on Python (cf., [source](https://medium.com/netflix-techblog/python-at-netflix-86b6028b3b3e))\n",
+ "- **[Dropbox](https://dropbox.com/)** \"stole\" Guido van Rossom from Google to help scale the platform (cf., [source](https://medium.com/dropbox-makers/guido-van-rossum-on-finding-his-way-e018e8b5f6b1))\n",
+ "- **[JPMorgan Chase](https://www.jpmorganchase.com/)** requires new employees to learn Python as part of the onboarding process starting with the 2018 intake (cf., [source](https://www.ft.com/content/4c17d6ce-c8b2-11e8-ba8f-ee390057b8c9?segmentId=a7371401-027d-d8bf-8a7f-2a746e767d56))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As images tell more than words, here are two plots of popular languages' \"market shares\" based on the number of questions asked on [Stack Overflow ](https://stackoverflow.blog/2017/09/06/incredible-growth-python/), the most relevant platform for answering programming-related questions: As of late 2017, Python surpassed [Java](https://www.java.com/en/), heavily used in big corporates, and [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript), the \"language of the internet\" that does everything in web browsers, in popularity. Two blog posts from \"technical\" people explain this in more depth to the layman: [Stack Overflow ](https://stackoverflow.blog/2017/09/14/python-growing-quickly/) and [DataCamp](https://www.datacamp.com/community/blog/python-scientific-computing-case)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "![](\"static/growth_of_major_programming_languages.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As the graph below shows, neither Google's very own language **[Go](https://golang.org/)** nor **[R](https://www.r-project.org/)**, a domain-specific language in the niche of statistics, can compete with Python's year-to-year growth."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "![](\"static/growth_of_smaller_programming_languages.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[IEEE Sprectrum](https://spectrum.ieee.org/computing/software/the-top-programming-languages-2019) provides a more recent comparison of programming language's popularity. Even news and media outlets notice the recent popularity of Python: [Economist](https://www.economist.com/graphic-detail/2018/07/26/python-is-becoming-the-worlds-most-popular-coding-language), [Huffington Post](https://www.huffingtonpost.com/entry/why-python-is-the-best-programming-language-with-which_us_59ef8f62e4b04809c05011b9), [TechRepublic](https://www.techrepublic.com/article/why-python-is-so-popular-with-developers-3-reasons-the-language-has-exploded/), and [QZ](https://qz.com/1408660/the-rise-of-python-as-seen-through-a-decade-of-stack-overflow/)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## How to learn Programming"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "### ABC Rule"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**A**lways **b**e **c**oding.\n",
+ "\n",
+ "Programming is more than just writing code into a text file. It means reading through parts of the [documentation ](https://docs.python.org/), blogs with best practices, and tutorials, or researching problems on [Stack Overflow ](https://stackoverflow.com/) while trying to implement features in the application at hand. Also, it means using command-line tools to automate some part of the work or manage different versions of a program, for example, with **[git](https://git-scm.com/)**. In short, programming involves a lot of \"muscle memory,\" which can only be built and kept up through near-daily usage.\n",
+ "\n",
+ "Further, many aspects of software architecture and best practices can only be understood after having implemented some requirements for the very first time. Coding also means \"breaking\" things to find out what makes them work in the first place.\n",
+ "\n",
+ "Therefore, coding is learned best by just doing it for some time on a daily or at least a regular basis and not right before some task is due, just like learning a \"real\" language."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "### The Maker's Schedule"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[Y Combinator ](https://www.ycombinator.com/) co-founder [Paul Graham ](https://en.wikipedia.org/wiki/Paul_Graham_%28programmer%29) wrote a very popular and often cited [article](http://www.paulgraham.com/makersschedule.html) where he divides every person into belonging to one of two groups:\n",
+ "\n",
+ "- **Managers**: People that need to organize things and command others (e.g., a \"boss\" or manager). Their schedule is usually organized by the hour or even 30-minute intervals.\n",
+ "- **Makers**: People that create things (e.g., programmers, artists, or writers). Such people think in half days or full days.\n",
+ "\n",
+ "Have you ever wondered why so many tech people work during nights and sleep at \"weird\" times? The reason is that many programming-related tasks require a \"flow\" state in one's mind that is hard to achieve when one can get interrupted, even if it is only for one short question. Graham describes that only knowing that one has an appointment in three hours can cause a programmer to not get into a flow state.\n",
+ "\n",
+ "As a result, do not set aside a certain amount of time for learning something but rather plan in an *entire evening* or a *rainy Sunday* where you can work on a problem in an *open end* setting. And do not be surprised anymore to hear \"I looked at it over the weekend\" from a programmer."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "### Phase Iteration"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When being asked the above question, most programmers answer something that can be classified into one of two broader groups.\n",
+ "\n",
+ "**1) Toy Problem, Case Study, or Prototype**: Pick some problem, break it down into smaller sub-problems, and solve them with an end in mind.\n",
+ "\n",
+ "**2) Books, Video Tutorials, and Courses**: Research the best book, blog, video, or tutorial for something and work it through from start to end.\n",
+ "\n",
+ "The truth is that you need to iterate between these two phases.\n",
+ "\n",
+ "Building a prototype always reveals issues no book or tutorial can think of before. Data is never as clean as it should be. An algorithm from a textbook must be adapted to a peculiar aspect of a case study. It is essential to learn to \"ship a product\" because only then will one have looked at all the aspects.\n",
+ "\n",
+ "The major downside of this approach is that one likely learns bad \"patterns\" overfitted to the case at hand, and one does not get the big picture or mental concepts behind a solution. This gap can be filled in by well-written books: For example, check the Python/programming books offered by [Packt](https://www.packtpub.com/packt/offers/free-learning/) or [O’Reilly](https://www.oreilly.com/)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "## Contents"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Part A: Expressing Logic**\n",
+ "\n",
+ "- What is a programming language? What kind of words exist?\n",
+ " - *Chapter 1*: [Elements of a Program ![](\"../static/link/to_nb.png\")
](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb)\n",
+ " - *Chapter 2*: [Functions & Modularization ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/00_content.ipynb)\n",
+ "- What is the flow of execution? How can we form sentences from words?\n",
+ " - *Chapter 3*: [Conditionals & Exceptions ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/03_conditionals/00_content.ipynb)\n",
+ " - *Chapter 4*: [Recursion & Looping ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/00_content.ipynb)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Part B: Managing Data and Memory**\n",
+ "\n",
+ "- How is data stored in memory?\n",
+ " - *Chapter 5*: [Numbers & Bits ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/00_content.ipynb)\n",
+ " - *Chapter 6*: [Text & Bytes ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/00_content.ipynb)\n",
+ " - *Chapter 7*: [Sequential Data ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/00_content.ipynb)\n",
+ " - *Chapter 8*: [Map, Filter, & Reduce ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/08_mfr/00_content.ipynb)\n",
+ " - *Chapter 9*: [Mappings & Sets ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/09_mappings/00_content.ipynb)\n",
+ " - *Chapter 10*: Arrays & Dataframes\n",
+ "- How can we create custom data types?\n",
+ " - *Chapter 11*: [Classes & Instances ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/00_content.ipynb)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "## xkcd Comic"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As with every good book, there has to be a [xkcd](https://xkcd.com/353/) comic somewhere."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import antigravity"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "![](\"static/xkcd.png\")
"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/00_intro/01_exercises_markdown.ipynb b/00_intro/01_exercises_markdown.ipynb
new file mode 100644
index 0000000..d80f9d8
--- /dev/null
+++ b/00_intro/01_exercises_markdown.ipynb
@@ -0,0 +1,115 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Run All*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *after* finishing the exercises to ensure that your solution runs top to bottom *without* any errors. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/00_intro/02_exercises.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 0: Introduction (Coding Exercises)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The exercises below assume that you have read [Chapter 0 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/00_intro/00_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Mastering Markdown"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Briefly review GitHub's guide on [Mastering Markdown](https://guides.github.com/features/mastering-markdown/) and create nicely formatted \"text\" cells below!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: Check the latest [Bundesliga standings](https://www.bundesliga.com/en/bundesliga/table) and provide a table of the top three teams with the following four columns: rank, team name, games played, and points scored. Render the rank in **bold**, make the team name a clickable link (to the team's website), and put both the games played and points scored in *italics*. The header row should be visually different from the three rows with the teams' information."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: The quote \"Education is what remains after one has forgotten what one has learned in school\" is attributed to Albert Einstein. Display the author and his quote appropriately!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: Integrate the image of the delicious dessert milk rice at this [URL](https://i.ytimg.com/vi/-BoSRlzy9c4/maxresdefault.jpg) into this notebook."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/00_intro/02_review.ipynb b/00_intro/02_review.ipynb
new file mode 100644
index 0000000..bf3a39a
--- /dev/null
+++ b/00_intro/02_review.ipynb
@@ -0,0 +1,215 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 0: Introduction (Review Questions)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The questions below assume that you have read [Chapter 0 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/00_intro/00_content.ipynb).\n",
+ "\n",
+ "Be concise in your answers! Most questions can be answered in *one* sentence."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Essay Questions "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: Describe the difference between the terms **programming** and **computer science**!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: Explain what is a **pull request** and elaborate on how this concept fits a *distributed* organization of work!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: In what sense are **open-source** communities democracies? How are they near-perfect [meritocracies ](https://en.wikipedia.org/wiki/Meritocracy)? How is open-source software development similar to academia?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: What is a *significant* advantage of a \"slow\" programming language like Python over a faster one like C?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## True / False Questions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Motivate your answer with *one short* sentence!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: Python has been the fastest-growing *major* programming language in recent years."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: Python is named after a snake to emphasize its agility and fast development speed right in its name."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7**: Python was initially designed for highly intensive numerical computing, in particular for use cases from physics and astronomy."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q8**: JavaScript is a subset of the Java language."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q9**: Python is **free software**. That means it does not cost anything."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q10**: The primary purpose of PEPs is to regulate how code should be documented and styled."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/00_intro/static/cli_example.png b/00_intro/static/cli_example.png
new file mode 100644
index 0000000..0e40e04
Binary files /dev/null and b/00_intro/static/cli_example.png differ
diff --git a/00_intro/static/example_python_users.png b/00_intro/static/example_python_users.png
new file mode 100644
index 0000000..b123bfb
Binary files /dev/null and b/00_intro/static/example_python_users.png differ
diff --git a/00_intro/static/growth_of_major_programming_languages.png b/00_intro/static/growth_of_major_programming_languages.png
new file mode 100644
index 0000000..acfdfbb
Binary files /dev/null and b/00_intro/static/growth_of_major_programming_languages.png differ
diff --git a/00_intro/static/growth_of_smaller_programming_languages.png b/00_intro/static/growth_of_smaller_programming_languages.png
new file mode 100644
index 0000000..51123f2
Binary files /dev/null and b/00_intro/static/growth_of_smaller_programming_languages.png differ
diff --git a/00_intro/static/logo.png b/00_intro/static/logo.png
new file mode 100644
index 0000000..b3b5b22
Binary files /dev/null and b/00_intro/static/logo.png differ
diff --git a/00_intro/static/xkcd.png b/00_intro/static/xkcd.png
new file mode 100644
index 0000000..23a4c6e
Binary files /dev/null and b/00_intro/static/xkcd.png differ
diff --git a/01_elements/00_content.ipynb b/01_elements/00_content.ipynb
new file mode 100644
index 0000000..af2d022
--- /dev/null
+++ b/01_elements/00_content.ipynb
@@ -0,0 +1,2188 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/01_elements/00_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 1: Elements of a Program"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Do you remember how you first learned to speak in your mother tongue? Probably not. No one's memory goes back that far. Your earliest memory as a child should probably be around the age of three or four years old when you could already say simple things and interact with your environment. Although you did not know any grammar rules yet, other people just understood what you said. At least most of the time.\n",
+ "\n",
+ "It is intuitively best to take the very mindset of a small child when learning a new language. And a programming language is no different from that. This first chapter introduces simplistic examples and we accept them as they are *without* knowing any of the \"grammar\" rules yet. Then, we analyze them in parts and slowly build up our understanding.\n",
+ "\n",
+ "Consequently, if parts of this chapter do not make sense right away, let's not worry too much. Besides introducing the basic elements, it also serves as an outlook for what is to come. So, many terms and concepts used here are deconstructed in great detail in the following chapters."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Example: Averaging all even Numbers in a List"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As our introductory example, we want to calculate the *average* of all *evens* in a **list** of whole numbers: `[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]`.\n",
+ "\n",
+ "While we are used to finding an [analytical solution](https://math.stackexchange.com/questions/935405/what-s-the-difference-between-analytical-and-numerical-approaches-to-problems/935446#935446) in math (i.e., derive some equation with \"pen and paper\"), we solve this task *programmatically* instead.\n",
+ "\n",
+ "We start by creating a list called `numbers` that holds all the individual numbers between **brackets** `[` and `]`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "numbers = [7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To verify that something happened in our computer's memory, we **reference** `numbers`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "So far, so good. Let's see how the desired **computation** could be expressed as a **sequence of instructions** in the next code cell.\n",
+ "\n",
+ "Intuitively, the line `for number in numbers` describes a \"loop\" over all the numbers in the `numbers` list, one at a time.\n",
+ "\n",
+ "The `if number % 2 == 0` may look confusing at first sight. Both `%` and `==` must have an unintuitive meaning here. Luckily, the **comment** in the same line after the `#` symbol has the answer: The program does something only for an even `number`.\n",
+ "\n",
+ "In particular, it increases `count` by `1` and adds the current `number` onto the [running ](https://en.wikipedia.org/wiki/Running_total) `total`. Both `count` and `number` are **initialized** to `0` and the single `=` symbol reads as \"... is *set* equal to ...\". It cannot indicate a mathematical equation as, for example, `count` is generally *not* equal to `count + 1`.\n",
+ "\n",
+ "Lastly, the `average` is calculated as the ratio of the final **values** of `total` and `count`. Overall, we divide the sum of all even numbers by their count: This is nothing but the definition of an average.\n",
+ "\n",
+ "The lines of code \"within\" the `for` and `if` **statements** are **indented** and aligned with multiples of *four spaces*: This shows immediately how the lines relate to each other."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "count = 0 # initialize variables to keep track of the\n",
+ "total = 0 # running total and the count of even numbers\n",
+ "\n",
+ "for number in numbers:\n",
+ " if number % 2 == 0: # only work with even numbers\n",
+ " count = count + 1\n",
+ " total = total + number\n",
+ "\n",
+ "average = total / count"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We do not see any **output** yet but obtain the value of `average` by referencing it again."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Output in a Jupyter Notebook"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Only two of the previous four code cells generate an **output** while two remained \"silent\" (i.e., nothing appears below the cell after running it).\n",
+ "\n",
+ "By default, Jupyter notebooks only show the value of the **expression** in the last line of a code cell. And, this output may also be suppressed by ending the last line with a semicolon `;`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'I am feeling great :-)'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Hello, World!\"\n",
+ "\"I am feeling great :-)\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "\"I am invisible!\";"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To see any output other than that, we use the built-in [print() ](https://docs.python.org/3/library/functions.html#print) **function**. Here, the parentheses `()` indicate that we **call** (i.e., \"execute\") code written somewhere else."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hello, World!\n",
+ "I am feeling great :-)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Hello, World!\")\n",
+ "print(\"I am feeling great :-)\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Outside Jupyter notebooks, the semicolon `;` is used as a **separator** between statements that must otherwise be on a line on their own. However, it is *not* considered good practice to use it as it makes code less readable."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hello, World!\n",
+ "I am feeling great :-)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Hello, World!\"); print(\"I am feeling great :-)\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## (Arithmetic) Operators"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Python comes with many built-in **[operators ](https://docs.python.org/3/reference/lexical_analysis.html#operators)**: They are **tokens** (i.e., \"symbols\") that have a special meaning to the Python interpreter.\n",
+ "\n",
+ "The arithmetic operators either \"operate\" with the number immediately following them, so-called **unary** operators (e.g., negation), or \"process\" the two numbers \"around\" them, so-called **binary** operators (e.g., addition).\n",
+ "\n",
+ "By definition, operators on their own have *no* permanent **side effects** in the computer's memory. Although the code cells in this section do indeed create *new* numbers in memory (e.g., `77 + 13` creates `90`), they are immediately \"forgotten\" as they are not stored in a **variable** like `numbers` or `average` above. We develop this thought further in the second part of this chapter when we compare **expressions** with **statements**.\n",
+ "\n",
+ "Let's see some examples of operators. We start with the binary `+` and the `-` operators for addition and subtraction. Binary operators mimic what mathematicians call [infix notation ](https://en.wikipedia.org/wiki/Infix_notation) and have the expected meaning."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "90"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "77 + 13"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "8"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "101 - 93"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `-` operator may be used as a unary operator as well. Then, it unsurprisingly flips the sign of a number."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-1"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "-1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When we compare the output of the `*` and `/` operators for multiplication and division, we note the subtle *difference* between the `42` and the `42.0`: They are the *same* number represented as a *different* **data type**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "2 * 21"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42.0"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "84 / 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The so-called **floor division operator** `//` always \"rounds\" to an integer and is thus also called **integer division operator**. It is an example of an arithmetic operator we commonly do not know from high school mathematics."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "84 // 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "85 // 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Even though it appears that the `//` operator **truncates** (i.e., \"cuts off\") the decimals so as to effectively round down (i.e., the `42.5` became `42` in the previous code cell), this is *not* the case: The result is always \"rounded\" towards minus infinity!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-43"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "-85 // 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To obtain the remainder of a division, we use the **modulo operator** `%`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "85 % 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The remainder is `0` *only if* a number is *divisible* by another.\n",
+ "\n",
+ "A popular convention in both computer science and mathematics is to abbreviate \"only if\" as \"iff\", which is short for \"**[if and only if ](https://en.wikipedia.org/wiki/If_and_only_if)**.\" The iff means that a remainder of `0` implies that a number is divisible by another but also that a number's being divisible by another implies a remainder of `0`. The implication goes in *both* directions!\n",
+ "\n",
+ "So, `49` is divisible by `7`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "49 % 7"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Modulo division is also useful if we want to extract the last couple of digits in a large integer."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "9"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "789 % 10"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "89"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "789 % 100"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The built-in [divmod() ](https://docs.python.org/3/library/functions.html#divmod) function combines the integer and modulo divisions into one step. However, grammatically this is *not* an operator but a function. Also, [divmod() ](https://docs.python.org/3/library/functions.html#divmod) returns a \"pair\" of integers and not a single one."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(4, 2)"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "divmod(42, 10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Raising a number to a power is performed with the **exponentiation operator** `**`. It is different from the `^` operator other programming languages may use and that also exists in Python with a *different* meaning."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "8"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "2 ** 3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The standard [order of precedence ](https://docs.python.org/3/reference/expressions.html#operator-precedence) from mathematics applies (i.e., [PEMDAS](http://mathworld.wolfram.com/PEMDAS.html) rule) when several operators are combined."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "18"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "3 ** 2 * 2 "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Parentheses help avoid confusion and take the role of a **delimiter** here."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "18"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(3 ** 2) * 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "81"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "3 ** (2 * 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Some programmers also use \"style\" conventions. For example, we might play with the **whitespace**, which is an umbrella term that refers to any non-printable sign like spaces, tabs, or the like. However, this is *not* a good practice and parentheses convey a much clearer picture."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "18"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "3**2 * 2 # bad style; it is better to use parentheses here"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "There exist many non-mathematical operators that are introduced throughout this book, together with the concepts they implement. They often come in a form different from the unary and binary ones mentioned above."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Operator Overloading"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Python **overloads** certain operators. For example, you may not only \"add\" numbers but also text: This is called **concatenation**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "greeting = \"Hi \"\n",
+ "audience = \"class\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Hi class'"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "greeting + audience"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Multiplying text with a whole number also works."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Hi Hi Hi Hi Hi Hi Hi Hi Hi Hi '"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "10 * greeting"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Objects vs. Types vs. Values"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Python is a so-called **object-oriented** language, which is a paradigm of organizing a program's memory.\n",
+ "\n",
+ "An **object** may be viewed as a \"bag\" of $0$s and $1$s in a given memory location. The $0$s and $1$s in a bag make up the object's **value**. There exist different **types** of bags, and each type comes with its own rules how the $0$s and $1$s are interpreted and may be worked with.\n",
+ "\n",
+ "So, an object *always* has *three* main characteristics. Let's look at the following examples and work them out."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "a = 42\n",
+ "b = 42.0\n",
+ "c = \"Python rocks\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Identity / \"Memory Location\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The built-in [id() ](https://docs.python.org/3/library/functions.html#id) function shows an object's \"address\" in memory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "94371758832672"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(a)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140673826512720"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(b)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140673817995952"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "These addresses are *not* meaningful for anything other than checking if two variables reference the *same* object.\n",
+ "\n",
+ "Obviously, `a` and `b` have the same *value* as revealed by the **equality operator** `==`: We say `a` and `b` \"evaluate equal.\" The resulting `True` - and the `False` further below - is yet another data type, a so-called **boolean**. We look into them in [Chapter 3 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/03_conditionals/00_content.ipynb#Boolean-Expressions)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a == b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "On the contrary, `a` and `b` are *different* objects as the **identity operator** `is` shows: They are stored at *different* addresses in the memory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 35,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a is b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If we want to check the opposite case, we use the negated version of the `is` operator, namely `is not`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a is not b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### (Data) Type / \"Behavior\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [type() ](https://docs.python.org/3/library/functions.html#type) built-in shows an object's type. For example, `a` is an integer (i.e., `int`) while `b` is a so-called [floating-point number ](https://en.wikipedia.org/wiki/Floating-point_arithmetic) (i.e., `float`)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "int"
+ ]
+ },
+ "execution_count": 37,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(a)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "float"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Different types imply different behaviors for the objects. The `b` object, for example, may be \"asked\" if it is a whole number with the [.is_integer() ](https://docs.python.org/3/library/stdtypes.html#float.is_integer) \"functionality\" that comes with *every* `float` object.\n",
+ "\n",
+ "Formally, we call such type-specific functionalities **methods** (i.e., as opposed to functions) and we look at them in detail in [Chapter 11 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/00_content.ipynb). For now, it suffices to know that we access them with the **dot operator** `.` on the object. Of course, `b` is a whole number, which the boolean object `True` tells us."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 39,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "b.is_integer()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For an `int` object, this [.is_integer() ](https://docs.python.org/3/library/stdtypes.html#float.is_integer) check does *not* make sense as we already know it is an `int`: We see the `AttributeError` below as `a` does not even know what `is_integer()` means."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "AttributeError",
+ "evalue": "'int' object has no attribute 'is_integer'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+ "\u001b[0;31mAttributeError\u001b[0m: 'int' object has no attribute 'is_integer'"
+ ]
+ }
+ ],
+ "source": [
+ "a.is_integer()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `c` object is a so-called **string** type (i.e., `str`), which is Python's way of representing text. Strings also come with peculiar behaviors, for example, to make a text lower or upper case."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "str"
+ ]
+ },
+ "execution_count": 41,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(c)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'python rocks'"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "c.lower()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'PYTHON ROCKS'"
+ ]
+ },
+ "execution_count": 43,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "c.upper()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Value / (Semantic) \"Meaning\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Almost trivially, every object also has a value to which it **evaluates** when referenced. We think of the value as the **conceptual idea** of what the $0$s and $1$s in the bag mean to *humans*. In other words, an object's value regards its *semantic* meaning.\n",
+ "\n",
+ "For built-in data types, Python prints out an object's value as a so-called **[literal ](https://docs.python.org/3/reference/lexical_analysis.html#literals)**: This means that we may copy and paste the value back into a code cell and create a *new* object with the *same* value."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 44,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42.0"
+ ]
+ },
+ "execution_count": 45,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In this book, we follow the convention of creating strings with **double quotes** `\"` instead of the **single quotes** `'` to which Python defaults in its *literal* notation for `str` objects. Both types of quotes may be used interchangeably. So, the `\"Python rocks\"` from above and `'Python rocks'` below create two objects that evaluate equal (i.e., `\"Python rocks\" == 'Python rocks'`)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Python rocks'"
+ ]
+ },
+ "execution_count": 46,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "c"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Formal vs. Natural Languages"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Just like the language of mathematics is good at expressing relationships among numbers and symbols, any programming language is just a formal language that is good at expressing computations.\n",
+ "\n",
+ "Formal languages come with their own \"grammatical rules\" called **syntax**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Syntax Errors"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If we do not follow the rules, the code cannot be **parsed** correctly, i.e., the program does not even start to run but **raises** a **syntax error** indicated as `SyntaxError` in the output. Computers are very dumb in the sense that the slightest syntax error leads to the machine not understanding our code.\n",
+ "\n",
+ "If we were to write an accounting program that adds up currencies, we would, for example, have to model dollar prices as `float` objects as the dollar symbol cannot be understood by Python."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "invalid syntax (73631267.py, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m Cell \u001b[0;32mIn[47], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m 3.99 $ + 10.40 $\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
+ ]
+ }
+ ],
+ "source": [
+ "3.99 $ + 10.40 $"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Python requires certain symbols at certain places (e.g., a `:` is missing here)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "expected ':' (2545637715.py, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m Cell \u001b[0;32mIn[48], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m for number in numbers\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m expected ':'\n"
+ ]
+ }
+ ],
+ "source": [
+ "for number in numbers\n",
+ " print(number)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Furthermore, it relies on whitespace (i.e., indentation), unlike many other programming languages. The `IndentationError` below is just a particular type of a `SyntaxError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "IndentationError",
+ "evalue": "expected an indented block after 'for' statement on line 1 (1544118965.py, line 2)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m Cell \u001b[0;32mIn[49], line 2\u001b[0;36m\u001b[0m\n\u001b[0;31m print(number)\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block after 'for' statement on line 1\n"
+ ]
+ }
+ ],
+ "source": [
+ "for number in numbers:\n",
+ "print(number)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Runtime Errors"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Syntax errors are easy to find as the code does *not* even run in the first place.\n",
+ "\n",
+ "However, there are also so-called **runtime errors** that occur whenever otherwise (i.e., syntactically) correct code does not run because of invalid input. Runtime errors are also often referred to as **exceptions**.\n",
+ "\n",
+ "This example does not work because just like in the \"real\" world, Python does not know how to divide by `0`. The syntactically correct code leads to a `ZeroDivisionError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "ZeroDivisionError",
+ "evalue": "division by zero",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mZeroDivisionError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[50], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;241;43m1\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\n",
+ "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
+ ]
+ }
+ ],
+ "source": [
+ "1 / 0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Semantic Errors"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "So-called **semantic errors**, on the contrary, are hard to spot as they do *not* crash the program. The only way to find such errors is to run a program with test input for which we can predict the output. However, testing software is a whole discipline on its own and often very hard to do in practice.\n",
+ "\n",
+ "The cell below copies our first example from above with a \"tiny\" error. How fast could you have spotted it without the comment?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "code_folding": [],
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "count = 0\n",
+ "total = 0\n",
+ "\n",
+ "for number in numbers:\n",
+ " if number % 2 == 0:\n",
+ " count = count + 1\n",
+ " total = total + count # count is wrong here, it should be number\n",
+ "\n",
+ "average = total / count"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3.5"
+ ]
+ },
+ "execution_count": 52,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Systematically finding errors is called **debugging**. For the history of the term, see this [article ](https://en.wikipedia.org/wiki/Debugging)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Best Practices"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Thus, adhering to just syntax rules is *never* enough. Over time, **best practices** and **style guides** were created to make it less likely for a developer to mess up a program and also to allow \"onboarding\" him as a contributor to an established code base, often called **legacy code**, faster. These rules are *not* enforced by Python itself: Badly styled code still runs. At the very least, Python programs should be styled according to [PEP 8 ](https://www.python.org/dev/peps/pep-0008/) and documented \"inline\" (i.e., in the code itself) according to [PEP 257 ](https://www.python.org/dev/peps/pep-0257/).\n",
+ "\n",
+ "An easier to read version of PEP 8 is [here](https://pep8.org/). The video below features a well known **[Pythonista](https://en.wiktionary.org/wiki/Pythonista)** talking about the importance of code style."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 53,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from IPython.display import YouTubeVideo\n",
+ "YouTubeVideo(\"Hwckt4J96dI\", width=\"60%\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For example, while the above code to calculate the average of the even numbers in `[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]` is correct, a Pythonista would rewrite it in a more \"Pythonic\" way and use the built-in [sum() ](https://docs.python.org/3/library/functions.html#sum) and [len() ](https://docs.python.org/3/library/functions.html#len) functions (cf., [Chapter 2 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/00_content.ipynb#Built-in-Functions)) as well as a so-called **list comprehension** (cf., [Chapter 8 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/08_mfr/00_content.ipynb#List-Comprehensions)). Pythonic code runs faster in many cases and is less error-prone."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "numbers = [7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "evens = [n for n in numbers if n % 2 == 0] # use of a list comprehension"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[8, 12, 2, 6, 10, 4]"
+ ]
+ },
+ "execution_count": 56,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "evens"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "average = sum(evens) / len(evens) # use built-in functions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 58,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To get a rough overview of the mindset of a typical Python programmer, look at these rules, also known as the **Zen of Python**, that are deemed so important that they are included in every Python installation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The Zen of Python, by Tim Peters\n",
+ "\n",
+ "Beautiful is better than ugly.\n",
+ "Explicit is better than implicit.\n",
+ "Simple is better than complex.\n",
+ "Complex is better than complicated.\n",
+ "Flat is better than nested.\n",
+ "Sparse is better than dense.\n",
+ "Readability counts.\n",
+ "Special cases aren't special enough to break the rules.\n",
+ "Although practicality beats purity.\n",
+ "Errors should never pass silently.\n",
+ "Unless explicitly silenced.\n",
+ "In the face of ambiguity, refuse the temptation to guess.\n",
+ "There should be one-- and preferably only one --obvious way to do it.\n",
+ "Although that way may not be obvious at first unless you're Dutch.\n",
+ "Now is better than never.\n",
+ "Although never is often better than *right* now.\n",
+ "If the implementation is hard to explain, it's a bad idea.\n",
+ "If the implementation is easy to explain, it may be a good idea.\n",
+ "Namespaces are one honking great idea -- let's do more of those!\n"
+ ]
+ }
+ ],
+ "source": [
+ "import this"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "### Jupyter Notebook Aspects"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "#### The Order of Code Cells is arbitrary"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We can run the code cells in a Jupyter notebook in *any* arbitrary order.\n",
+ "\n",
+ "That means, for example, that a variable defined towards the bottom could accidentally be referenced at the top of the notebook. This happens quickly when we iteratively built a program and go back and forth between cells.\n",
+ "\n",
+ "As a good practice, it is recommended to click on \"Kernel\" > \"Restart Kernel and Run All Cells\" in the navigation bar once a notebook is finished. That restarts the Python process forgetting all **state** (i.e., all variables) and ensures that the notebook runs top to bottom without any errors the next time it is opened."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "#### Notebooks are linear"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While this book is built with Jupyter notebooks, it is crucial to understand that \"real\" programs are almost never \"linear\" (i.e., top to bottom) sequences of instructions but instead may take many different **flows of execution**.\n",
+ "\n",
+ "At the same time, for a beginner's course, it is often easier to code linearly.\n",
+ "\n",
+ "In real data science projects, one would probably employ a mixed approach and put reusable code into so-called Python modules (i.e., *.py* files; cf., [Chapter 2 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/00_content.ipynb#Local-Modules-and-Packages)) and then use Jupyter notebooks to build up a linear report or storyline for an analysis."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "303.333px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/01_elements/01_exercises_print.ipynb b/01_elements/01_exercises_print.ipynb
new file mode 100644
index 0000000..68432ee
--- /dev/null
+++ b/01_elements/01_exercises_print.ipynb
@@ -0,0 +1,172 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Run All*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *after* finishing the exercises to ensure that your solution runs top to bottom *without* any errors. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/01_elements/01_exercises.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 1: Elements of a Program (Coding Exercises)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The exercises below assume that you have read the [first part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb) of Chapter 1.\n",
+ "\n",
+ "The `...`'s in the code cells indicate where you need to fill in code snippets. The number of `...`'s within a code cell give you a rough idea of how many lines of code are needed to solve the task. You should not need to create any additional code cells for your final solution. However, you may want to use temporary code cells to try out some ideas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Printing Output"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: *Concatenate* `greeting` and `audience` below with the `+` operator and print out the resulting message `\"Hello World\"` with only *one* call of the built-in [print() ](https://docs.python.org/3/library/functions.html#print) function!\n",
+ "\n",
+ "Hint: You may have to \"add\" a space character in between `greeting` and `audience`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "greeting = \"Hello\"\n",
+ "audience = \"World\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(...)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: How is your answer to **Q1** an example of the concept of **operator overloading**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: Read the documentation on the built-in [print() ](https://docs.python.org/3/library/functions.html#print) function! How can you print the above message *without* concatenating `greeting` and `audience` first in *one* call of [print() ](https://docs.python.org/3/library/functions.html#print)?\n",
+ "\n",
+ "Hint: The `*objects` in the documentation implies that we can put several *expressions* (i.e., variables) separated by commas within the same call of the [print() ](https://docs.python.org/3/library/functions.html#print) function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(...)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: What does the `sep=\" \"` mean in the documentation on the built-in [print() ](https://docs.python.org/3/library/functions.html#print) function? Adjust and use it to print out the three names referenced by `first`, `second`, and `third` on *one* line separated by *commas* with only *one* call of the [print() ](https://docs.python.org/3/library/functions.html#print) function!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "first = \"Anthony\"\n",
+ "second = \"Berta\"\n",
+ "third = \"Christian\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(...)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: Lastly, what does the `end=\"\\n\"` mean in the documentation? Adjust and use it within the `for`-loop to print the numbers `1` through `10` on *one* line with only *one* call of the [print() ](https://docs.python.org/3/library/functions.html#print) function!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for number in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:\n",
+ " print(...)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/01_elements/02_exercises_for-loops.ipynb b/01_elements/02_exercises_for-loops.ipynb
new file mode 100644
index 0000000..fab3299
--- /dev/null
+++ b/01_elements/02_exercises_for-loops.ipynb
@@ -0,0 +1,218 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Run All*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *after* finishing the exercises to ensure that your solution runs top to bottom *without* any errors. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/01_elements/02_exercises.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 1: Elements of a Program (Coding Exercises)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The exercises below assume that you have read the [first part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb) of Chapter 1.\n",
+ "\n",
+ "The `...`'s in the code cells indicate where you need to fill in code snippets. The number of `...`'s within a code cell give you a rough idea of how many lines of code are needed to solve the task. You should not need to create any additional code cells for your final solution. However, you may want to use temporary code cells to try out some ideas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Simple `for`-loops"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "`for`-loops are extremely versatile in Python. That is different from many other programming languages.\n",
+ "\n",
+ "As shown in the first example in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#Example:-Averaging-all-even-Numbers-in-a-List), we can create a `list` like `numbers` and loop over the numbers in it on a one-by-one basis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "numbers = [7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: Fill in the *condition* of the `if` statement such that only numbers divisible by `3` are printed! Adjust the call of the [print() ](https://docs.python.org/3/library/functions.html#print) function such that the `for`-loop prints out all the numbers on *one* line of output!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for number in numbers:\n",
+ " if ...:\n",
+ " print(...)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Instead of looping over an *existing* object referenced by a variable like `numbers`, we may also create a *new* object within the `for` statement and loop over it directly. For example, below we write out the `list` object as a *literal*.\n",
+ "\n",
+ "Generically, the objects contained in a `list` objects are referred to as its **elements**. We reflect that in the name of the *target* variable `element` that is assigned a different number in every iteration of the `for`-loop. While we could use *any* syntactically valid name, it is best to choose one that makes sense in the context (e.g., `number` in `numbers`).\n",
+ "\n",
+ "**Q2**: Fill in the condition of the `if` statement such that only numbers consisting of *one* digit are printed out! As before, print out all the numbers on *one* line of output!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for element in [7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]:\n",
+ " if ...:\n",
+ " print(...)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "An easy way to loop over a `list` object in a sorted manner, is to wrap it with the built-in [sorted() ](https://docs.python.org/3/library/functions.html#sorted) function.\n",
+ "\n",
+ "**Q3**: Fill in the condition of the `if` statement such that only odd numbers are printed out! Put all the numbers on *one* line of output!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for number in sorted(numbers):\n",
+ " if ...:\n",
+ " print(...)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Whenever we want to loop over numbers representing a [series ](https://en.wikipedia.org/wiki/Series_%28mathematics%29) in the mathematical sense (i.e., a rule to calculate the next number from its predecessor), we may be able to use the [range() ](https://docs.python.org/3/library/functions.html#func-range) built-in.\n",
+ "\n",
+ "For example, to loop over the whole numbers from `0` to `9` (both including) in order, we could write them out in a `list` like below.\n",
+ "\n",
+ "**Q4**: Fill in the call to the [print() ](https://docs.python.org/3/library/functions.html#print) function such that all the numbers are printed on *one* line ouf output!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for number in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:\n",
+ " print(...)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: Read the documentation on the [range() ](https://docs.python.org/3/library/functions.html#func-range) built-in! It may be used with either one, two, or three expressions \"passed\" in. What do `start`, `stop`, and `step` mean? Fill in the calls to [range() ](https://docs.python.org/3/library/functions.html#func-range) and [print() ](https://docs.python.org/3/library/functions.html#print) to mimic the output of **Q4**!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for number in range(...):\n",
+ " print(...)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: Fill in the calls to [range() ](https://docs.python.org/3/library/functions.html#func-range) and [print() ](https://docs.python.org/3/library/functions.html#print) to print out *all* numbers from `1` to `10` (both including)!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for number in range(...):\n",
+ " print(...)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7**: Fill in the calls to [range() ](https://docs.python.org/3/library/functions.html#func-range) and [print() ](https://docs.python.org/3/library/functions.html#print) to print out the *even* numbers from `1` to `10` (both including)! Do *not* use an `if` statement to accomplish this!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for number in range(...):\n",
+ " print(...)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/01_elements/03_content.ipynb b/01_elements/03_content.ipynb
new file mode 100644
index 0000000..a438ab7
--- /dev/null
+++ b/01_elements/03_content.ipynb
@@ -0,0 +1,1725 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/01_elements/03_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 1: Elements of a Program (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In this second part of Chapter 1, we look a bit closer into how the memory works and introduce a couple of \"theoretical\" terms."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Variables vs. Names vs. Identifiers vs. References"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Variables** are created with the **[assignment statement ](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements)** `=`, which is *not* an operator because of its *side effect* of making a **[name ](https://docs.python.org/3/reference/lexical_analysis.html#identifiers)** reference an object in memory.\n",
+ "\n",
+ "We read the terms **variable**, **name**, and **identifier** used interchangebly in many Python-related texts. In this book, we adopt the following convention: First, we treat *name* and *identifier* as perfect synonyms but only use the term *name* in the text for clarity. Second, whereas *name* only refers to a string of letters, numbers, and some other symbols, a *variable* means the combination of a *name* and a *reference* to an object in memory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "variable = 20.0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When used as a *literal*, a variable evaluates to the value of the object it references. Colloquially, we could say that `variable` evaluates to `20.0`, but this would not be an accurate description of what is going on in memory. We see some more colloquialisms in this section but should always relate this to what Python actually does in memory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "20.0"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "variable"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A variable may be **re-assigned** as often as we wish. Thereby, we could also assign an object of a *different* type. Because this is allowed, Python is said to be a **dynamically typed** language. On the contrary, a **statically typed** language like C also allows re-assignment but only with objects of the *same* type. This subtle distinction is one reason why Python is slower at execution than C: As it runs a program, it needs to figure out an object's type each time it is referenced."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "variable = 20"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "20"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "variable"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If we want to re-assign a variable while referencing its \"old\" (i.e., current) object, we may also **update** it using a so-called **[augmented assignment statement ](https://docs.python.org/3/reference/simple_stmts.html#augmented-assignment-statements)** (i.e., *not* operator), as introduced with [PEP 203 ](https://www.python.org/dev/peps/pep-0203/): The currently mapped object is implicitly inserted as the first operand on the right-hand side."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "variable *= 4 # same as variable = variable * 4"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "80"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "variable"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "variable //= 2 # same as variable = variable // 2; \"//\" to retain the integer type"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "40"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "variable"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "variable += 2 # same as variable = variable + 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "variable"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Variables are **[dereferenced ](https://docs.python.org/3/reference/simple_stmts.html#the-del-statement)** (i.e., \"deleted\") with the `del` statement. This does *not* delete the object a variable references but merely removes the variable's name from the \"global list of all names.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "variable"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "del variable"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If we refer to an unknown name, a *runtime* error occurs, namely a `NameError`. The `Name` in `NameError` gives a hint why we choose the term *name* over *identifier* above: Python uses it more often in its error messages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "name 'variable' is not defined",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[13], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mvariable\u001b[49m\n",
+ "\u001b[0;31mNameError\u001b[0m: name 'variable' is not defined"
+ ]
+ }
+ ],
+ "source": [
+ "variable"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Some variables magically exist when a Python process is started or are added by Jupyter. We may safely ignore the former until [Chapter 11 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/00_content.ipynb) and the latter for good."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'__main__'"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "__name__"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To see all defined names, the built-in function [dir() ](https://docs.python.org/3/library/functions.html#dir) is helpful."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['In',\n",
+ " 'Out',\n",
+ " 'Path',\n",
+ " '_',\n",
+ " '_10',\n",
+ " '_11',\n",
+ " '_14',\n",
+ " '_2',\n",
+ " '_4',\n",
+ " '_6',\n",
+ " '_8',\n",
+ " '__',\n",
+ " '___',\n",
+ " '__builtin__',\n",
+ " '__builtins__',\n",
+ " '__doc__',\n",
+ " '__loader__',\n",
+ " '__name__',\n",
+ " '__package__',\n",
+ " '__session__',\n",
+ " '__spec__',\n",
+ " '_dh',\n",
+ " '_i',\n",
+ " '_i1',\n",
+ " '_i10',\n",
+ " '_i11',\n",
+ " '_i12',\n",
+ " '_i13',\n",
+ " '_i14',\n",
+ " '_i15',\n",
+ " '_i2',\n",
+ " '_i3',\n",
+ " '_i4',\n",
+ " '_i5',\n",
+ " '_i6',\n",
+ " '_i7',\n",
+ " '_i8',\n",
+ " '_i9',\n",
+ " '_ih',\n",
+ " '_ii',\n",
+ " '_iii',\n",
+ " '_oh',\n",
+ " 'atexit',\n",
+ " 'exit',\n",
+ " 'get_ipython',\n",
+ " 'history',\n",
+ " 'history_path',\n",
+ " 'open',\n",
+ " 'os',\n",
+ " 'quit',\n",
+ " 'readline',\n",
+ " 'state_home',\n",
+ " 'write_history']"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "dir()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Naming Conventions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[Phil Karlton](https://skeptics.stackexchange.com/questions/19836/has-phil-karlton-ever-said-there-are-only-two-hard-things-in-computer-science) famously noted during his time at [Netscape ](https://en.wikipedia.org/wiki/Netscape):\n",
+ "\n",
+ "> \"There are *two* hard problems in computer science: *naming things* and *cache invalidation* ... and *off-by-one* errors.\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Variable names may contain upper and lower case letters, numbers, and underscores (i.e., `_`) and be as long as we want them to be. However, they must not begin with a number. Also, they must not be any of Python's built-in **[keywords ](https://docs.python.org/3/reference/lexical_analysis.html#keywords)** like `for` or `if`.\n",
+ "\n",
+ "Variable names should be chosen such that they do not need any more documentation and are self-explanatory. A widespread convention is to use so-called **[snake\\_case ](https://en.wikipedia.org/wiki/Snake_case)**: Keep everything lowercase and use underscores to separate words.\n",
+ "\n",
+ "See this [link ](https://en.wikipedia.org/wiki/Naming_convention_%28programming%29#Python_and_Ruby) for a comparison of different naming conventions."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "#### Good examples"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "pi = 3.14"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "answer_to_everything = 42"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "my_name = \"Alexander\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "work_address = \"WHU, Burgplatz 2, Vallendar\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "#### Bad examples"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "PI = 3.14 # unless used as a \"global\" constant"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "answerToEverything = 42 # this is a style used in languages like Java"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "name = \"Alexander\" # name of what?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "cannot assign to expression here. Maybe you meant '==' instead of '='? (202417111.py, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m Cell \u001b[0;32mIn[23], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m address@work = \"WHU, Burgplatz 2, Vallendar\"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m cannot assign to expression here. Maybe you meant '==' instead of '='?\n"
+ ]
+ }
+ ],
+ "source": [
+ "address@work = \"WHU, Burgplatz 2, Vallendar\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If a variable name collides with a built-in name, we add a trailing underscore."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "type_ = \"student\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Variables with leading and trailing double underscores, referred to as **dunder** in Python jargon, are used for built-in functionalities and to implement object-oriented features as we see in [Chapter 11 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/00_content.ipynb). We must *not* use this style for variables!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'__main__'"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "__name__"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Who am I? And how many?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "It is *crucial* to understand that *several* variables may reference the *same* object in memory. Not having this in mind may lead to many hard to track down bugs.\n",
+ "\n",
+ "Let's make `b` reference whatever object `a` is referencing."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "a = 42"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "b = a"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For \"simple\" types like `int` or `float` this never causes troubles.\n",
+ "\n",
+ "Let's \"change the value\" of `a`. To be precise, let's create a *new* `87` object and make `a` reference it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "a = 87"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "87"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`b` \"is still the same\" as before. To be precise, `b` still references the *same object* as before."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, if a variable references an object of a more \"complex\" type (e.g., `list`), predicting the outcome of a code snippet may be unintuitive for a beginner."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "x = [1, 2, 3]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "list"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(x)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "y = x"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[1, 2, 3]"
+ ]
+ },
+ "execution_count": 35,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Let's change the first element of `x`.\n",
+ "\n",
+ "[Chapter 7 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/00_content.ipynb#The-list-Type) discusses lists in more depth. For now, let's view a `list` object as some sort of **container** that holds an arbitrary number of references to other objects and treat the brackets `[]` attached to it as yet another operator, namely the **indexing operator**. So, `x[0]` instructs Python to first follow the reference from the global list of all names to the `x` object. Then, it follows the first reference it finds there to the `1` object we put in the list. The indexing operator must be an operator as we merely *read* the first element and do not change anything in memory permanently.\n",
+ "\n",
+ "Python **begins counting at 0**. This is not the case for many other languages, for example, [MATLAB ](https://en.wikipedia.org/wiki/MATLAB), [R ](https://en.wikipedia.org/wiki/R_%28programming_language%29), or [Stata ](https://en.wikipedia.org/wiki/Stata). To understand why this makes sense, see this short [note](https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html) by one of the all-time greats in computer science, the late [Edsger Dijkstra ](https://en.wikipedia.org/wiki/Edsger_W._Dijkstra)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x[0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To change the first entry in the list, we use the assignment statement `=` again. Here, this does *not* create a *new* variable, nor overwrite an existing one, but only changes the object referenced as the first element in `x`. As we only change parts of the `x` object, we say that we **mutate** its **state**. To use the bag analogy from above, we keep the same bag but \"flip\" some of the $0$s into $1$s and some of the $1$s into $0$s."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "x[0] = 99"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[99, 2, 3]"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The changes made to the object `x` is referencing can also be seen through the `y` variable!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[99, 2, 3]"
+ ]
+ },
+ "execution_count": 39,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The difference in behavior illustrated in this sub-section has to do with the fact that `int` and `float` objects are **immutable** types while `list` objects are **mutable**.\n",
+ "\n",
+ "In the first case, an object cannot be changed \"in place\" once it is created in memory. When we assigned `87` to the already existing `a`, we did *not* change the $0$s and $1$s in the object `a` referenced before the assignment but created a new `int` object and made `a` reference it while the `b` variable is *not* affected.\n",
+ "\n",
+ "In the second case, `x[0] = 99` creates a *new* `int` object `99` and merely changes the first reference in the `x` list.\n",
+ "\n",
+ "In general, the assignment statement creates a new name and makes it reference whatever object is on the right-hand side *iff* the left-hand side is a *pure* name (i.e., it contains no operators like the indexing operator in the example). Otherwise, it *mutates* an already existing object. And, we must always expect that the latter may have more than one variable referencing it.\n",
+ "\n",
+ "Visualizing what is going on in memory with a tool like [PythonTutor ](http://pythontutor.com/visualize.html#code=x%20%3D%20%5B1,%202,%203%5D%0Ay%20%3D%20x%0Ax%5B0%5D%20%3D%2099%0Aprint%28y%5B0%5D%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) may be helpful for a beginner."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## How Python reads \"Commands\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As we saw in the previous `list` example, it is important to understand in what order Python executes the \"commands\" (= not an officially used term) we give it. In this last section of the chapter, we introduce a classification scheme and look at its implications."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Expressions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "An **[expression ](https://docs.python.org/3/reference/expressions.html)** is any syntactically correct *combination* of *variables* and *literals* with *operators* that **evaluates** (i.e., \"becomes\") to an object. That object may already exist *before* the expression is parsed or created as a result thereof. The point is that *after* the expression is parsed, Python returns a reference to this object that may be used for further processing.\n",
+ "\n",
+ "In simple words, anything that may be used on the *right-hand* side of an assignment statement without creating a `SyntaxError` is an expression.\n",
+ "\n",
+ "What we have said about *individual* operators before, namely that they have *no* permanent side effects in memory, actually belongs here, to begin with: The absence of any *permanent* side effects is the characteristic property of expressions, and all the code cells in the \"*(Arithmetic) Operators*\" section in the [first part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#%28Arithmetic%29-Operators) of this chapter are examples of expressions.\n",
+ "\n",
+ "The simplest possible expressions contain only one variable or literal. The output below a code cell is Jupyter's way of returning the reference to the object to us!\n",
+ "\n",
+ "Whereas `a` evaluates to the *existing* `87` object, ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "87"
+ ]
+ },
+ "execution_count": 40,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "... parsing the literal `42` creates a *new* `int` object and returns a reference to it (Note: for optimization reasons, the CPython implementation may already have a `42` object in memory)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 41,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For sure, we need to include operators to achieve something useful. Here, Python takes the existing `a` object, creates a new `42` object, creates the resulting `45` object, and returns a reference to that."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "45"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a - 42"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The definition of an expression is **recursive**. So, the sub-expression `a - 42` is combined with the literal `9` by the operator `//` to form the full expression `(a - 42) // 9`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "5"
+ ]
+ },
+ "execution_count": 43,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(a - 42) // 9"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Below, the variable `x` is combined with the literal `2` by the indexing operator `[]`. The resulting expression evaluates to the third element in the `x` list."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 44,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x[2]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When not used as a delimiter, parentheses also constitute an operator, namely the **call operator** `()`. We saw this syntax before when we called built-in functions and methods."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "104"
+ ]
+ },
+ "execution_count": 45,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sum(x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Statements"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A **[statement ](https://docs.python.org/3/reference/simple_stmts.html)** is any *single* command Python understands.\n",
+ "\n",
+ "So, what we mean with statement is a [strict superset ](https://en.wikipedia.org/wiki/Subset) of what we mean with expression: All expressions are statements, but some statements are *not* expressions. That implies that all code cells in the previous \"*Expressions*\" section are also examples of statements.\n",
+ "\n",
+ "Unfortunately, many texts on Python use the two terms as mutually exclusive concepts by saying that a statement (always) *changes* the *state of a program* with a permanent *side effect* in memory (e.g., by creating a variable) whereas an expression does not. That is not an accurate way of distinguishing the two in all cases!\n",
+ "\n",
+ "So, often, the term statement is used in the meaning of \"a statement that is *not* an expression.\" We can identify such statements easily in Jupyter as the correspoding code cells have *no* output below them.\n",
+ "\n",
+ "While many statements, for example `=` and `del`, indeed have *permanent* side effects, ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "a = 21 * 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "del a"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "... calling the built-in [print() ](https://docs.python.org/3/library/functions.html#print) function does *neither* change the memory *nor* evaluate to an object (disregarding the `None` object explained in [Chapter 2 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/00_content.ipynb#Function-Definitions)). We could view changing the computer's screen as a side effect but this is outside of Python's memory!\n",
+ "\n",
+ "Also, the cell below has *no* output! It only looks like it does as Jupyter redirects whatever [print() ](https://docs.python.org/3/library/functions.html#print) writes to the \"screen\" to below a cell. We see a difference to the expressions above in that there are no brackets `[...]` next to the output showing the execution count number."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Don't I change the state of the computer's display?\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Don't I change the state of the computer's display?\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Logical vs. Physical Lines"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "How many lines of code does the next cell constitute?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The answer is: 42\n"
+ ]
+ }
+ ],
+ "source": [
+ "result = 21 * 2; print(\"The answer is:\", result)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The answer depends on how we are counting. If we count the number of lines of written source code, the answer is *one*. This gives us the number of **physical lines**. On the contrary, if we count the number of statements separated by the `;`, the answer is *two*. This gives us the number of **logical lines**.\n",
+ "\n",
+ "While physical lines are what we, the humans, see, logical lines are how computers read. To align the two ways, it is a best practice to not write more than one logical lines on a single physical one. So, from Python's point of view, the cells above and below are the same. More importantly, the one above is *not* somehow \"magically\" faster."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The answer is: 42\n"
+ ]
+ }
+ ],
+ "source": [
+ "result = 21 * 2\n",
+ "print(\"The answer is:\", result)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "It is also possible to write a single logical line over several physical ones. The cell below is yet another physical representation of the same *two* logical lines. Any pair of delimiters, like `(` and `)` below, can be used to \"format\" the code in between with whitespace. The style guides mentioned before should still be taken into account (i.e., indent with 4 spaces)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The answer is: 42\n"
+ ]
+ }
+ ],
+ "source": [
+ "result = 21 * 2\n",
+ "print(\n",
+ " \"The answer is:\",\n",
+ " result\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Another situation, in which several physical lines are treated as a logical one, is with so-called **[compound statements ](https://docs.python.org/3/reference/compound_stmts.html)**. In contrast to simple statements like `=` and `del` above, the purpose of compound statements is to group other statements.\n",
+ "\n",
+ "We have seen two examples of compound statements already: `for` and `if`. They both consist of a **header** line ending with a `:` and an indented **(code) block** spanning an arbitrary number of logical lines.\n",
+ "\n",
+ "In the example, the first logical line spans the entire cell, the second logical line contains all physical lines except the first, and the third and fourth logical lines are just the third and fourth physical lines, respectively."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2 -> 4\n"
+ ]
+ }
+ ],
+ "source": [
+ "for number in [1, 2, 3]:\n",
+ " if number % 2 == 0:\n",
+ " double = 2 * number \n",
+ " print(number, \"->\", double)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Comments"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A comment is a physical line that is *not* a logical line.\n",
+ "\n",
+ "We use the `#` symbol to write comments in plain text right into the code. Anything after the `#` until the end of the physical line is ignored by Python.\n",
+ "\n",
+ "As a good practice, comments should *not* describe *what* happens. This should be evident by reading the code. Otherwise, it is most likely badly written code. Rather, comments should describe *why* something happens.\n",
+ "\n",
+ "Comments may be added either at the end of a line of code, by convention separated with two spaces, or on a line on their own."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "distance = 891 # in meters\n",
+ "elapsed_time = 93 # in seconds\n",
+ "\n",
+ "# Calculate the speed in km/h.\n",
+ "speed = 3.6 * distance / elapsed_time"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "But let's think wisely if we need to use a comment.\n",
+ "The second cell is a lot more Pythonic."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "seconds = 365 * 24 * 60 * 60 # = seconds in the year"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "seconds_per_year = 365 * 24 * 60 * 60"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "303.333px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/01_elements/04_exercises_calculator.ipynb b/01_elements/04_exercises_calculator.ipynb
new file mode 100644
index 0000000..5b66384
--- /dev/null
+++ b/01_elements/04_exercises_calculator.ipynb
@@ -0,0 +1,212 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Run All*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *after* finishing the exercises to ensure that your solution runs top to bottom *without* any errors. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/01_elements/04_exercises.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 1: Elements of a Program (Coding Exercises)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The exercises below assume that you have read the [second part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/03_content.ipynb) Chapter 1.\n",
+ "\n",
+ "The `...`'s in the code cells indicate where you need to fill in code snippets. The number of `...`'s within a code cell give you a rough idea of how many lines of code are needed to solve the task. You should not need to create any additional code cells for your final solution. However, you may want to use temporary code cells to try out some ideas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Python as a Calculator"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The [volume of a sphere ](https://en.wikipedia.org/wiki/Sphere) is defined as $\\frac{4}{3} * \\pi * r^3$.\n",
+ "\n",
+ "**Q1**: Calculate it for `r = 2.88` and approximate $\\pi$ with `pi = 3.14`!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pi = 3.14\n",
+ "r = 2.88"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "While Python may be used as a calculator, it behaves a bit differently compared to calculator apps that phones or computers come with and that we are accustomed to.\n",
+ "\n",
+ "A major difference is that Python \"forgets\" intermediate results that are not assigned to variables. On the contrary, the calculators we work with outside of programming always keep the last result and allow us to use it as the first input for the next calculation.\n",
+ "\n",
+ "One way to keep on working with intermediate results in Python is to write the entire calculation as just *one* big expression that is composed of many sub-expressions representing the individual steps in our overall calculation.\n",
+ "\n",
+ "**Q2.1**: Given `a` and `b` like below, subtract the smaller `a` from the larger `b`, divide the difference by `9`, and raise the result to the power of `2`! Use operators that preserve the `int` type of the final result! The entire calculations *must* be placed within *one* code cell.\n",
+ "\n",
+ "Hint: You may need to group sub-expressions with parentheses `(` and `)`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "a = 42\n",
+ "b = 87"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The code cell below contains nothing but a single underscore `_`. In both, a Python command-line prompt and Jupyter notebooks, the variable `_` is automatically updated and always references the object to which the *last* expression executed evaluated to.\n",
+ "\n",
+ "**Q2.2**: Execute the code cell below! It should evaluate to the *same* result as the previous code cell (i.e., your answer to **Q2.1** assuming you go through this notebook in order)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "_"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2.3**: Implement the same overall calculation as in your answer to **Q2.1** in several independent steps (i.e., code cells)! Use only *one* operator per code cell!\n",
+ "\n",
+ "Hint: You should need *two* more code cells after the `b - a` one immediately below. If you *need* to use parentheses, you must be doing something wrong."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "b - a"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "_ ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "_ ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3.1**: When answering the questions above, you should have used only **expressions** in the code cells. What are expressions syntactically?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3.2**: The code cells that provide the numbers to work with contain **statements** that are *not* expressions. What are statements? How are they different from expressions?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/01_elements/05_summary.ipynb b/01_elements/05_summary.ipynb
new file mode 100644
index 0000000..e5a7dd0
--- /dev/null
+++ b/01_elements/05_summary.ipynb
@@ -0,0 +1,142 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 1: Elements of a Program (TL;DR)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We end each chapter with a summary of the main points (i.e., **TL;DR** = \"too long; didn't read\"). The essence in this first chapter is that just as a sentence in a real language like English may be decomposed into its parts (e.g., subject, predicate, and objects), the same may be done with programming languages.\n",
+ "\n",
+ "- program\n",
+ " - **sequence** of **instructions** that specify how to perform a computation (= a \"recipe\")\n",
+ " - a \"black box\" that processes **inputs** and transforms them into meaningful **outputs** in a *deterministic* way\n",
+ " - conceptually similar to a mathematical function $f$ that maps some input $x$ to an output $y = f(x)$\n",
+ "\n",
+ "\n",
+ "- input (examples)\n",
+ " - data from a CSV file\n",
+ " - text entered on a command line\n",
+ " - data obtained from a database\n",
+ " - etc.\n",
+ "\n",
+ "\n",
+ "- output (examples)\n",
+ " - result of a computation (e.g., statistical summary of a sample dataset)\n",
+ " - a \"side effect\" (e.g., a transformation of raw input data into cleaned data)\n",
+ " - a physical \"behavior\" (e.g., a robot moving or a document printed)\n",
+ " - etc.\n",
+ "\n",
+ "\n",
+ "- objects\n",
+ " - distinct and well-contained areas/parts of the memory that hold the actual data\n",
+ " - the concept by which Python manages the memory for us\n",
+ " - can be classified into objects of the same **type** (i.e., same abstract \"structure\" but different concrete data)\n",
+ " - built-in objects (incl. **literals**) vs. user-defined objects (cf., [Chapter 11 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/00_content.ipynb))\n",
+ " - e.g., `1`, `1.0`, and `\"one\"` are three different objects of distinct types that are also literals (i.e., by the way we type them into the command line Python knows what the value and type are)\n",
+ "\n",
+ "\n",
+ "- variables\n",
+ " - storage of intermediate **state**\n",
+ " - are **names** referencing **objects** in **memory**\n",
+ " - e.g., `x = 1` creates the variable `x` that references the object `1`\n",
+ "\n",
+ "\n",
+ "- operators\n",
+ " - special built-in symbols that perform operations with objects in memory\n",
+ " - usually, operate with one or two objects\n",
+ " - e.g., addition `+`, subtraction `-`, multiplication `*`, and division `/` all take two objects, whereas the negation `-` only takes one\n",
+ "\n",
+ "\n",
+ "- expressions\n",
+ " - **combinations** of **variables** (incl. **literals**) and **operators**\n",
+ " - do *not* change the involved objects/state of the program\n",
+ " - evaluate to a **value** (i.e., the \"result\" of the expression, usually a new object)\n",
+ " - e.g., `x + 2` evaluates to the (new) object `3` and `1 - 1.0` to `0.0`\n",
+ "\n",
+ "\n",
+ "- statements\n",
+ " - instructions that **\"do\" something** and **have side effects** in memory\n",
+ " - (re-)assign names to (different) objects, *change* an existing object *in place*, or, more conceptually, *change* the state of the program\n",
+ " - usually, work with expressions\n",
+ " - e.g., the assignment statement `=` makes a name reference an object\n",
+ "\n",
+ "\n",
+ "- comments\n",
+ " - **prose** supporting a **human's understanding** of the program\n",
+ " - ignored by Python\n",
+ "\n",
+ "\n",
+ "- functions (cf., [Chapter 2 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/00_content.ipynb))\n",
+ " - named sequences of instructions\n",
+ " - the smaller parts in a larger program\n",
+ " - make a program more modular and thus easier to understand\n",
+ " - include [built-in functions ](https://docs.python.org/3/library/functions.html) like [print() ](https://docs.python.org/3/library/functions.html#print), [sum() ](https://docs.python.org/3/library/functions.html#sum), or [len() ](https://docs.python.org/3/library/functions.html#len)\n",
+ "\n",
+ "\n",
+ "- flow control (cf., [Chapter 3 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/03_conditionals/00_content.ipynb) and [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/00_content.ipynb))\n",
+ " - expression of **business logic** or an **algorithm**\n",
+ " - conditional execution of parts of a program (e.g., `if` statements)\n",
+ " - repetitive execution of parts of a program (e.g., `for`-loops)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "303.333px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/01_elements/06_review.ipynb b/01_elements/06_review.ipynb
new file mode 100644
index 0000000..60c9360
--- /dev/null
+++ b/01_elements/06_review.ipynb
@@ -0,0 +1,215 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 1: Elements of a Program (Review Questions)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The questions below assume that you have read the [first ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb) and the [second ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/03_content.ipynb) part of Chapter 1.\n",
+ "\n",
+ "Be concise in your answers! Most questions can be answered in *one* sentence."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Essay Questions "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: Elaborate on how **modulo division** might be a handy operation to know!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: What is a **dynamically typed** language? How does it differ from a **statically typed** language? What does that mean for Python?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: Why is it useful to start counting at $0$?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: What is **operator overloading**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: What are the basic **naming conventions** for variables? What happens if a name collides with one of Python's [keywords ](https://docs.python.org/3/reference/lexical_analysis.html#keywords)?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: Advocates of the [functional programming ](https://en.wikipedia.org/wiki/Functional_programming) paradigm suggest not to use **mutable** data types in a program. What are the advantages of that approach? What might be a downside?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## True / False Questions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Motivate your answer with *one short* sentence!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7**: \"**dunder**\" refers to a group of Australian (i.e., \"down under\") geeks that work on core Python."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q8**: The **Zen of Python** talks about Indian genius programmers."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q9**: When NASA famously converted some measurements to the wrong unit and lost a Mars satellite in 1999 (cf., [source](https://www.wired.com/2010/11/1110mars-climate-observer-report/)), this is an example of a so-called **runtime error**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q10**: [PEP 8 ](https://www.python.org/dev/peps/pep-0008/) suggests that developers use **8 spaces** per level of indentation."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/01_elements/07_resources.ipynb b/01_elements/07_resources.ipynb
new file mode 100644
index 0000000..0bf7edb
--- /dev/null
+++ b/01_elements/07_resources.ipynb
@@ -0,0 +1,115 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/01_elements/07_resources.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 1: Elements of a Program (Further Resources)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This PyCon 2015 talk by [Ned Batchelder](https://nedbatchelder.com/), a well-known Pythonista and the organizer of the [Python User Group](https://www.meetup.com/bostonpython/) in Boston, summarizes all situations where some sort of assignment is done in Python and, thus, reviews how *variables are just names referencing objects*. The content is intermediate, and, thus, it might be worthwhile to come back to this talk at a later point in time. However, the contents should be known by everyone claiming to be proficient in Python."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from IPython.display import YouTubeVideo\n",
+ "YouTubeVideo(\"_AEJHKGk9ns\", width=\"60%\")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "303.333px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/02_functions/00_content.ipynb b/02_functions/00_content.ipynb
new file mode 100644
index 0000000..a40b1e6
--- /dev/null
+++ b/02_functions/00_content.ipynb
@@ -0,0 +1,3064 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/02_functions/00_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 2: Functions & Modularization"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#Example:-Averaging-all-even-Numbers-in-a-List), we simply typed the code to calculate the average of the even numbers in a list of whole numbers into several code cells. Then, we executed them one after another. We had no way of *reusing* the code except for either executing cells multiple times. And, whenever we find ourselves doing repetitive manual work, we can be sure that there must be a way of automating what we are doing.\n",
+ "\n",
+ "This chapter shows how Python offers language constructs that let us **define** functions ourselves that we may then **call** just like the built-in ones. Also, we look at how we can extend our Python installation with functionalities written by other people."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## [Built-in Functions ](https://docs.python.org/3/library/functions.html)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Python comes with plenty of useful functions built in, some of which we have already seen before (e.g., [print() ](https://docs.python.org/3/library/functions.html#print), [sum() ](https://docs.python.org/3/library/functions.html#sum), [len() ](https://docs.python.org/3/library/functions.html#len), or [id() ](https://docs.python.org/3/library/functions.html#id)). The [documentation ](https://docs.python.org/3/library/functions.html) has the full list. Just as core Python itself, they are mostly implemented in C and thus very fast.\n",
+ "\n",
+ "Below, [sum() ](https://docs.python.org/3/library/functions.html#sum) adds up all the elements in the `numbers` list while [len() ](https://docs.python.org/3/library/functions.html#len) counts the number of elements in it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "numbers = [7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "78"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sum(numbers)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "12"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`sum` and `len` are *no* [keywords ](https://docs.python.org/3/reference/lexical_analysis.html#keywords) like `for` or `if` but variables that reference *objects* in memory. Often, we hear people say that \"everything is an object in Python\" (e.g., this [question ](https://stackoverflow.com/questions/40478536/in-python-what-does-it-mean-by-everything-is-an-object)). While this phrase may sound abstract in the beginning, it simply means that the entire memory is organized with \"bags\" of $0$s and $1$s, and there are even bags for the built-in functions. That is *not* true for many other languages (e.g., C or Java) and often a source of confusion for people coming to Python from another language.\n",
+ "\n",
+ "The built-in [id() ](https://docs.python.org/3/library/functions.html#id) function tells us where in memory a particular built-in function is stored."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "139940703477088"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(sum)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "139940703476048"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(len)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[type() ](https://docs.python.org/3/library/functions.html#type) reveals that built-in functions like [sum() ](https://docs.python.org/3/library/functions.html#sum) or [len() ](https://docs.python.org/3/library/functions.html#len) are objects of type `builtin_function_or_method`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "builtin_function_or_method"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(sum)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "builtin_function_or_method"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(len)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Python's object-oriented nature allows us to have functions work with themselves. While seemingly not useful from a beginner's point of view, that enables a lot of powerful programming styles later on."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "139940703475648"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(id)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "type"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(type)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To execute a function, we **call** it with the **call operator** `()` as shown many times in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb) and above.\n",
+ "\n",
+ "If we are unsure whether a variable references a function or not, we can verify that with the built-in [callable() ](https://docs.python.org/3/library/functions.html#callable) function.\n",
+ "\n",
+ "Abstractly speaking, *any* object that can be called with the call operator `()` is a so-called **callable**. And, objects of type `builtin_function_or_method` are just one kind of examples thereof. We will see another one already in the next sub-section."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "callable(sum)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "callable(len)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`list` objects, for example, are *not* callable."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "callable(numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Constructors"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The list of [built-in functions ](https://docs.python.org/3/library/functions.html) in the documentation should really be named a list of built-in *callables*.\n",
+ "\n",
+ "Besides the built-in functions, the list also features **constructors** for the built-in types. They may be used to **[cast ](https://en.wikipedia.org/wiki/Type_conversion)** (i.e., \"convert\") any object as an object of a given type.\n",
+ "\n",
+ "For example, to \"convert\" a `float` or a `str` into an `int` object, we use the [int() ](https://docs.python.org/3/library/functions.html#int) built-in. Below, *new* `int` objects are created from the `7.0` and `\"7\"` objects that are *newly* created themselves before being processed by [int() ](https://docs.python.org/3/library/functions.html#int) right away *without* ever being referenced by a variable."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "int(7.0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "int(\"7\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Casting an object as an `int` is different from rounding with the built-in [round() ](https://docs.python.org/3/library/functions.html#round) function!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "int(7.99)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "8"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "round(7.99)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Notice the subtle difference compared to the behavior of the `//` operator in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb##%28Arithmetic#%29-Operators) that \"rounds\" towards minus infinity: [int() ](https://docs.python.org/3/library/functions.html#int) always \"rounds\" towards `0`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-7"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "int(-7.99)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Not all conversions are valid and *runtime* errors may occur as the `ValueError` shows."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "invalid literal for int() with base 10: 'seven'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[18], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mseven\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'seven'"
+ ]
+ }
+ ],
+ "source": [
+ "int(\"seven\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We may also cast in the other direction with the [float() ](https://docs.python.org/3/library/functions.html#float) or [str() ](https://docs.python.org/3/library/functions.html#func-str) built-ins."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(7)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'7'"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "str(7)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Constructors are full-fledged objects as well."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "94623097764960"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(int)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "94623097758720"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(float)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "They are of type `type`, which is different from `builtin_function_or_method` above."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "type"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(int)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "type"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(float)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As already noted, constructors are *callables*. In that regard, they behave the same as built-in functions. We may call them with the call operator `()`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "callable(int)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "callable(float)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The attentive student may already have discovered that we refer to `builtin_function_or_method` objects as \"built-in functions\" and `type` objects as just \"built-ins.\" For a beginner, that difference is not so important. But, the ambitious student should already be aware that such subtleties exist.\n",
+ "\n",
+ "Next, let's look at a third kind of callables."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Function Definitions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We may create so-called *user-defined* **functions** with the `def` statement (cf., [reference ](https://docs.python.org/3/reference/compound_stmts.html#function-definitions)). To extend an already familiar example, we reuse the introductory example from [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#Best-Practices) in its final Pythonic version and transform it into the function `average_evens()` below. We replace the variable name `numbers` with `integers` for didactical purposes in the first couple of examples.\n",
+ "\n",
+ "A function's **name** must be chosen according to the same naming rules as ordinary variables since Python manages function names like variables. In this book, we further adopt the convention of ending function names with parentheses `()` in text cells for faster comprehension when reading (i.e., `average_evens()` vs. `average_evens`). These are *not* part of the name but must always be written out in the `def` statement for syntactic reasons.\n",
+ "\n",
+ "Functions may define an arbitrary number of **parameters** as inputs that can then be referenced within the indented **code block**: They are listed within the parentheses in the `def` statement (i.e., `integers` below). \n",
+ "\n",
+ "The code block is also called a function's **body**, while the first line starting with `def` and ending with a colon is the **header**.\n",
+ "\n",
+ "Together, the name and the list of parameters are also referred to as the function's **[signature ](https://en.wikipedia.org/wiki/Type_signature)** (i.e., `average_evens(integers)` below).\n",
+ "\n",
+ "A function may specify an *explicit* **return value** (i.e., \"result\" or \"output\") with the `return` statement (cf., [reference ](https://docs.python.org/3/reference/simple_stmts.html#the-return-statement)): Functions that have one are considered **fruitful**; otherwise, they are **void**. Functions of the latter kind are still useful because of their **side effects**. For example, the built-in [print() ](https://docs.python.org/3/library/functions.html#print) function changes what we see on the screen. Strictly speaking, [print() ](https://docs.python.org/3/library/functions.html#print) and other void functions also have an *implicit* return value, namely the `None` object.\n",
+ "\n",
+ "A function should define a **docstring** that describes what it does in a short subject line, what parameters it expects (i.e., their types), and what it returns, if anything. A docstring is a syntactically valid multi-line string (i.e., type `str`) defined within **triple-double quotes** `\"\"\"`. Strings are covered in depth in [Chapter 6 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/00_content.ipynb#The-str-Type). Widely adopted standards for docstrings are [PEP 257 ](https://www.python.org/dev/peps/pep-0257/) and section 3.8 of [Google's Python Style Guide ](https://github.com/google/styleguide/blob/gh-pages/pyguide.md)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def average_evens(integers):\n",
+ " \"\"\"Calculate the average of all even numbers in a list.\n",
+ "\n",
+ " Args:\n",
+ " integers (list of int's): whole numbers to be averaged\n",
+ "\n",
+ " Returns:\n",
+ " average (float)\n",
+ " \"\"\"\n",
+ " evens = [n for n in integers if n % 2 == 0]\n",
+ " average = sum(evens) / len(evens)\n",
+ " return average"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Once defined, a function may be referenced just like any other variable by its name (i.e., *without* the parentheses)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_evens"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This works as functions are full-fledged *objects*. So, `average_evens` is just a name referencing an object in memory with an **identity**, a **type**, namely `function`, and a **value**. In that regard, `average_evens` is *no* different from the variable `numbers` or the built-ins' names."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "139940571731424"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(average_evens)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "function"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(average_evens)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Its value may seem awkward at first: It consists of a location showing where the function is defined (i.e., `__main__` here, which is Python's way of saying \"in this notebook\") and the signature wrapped inside angle brackets `<` and `>`.\n",
+ " \n",
+ "The angle brackets are a convention to indicate that the value may *not* be used as a *literal* (i.e., typed back into another code cell). [Chapter 11 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/00_content.ipynb) introduces the concept of a **text representation** of an object, which is related to the *semantic* meaning of an object's value as discussed in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#Value-/-\"Meaning\"), and the angle brackets convention is one such way to represent an object as text. When executed, the angle brackets cause a `SyntaxError` because Python expects the `<` operator to come with an operand on both sides (cf., [Chapter 3 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/03_conditionals/00_content.ipynb#Relational-Operators))."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "invalid syntax (2246690741.py, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m Cell \u001b[0;32mIn[31], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m \u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
+ ]
+ }
+ ],
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`average_evens` is, of course, callable. So, the `function` type is the third kind of callable in this chapter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "callable(average_evens)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The built-in [help() ](https://docs.python.org/3/library/functions.html#help) function shows a function's docstring.\n",
+ "\n",
+ "Whenever we use code to analyze or obtain information on an object, we say that we **[introspect ](https://en.wikipedia.org/wiki/Type_introspection)** it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on function average_evens in module __main__:\n",
+ "\n",
+ "average_evens(integers)\n",
+ " Calculate the average of all even numbers in a list.\n",
+ "\n",
+ " Args:\n",
+ " integers (list of int's): whole numbers to be averaged\n",
+ "\n",
+ " Returns:\n",
+ " average (float)\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "help(average_evens)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In JupyterLab, we can just as well add a question mark `?` to a function's name to achieve the same."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\u001b[0;31mSignature:\u001b[0m \u001b[0maverage_evens\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mintegers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mDocstring:\u001b[0m\n",
+ "Calculate the average of all even numbers in a list.\n",
+ "\n",
+ "Args:\n",
+ " integers (list of int's): whole numbers to be averaged\n",
+ "\n",
+ "Returns:\n",
+ " average (float)\n",
+ "\u001b[0;31mFile:\u001b[0m /tmp/ipykernel_152540/3598721284.py\n",
+ "\u001b[0;31mType:\u001b[0m function"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "average_evens?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Two question marks `??` show a function's source code."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\u001b[0;31mSignature:\u001b[0m \u001b[0maverage_evens\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mintegers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mSource:\u001b[0m \n",
+ "\u001b[0;32mdef\u001b[0m \u001b[0maverage_evens\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mintegers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"Calculate the average of all even numbers in a list.\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m Args:\u001b[0m\n",
+ "\u001b[0;34m integers (list of int's): whole numbers to be averaged\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m Returns:\u001b[0m\n",
+ "\u001b[0;34m average (float)\u001b[0m\n",
+ "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0mevens\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mn\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mn\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mintegers\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mn\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0maverage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mevens\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mevens\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0maverage\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mFile:\u001b[0m /tmp/ipykernel_152540/3598721284.py\n",
+ "\u001b[0;31mType:\u001b[0m function"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "average_evens??"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[help() ](https://docs.python.org/3/library/functions.html#help) and the `?`s also work for built-ins."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on built-in function sum in module builtins:\n",
+ "\n",
+ "sum(iterable, /, start=0)\n",
+ " Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
+ "\n",
+ " When the iterable is empty, return the start value.\n",
+ " This function is intended specifically for use with numeric values and may\n",
+ " reject non-numeric types.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "help(sum)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Function Calls"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Once defined, we may call a function with the call operator `()` as often as we wish. The formal parameters are then filled in by **passing** *expressions* (e.g., literals or variables) as **arguments** to the function within the parentheses."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 37,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_evens([7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_evens(numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A function call's return value is commonly assigned to a variable for subsequent use. Otherwise, we lose access to the returned object right away."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "result = average_evens(numbers)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 40,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "result"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Scoping Rules"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Local Scope disappears"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The parameters listed in a function's definition (i.e., `integers` in the example) and variables created *inside* it during execution (i.e., `evens` and `average`) are **local** to that function. That means they only reference an object in memory *while* the function is being executed and are dereferenced immediately when the function call returns. We say they go out of **scope**. That is why we see the `NameError`s below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "name 'integers' is not defined",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[41], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mintegers\u001b[49m\n",
+ "\u001b[0;31mNameError\u001b[0m: name 'integers' is not defined"
+ ]
+ }
+ ],
+ "source": [
+ "integers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "name 'evens' is not defined",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[42], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mevens\u001b[49m\n",
+ "\u001b[0;31mNameError\u001b[0m: name 'evens' is not defined"
+ ]
+ }
+ ],
+ "source": [
+ "evens"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "name 'average' is not defined",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[43], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43maverage\u001b[49m\n",
+ "\u001b[0;31mNameError\u001b[0m: name 'average' is not defined"
+ ]
+ }
+ ],
+ "source": [
+ "average"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[PythonTutor ](http://pythontutor.com/visualize.html#code=numbers%20%3D%20%5B7,%2011,%208,%205,%203,%2012,%202,%206,%209,%2010,%201,%204%5D%0A%0Adef%20average_evens%28integers%29%3A%0A%20%20%20%20evens%20%3D%20%5Bn%20for%20n%20in%20integers%20if%20n%20%25%202%20%3D%3D%200%5D%0A%20%20%20%20average%20%3D%20sum%28evens%29%20/%20len%28evens%29%0A%20%20%20%20return%20average%0A%0Aresult%20%3D%20average_evens%28numbers%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) visualizes what happens in memory: To be precise, in the exact moment when the function call is initiated and `numbers` passed in as the `integers` argument, there are *two* references to the *same* `list` object (cf., steps 4-5 in the visualization). We also see how Python creates a *new* **frame** that holds the function's local scope (i.e., \"internal names\") in addition to the **global** frame. Frames are nothing but [namespaces ](https://en.wikipedia.org/wiki/Namespace) to *isolate* the names of different **scopes** from each other. The list comprehension `[n for n in integers if n % 2 == 0]` constitutes yet another frame that is in scope as the `list` object assigned to `evens` is *being* created (cf., steps 6-20). When the function returns, only the global frame is left (cf., last step)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Global Scope is everywhere"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "On the contrary, while a function is *being* executed, it may reference the variables of **enclosing scopes** (i.e., \"outside\" of it). This is a common source of *semantic* errors. Consider the following stylized and incorrect example `average_wrong()`. The error is hard to spot with eyes: The function never references the `integers` parameter but the `numbers` variable in the **global scope** instead."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def average_wrong(integers):\n",
+ " \"\"\"Calculate the average of all even numbers in a list.\n",
+ "\n",
+ " Args:\n",
+ " integers (list of int's): whole numbers to be averaged\n",
+ "\n",
+ " Returns:\n",
+ " average (float)\n",
+ " \"\"\"\n",
+ " evens = [n for n in numbers if n % 2 == 0]\n",
+ " average = sum(evens) / len(evens)\n",
+ " return average"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`numbers` in the global scope is, of course, *not* changed by merely defining `average_wrong()`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ "execution_count": 45,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Sometimes a function may return a correct solution for *some* inputs ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 46,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_wrong(numbers) # correct by accident"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "... but still be wrong *in general*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 47,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_wrong([123, 456, 789])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[PythonTutor ](http://pythontutor.com/visualize.html#code=numbers%20%3D%20%5B7,%2011,%208,%205,%203,%2012,%202,%206,%209,%2010,%201,%204%5D%0A%0Adef%20average_wrong%28integers%29%3A%0A%20%20%20%20evens%20%3D%20%5Bn%20for%20n%20in%20numbers%20if%20n%20%25%202%20%3D%3D%200%5D%0A%20%20%20%20average%20%3D%20sum%28evens%29%20/%20len%28evens%29%0A%20%20%20%20return%20average%0A%0Aresult%20%3D%20average_wrong%28%5B123,%20456,%20789%5D%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) is again helpful at visualizing the error interactively: Creating the `list` object `evens` eventually references takes *16* computational steps, namely two for managing the list comprehension, one for setting up an empty `list` object, *twelve* for filling it with elements derived from `numbers` in the global scope (i.e., that is the error), and one to make `evens` reference it (cf., steps 6-21).\n",
+ "\n",
+ "The frames logic shown by PythonTutor is the mechanism with which Python not only manages the names inside *one* function call but also for *many* potentially *simultaneous* calls, as revealed in [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/00_content.ipynb#Trivial-Example:-Countdown). It is the reason why we may reuse the same names for the parameters and variables inside both `average_evens()` and `average_wrong()` without Python mixing them up. So, as we already read in the [Zen of Python ](https://www.python.org/dev/peps/pep-0020/), \"namespaces are one honking great idea\" (cf., `import this`), and a frame is just a special kind of namespace."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Shadowing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Code gets even more confusing when variables by the *same* name from *different* scopes collide. In particular, what should we expect to happen if a function \"changes\" a globally defined variable in its body?\n",
+ "\n",
+ "`average_evens()` below works like `average_evens()` above except that it rounds the numbers in `integers` with the built-in [round() ](https://docs.python.org/3/library/functions.html#round) function before filtering and averaging them. [round() ](https://docs.python.org/3/library/functions.html#round) returns `int` objects independent of its argument being an `int` or a `float` object. On the first line in its body, `average_evens()` introduces a *local* variable `numbers` whose name collides with the one defined in the global scope."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def average_evens(integers):\n",
+ " \"\"\"Calculate the average of all even numbers in a list.\n",
+ "\n",
+ " Args:\n",
+ " integers (list of int's/float's): numbers to be averaged;\n",
+ " if non-whole numbers are provided, they are rounded\n",
+ "\n",
+ " Returns:\n",
+ " average (float)\n",
+ " \"\"\"\n",
+ " numbers = [round(n) for n in integers]\n",
+ " evens = [n for n in numbers if n % 2 == 0]\n",
+ " average = sum(evens) / len(evens)\n",
+ " return average"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As a good practice, let's first \"verify\" that `average_evens()` is \"correct\" by calling it with inputs for which we can calculate the answer in our heads. Treating a function as a \"black box\" (i.e., input-output specification) when testing is also called [unit testing ](https://en.wikipedia.org/wiki/Unit_testing) and plays an important role in modern software engineering."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42.0"
+ ]
+ },
+ "execution_count": 49,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_evens([40.0, 41.1, 42.2, 43.3, 44.4])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Such tests are often and conveniently expressed with the `assert` statement (cf., [reference ](https://docs.python.org/3/reference/simple_stmts.html#the-assert-statement)): If the expression following `assert` evaluates to `True`, nothing happens."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "assert average_evens([40.0, 41.1, 42.2, 43.3, 44.4]) == 42.0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, if the expression evaluates to `False`, an `AssertionError` is raised."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "AssertionError",
+ "evalue": "",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[51], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m average_evens([\u001b[38;5;241m40.0\u001b[39m, \u001b[38;5;241m41.1\u001b[39m, \u001b[38;5;241m42.2\u001b[39m, \u001b[38;5;241m43.3\u001b[39m, \u001b[38;5;241m44.4\u001b[39m]) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m87.0\u001b[39m\n",
+ "\u001b[0;31mAssertionError\u001b[0m: "
+ ]
+ }
+ ],
+ "source": [
+ "assert average_evens([40.0, 41.1, 42.2, 43.3, 44.4]) == 87.0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Calling `average_evens()` leaves `numbers` in the global scope unchanged."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ "execution_count": 52,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To add to the confusion, let's also pass the global `numbers` list as an argument to `average_evens()`. The return value is the same as before."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 53,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_evens(numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In summary, Python is smart enough to keep all the involved `numbers` variables apart. So, the global `numbers` variable is still referencing the *same* `list` object as before."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ "execution_count": 54,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The reason why everything works is that *every* time we (re-)assign an object to a variable *inside* a function's body with the `=` statement, this is done in the *local* scope by default. There are ways to change variables existing in an outer scope from within a function, but this is a rather advanced topic.\n",
+ "\n",
+ "[PythonTutor ](http://pythontutor.com/visualize.html#code=numbers%20%3D%20%5B7,%2011,%208,%205,%203,%2012,%202,%206,%209,%2010,%201,%204%5D%0A%0Adef%20average_evens%28integers%29%3A%0A%20%20%20%20numbers%20%3D%20%5Bround%28n%29%20for%20n%20in%20integers%5D%0A%20%20%20%20evens%20%3D%20%5Bn%20for%20n%20in%20numbers%20if%20n%20%25%202%20%3D%3D%200%5D%0A%20%20%20%20average%20%3D%20sum%28evens%29%20/%20len%28evens%29%0A%20%20%20%20return%20average%0A%0Aresult%20%3D%20average_evens%28%5B40.0,%2041.1,%2042.2,%2043.3,%2044.4%5D%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) shows how *two* `numbers` variables exist in *different* scopes referencing *different* objects (cf., steps 14-25) when we execute `average_evens([40.0, 41.1, 42.2, 43.3, 44.4])`.\n",
+ "\n",
+ "Variables whose names collide with the ones of variables in enclosing scopes - and the global scope is just the most enclosing scope - are said to **shadow** them.\n",
+ "\n",
+ "While this is not a problem for Python, it may lead to less readable code for humans and should be avoided if possible. But, as the software engineering wisdom goes, \"[naming things](https://skeptics.stackexchange.com/questions/19836/has-phil-karlton-ever-said-there-are-only-two-hard-things-in-computer-science)\" is often considered a hard problem as well, and we have to be prepared to encounter shadowing variables.\n",
+ "\n",
+ "Shadowing also occurs if a parameter in the function definition goes by the same name as a variable in an outer scope. Below, `average_evens()` is identical to the first version in this chapter except that the parameter `integers` is now called `numbers` as well."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def average_evens(numbers):\n",
+ " \"\"\"Calculate the average of all even numbers in a list.\n",
+ "\n",
+ " Args:\n",
+ " numbers (list of int's): whole numbers to be averaged\n",
+ "\n",
+ " Returns:\n",
+ " average (float)\n",
+ " \"\"\"\n",
+ " evens = [n for n in numbers if n % 2 == 0]\n",
+ " average = sum(evens) / len(evens)\n",
+ " return average"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 56,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_evens(numbers)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ "execution_count": 57,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[PythonTutor ](http://pythontutor.com/visualize.html#code=numbers%20%3D%20%5B7,%2011,%208,%205,%203,%2012,%202,%206,%209,%2010,%201,%204%5D%0A%0Adef%20average_evens%28numbers%29%3A%0A%20%20%20%20evens%20%3D%20%5Bn%20for%20n%20in%20numbers%20if%20n%20%25%202%20%3D%3D%200%5D%0A%20%20%20%20average%20%3D%20sum%28evens%29%20/%20len%28evens%29%0A%20%20%20%20return%20average%0A%0Aresult%20%3D%20average_evens%28numbers%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) reveals that in this example there are *two* `numbers` variables in *different* scope referencing the *same* `list` object in memory (cf., steps 4-23)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Positional vs. Keyword Arguments"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "So far, we have specified only one parameter in each of our user-defined functions. In [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#%28Arithmetic%29-Operators), however, we saw the built-in [divmod() ](https://docs.python.org/3/library/functions.html#divmod) function take two arguments. And, the order in which they are passed in matters! Whenever we call a function and list its arguments in a comma separated manner, we say that we pass in the arguments *by position* or refer to them as **positional arguments**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(4, 2)"
+ ]
+ },
+ "execution_count": 58,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "divmod(42, 10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(0, 10)"
+ ]
+ },
+ "execution_count": 59,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "divmod(10, 42)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For many functions, there is a natural order to the arguments: For example, for any kind of division passing the dividend first and the divisor second seems intuitive. But what if that is not the case in another setting? For example, let's create a close relative of the above `average_evens()` function that also scales the resulting average by a factor. What is more natural? Passing in `numbers` first? Or `scalar`? There is no obvious way and we continue with the first alternative for no concrete reason."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def scaled_average_evens(numbers, scalar):\n",
+ " \"\"\"Calculate the scaled average of all even numbers in a list.\n",
+ "\n",
+ " Args:\n",
+ " numbers (list of int's/float's): numbers to be averaged;\n",
+ " if non-whole numbers are provided, they are rounded\n",
+ " scalar (float): multiplies the average\n",
+ "\n",
+ " Returns:\n",
+ " scaled_average (float)\n",
+ " \"\"\"\n",
+ " numbers = [round(n) for n in numbers]\n",
+ " evens = [n for n in numbers if n % 2 == 0]\n",
+ " average = sum(evens) / len(evens)\n",
+ " return scalar * average"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As with [divmod() ](https://docs.python.org/3/library/functions.html#divmod), we may pass in the arguments by position."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "14.0"
+ ]
+ },
+ "execution_count": 61,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "scaled_average_evens(numbers, 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Now, this function call is a bit harder to understand as we always need to remember what the `2` means. This becomes even harder with more parameters.\n",
+ "\n",
+ "Luckily, we may also pass in arguments *by name*. Then, we refer to them as **keyword arguments**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "14.0"
+ ]
+ },
+ "execution_count": 62,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "scaled_average_evens(numbers=numbers, scalar=2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When passing all arguments by name, we may do so in any order."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "14.0"
+ ]
+ },
+ "execution_count": 63,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "scaled_average_evens(scalar=2, numbers=numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We may even combine positional and keyword arguments in the same function call."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "14.0"
+ ]
+ },
+ "execution_count": 64,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "scaled_average_evens(numbers, scalar=2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Unfortunately, there are ways to screw this up with a `SyntaxError`: If positional and keyword arguments are mixed, the keyword arguments *must* come last."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "positional argument follows keyword argument (159253642.py, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m Cell \u001b[0;32mIn[65], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m scaled_average_evens(numbers=numbers, 2)\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m positional argument follows keyword argument\n"
+ ]
+ }
+ ],
+ "source": [
+ "scaled_average_evens(numbers=numbers, 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Similarly, we must always pass in the right number of arguments. Otherwise, a `TypeError` is raised."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "scaled_average_evens() missing 1 required positional argument: 'scalar'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[66], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mscaled_average_evens\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnumbers\u001b[49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mTypeError\u001b[0m: scaled_average_evens() missing 1 required positional argument: 'scalar'"
+ ]
+ }
+ ],
+ "source": [
+ "scaled_average_evens(numbers)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 67,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "scaled_average_evens() takes 2 positional arguments but 3 were given",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[67], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mscaled_average_evens\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnumbers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mTypeError\u001b[0m: scaled_average_evens() takes 2 positional arguments but 3 were given"
+ ]
+ }
+ ],
+ "source": [
+ "scaled_average_evens(numbers, 2, 3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Modularization"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Defining `average_evens()` and `scaled_average_evens()` as above leads to a repetition of most of their code. That is *not* good as such a redundancy makes a code base hard to maintain in the long run: Whenever we change the logic in one function, we must *not* forget to do so for the other function as well. And, most likely, we forget about such issues in larger projects.\n",
+ "\n",
+ "Below, three of four lines in the functions' bodies are identical!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def average_evens(numbers):\n",
+ " \"\"\" ... ... ... \"\"\"\n",
+ " numbers = [round(n) for n in numbers]\n",
+ " evens = [n for n in numbers if n % 2 == 0]\n",
+ " average = sum(evens) / len(evens)\n",
+ " return average"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 69,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "-"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def scaled_average_evens(numbers, scalar):\n",
+ " \"\"\" ... ... ... \"\"\"\n",
+ " numbers = [round(n) for n in numbers]\n",
+ " evens = [n for n in numbers if n % 2 == 0]\n",
+ " average = sum(evens) / len(evens)\n",
+ " return scalar * average"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A better way is to design related functions in a **modular** fashion such that they reuse each other's code.\n",
+ "\n",
+ "For example, as not scaling an average is just a special case of scaling it with `1`, we could redefine the two functions like below: In this version, the function resembling the *special* case, `average_evens()`, **forwards** the call to the more *general* function, `scaled_average_evens()`, passing a `scalar` argument of `1`. As the name `scaled_average_evens` within the body of `average_evens()` is looked up each time the function is *being* executed, we may define `average_evens()` before `scaled_average_evens()`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 70,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def average_evens(numbers):\n",
+ " \"\"\" ... ... ... \"\"\"\n",
+ " return scaled_average_evens(numbers, scalar=1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 71,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "-"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def scaled_average_evens(numbers, scalar):\n",
+ " \"\"\" ... ... ... \"\"\"\n",
+ " numbers = [round(n) for n in numbers]\n",
+ " evens = [n for n in numbers if n % 2 == 0]\n",
+ " average = sum(evens) / len(evens)\n",
+ " return scalar * average"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "After **refactoring** the functions, it is a good idea to test them again."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 72,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "assert average_evens(numbers) == 7.0"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "assert scaled_average_evens(numbers, 2) == 14.0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Default Arguments"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "*Assuming* that scaling the average occurs rarely, it may be a good idea to handle both cases in *one* function definition by providing a **default argument** of `1` for the `scalar` parameter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 74,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def average_evens(numbers, scalar=1):\n",
+ " \"\"\"Calculate the average of all even numbers in a list.\n",
+ "\n",
+ " Args:\n",
+ " numbers (list of int's/float's): numbers to be averaged;\n",
+ " if non-whole numbers are provided, they are rounded\n",
+ " scalar (float, optional): multiplies the average; defaults to 1\n",
+ "\n",
+ " Returns:\n",
+ " scaled_average (float)\n",
+ " \"\"\"\n",
+ " numbers = [round(n) for n in numbers]\n",
+ " evens = [n for n in numbers if n % 2 == 0]\n",
+ " average = sum(evens) / len(evens)\n",
+ " return scalar * average"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Now, we call the function with or without passing a `scalar` argument.\n",
+ "\n",
+ "If `scalar` is *not* passed in, it automatically takes the value `1`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 75,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 75,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_evens(numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If `scalar` is passed in, this may be done as either a positional or a keyword argument. Which of the two calls where `scalar` is `2` is faster to understand in a larger program?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 76,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "14.0"
+ ]
+ },
+ "execution_count": 76,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_evens(numbers, 2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 77,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "14.0"
+ ]
+ },
+ "execution_count": 77,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_evens(numbers, scalar=2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Keyword-only Arguments"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Because we *assumed* that scaling occurs rarely, we would prefer that our new version of `average_evens()` be called with a *keyword argument* whenever `scalar` is passed in. Then, a function call is never ambiguous when reading the source code.\n",
+ "\n",
+ "Python offers a **keyword-only** syntax when defining a function that *forces* a caller to pass the `scalar` argument *by name* if it is passed in at all: To do so, we place an asterisk `*` before the arguments that may only be passed in by name. Note that the keyword-only syntax also works *without* a default argument."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 78,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def average_evens(numbers, *, scalar=1):\n",
+ " \"\"\"Calculate the average of all even numbers in a list.\n",
+ "\n",
+ " Args:\n",
+ " numbers (list of int's/float's): numbers to be averaged;\n",
+ " if non-whole numbers are provided, they are rounded\n",
+ " scalar (float, optional): multiplies the average; defaults to 1\n",
+ "\n",
+ " Returns:\n",
+ " scaled_average (float)\n",
+ " \"\"\"\n",
+ " numbers = [round(n) for n in numbers]\n",
+ " evens = [n for n in numbers if n % 2 == 0]\n",
+ " average = sum(evens) / len(evens)\n",
+ " return scalar * average"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As before, we may call `average_evens()` without passing in an argument for the `scalar` parameter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 79,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 79,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_evens(numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If we call `average_evens()` with a `scalar` argument, we *must* use keyword notation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 80,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "14.0"
+ ]
+ },
+ "execution_count": 80,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "average_evens(numbers, scalar=2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If instead we pass in `scalar` as a positional argument, we get a `TypeError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 81,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "average_evens() takes 1 positional argument but 2 were given",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[81], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43maverage_evens\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnumbers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mTypeError\u001b[0m: average_evens() takes 1 positional argument but 2 were given"
+ ]
+ }
+ ],
+ "source": [
+ "average_evens(numbers, 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "## Anonymous Functions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `def` statement is a statement because of its *side effect* of creating a *new* name that references a *new* `function` object in memory.\n",
+ "\n",
+ "We can thus think of it as doing *two* things **atomically** (i.e., either both of them happen or none). First, a `function` object is created that contains the concrete $0$s and $1$s that resemble the instructions we put into the function's body. In the context of a function, these $0$s and $1$s are also called **[byte code ](https://en.wikipedia.org/wiki/Bytecode)**. Then, a name referencing the new `function` object is created.\n",
+ "\n",
+ "Only this second aspect makes `def` a statement: Merely creating a new object in memory without making it accessible for later reference does *not* constitute a side effect because the state the program is *not* changed. After all, if we cannot reference an object, how do we know it exists in the first place?\n",
+ "\n",
+ "Python provides a `lambda` expression syntax that allows us to *only* create a `function` object in memory *without* making a name reference it (cf., [reference ](https://docs.python.org/3/reference/expressions.html#lambda)). It starts with the keyword `lambda` followed by an optional listing of comma separated parameters, a mandatory colon, and *one* expression that serves as the return value of the resulting `function` object. Because it does *not* create a name referencing the object, we effectively create \"anonymous\" functions with it.\n",
+ "\n",
+ "In the example, we create a `function` object that adds `3` to the only argument passed in as the parameter `x` and returns that sum."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 82,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(x)>"
+ ]
+ },
+ "execution_count": 82,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "lambda x: x + 3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If you think this is rather pointless to do, you are absolutely correct!\n",
+ "\n",
+ "We created a `function` object, dit *not* call it, and Python immediately forgot about it. So what's the point?\n",
+ "\n",
+ "To inspect the object created by a `lambda` expression, we use the simple `=` statement and assign it to the variable `add_three`, which is really `add_three()` as per our convention from above."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 83,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "add_three = lambda x: x + 3 # we could and should use def instead"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[type() ](https://docs.python.org/3/library/functions.html#type) and [callable() ](https://docs.python.org/3/library/functions.html#callable) confirm that `add_three` is indeed a callable `function` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 84,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "function"
+ ]
+ },
+ "execution_count": 84,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(add_three)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 85,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 85,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "callable(add_three)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Now we may call `add_three()` as if we defined it with the `def` statement."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 86,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 86,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "add_three(39)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Alternatively, we could call an `function` object created with a `lambda` expression right away (i.e., without assigning it to a variable), which looks quite weird for now as we need *two* pairs of parentheses: The first one serves as a delimiter whereas the second represents the call operator."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 87,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 87,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(lambda x: x + 3)(39)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The main point of having functions without a reference to them is to use them in a situation where we know ahead of time that we use the function only *once*.\n",
+ "\n",
+ "Popular applications of lambda expressions occur in combination with the **map-filter-reduce** paradigm (cf., [Chapter 8 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/08_mfr/00_content.ipynb#Lambda-Expressions))."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/02_functions/01_exercises_sphere-volume.ipynb b/02_functions/01_exercises_sphere-volume.ipynb
new file mode 100644
index 0000000..49f957e
--- /dev/null
+++ b/02_functions/01_exercises_sphere-volume.ipynb
@@ -0,0 +1,241 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Run All*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *after* finishing the exercises to ensure that your solution runs top to bottom *without* any errors. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/02_functions/01_exercises.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 2: Functions & Modularization (Coding Exercises)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The exercises below assume that you have read the [first part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/00_content.ipynb) of Chapter 2.\n",
+ "\n",
+ "The `...`'s in the code cells indicate where you need to fill in code snippets. The number of `...`'s within a code cell give you a rough idea of how many lines of code are needed to solve the task. You should not need to create any additional code cells for your final solution. However, you may want to use temporary code cells to try out some ideas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Volume of a Sphere"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: The [volume of a sphere ](https://en.wikipedia.org/wiki/Sphere) is defined as $\\frac{4}{3} * \\pi * r^3$. Calculate this value for $r=10.0$ and round it to 10 digits after the comma.\n",
+ "\n",
+ "Hints:\n",
+ "- use an appropriate approximation for $\\pi$\n",
+ "- you may use the [standard library ](https://docs.python.org/3/library/index.html) to do so if you have already looked at the [second part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/02_content.ipynb) of Chapter 2."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ... # you may drop this cell and use your own approximation for Pi"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: Encapsulate the logic into a function `sphere_volume()` that takes one *positional* argument `radius` and one *keyword-only* argument `digits` defaulting to `5`. The volume should be returned as a `float` object under *all* circumstances."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def sphere_volume(...):\n",
+ " \"\"\"Calculate the volume of a sphere.\n",
+ "\n",
+ " Args:\n",
+ " radius (float): radius of the sphere\n",
+ " digits (optional, int): number of digits\n",
+ " for rounding the resulting volume\n",
+ "\n",
+ " Returns:\n",
+ " volume (float)\n",
+ " \"\"\"\n",
+ " return ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: Evaluate the function with `radius = 100.0` and 1, 5, 10, 15, and 20 digits respectively."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "radius = ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sphere_volume(...)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sphere_volume(...)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sphere_volume(...)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sphere_volume(...)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sphere_volume(...)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: What observation do you make?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: Using the [range() ](https://docs.python.org/3/library/functions.html#func-range) built-in, write a `for`-loop and calculate the volume of a sphere with `radius = 42.0` for all `digits` from `1` through `20`. Print out each volume on a separate line.\n",
+ "\n",
+ "Note: This is the first task where you need to use the built-in [print() ](https://docs.python.org/3/library/functions.html#print) function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "radius = ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for ... in ...:\n",
+ " ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: What lesson do you learn about the `float` type?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/02_functions/02_content.ipynb b/02_functions/02_content.ipynb
new file mode 100644
index 0000000..5e663cc
--- /dev/null
+++ b/02_functions/02_content.ipynb
@@ -0,0 +1,1639 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/02_functions/02_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 2: Functions & Modularization (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "So far, we have only used what we refer to as **core** Python in this book. By this, we mean all the syntactical rules as specified in the [language reference ](https://docs.python.org/3/reference/) and a minimal set of about 50 built-in [functions ](https://docs.python.org/3/library/functions.html). With this, we could already implement any algorithm or business logic we can think of!\n",
+ "\n",
+ "However, after our first couple of programs, we would already start seeing recurring patterns in the code we write. In other words, we would constantly be \"reinventing the wheel\" in each new project.\n",
+ "\n",
+ "Would it not be smarter to pull out the reusable components from our programs and put them into some project independent **library** of generically useful functionalities? Then we would only need a way of including these **utilities** in our projects.\n",
+ "\n",
+ "As all programmers across all languages face this very same issue, most programming languages come with a so-called **[standard library ](https://en.wikipedia.org/wiki/Standard_library)** that provides utilities to accomplish everyday tasks without much code. Examples are making an HTTP request to some website, open and read popular file types (e.g., CSV or Excel files), do something on a computer's file system, and many more."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The Standard Library"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Python also comes with a [standard library ](https://docs.python.org/3/library/index.html) that is structured into coherent modules and packages for given topics: A **module** is just a plain text file with the file extension *.py* that contains Python code while a **package** is a folder that groups several related modules.\n",
+ "\n",
+ "The code in the [standard library ](https://docs.python.org/3/library/index.html) is contributed and maintained by many volunteers around the world. In contrast to so-called \"third-party\" packages (cf., the next section below), the Python core development team closely monitors and tests the code in the [standard library ](https://docs.python.org/3/library/index.html). Consequently, we can be reasonably sure that anything provided by it works correctly independent of our computer's operating system and will most likely also be there in the next Python versions. Parts in the [standard library ](https://docs.python.org/3/library/index.html) that are computationally expensive are often rewritten in C and, therefore, much faster than anything we could write in Python ourselves. So, whenever we can solve a problem with the help of the [standard library ](https://docs.python.org/3/library/index.html), it is almost always the best way to do so as well.\n",
+ "\n",
+ "The [standard library ](https://docs.python.org/3/library/index.html) has grown very big over the years, and we refer to the website [PYMOTW](https://pymotw.com/3/index.html) (i.e., \"Python Module of the Week\") that features well written introductory tutorials and how-to guides to most parts of the library. The same author also published a [book](https://www.amazon.com/Python-Standard-Library-Example-Developers/dp/0134291050/ref=as_li_ss_tl?ie=UTF8&qid=1493563121&sr=8-1&keywords=python+3+standard+library+by+example) that many Pythonistas keep on their shelf for reference. Knowing what is in the [standard library ](https://docs.python.org/3/library/index.html) is quite valuable for solving real-world tasks quickly.\n",
+ "\n",
+ "Throughout this book, we look at many modules and packages from the [standard library ](https://docs.python.org/3/library/index.html) in more depth, starting with the [math ](https://docs.python.org/3/library/math.html) and [random ](https://docs.python.org/3/library/random.html) modules in this chapter."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### [math ](https://docs.python.org/3/library/math.html) Module"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [math ](https://docs.python.org/3/library/math.html) module provides non-trivial mathematical functions like $sin(x)$ and constants like $\\pi$ or $\\text{e}$.\n",
+ "\n",
+ "To make functions and variables defined \"somewhere else\" available in our current program, we must first **import** them with the `import` statement (cf., [reference ](https://docs.python.org/3/reference/simple_stmts.html#import)). "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import math"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This creates the variable `math` that references a **[module object ](https://docs.python.org/3/glossary.html#term-module)** (i.e., type `module`) in memory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "math"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140177537558144"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(math)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "module"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(math)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`module` objects serve as namespaces to organize the names inside a module. In this context, a namespace is nothing but a prefix that avoids collision with the variables already defined at the location where we import the module into.\n",
+ "\n",
+ "Let's see what we can do with the `math` module.\n",
+ "\n",
+ "The [dir() ](https://docs.python.org/3/library/functions.html#dir) built-in function may also be used with an argument passed in. Ignoring the dunder-style names, `math` offers quite a lot of names. As we cannot know at this point if a listed name refers to a function or an ordinary variable, we use the more generic term **attribute** to mean either one of them."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['__doc__',\n",
+ " '__file__',\n",
+ " '__loader__',\n",
+ " '__name__',\n",
+ " '__package__',\n",
+ " '__spec__',\n",
+ " 'acos',\n",
+ " 'acosh',\n",
+ " 'asin',\n",
+ " 'asinh',\n",
+ " 'atan',\n",
+ " 'atan2',\n",
+ " 'atanh',\n",
+ " 'cbrt',\n",
+ " 'ceil',\n",
+ " 'comb',\n",
+ " 'copysign',\n",
+ " 'cos',\n",
+ " 'cosh',\n",
+ " 'degrees',\n",
+ " 'dist',\n",
+ " 'e',\n",
+ " 'erf',\n",
+ " 'erfc',\n",
+ " 'exp',\n",
+ " 'exp2',\n",
+ " 'expm1',\n",
+ " 'fabs',\n",
+ " 'factorial',\n",
+ " 'floor',\n",
+ " 'fmod',\n",
+ " 'frexp',\n",
+ " 'fsum',\n",
+ " 'gamma',\n",
+ " 'gcd',\n",
+ " 'hypot',\n",
+ " 'inf',\n",
+ " 'isclose',\n",
+ " 'isfinite',\n",
+ " 'isinf',\n",
+ " 'isnan',\n",
+ " 'isqrt',\n",
+ " 'lcm',\n",
+ " 'ldexp',\n",
+ " 'lgamma',\n",
+ " 'log',\n",
+ " 'log10',\n",
+ " 'log1p',\n",
+ " 'log2',\n",
+ " 'modf',\n",
+ " 'nan',\n",
+ " 'nextafter',\n",
+ " 'perm',\n",
+ " 'pi',\n",
+ " 'pow',\n",
+ " 'prod',\n",
+ " 'radians',\n",
+ " 'remainder',\n",
+ " 'sin',\n",
+ " 'sinh',\n",
+ " 'sqrt',\n",
+ " 'sumprod',\n",
+ " 'tan',\n",
+ " 'tanh',\n",
+ " 'tau',\n",
+ " 'trunc',\n",
+ " 'ulp']"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "dir(math)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Common mathematical constants and functions are now available via the dot operator `.` on the `math` object. This operator is sometimes also called the **attribute access operator**, in line with the just introduced term."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3.141592653589793"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "math.pi"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2.718281828459045"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "math.e"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "math.sqrt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on built-in function sqrt in module math:\n",
+ "\n",
+ "sqrt(x, /)\n",
+ " Return the square root of x.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "help(math.sqrt)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1.4142135623730951"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "math.sqrt(2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Observe how the arguments passed to functions do not need to be just variables or simple literals. Instead, we may pass in any *expression* that evaluates to a *new* object of the type the function expects.\n",
+ "\n",
+ "So just as a reminder from the expression vs. statement discussion in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/03_content.ipynb#Expressions): An expression is *any* syntactically correct combination of variables and literals with operators. And the call operator `()` is yet another operator. So both of the next two code cells are just expressions! They have no permanent side effects in memory. We may execute them as often as we want *without* changing the state of the program (i.e., this Jupyter notebook).\n",
+ "\n",
+ "So, regarding the very next cell in particular: Although the `2 ** 2` creates a *new* object `4` in memory that is then immediately passed into the [math.sqrt() ](https://docs.python.org/3/library/math.html#math.sqrt) function, once that function call returns, \"all is lost\" and the newly created `4` object is forgotten again, as well as the return value of [math.sqrt() ](https://docs.python.org/3/library/math.html#math.sqrt)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2.0"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "math.sqrt(2 ** 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Even the **composition** of several function calls only constitutes another expression."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "10.0"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "math.sqrt(sum([99, 100, 101]) / 3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If we only need one particular function from a module, we may also use the alternative `from ... import ...` syntax.\n",
+ "\n",
+ "This does *not* create a module object but only makes a variable in our current location reference an object defined inside a module directly."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "from math import sqrt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4.0"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sqrt(16)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### [random ](https://docs.python.org/3/library/random.html) Module"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Often, we need a random variable, for example, when we want to build a simulation. The [random ](https://docs.python.org/3/library/random.html) module in the [standard library ](https://docs.python.org/3/library/index.html) often suffices for that."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import random"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "random"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Besides the usual dunder-style attributes, the built-in [dir() ](https://docs.python.org/3/library/functions.html#dir) function lists some attributes in an upper case naming convention and many others starting with a *single* underscore `_`. To understand the former, we must wait until [Chapter 11 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/00_content.ipynb), while the latter is explained further below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['BPF',\n",
+ " 'LOG4',\n",
+ " 'NV_MAGICCONST',\n",
+ " 'RECIP_BPF',\n",
+ " 'Random',\n",
+ " 'SG_MAGICCONST',\n",
+ " 'SystemRandom',\n",
+ " 'TWOPI',\n",
+ " '_ONE',\n",
+ " '_Sequence',\n",
+ " '__all__',\n",
+ " '__builtins__',\n",
+ " '__cached__',\n",
+ " '__doc__',\n",
+ " '__file__',\n",
+ " '__loader__',\n",
+ " '__name__',\n",
+ " '__package__',\n",
+ " '__spec__',\n",
+ " '_accumulate',\n",
+ " '_acos',\n",
+ " '_bisect',\n",
+ " '_ceil',\n",
+ " '_cos',\n",
+ " '_e',\n",
+ " '_exp',\n",
+ " '_fabs',\n",
+ " '_floor',\n",
+ " '_index',\n",
+ " '_inst',\n",
+ " '_isfinite',\n",
+ " '_lgamma',\n",
+ " '_log',\n",
+ " '_log2',\n",
+ " '_os',\n",
+ " '_pi',\n",
+ " '_random',\n",
+ " '_repeat',\n",
+ " '_sha512',\n",
+ " '_sin',\n",
+ " '_sqrt',\n",
+ " '_test',\n",
+ " '_test_generator',\n",
+ " '_urandom',\n",
+ " '_warn',\n",
+ " 'betavariate',\n",
+ " 'binomialvariate',\n",
+ " 'choice',\n",
+ " 'choices',\n",
+ " 'expovariate',\n",
+ " 'gammavariate',\n",
+ " 'gauss',\n",
+ " 'getrandbits',\n",
+ " 'getstate',\n",
+ " 'lognormvariate',\n",
+ " 'normalvariate',\n",
+ " 'paretovariate',\n",
+ " 'randbytes',\n",
+ " 'randint',\n",
+ " 'random',\n",
+ " 'randrange',\n",
+ " 'sample',\n",
+ " 'seed',\n",
+ " 'setstate',\n",
+ " 'shuffle',\n",
+ " 'triangular',\n",
+ " 'uniform',\n",
+ " 'vonmisesvariate',\n",
+ " 'weibullvariate']"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "dir(random)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [random.random() ](https://docs.python.org/3/library/random.html#random.random) function generates a uniformly distributed `float` number between $0$ (including) and $1$ (excluding)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "random.random"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on built-in function random:\n",
+ "\n",
+ "random() method of random.Random instance\n",
+ " random() -> x in the interval [0, 1).\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "help(random.random)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.782609162553633"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "random.random()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While we could build some conditional logic with an `if` statement to map the number generated by [random.random() ](https://docs.python.org/3/library/random.html#random.random) to a finite set of elements manually, the [random.choice() ](https://docs.python.org/3/library/random.html#random.choice) function provides a lot more **convenience** for us. We call it with, for example, the `numbers` list and it draws one element out of it with equal chance."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ">"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "random.choice"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on method choice in module random:\n",
+ "\n",
+ "choice(seq) method of random.Random instance\n",
+ " Choose a random element from a non-empty sequence.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "help(random.choice)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "numbers = [7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "-"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "random.choice(numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To reproduce the *same* random numbers in a simulation each time we run it, we set the **[random seed ](https://en.wikipedia.org/wiki/Random_seed)**. It is good practice to do that at the beginning of a program or notebook. It becomes essential when we employ randomized machine learning algorithms, like the [Random Forest ](https://en.wikipedia.org/wiki/Random_forest), and want to obtain **reproducible** results for publication in academic journals.\n",
+ "\n",
+ "The [random ](https://docs.python.org/3/library/random.html) module provides the [random.seed() ](https://docs.python.org/3/library/random.html#random.seed) function to do that."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.6394267984578837"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "random.random()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.6394267984578837"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "random.random()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Third-party Packages"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As the Python community is based around open source, many developers publish their code, for example, on the Python Package Index [PyPI](https://pypi.org) from where anyone may download and install it for free using command-line based tools like [pip](https://pip.pypa.io/en/stable/) or [conda](https://conda.io/en/latest/). This way, we can always customize our Python installation even more. Managing many such packages is quite a deep topic on its own, sometimes fearfully called **[dependency hell ](https://en.wikipedia.org/wiki/Dependency_hell)**.\n",
+ "\n",
+ "The difference between the [standard library ](https://docs.python.org/3/library/index.html) and such **third-party** packages is that in the first case, the code goes through a much more formalized review process and is officially endorsed by the Python core developers. Yet, many third-party projects also offer the highest quality standards and are also relied on by many businesses and researchers.\n",
+ "\n",
+ "Throughout this book, we will look at many third-party libraries, mostly from Python's [scientific stack](https://scipy.org/about.html), a tightly coupled set of third-party libraries for storing **big data** efficiently (e.g., [numpy](http://www.numpy.org/)), \"wrangling\" (e.g., [pandas](https://pandas.pydata.org/)) and visualizing them (e.g., [matplotlib](https://matplotlib.org/) or [seaborn](https://seaborn.pydata.org/)), fitting classical statistical models (e.g., [statsmodels](http://www.statsmodels.org/)), training machine learning models (e.g., [sklearn](http://scikit-learn.org/)), and much more.\n",
+ "\n",
+ "Below, we briefly show how to install third-party libraries."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### [numpy](http://www.numpy.org/) Library"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[numpy](http://www.numpy.org/) is the de-facto standard in the Python world for handling **array-like** data. That is a fancy word for data that can be put into a matrix or vector format.\n",
+ "\n",
+ "As [numpy](http://www.numpy.org/) is *not* in the [standard library ](https://docs.python.org/3/library/index.html), it must be *manually* installed, for example, with the [pip](https://pip.pypa.io/en/stable/) tool. As mentioned in [Chapter 0 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/00_intro/00_content.ipynb#Markdown-Cells-vs.-Code-Cells), to execute terminal commands from within a Jupyter notebook, we start a code cell with an exclamation mark.\n",
+ "\n",
+ "If you are running this notebook with an installation of the [Anaconda Distribution](https://www.anaconda.com/distribution/), then [numpy](http://www.numpy.org/) is probably already installed. Running the cell below confirms that."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: numpy in /home/alexander/Repositories/intro-to-python/.venv/lib64/python3.12/site-packages (1.26.4)\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install numpy"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[numpy](http://www.numpy.org/) is conventionally imported with the shorter **idiomatic** name `np`. The `as` in the import statement changes the resulting variable name. It is a shortcut for the three lines `import numpy`, `np = numpy`, and `del numpy`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`np` is used in the same way as `math` or `random` above."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Let's convert the above `numbers` list into a vector-like object of type `numpy.ndarray`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "vec = np.array(numbers)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([ 7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4])"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "vec"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "numpy.ndarray"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(vec)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[numpy](http://www.numpy.org/) somehow magically adds new behavior to Python's built-in arithmetic operators. For example, we may now [scalar-multiply ](https://en.wikipedia.org/wiki/Scalar_multiplication) `vec`. Also, [numpy](http://www.numpy.org/)'s functions are implemented in highly optimized C code and, therefore, are fast, especially when dealing with bigger amounts of data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([14, 22, 16, 10, 6, 24, 4, 12, 18, 20, 2, 8])"
+ ]
+ },
+ "execution_count": 35,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "2 * vec"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This scalar multiplication would \"fail\" if we used a plain `list` object like `numbers` instead of an `numpy.ndarray` object like `vec`. The two types exhibit different **behavior** when used with the same operator, another example of **operator overloading**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4, 7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "2 * numbers # surprise, surprise"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[numpy](http://www.numpy.org/)'s `numpy.ndarray` objects integrate nicely with Python's built-in functions (e.g., [sum() ](https://docs.python.org/3/library/functions.html#sum)) or functions from the [standard library ](https://docs.python.org/3/library/index.html) (e.g., [random.choice() ](https://docs.python.org/3/library/random.html#random.choice))."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "78"
+ ]
+ },
+ "execution_count": 37,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sum(vec)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "random.choice(vec)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Local Modules and Packages"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For sure, we can create local modules and packages. In the Chapter 2 directory, there is a [*sample_module.py* ](https://github.com/webartifex/intro-to-python/blob/main/02_functions/sample_module.py) file that contains, among others, a function equivalent to the final version of `average_evens()`. To be realistic, this sample module is structured in a modular manner with several functions building on each other. It is best to skim over it *now* before reading on.\n",
+ "\n",
+ "To make code we put into a *.py* file available in our program, we import it as a module just as we did above with modules in the [standard library ](https://docs.python.org/3/library/index.html) or third-party packages.\n",
+ "\n",
+ "The `pwd` utility tells us in which directory Python is currently in. We refer to that as the **working directory**, and `pwd` reads \"print working directory.\" JupyterLab automatically sets this to the directory in which the notebook is in."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/home/alexander/Repositories/intro-to-python/02_functions\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pwd"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The *name* to be imported is the file's name except for the *.py* part. For this to work, the file's name *must* adhere to the *same* rules as hold for [variable names ](https://docs.python.org/3/reference/lexical_analysis.html#identifiers) in general.\n",
+ "\n",
+ "What happens during an import is as follows. When Python sees the `import sample_module` part, it first creates a *new* object of type `module` in memory. This is effectively an *empty* namespace. Then, it executes the imported file's code from top to bottom. Whatever variables are still defined at the end of this, are put into the module's namespace. Only if the file's code does *not* raise an error, will Python make a variable in our current location (i.e., `mod` here) reference the created `module` object. Otherwise, it is discarded. In essence, it is as if we copied and pasted the file's code in place of the import statement. If we import an already imported module again, Python is smart enough to avoid doing all this work all over and does nothing."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import sample_module as mod"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 41,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "mod"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Disregarding the dunder-style attributes, `mod` defines the attributes `_round_all`, `_scaled_average`, `average`, `average_evens`, and `average_odds`, which are exactly the ones we would expect from reading the [*sample_module.py* ](https://github.com/webartifex/intro-to-python/blob/main/02_functions/sample_module.py) file.\n",
+ "\n",
+ "A convention when working with imported code is to *disregard* any attributes starting with a single underscore `_`. These are considered **private** and constitute **implementation details** the author of the imported code might change in a future version of his software. We *must not* rely on them in any way.\n",
+ "\n",
+ "In contrast, the three remaining **public** attributes are the functions `average()`, `average_evens()`, and `average_odds()` that we may use after the import."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['__builtins__',\n",
+ " '__cached__',\n",
+ " '__doc__',\n",
+ " '__file__',\n",
+ " '__loader__',\n",
+ " '__name__',\n",
+ " '__package__',\n",
+ " '__spec__',\n",
+ " '_round_all',\n",
+ " '_scaled_average',\n",
+ " 'average',\n",
+ " 'average_evens',\n",
+ " 'average_odds']"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "dir(mod)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We use the imported `mod.average_evens()` just like `average_evens()` defined in the [first part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/00_content.ipynb) of this chapter. The advantage we get from **modularization** with *.py* files is that we can now easily reuse functions across different Jupyter notebooks without redefining them again and again. Also, we can \"source out\" code that distracts from the storyline told in a notebook."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 43,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "mod.average_evens"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on function average_evens in module sample_module:\n",
+ "\n",
+ "average_evens(numbers, *, scalar=1)\n",
+ " Calculate the average of all even numbers in a list.\n",
+ "\n",
+ " Args:\n",
+ " numbers (list of int's/float's): numbers to be averaged;\n",
+ " if non-whole numbers are provided, they are rounded\n",
+ " scalar (float, optional): multiplies the average; defaults to 1\n",
+ "\n",
+ " Returns:\n",
+ " scaled_average (float)\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "help(mod.average_evens)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7.0"
+ ]
+ },
+ "execution_count": 45,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "mod.average_evens(numbers)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "14.0"
+ ]
+ },
+ "execution_count": 46,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "mod.average_evens(numbers, scalar=2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Packages are a generalization of modules, and we look at one in detail in [Chapter 11 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/04_content.ipynb#Packages-vs.-Modules).\n",
+ "\n",
+ "As a further reading on modules and packages, we refer to the [official tutorial ](https://docs.python.org/3/tutorial/modules.html)."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/02_functions/03_summary.ipynb b/02_functions/03_summary.ipynb
new file mode 100644
index 0000000..f5efdad
--- /dev/null
+++ b/02_functions/03_summary.ipynb
@@ -0,0 +1,90 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 2: Functions & Modularization (TL;DR)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A user-defined **function** is a **named sequence** of statements that perform a computation.\n",
+ "\n",
+ "Functions provide benefits as they\n",
+ "\n",
+ "- make programs easier to comprehend and debug for humans as they give names to the smaller parts of a larger program (i.e., they **modularize** a code base), and\n",
+ "- eliminate redundancies by allowing **reuse of code**.\n",
+ "\n",
+ "Functions are **defined** once with the `def` statement. Then, they may be **called** many times with the call operator `()`.\n",
+ "\n",
+ "They may process **parameterized** inputs, **passed** in as **arguments**, and output a **return value**.\n",
+ "\n",
+ "Arguments may be passed in by **position** or **keyword**. Some functions may even require **keyword-only** arguments.\n",
+ "\n",
+ "**Lambda expressions** create anonymous functions.\n",
+ "\n",
+ "Functions are a special kind of **callables**. Any object that may be **called** with the call operator `()` is a callable. Built-in functions and **constructors** are other kinds of callables.\n",
+ "\n",
+ "Core Python can be extended with code from either the **standard library** or **third-party** libraries.\n",
+ "\n",
+ "Outside Jupyter notebooks, Python code is put into **modules** that are grouped in **packages**."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/02_functions/04_review.ipynb b/02_functions/04_review.ipynb
new file mode 100644
index 0000000..f3b7ab9
--- /dev/null
+++ b/02_functions/04_review.ipynb
@@ -0,0 +1,229 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 2: Functions & Modularization (Review Questions)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The questions below assume that you have read the [first ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/00_content.ipynb) and the [second ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/02_content.ipynb) part of Chapter 2.\n",
+ "\n",
+ "Be concise in your answers! Most questions can be answered in *one* sentence."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Essay Questions "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: What behavior of the `def` statement makes it a **statement**? Is there a way to use an **expression** to create a function?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: One of the first confusions of experienced programmers coming from other languages to Python regards the observation that **\"everything in Python is an object\"** (cf., this [discussion](https://www.reddit.com/r/learnpython/comments/8rypx9/everything_in_python_is_an_object/)). How does this relate to **functions**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: What does it mean for a variable to go out of **scope**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: How can a **global** variable be **shadowed**? Is this good or bad?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: Explain the concept of **forwarding** a **function call**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: What are **keyword-only arguments** and when is it appropriate to use them?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7**: What are **callables**? How do they relate to `function` objects?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## True / False Questions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Motivate your answer with *one short* sentence!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q8**: A mere function **call** is just an **expression**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q9**: When using the `import` statement, we need to ensure that the imported attributes do *not* overwrite any already defined variables and functions."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q10:** Functions always have a name by which we can call them."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q11**: The [standard library ](https://docs.python.org/3/library/index.html) is a collection of numerical tools often used in scientific computing, for example, advanced mathematical functions or utilities for simulation."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/02_functions/sample_module.py b/02_functions/sample_module.py
new file mode 100644
index 0000000..3a097e1
--- /dev/null
+++ b/02_functions/sample_module.py
@@ -0,0 +1,76 @@
+"""This is a sample module.
+
+It defines three functions average(), average_evens(), and average_odds().
+The point is to show how we can put Python code in a .py file to be re-used
+in some other place.
+
+We should never forget to document the code as well, both on the module
+level (i.e., this docstring) but also in every function it defines.
+
+When imported, Python modules are executed top to bottom before the flow of
+execution returns to wherever they were imported into.
+
+An important convention is to prefix variables and functions that are not to
+be used outside the module with a single underscore "_". This way, we can
+design the code within a module in a modular fashion and only "export" what we
+want.
+
+Here, all three functions internally forward parts of their computations
+to the utility functions _round_all() and _scaled_average() that contain all
+the logic common to the three functions.
+
+While this example is stylized, it shows how Python modules are often
+designed.
+"""
+
+def _round_all(numbers):
+ """Internal utility function to round all numbers in a list."""
+ return [round(n) for n in numbers]
+
+
+def _scaled_average(numbers, scalar):
+ """Internal utility function to calculate scaled averages."""
+ average = sum(numbers) / len(numbers)
+ return scalar * average
+
+
+def average(numbers, *, scalar=1):
+ """Calculate the average of all numbers in a list.
+
+ Args:
+ numbers (list of int's/float's): numbers to be averaged;
+ if non-whole numbers are provided, they are rounded
+ scalar (float, optional): multiplies the average; defaults to 1
+
+ Returns:
+ scaled_average (float)
+ """
+ return _scaled_average(_round_all(numbers), scalar)
+
+
+def average_evens(numbers, *, scalar=1):
+ """Calculate the average of all even numbers in a list.
+
+ Args:
+ numbers (list of int's/float's): numbers to be averaged;
+ if non-whole numbers are provided, they are rounded
+ scalar (float, optional): multiplies the average; defaults to 1
+
+ Returns:
+ scaled_average (float)
+ """
+ return _scaled_average([n for n in _round_all(numbers) if n % 2 == 0], scalar)
+
+
+def average_odds(numbers, *, scalar=1):
+ """Calculate the average of all odd numbers in a list.
+
+ Args:
+ numbers (list of int's/float's): numbers to be averaged;
+ if non-whole numbers are provided, they are rounded
+ scalar (float, optional): multiplies the average; defaults to 1
+
+ Returns:
+ scaled_average (float)
+ """
+ return _scaled_average([n for n in _round_all(numbers) if n % 2 != 0], scalar)
diff --git a/03_conditionals/00_content.ipynb b/03_conditionals/00_content.ipynb
new file mode 100644
index 0000000..8797d0a
--- /dev/null
+++ b/03_conditionals/00_content.ipynb
@@ -0,0 +1,2831 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/03_conditionals/00_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 3: Conditionals & Exceptions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We analyzed every aspect of the `average_evens()` function in [Chapter 2 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/00_content.ipynb) except for the `if`-related parts. While it does what we expect it to, there is a whole lot more to learn by taking it apart. In particular, the `if` may occur within both a **statement** or an **expression**, analogous as to how a noun in a natural language can be the subject of *or* an object in a sentence. What is common to both usages is that it leads to code being executed for *parts* of the input only. It is a way of controlling the **flow of execution** in a program.\n",
+ "\n",
+ "After deconstructing `if` in the first part of this chapter, we take a close look at a similar concept, namely handling **exceptions**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Boolean Expressions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Any expression that is either true or not is called a **boolean expression**. It is such simple true-or-false observations about the world on which mathematicians, and originally philosophers, base their rules of reasoning: They are studied formally in the field of [propositional logic ](https://en.wikipedia.org/wiki/Propositional_calculus).\n",
+ "\n",
+ "A trivial example involves the equality operator `==` that evaluates to either `True` or `False` depending on its operands \"comparing equal\" or not."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 == 42"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 == 123"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `==` operator handles objects of *different* types: Because of that, it implements a notion of equality in line with how humans think of things being equal or not. After all, `42` and `42.0` are different $0$s and $1$s for a computer and other programming languages may say `False` here! Technically, this is yet another example of operator overloading."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 == 42.0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "There are, however, cases where the `==` operator seems to not work intuitively. [Chapter 5 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/00_content.ipynb#Imprecision) provides more insights into this \"bug.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 == 42.000000000000001"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `bool` Type"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`True` and `False` are built-in *objects* of type `bool`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "94478067031520"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "bool"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "94478067031552"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(False)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "bool"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Let's not confuse the boolean `False` with `None`, another built-in object! We saw the latter before in [Chapter 2 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/00_content.ipynb#Function-Definitions) as the *implicit* return value of a function without a `return` statement.\n",
+ "\n",
+ "We might think of `None` indicating a \"maybe\" or even an \"unknown\" answer; however, for Python, there are no \"maybe\" or \"unknown\" objects, as we see further below!\n",
+ "\n",
+ "Whereas `False` is of type `bool`, `None` is of type `NoneType`. So, they are unrelated! On the contrary, as both `True` and `False` are of the same type, we could call them \"siblings.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "None"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "94478066920032"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(None)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "NoneType"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(None)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Singletons"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`True`, `False`, and `None` have the property that they each exist in memory only *once*. Objects designed this way are so-called **singletons**. This **[design pattern ](https://en.wikipedia.org/wiki/Design_Patterns)** was originally developed to keep a program's memory usage at a minimum. It may only be employed in situations where we know that an object does *not* mutate its value (i.e., to reuse the bag analogy from [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#Objects-vs.-Types-vs.-Values), no flipping of $0$s and $1$s in the bag is allowed). In languages \"closer\" to the memory like C, we would have to code this singleton logic ourselves, but Python has this built in for *some* types.\n",
+ "\n",
+ "We verify this with either the `is` operator or by comparing memory addresses."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a = True\n",
+ "b = True\n",
+ "\n",
+ "a is b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To contrast this, we create *two* `789` objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a = 789\n",
+ "b = 789\n",
+ "\n",
+ "a is b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "So the following expression regards *four* objects in memory: *One* `list` object holding six references to *three* other objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[True, False, None, True, False, None]"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "[True, False, None, True, False, None]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Relational Operators"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The equality operator is only one of several **relational** (i.e., \"comparison\") **operators** who all evaluate to a `bool` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 == 123"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 != 123"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The \"less than\" `<` or \"greater than\" `>` operators mean \"*strictly* less than\" or \"*strictly* greater than\" but may be combined with the equality operator into just `<=` and `>=`. This is a shortcut for using the logical `or` operator as described in the next section."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 < 123"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 <= 123"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 > 123"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 >= 123"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Logical Operators"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Boolean expressions may be combined or negated with the **logical operators** `and`, `or`, and `not` to form new boolean expressions. This may be done repeatedly to obtain boolean expressions of arbitrary complexity.\n",
+ "\n",
+ "Their usage is similar to how the equivalent words are used in everyday English:\n",
+ "\n",
+ "- `and` evaluates to `True` if *both* operands evaluate to `True` and `False` otherwise,\n",
+ "- `or` evaluates to `True` if either one *or* both operands evaluate to `True` and `False` otherwise, and\n",
+ "- `not` evaluates to `True` if its *only* operand evaluates to `False` and vice versa."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "a = 42\n",
+ "b = 87"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Relational operators have **[higher precedence ](https://docs.python.org/3/reference/expressions.html#operator-precedence)** over logical operators. So the following expression means what we intuitively think it does."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a > 5 and b <= 100"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, sometimes, it is good to use *parentheses* around each operand for clarity."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(a > 5) and (b <= 100)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This is especially so when several logical operators are combined."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a <= 5 or not b > 100"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(a <= 5) or not (b > 100)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(a <= 5) or (not (b > 100)) # no need to \"over do\" it"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For even better readability, some practitioners suggest to *never* use the `>` and `>=` operators (cf., [source](https://llewellynfalco.blogspot.com/2016/02/dont-use-greater-than-sign-in.html); note that the included example is written in [Java ](https://en.wikipedia.org/wiki/Java_%28programming_language%29) where `&&` means `and` and `||` means `or`).\n",
+ "\n",
+ "We may **chain** operators if the expressions that contain them are combined with the `and` operator. For example, the following two cells implement the same logic, where the second is a lot easier to read."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "5 < a and a < 87"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "5 < a < 87"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Truthy vs. Falsy"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The operands of a logical operator do not need to be *boolean* expressions but may be *any* expression. If an operand does *not* evaluate to an object of type `bool`, Python automatically casts it as such. Then, Pythonistas say that the expression is evaluated in a boolean context.\n",
+ "\n",
+ "For example, any non-zero numeric object is cast as `True`. While this behavior allows writing more concise and thus more \"beautiful\" code, it may also be a source of confusion.\n",
+ "\n",
+ "So, `(a - 40)` is cast as `True` and then the overall expression evaluates to `True` as well."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(a - 40) and (b < 100)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Whenever we are unsure how Python evaluates a non-boolean expression in a boolean context, the [bool() ](https://docs.python.org/3/library/functions.html#bool) built-in allows us to do it ourselves. [bool() ](https://docs.python.org/3/library/functions.html#bool), like [int() ](https://docs.python.org/3/library/functions.html#int), is yet another *constructor*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bool(a - 40)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bool(a - 42)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Let's keep in mind that negative numbers also evaluate to `True`!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bool(a - 44)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In a boolean context, `None` is cast as `False`! So, `None` is *not* a \"maybe\" answer but a \"no.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 35,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bool(None)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Another good rule to know is that container types (e.g., `list`) evaluate to `False` whenever they are empty and `True` if they hold at least one element."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bool([])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 37,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bool([False])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With `str` objects, the empty `\"\"` evaluates to `False`, and any other to `True`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bool(\"\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 39,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bool(\"Lorem ipsum dolor sit amet.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Pythonistas use the terms **truthy** or **falsy** to describe a non-boolean expression's behavior when evaluated in a boolean context."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Short-Circuiting"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When evaluating expressions involving the `and` and `or` operators, Python follows the **[short-circuiting ](https://en.wikipedia.org/wiki/Short-circuit_evaluation)** strategy: Once it is clear what the overall truth value is, no more operands are evaluated, and the result is *immediately* returned.\n",
+ "\n",
+ "Also, if such expressions are evaluated in a non-boolean context, the result is returned as is and *not* cast as a `bool` type.\n",
+ "\n",
+ "The two rules can be summarized as:\n",
+ "\n",
+ "- `a or b`: If `a` is truthy, it is returned *without* evaluating `b`. Otherwise, `b` is evaluated *and* returned.\n",
+ "- `a and b`: If `a` is falsy, it is returned *without* evaluating `b`. Otherwise, `b` is evaluated *and* returned.\n",
+ "\n",
+ "The rules may also be chained or combined.\n",
+ "\n",
+ "Let's look at a couple of examples below. To visualize which operands are evaluated, we define a helper function `expr()` that prints out the only argument it is passed before returning it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def expr(arg):\n",
+ " \"\"\"Print and return the only argument.\"\"\"\n",
+ " print(\"Arg:\", arg)\n",
+ " return arg"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With the `or` operator, the first truthy operand is returned."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 41,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0 or 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Arg: 0\n",
+ "Arg: 1\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "expr(0) or expr(1) # both operands are evaluated"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 43,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 or 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Arg: 1\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 44,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "expr(1) or expr(2) # 2 is not evaluated"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 45,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0 or 1 or 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Arg: 0\n",
+ "Arg: 1\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 46,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "expr(0) or expr(1) or expr(2) # 2 is not evaluated"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If all operands are falsy, the last one is returned."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 47,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "False or [] or 0"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Arg: False\n",
+ "Arg: []\n",
+ "Arg: 0\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 48,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "expr(False) or expr([]) or expr(0) # all operands are evaluated"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With the `and` operator, the first falsy operand is returned."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 49,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0 and 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Arg: 0\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 50,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "expr(0) and expr(1) # 1 is not evaluated"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 51,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 and 0"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Arg: 1\n",
+ "Arg: 0\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 52,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "expr(1) and expr(0) # both operands are evaluated"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 53,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 and 0 and 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Arg: 1\n",
+ "Arg: 0\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 54,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "expr(1) and expr(0) and expr(2) # 2 is not evaluated"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If all operands are truthy, the last one is returned."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 55,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 and 2 and 3"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Arg: 1\n",
+ "Arg: 2\n",
+ "Arg: 3\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 56,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "expr(1) and expr(2) and expr(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The crucial takeaway is that Python does *not* necessarily evaluate *all* operands and, therefore, our code should never rely on that assumption."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `if` Statement"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To write useful programs, we need to control the flow of execution, for example, to react to user input. The logic by which a program follows the rules from the \"real world\" is referred to as **[business logic ](https://en.wikipedia.org/wiki/Business_logic)**.\n",
+ "\n",
+ "One language feature to do so is the `if` statement (cf., [reference ](https://docs.python.org/3/reference/compound_stmts.html#the-if-statement)). It consists of:\n",
+ "\n",
+ "- *one* mandatory `if`-clause,\n",
+ "- an *arbitrary* number of `elif`-clauses (i.e., \"else if\"), and\n",
+ "- an *optional* `else`-clause.\n",
+ "\n",
+ "The `if`- and `elif`-clauses each specify one *boolean* expression, also called **condition** here, while the `else`-clause serves as the \"catch everything else\" case.\n",
+ "\n",
+ "In contrast to our intuitive interpretation in natural languages, only the code in *one* of the alternatives, also called **branches**, is executed. To be precise, it is always the code in the first clause whose condition evaluates to `True`.\n",
+ "\n",
+ "In terms of syntax, the header lines end with a colon, and the code blocks are indented. Formally, any statement that is written across several lines is called a **[compound statement ](https://docs.python.org/3/reference/compound_stmts.html#compound-statements)**, the code blocks are called **suites** and belong to one header line, and the term **clause** refers to a header line and its suite as a whole. So far, we have seen three compound statements: `for`, `if`, and `def`. On the contrary, **[simple statements ](https://docs.python.org/3/reference/simple_stmts.html#simple-statements)**, for example, `=`, `del`, or `return`, are written on *one* line.\n",
+ "\n",
+ "As an example, let's write code that checks if a randomly drawn number is divisible by `2`, `3`, both, or none. The code should print out a customized message for each of the *four* cases."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "numbers = [7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import random"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(789)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "#### \"Wrong Logic\" Example: Is the number divisible by `2`, `3`, both, or none?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "It turns out that translating this task into code is not so trivial. Whereas the code below looks right, it is *incorrect*. The reason is that the order of the `if`-, `elif`-, and `else`-clauses matters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "6 is divisible by 2 only\n"
+ ]
+ }
+ ],
+ "source": [
+ "number = random.choice(numbers)\n",
+ "\n",
+ "if number % 2 == 0:\n",
+ " print(number, \"is divisible by 2 only\")\n",
+ "elif number % 3 == 0:\n",
+ " print(number, \"is divisible by 3 only\")\n",
+ "elif number % 2 == 0 and number % 3 == 0:\n",
+ " print(number, \"is divisible by 2 and 3\")\n",
+ "else:\n",
+ " print(number, \"is divisible by neither 2 nor 3\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "#### \"Correct Logic\" Example: Is the number divisible by `2`, `3`, both, or none?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As a number divisible by both `2` and `3` is always a special (i.e., narrower) case of a number being divisible by either `2` or `3` on their own, we must check for that condition first. The order of the two latter cases is not important as they are mutually exclusive. Below is a correct implementation of the program."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(789)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {
+ "code_folding": [],
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "6 is divisible by 2 and 3\n"
+ ]
+ }
+ ],
+ "source": [
+ "number = random.choice(numbers)\n",
+ "\n",
+ "if number % 3 == 0 and number % 2 == 0:\n",
+ " print(number, \"is divisible by 2 and 3\")\n",
+ "elif number % 3 == 0:\n",
+ " print(number, \"is divisible by 3 only\")\n",
+ "elif number % 2 == 0:\n",
+ " print(number, \"is divisible by 2 only\")\n",
+ "else:\n",
+ " print(number, \"is divisible by neither 2 nor 3\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "#### \"Concise Logic\" Example: Is the number divisible by `2`, `3`, both, or none?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A minor improvement could be to replace `number % 3 == 0 and number % 2 == 0` with the conciser `number % 6 == 0`. However, this has no effect on the order that is still essential for the code's correctness."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(789)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "6 is divisible by 2 and 3\n"
+ ]
+ }
+ ],
+ "source": [
+ "number = random.choice(numbers)\n",
+ "\n",
+ "if number % 6 == 0:\n",
+ " print(number, \"is divisible by 2 and 3\")\n",
+ "elif number % 3 == 0:\n",
+ " print(number, \"is divisible by 3 only\")\n",
+ "elif number % 2 == 0:\n",
+ " print(number, \"is divisible by 2 only\")\n",
+ "else:\n",
+ " print(number, \"is divisible by neither 2 nor 3\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "#### Only the `if`-clause is mandatory"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Often, we only need a reduced form of the `if` statement.\n",
+ "\n",
+ "For example, below we **inject** code to print a message at random."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "You read this as often as you see heads when tossing a coin\n"
+ ]
+ }
+ ],
+ "source": [
+ "if random.random() > 0.5:\n",
+ " print(\"You read this as often as you see heads when tossing a coin\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "#### Common Use Case: A binary Choice"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "More often than not, we model a **binary choice**. Then, we only need to write an `if`- and an `else`-clause."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(789)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 67,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "6 is even\n"
+ ]
+ }
+ ],
+ "source": [
+ "number = random.choice(numbers)\n",
+ "\n",
+ "if number % 2 == 0:\n",
+ " print(number, \"is even\")\n",
+ "else:\n",
+ " print(number, \"is odd\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To write the condition even conciser, we may take advantage of Python's implicit casting and leave out the `== 0`. However, then we *must* exchange the two suits! The `if`-clause below means \"If the `number` is odd\" in plain English. That is the opposite of the `if`-clause above."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(789)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 69,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "6 is even\n"
+ ]
+ }
+ ],
+ "source": [
+ "number = random.choice(numbers)\n",
+ "\n",
+ "if number % 2: # Note the opposite meaning!\n",
+ " print(number, \"is odd\")\n",
+ "else:\n",
+ " print(number, \"is even\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "#### \"Hard to read\" Example: Nesting `if` Statements"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We may **nest** `if` statements to control the flow of execution in a more granular way. Every additional layer, however, makes the code *less* readable, in particular, if we have more than one line per code block.\n",
+ "\n",
+ "For example, the code cell below implements an [A/B Testing ](https://en.wikipedia.org/wiki/A/B_testing) strategy where half the time a \"complex\" message is shown to a \"user\" while in the remaining times an \"easy\" message is shown. To do so, the code first \"tosses a coin\" and then checks a randomly drawn `number`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 70,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(789)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 71,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "6 can be divided by 2 without a rest\n"
+ ]
+ }
+ ],
+ "source": [
+ "number = random.choice(numbers)\n",
+ "\n",
+ "# Coin is heads.\n",
+ "if random.random() > 0.5:\n",
+ " if number % 2 == 0:\n",
+ " print(number, \"can be divided by 2 without a rest\")\n",
+ " else:\n",
+ " print(number, \"divided by 2 results in a non-zero rest\")\n",
+ "# Coin is tails.\n",
+ "else:\n",
+ " if number % 2 == 0:\n",
+ " print(number, \"is even\")\n",
+ " else:\n",
+ " print(number, \"is odd\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "#### \"Easy to read\" Example: Flattening nested `if` Statements"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A way to make this code more readable is to introduce **temporary variables** *in combination* with the `and` operator to **flatten** the branching logic. The `if` statement then reads almost like plain English. In contrast to many other languages, creating variables is a computationally *cheap* operation in Python (i.e., only a reference is created) and also helps to document the code *inline* with meaningful variable names.\n",
+ "\n",
+ "Flattening the logic *without* temporary variables could lead to *more* sub-expressions in the conditions be evaluated than necessary. Do you see why?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 72,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(789)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "6 can be divided by 2 without a rest\n"
+ ]
+ }
+ ],
+ "source": [
+ "number = random.choice(numbers)\n",
+ "\n",
+ "coin_is_heads = random.random() > 0.5\n",
+ "number_is_even = number % 2 == 0\n",
+ "\n",
+ "if coin_is_heads and number_is_even:\n",
+ " print(number, \"can be divided by 2 without a rest\")\n",
+ "elif coin_is_heads and not number_is_even:\n",
+ " print(number, \"divided by 2 results in a non-zero rest\")\n",
+ "elif not coin_is_heads and number_is_even:\n",
+ " print(number, \"is even\")\n",
+ "else:\n",
+ " print(number, \"is odd\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `if` Expression"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When an `if` statement assigns an object to a variable according to a true-or-false condition (i.e., a binary choice), there is a shortcut: We assign the variable the result of a so-called **[conditional expression ](https://docs.python.org/3/reference/expressions.html#conditional-expressions)**, or `if` expression for short, instead.\n",
+ "\n",
+ "Think of a situation where we evaluate a piece-wise functional relationship $y = f(x)$ at a given $x$, for example:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "$\n",
+ "y = f(x) =\n",
+ "\\begin{cases}\n",
+ "0, \\text{ if } x \\le 0 \\\\\n",
+ "x, \\text{ otherwise}\n",
+ "\\end{cases}\n",
+ "$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Of course, we could use an `if` statement as above to do the job. Yet, this is rather lengthy."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 74,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 74,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x = 3\n",
+ "\n",
+ "if x <= 0:\n",
+ " y = 0\n",
+ "else:\n",
+ " y = x\n",
+ "\n",
+ "y"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "On the contrary, the `if` expression fits into one line. The main downside is a potential loss in readability, in particular, if the functional relationship is not that simple. Also, some practitioners do *not* like that the condition is in the middle of the expression."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 75,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 75,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x = 3\n",
+ "\n",
+ "y = 0 if x <= 0 else x\n",
+ "\n",
+ "y"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In this example, however, the most elegant solution is to use the built-in [max() ](https://docs.python.org/3/library/functions.html#max) function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 76,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 76,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x = 3\n",
+ "\n",
+ "y = max(0, x)\n",
+ "\n",
+ "y"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `try` Statement"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In the previous two chapters, we encountered a couple of *runtime* errors. A natural urge we might have after reading about conditional statements is to write code that somehow reacts to the occurrence of such exceptions.\n",
+ "\n",
+ "Consider a situation where we are given some user input that may contain values that cause problems. To illustrate this, we draw a random integer between `0` and `5`, and then divide by this number. Naturally, we see a `ZeroDivisionError` in 16.6% of the cases."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 77,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(123)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 78,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "ZeroDivisionError",
+ "evalue": "division by zero",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mZeroDivisionError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[78], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m user_input \u001b[38;5;241m=\u001b[39m random\u001b[38;5;241m.\u001b[39mchoice([\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m5\u001b[39m])\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;241;43m1\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[43muser_input\u001b[49m\n",
+ "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
+ ]
+ }
+ ],
+ "source": [
+ "user_input = random.choice([0, 1, 2, 3, 4, 5])\n",
+ "\n",
+ "1 / user_input"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With the compound `try` statement (cf., [reference ](https://docs.python.org/3/reference/compound_stmts.html#the-try-statement)), we can **handle** any *runtime* error.\n",
+ "\n",
+ "In its simplest form, it comes with just two clauses: `try` and `except`. The following tells Python to execute the code in the `try`-clause, and if *anything* goes wrong, continue in the `except`-clause instead of **raising** an error to us. Of course, if nothing goes wrong, the `except`-clause is *not* executed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 79,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(123)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 80,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Something went wrong\n"
+ ]
+ }
+ ],
+ "source": [
+ "user_input = random.choice([0, 1, 2, 3, 4, 5])\n",
+ "\n",
+ "try:\n",
+ " print(\"The result is\", 1 / user_input)\n",
+ "except:\n",
+ " print(\"Something went wrong\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, it is good practice *not* to handle *any* possible exception but only the ones we may *expect* from the code in the `try`-clause. The reason for that is that we do not want to risk *suppressing* an exception that we do *not* expect. Also, the code base becomes easier to understand as we communicate what could go wrong during execution in an *explicit* way to the (human) reader. Python comes with a lot of [built-in exceptions ](https://docs.python.org/3/library/exceptions.html#concrete-exceptions) that we should familiarize ourselves with.\n",
+ "\n",
+ "Another good practice is to always keep the code in the `try`-clause short to not *accidentally* handle an exception we do *not* want to handle.\n",
+ "\n",
+ "In the example, we are dividing numbers and may expect a `ZeroDivisionError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 81,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(123)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 82,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Something went wrong\n"
+ ]
+ }
+ ],
+ "source": [
+ "user_input = random.choice([0, 1, 2, 3, 4, 5])\n",
+ "\n",
+ "try:\n",
+ " print(\"The result is\", 1 / user_input)\n",
+ "except ZeroDivisionError:\n",
+ " print(\"Something went wrong\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Often, we may have to run some code *independent* of an exception occurring, for example, to close a connection to a database. To achieve that, we add a `finally`-clause to the `try` statement.\n",
+ "\n",
+ "Similarly, we may have to run some code *only if* no exception occurs, but we do not want to put it in the `try`-clause as per the good practice mentioned above. To achieve that, we add an `else`-clause to the `try` statement.\n",
+ "\n",
+ "To showcase everything together, we look at one last example. It is randomized: So, run the cell several times and see for yourself."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 83,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(123)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 84,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Oops. Division by 0. How does that work?\n",
+ "I am always printed\n"
+ ]
+ }
+ ],
+ "source": [
+ "user_input = random.choice([0, 1, 2, 3, 4, 5])\n",
+ "\n",
+ "try:\n",
+ " result = 1 / user_input\n",
+ "except ZeroDivisionError:\n",
+ " print(\"Oops. Division by 0. How does that work?\")\n",
+ "else:\n",
+ " print(\"The result is\", result)\n",
+ "finally:\n",
+ " print(\"I am always printed\")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/03_conditionals/01_exercises_discounts.ipynb b/03_conditionals/01_exercises_discounts.ipynb
new file mode 100644
index 0000000..9764fd6
--- /dev/null
+++ b/03_conditionals/01_exercises_discounts.ipynb
@@ -0,0 +1,205 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Run All*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *after* finishing the exercises to ensure that your solution runs top to bottom *without* any errors. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/03_conditionals/01_exercises.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 3: Conditionals & Exceptions (Coding Exercises)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The exercises below assume that you have read [Chapter 3 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/03_conditionals/00_content.ipynb).\n",
+ "\n",
+ "The `...`'s in the code cells indicate where you need to fill in code snippets. The number of `...`'s within a code cell give you a rough idea of how many lines of code are needed to solve the task. You should not need to create any additional code cells for your final solution. However, you may want to use temporary code cells to try out some ideas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Discounting Customer Orders"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: Write a function `discounted_price()` that takes the positional arguments `unit_price` (of type `float`) and `quantity` (of type `int`) and implements a discount scheme for a line item in a customer order as follows:\n",
+ "\n",
+ "- if the unit price is over 100 dollars, grant 10% relative discount\n",
+ "- if a customer orders more than 10 items, one in every five items is for free\n",
+ "\n",
+ "Only one of the two discounts is granted, whichever is better for the customer.\n",
+ "\n",
+ "The function should then return the overall price for the line item. Do not forget to round appropriately."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def discounted_price(unit_price, quantity):\n",
+ " \"\"\"Calculate the price of a line item in an order.\n",
+ "\n",
+ " Args:\n",
+ " unit_price (float): price of one ordered item\n",
+ " quantity (int): number of items ordered\n",
+ "\n",
+ " Returns:\n",
+ " line_item_price (float)\n",
+ " \"\"\"\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " return ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: Calculate the final price for the following line items of an order:\n",
+ "- $7$ smartphones @ $99.00$ USD\n",
+ "- $3$ workstations @ $999.00$ USD\n",
+ "- $19$ GPUs @ $879.95$ USD\n",
+ "- $14$ Raspberry Pis @ $35.00$ USD"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "discounted_price(...)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "discounted_price(...)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "discounted_price(...)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "discounted_price(...)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: Calculate the last two line items with order quantities of $20$ and $15$. What do you observe?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "discounted_price(...)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "discounted_price(...)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: Looking at the `if`-`else`-logic in the function, why do you think the four example line items in **Q2** were chosen as they were?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/03_conditionals/02_exercises_fizz-buzz.ipynb b/03_conditionals/02_exercises_fizz-buzz.ipynb
new file mode 100644
index 0000000..5b0ce28
--- /dev/null
+++ b/03_conditionals/02_exercises_fizz-buzz.ipynb
@@ -0,0 +1,140 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Run All*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *after* finishing the exercises to ensure that your solution runs top to bottom *without* any errors. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/03_conditionals/02_exercises.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 3: Conditionals & Exceptions (Coding Exercises)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The exercises below assume that you have read [Chapter 3 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/03_conditionals/00_content.ipynb).\n",
+ "\n",
+ "The `...`'s in the code cells indicate where you need to fill in code snippets. The number of `...`'s within a code cell give you a rough idea of how many lines of code are needed to solve the task. You should not need to create any additional code cells for your final solution. However, you may want to use temporary code cells to try out some ideas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Fizz Buzz"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The kids game [Fizz Buzz ](https://en.wikipedia.org/wiki/Fizz_buzz) is said to be often used in job interviews for entry-level positions. However, opinions vary as to how good of a test it is (cf., [source ](https://news.ycombinator.com/item?id=16446774)).\n",
+ "\n",
+ "In its simplest form, a group of people starts counting upwards in an alternating fashion. Whenever a number is divisible by $3$, the person must say \"Fizz\" instead of the number. The same holds for numbers divisible by $5$ when the person must say \"Buzz.\" If a number is divisible by both numbers, one must say \"FizzBuzz.\" Probably, this game would also make a good drinking game with the \"right\" beverages."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: First, create a list `numbers` with the numbers from 1 through 100. You could type all numbers manually, but there is, of course, a smarter way. The built-in [range() ](https://docs.python.org/3/library/functions.html#func-range) may be useful here. Read how it works in the documentation. To make the output of [range() ](https://docs.python.org/3/library/functions.html#func-range) a `list` object, you have to wrap it with the [list() ](https://docs.python.org/3/library/functions.html#func-list) built-in (i.e., `list(range(...))`)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "numbers = ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: Loop over the `numbers` list and *replace* numbers for which one of the two (or both) conditions apply with text strings `\"Fizz\"`, `\"Buzz\"`, or `\"FizzBuzz\"` using the indexing operator `[]` and the assignment statement `=`.\n",
+ "\n",
+ "In [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/03_content.ipynb#Who-am-I?-And-how-many?), we saw that Python starts indexing with `0` as the first element. Keep that in mind.\n",
+ "\n",
+ "So in each iteration of the `for`-loop, you have to determine an `index` variable as well as check the actual `number` for its divisors.\n",
+ "\n",
+ "Hint: the order of the conditions is important!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for number in numbers:\n",
+ " ...\n",
+ "\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: Create a loop that prints out either the number or any of the Fizz Buzz substitutes in `numbers`! Do it in such a way that the output is concise!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for number in numbers:\n",
+ " print(...)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/03_conditionals/03_summary.ipynb b/03_conditionals/03_summary.ipynb
new file mode 100644
index 0000000..7d7b12d
--- /dev/null
+++ b/03_conditionals/03_summary.ipynb
@@ -0,0 +1,76 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 3: Conditionals & Exceptions (TL;DR)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "- **boolean expressions** evaluate to either `True` or `False`\n",
+ "- **relational operators** (e.g., `==` or `!=`) compare operands according to \"human\" interpretations\n",
+ "- **logical operators** (e.g., `and` )combine boolean sub-expressions to more \"complex\" expressions\n",
+ "- the **conditional statement** (i.e., the `if` statement) allows **controlling** the **flow of execution** depending on some **conditions**\n",
+ "- a **conditional expression** is a short form of a conditional statement\n",
+ "- **exception handling** is also a common way of **controlling** the **flow of execution**, in particular, if we have to be prepared for bad input data"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/03_conditionals/04_review.ipynb b/03_conditionals/04_review.ipynb
new file mode 100644
index 0000000..67e9dd3
--- /dev/null
+++ b/03_conditionals/04_review.ipynb
@@ -0,0 +1,201 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 3: Conditionals & Exceptions (Review Questions)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The questions below assume that you have read [Chapter 3 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/03_conditionals/00_content.ipynb).\n",
+ "\n",
+ "Be concise in your answers! Most questions can be answered in *one* sentence."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Essay Questions "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: What is the **singleton** design pattern? How many objects does the expression `[True, False, True, False]` generate in memory?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: What do we mean when we talk about **truthy** and **falsy** expressions?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: Describe in your own words the concept of **short-circuiting**! What does it imply for an individual sub-expression in a boolean expression?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: Explain how the conceptual difference between a **statement** and an **expression** relates to the difference between a **conditional statement** and a **conditional expression**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: Why is the use of **temporary variables** encouraged in Python?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: What does the `finally`-clause enforce in this code snippet? How can a `try` statement be useful *without* an `except`-clause?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```python\n",
+ "try:\n",
+ " print(\"Make a request to a service on the internet\")\n",
+ "finally:\n",
+ " print(\"This could be clean-up code\")\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## True / False Questions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Motivate your answer with *one short* sentence!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7**: The objects `True`, `False`, and `None` represent the idea of *yes*, *no*, and *maybe* answers in a natural language.\n",
+ "\n",
+ "Hint: you also respond with a code cell."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q8**: The `try` statement is useful for handling **syntax** errors."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/04_iteration/00_content.ipynb b/04_iteration/00_content.ipynb
new file mode 100644
index 0000000..362583b
--- /dev/null
+++ b/04_iteration/00_content.ipynb
@@ -0,0 +1,4942 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/04_iteration/00_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 4: Recursion & Looping"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While controlling the flow of execution with an `if` statement is a must-have building block in any programming language, it alone does not allow us to run a block of code repetitively, and we need to be able to do precisely that to write useful software.\n",
+ "\n",
+ "The `for` statement shown in some examples before might be the missing piece in the puzzle. However, we can live without it and postpone its official introduction until the second half of this chapter.\n",
+ "\n",
+ "Instead, we dive into the big idea of **iteration** by studying the concept of **recursion** first. This order is opposite to many other introductory books that only treat the latter as a nice-to-have artifact, if at all. Yet, understanding recursion sharpens one's mind and contributes to seeing problems from a different angle."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Recursion"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A popular joke among programmers by an unknown author goes like this (cf., [discussion](https://www.quora.com/What-does-the-phrase-in-order-to-understand-recursion-you-must-first-understand-recursion-mean-to-you)):"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "> \"In order to understand **recursion**, you must first understand **recursion**.\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A function that calls itself is **recursive**, and the process of executing such a function is called **recursion**.\n",
+ "\n",
+ "Recursive functions contain some form of a conditional check (e.g., `if` statement) to identify a **base case** that ends the recursion *when* reached. Otherwise, the function would keep calling itself forever.\n",
+ "\n",
+ "The meaning of the word *recursive* is similar to *circular*. However, a truly circular definition is not very helpful, and we think of a recursive function as kind of a \"circular function with a way out at the end.\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Trivial Example: Countdown"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A rather trivial toy example illustrates the important aspects concretely: If called with any positive integer as its `n` argument, `countdown()` just prints that number and calls itself with the *new* `n` being the *old* `n` minus `1`. This continues until `countdown()` is called with `n=0`. Then, the flow of execution hits the base case, and the function calls stop."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "code_folding": [],
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def countdown(n):\n",
+ " \"\"\"Print a countdown until the party starts.\n",
+ "\n",
+ " Args:\n",
+ " n (int): seconds until the party begins\n",
+ " \"\"\"\n",
+ " if n == 0:\n",
+ " print(\"Happy New Year!\")\n",
+ " else:\n",
+ " print(n)\n",
+ " countdown(n - 1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3\n",
+ "2\n",
+ "1\n",
+ "Happy New Year!\n"
+ ]
+ }
+ ],
+ "source": [
+ "countdown(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As trivial as this seems, a lot of complexity is hidden in this implementation. In particular, the order in which objects are created and de-referenced in memory might not be apparent right away as [PythonTutor ](http://pythontutor.com/visualize.html#code=def%20countdown%28n%29%3A%0A%20%20%20%20if%20n%20%3D%3D%200%3A%0A%20%20%20%20%20%20%20%20print%28%22Happy%20new%20Year!%22%29%0A%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20print%28n%29%0A%20%20%20%20%20%20%20%20countdown%28n%20-%201%29%0A%0Acountdown%283%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) shows: Each time `countdown()` is called, Python creates a *new* frame in the part of the memory where it manages all the names. This way, Python *isolates* all the different `n` variables from each other. As new frames are created until we reach the base case, after which the frames are destroyed in the *reversed* order, this is called a **[stack ](https://en.wikipedia.org/wiki/Stack_(abstract_data_type))** of frames in computer science terminology. In simple words, a stack is a last-in-first-out (LIFO) task queue. Each frame has a single parent frame, namely the one whose recursive function call created it."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Recursion in Mathematics"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Recursion plays a vital role in mathematics as well, and we likely know about it from some introductory course, for example, in [combinatorics ](https://en.wikipedia.org/wiki/Combinatorics)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Easy Example: [Factorial ](https://en.wikipedia.org/wiki/Factorial)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The factorial function, denoted with the $!$ symbol, is defined as follows for all non-negative integers:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "$$0! = 1$$\n",
+ "$$n! = n*(n-1)!$$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Whenever we find a recursive way of formulating an idea, we can immediately translate it into Python in a *naive* way (i.e., we create a *correct* program that may *not* be an *efficient* implementation yet).\n",
+ "\n",
+ "Below is a first version of `factorial()`: The `return` statement does not have to be a function's last code line, and we may indeed have several `return` statements as well."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "code_folding": [],
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def factorial(n):\n",
+ " \"\"\"Calculate the factorial of a number.\n",
+ "\n",
+ " Args:\n",
+ " n (int): number to calculate the factorial for\n",
+ "\n",
+ " Returns:\n",
+ " factorial (int)\n",
+ " \"\"\"\n",
+ " if n == 0:\n",
+ " return 1\n",
+ " else:\n",
+ " recurse = factorial(n - 1)\n",
+ " result = n * recurse\n",
+ " return result"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When we read such code, it is often easier not to follow every function call (i.e., `factorial(n - 1)` here) in one's mind but assume we receive a return value as specified in the documentation. Some call this approach a **[leap of faith](http://greenteapress.com/thinkpython2/html/thinkpython2007.html#sec75)**. We practice this already whenever we call built-in functions (e.g., [print() ](https://docs.python.org/3/library/functions.html#print) or [len() ](https://docs.python.org/3/library/functions.html#len)) where we would have to read C code in many cases.\n",
+ "\n",
+ "To visualize *all* the computational steps of the exemplary `factorial(3)`, we use [PythonTutor ](http://pythontutor.com/visualize.html#code=def%20factorial%28n%29%3A%0A%20%20%20%20if%20n%20%3D%3D%200%3A%0A%20%20%20%20%20%20%20%20return%201%0A%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20recurse%20%3D%20factorial%28n%20-%201%29%0A%20%20%20%20%20%20%20%20result%20%3D%20n%20*%20recurse%0A%20%20%20%20%20%20%20%20return%20result%0A%0Asolution%20%3D%20factorial%283%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false): The recursion again creates a stack of frames in memory. In contrast to the previous trivial example, each frame leaves a return value in memory after it is destroyed. This return value is then assigned to the `recurse` variable within the parent frame and used to compute `result`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3628800"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A Pythonista would formulate `factorial()` in a more concise way using the so-called **early exit** pattern: No `else`-clause is needed as reaching a `return` statement ends a function call *immediately*. Furthermore, we do not need the temporary variables `recurse` and `result`.\n",
+ "\n",
+ "As [PythonTutor ](http://pythontutor.com/visualize.html#code=def%20factorial%28n%29%3A%0A%20%20%20%20if%20n%20%3D%3D%200%3A%0A%20%20%20%20%20%20%20%20return%201%0A%20%20%20%20return%20n%20*%20factorial%28n%20-%201%29%0A%0Asolution%20%3D%20factorial%283%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) shows, this implementation is more efficient as it only requires 18 computational steps instead of 24 to calculate `factorial(3)`, an improvement of 25 percent! "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def factorial(n):\n",
+ " \"\"\"Calculate the factorial of a number.\n",
+ "\n",
+ " Args:\n",
+ " n (int): number to calculate the factorial for\n",
+ "\n",
+ " Returns:\n",
+ " factorial (int)\n",
+ " \"\"\"\n",
+ " if n == 0:\n",
+ " return 1\n",
+ " return n * factorial(n - 1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3628800"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Note that the [math ](https://docs.python.org/3/library/math.html) module in the [standard library ](https://docs.python.org/3/library/index.html) provides a [factorial() ](https://docs.python.org/3/library/math.html#math.factorial) function as well, and we should, therefore, *never* implement it ourselves in a real codebase."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import math"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on built-in function factorial in module math:\n",
+ "\n",
+ "factorial(n, /)\n",
+ " Find n!.\n",
+ "\n",
+ " Raise a ValueError if x is negative or non-integral.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "help(math.factorial)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "math.factorial(3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3628800"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "math.factorial(10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### \"Involved\" Example: [Euclid's Algorithm ](https://en.wikipedia.org/wiki/Euclidean_algorithm)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As famous philosopher Euclid already shows in his \"Elements\" (ca. 300 BC), the greatest common divisor of two integers, i.e., the largest number that divides both integers without a remainder, can be efficiently computed with the following code. This example illustrates that a recursive solution to a problem is not always easy to understand."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def gcd(a, b):\n",
+ " \"\"\"Calculate the greatest common divisor of two numbers.\n",
+ "\n",
+ " Args:\n",
+ " a (int): first number\n",
+ " b (int): second number\n",
+ "\n",
+ " Returns:\n",
+ " gcd (int)\n",
+ " \"\"\"\n",
+ " if b == 0:\n",
+ " return a \n",
+ " return gcd(b, a % b)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "gcd(12, 4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Euclid's algorithm is stunningly fast, even for large numbers. Its speed comes from the use of the modulo operator `%`. However, this is *not* true for recursion in general, which may result in slow programs if not applied correctly."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "9"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "gcd(112233445566778899, 987654321)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As expected, for two [prime numbers ](https://en.wikipedia.org/wiki/List_of_prime_numbers) the greatest common divisor is of course $1$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "gcd(7, 7919)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [math ](https://docs.python.org/3/library/math.html) module in the [standard library ](https://docs.python.org/3/library/index.html) provides a [gcd() ](https://docs.python.org/3/library/math.html#math.gcd) function as well, and, therefore, we should again *never* implement it on our own."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on built-in function gcd in module math:\n",
+ "\n",
+ "gcd(*integers)\n",
+ " Greatest Common Divisor.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "help(math.gcd)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "math.gcd(12, 4)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "9"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "math.gcd(112233445566778899, 987654321)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "math.gcd(7, 7919)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### \"Easy at first Glance\" Example: [Fibonacci Numbers ](https://en.wikipedia.org/wiki/Fibonacci_number)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The Fibonacci numbers are an infinite sequence of non-negative integers that are calculated such that every number is the sum of its two predecessors where the first two numbers of the sequence are defined to be $0$ and $1$. For example, the first 13 numbers are:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "$0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Let's write a function `fibonacci()` that calculates the $i$th Fibonacci number where $0$ is the $0$th number. Looking at the numbers in a **backward** fashion (i.e., from right to left), we realize that the return value for `fibonacci(i)` can be reduced to the sum of the return values for `fibonacci(i - 1)` and `fibonacci(i - 2)` disregarding the *two* base cases."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def fibonacci(i):\n",
+ " \"\"\"Calculate the ith Fibonacci number.\n",
+ "\n",
+ " Args:\n",
+ " i (int): index of the Fibonacci number to calculate\n",
+ "\n",
+ " Returns:\n",
+ " ith_fibonacci (int)\n",
+ " \"\"\"\n",
+ " if i == 0:\n",
+ " return 0\n",
+ " elif i == 1:\n",
+ " return 1\n",
+ " return fibonacci(i - 1) + fibonacci(i - 2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "144"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "fibonacci(12) # = 13th number"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "#### Efficiency of Algorithms"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This implementation is *highly* **inefficient** as small Fibonacci numbers already take a very long time to compute. The reason for this is **exponential growth** in the number of function calls. As [PythonTutor ](http://pythontutor.com/visualize.html#code=def%20fibonacci%28i%29%3A%0A%20%20%20%20if%20i%20%3D%3D%200%3A%0A%20%20%20%20%20%20%20%20return%200%0A%20%20%20%20elif%20i%20%3D%3D%201%3A%0A%20%20%20%20%20%20%20%20return%201%0A%20%20%20%20return%20fibonacci%28i%20-%201%29%20%2B%20fibonacci%28i%20-%202%29%0A%0Arv%20%3D%20fibonacci%285%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) shows, `fibonacci()` is called again and again with the same `i` arguments.\n",
+ "\n",
+ "To understand this in detail, we have to study algorithms and data structures (e.g., with [this book](https://www.amazon.de/Introduction-Algorithms-Press-Thomas-Cormen/dp/0262033844/ref=sr_1_1?__mk_de_DE=%C3%85M%C3%85%C5%BD%C3%95%C3%91&crid=1JNE8U0VZGU0O&qid=1569837169&s=gateway&sprefix=algorithms+an%2Caps%2C180&sr=8-1)), a discipline within computer science, and dive into the analysis of **[time complexity of algorithms ](https://en.wikipedia.org/wiki/Time_complexity)**.\n",
+ "\n",
+ "Luckily, in the Fibonacci case, the inefficiency can be resolved with a **caching** (i.e., \"reuse\") strategy from the field of **[dynamic programming ](https://en.wikipedia.org/wiki/Dynamic_programming)**, namely **[memoization ](https://en.wikipedia.org/wiki/Memoization)**. We do so in [Chapter 9 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/09_mappings/02_content.ipynb#Memoization), after introducing the `dict` data type.\n",
+ "\n",
+ "Let's measure the average run times for `fibonacci()` and varying `i` arguments with the `%%timeit` [cell magic](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-timeit) that comes with Jupyter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "38.9 µs ± 1.48 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%timeit -n 100\n",
+ "fibonacci(12)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "12.2 ms ± 77.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%timeit -n 100\n",
+ "fibonacci(24)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3.89 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%timeit -n 1 -r 1\n",
+ "fibonacci(36)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "6.28 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%timeit -n 1 -r 1\n",
+ "fibonacci(37)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Infinite Recursion"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If a recursion does not reach its base case, it theoretically runs forever. Luckily, Python detects that and saves the computer from crashing by raising a `RecursionError`.\n",
+ "\n",
+ "The simplest possible infinite recursion is generated like so."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def run_forever():\n",
+ " \"\"\"Also a pointless function should have a docstring.\"\"\"\n",
+ " run_forever()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "RecursionError",
+ "evalue": "maximum recursion depth exceeded",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mRecursionError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[28], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mrun_forever\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[27], line 3\u001b[0m, in \u001b[0;36mrun_forever\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun_forever\u001b[39m():\n\u001b[1;32m 2\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Also a pointless function should have a docstring.\"\"\"\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[43mrun_forever\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[27], line 3\u001b[0m, in \u001b[0;36mrun_forever\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun_forever\u001b[39m():\n\u001b[1;32m 2\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Also a pointless function should have a docstring.\"\"\"\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[43mrun_forever\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
+ " \u001b[0;31m[... skipping similar frames: run_forever at line 3 (2974 times)]\u001b[0m\n",
+ "Cell \u001b[0;32mIn[27], line 3\u001b[0m, in \u001b[0;36mrun_forever\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun_forever\u001b[39m():\n\u001b[1;32m 2\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Also a pointless function should have a docstring.\"\"\"\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[43mrun_forever\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mRecursionError\u001b[0m: maximum recursion depth exceeded"
+ ]
+ }
+ ],
+ "source": [
+ "run_forever()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, even the trivial `countdown()` function from above is not immune to infinite recursion. Let's call it with `3.1` instead of `3`. What goes wrong here?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3.1\n",
+ "2.1\n",
+ "1.1\n",
+ "0.10000000000000009\n",
+ "-0.8999999999999999\n",
+ "-1.9\n",
+ "-2.9\n",
+ "-3.9\n",
+ "-4.9\n",
+ "-5.9\n",
+ "-6.9\n",
+ "-7.9\n",
+ "-8.9\n",
+ "-9.9\n",
+ "-10.9\n",
+ "-11.9\n",
+ "-12.9\n",
+ "-13.9\n",
+ "-14.9\n",
+ "-15.9\n",
+ "-16.9\n",
+ "-17.9\n",
+ "-18.9\n",
+ "-19.9\n",
+ "-20.9\n",
+ "-21.9\n",
+ "-22.9\n",
+ "-23.9\n",
+ "-24.9\n",
+ "-25.9\n",
+ "-26.9\n",
+ "-27.9\n",
+ "-28.9\n",
+ "-29.9\n",
+ "-30.9\n",
+ "-31.9\n",
+ "-32.9\n",
+ "-33.9\n",
+ "-34.9\n",
+ "-35.9\n",
+ "-36.9\n",
+ "-37.9\n",
+ "-38.9\n",
+ "-39.9\n",
+ "-40.9\n",
+ "-41.9\n",
+ "-42.9\n",
+ "-43.9\n",
+ "-44.9\n",
+ "-45.9\n",
+ "-46.9\n",
+ "-47.9\n",
+ "-48.9\n",
+ "-49.9\n",
+ "-50.9\n",
+ "-51.9\n",
+ "-52.9\n",
+ "-53.9\n",
+ "-54.9\n",
+ "-55.9\n",
+ "-56.9\n",
+ "-57.9\n",
+ "-58.9\n",
+ "-59.9\n",
+ "-60.9\n",
+ "-61.9\n",
+ "-62.9\n",
+ "-63.9\n",
+ "-64.9\n",
+ "-65.9\n",
+ "-66.9\n",
+ "-67.9\n",
+ "-68.9\n",
+ "-69.9\n",
+ "-70.9\n",
+ "-71.9\n",
+ "-72.9\n",
+ "-73.9\n",
+ "-74.9\n",
+ "-75.9\n",
+ "-76.9\n",
+ "-77.9\n",
+ "-78.9\n",
+ "-79.9\n",
+ "-80.9\n",
+ "-81.9\n",
+ "-82.9\n",
+ "-83.9\n",
+ "-84.9\n",
+ "-85.9\n",
+ "-86.9\n",
+ "-87.9\n",
+ "-88.9\n",
+ "-89.9\n",
+ "-90.9\n",
+ "-91.9\n",
+ "-92.9\n",
+ "-93.9\n",
+ "-94.9\n",
+ "-95.9\n",
+ "-96.9\n",
+ "-97.9\n",
+ "-98.9\n",
+ "-99.9\n",
+ "-100.9\n",
+ "-101.9\n",
+ "-102.9\n",
+ "-103.9\n",
+ "-104.9\n",
+ "-105.9\n",
+ "-106.9\n",
+ "-107.9\n",
+ "-108.9\n",
+ "-109.9\n",
+ "-110.9\n",
+ "-111.9\n",
+ "-112.9\n",
+ "-113.9\n",
+ "-114.9\n",
+ "-115.9\n",
+ "-116.9\n",
+ "-117.9\n",
+ "-118.9\n",
+ "-119.9\n",
+ "-120.9\n",
+ "-121.9\n",
+ "-122.9\n",
+ "-123.9\n",
+ "-124.9\n",
+ "-125.9\n",
+ "-126.9\n",
+ "-127.9\n",
+ "-128.9\n",
+ "-129.9\n",
+ "-130.9\n",
+ "-131.9\n",
+ "-132.9\n",
+ "-133.9\n",
+ "-134.9\n",
+ "-135.9\n",
+ "-136.9\n",
+ "-137.9\n",
+ "-138.9\n",
+ "-139.9\n",
+ "-140.9\n",
+ "-141.9\n",
+ "-142.9\n",
+ "-143.9\n",
+ "-144.9\n",
+ "-145.9\n",
+ "-146.9\n",
+ "-147.9\n",
+ "-148.9\n",
+ "-149.9\n",
+ "-150.9\n",
+ "-151.9\n",
+ "-152.9\n",
+ "-153.9\n",
+ "-154.9\n",
+ "-155.9\n",
+ "-156.9\n",
+ "-157.9\n",
+ "-158.9\n",
+ "-159.9\n",
+ "-160.9\n",
+ "-161.9\n",
+ "-162.9\n",
+ "-163.9\n",
+ "-164.9\n",
+ "-165.9\n",
+ "-166.9\n",
+ "-167.9\n",
+ "-168.9\n",
+ "-169.9\n",
+ "-170.9\n",
+ "-171.9\n",
+ "-172.9\n",
+ "-173.9\n",
+ "-174.9\n",
+ "-175.9\n",
+ "-176.9\n",
+ "-177.9\n",
+ "-178.9\n",
+ "-179.9\n",
+ "-180.9\n",
+ "-181.9\n",
+ "-182.9\n",
+ "-183.9\n",
+ "-184.9\n",
+ "-185.9\n",
+ "-186.9\n",
+ "-187.9\n",
+ "-188.9\n",
+ "-189.9\n",
+ "-190.9\n",
+ "-191.9\n",
+ "-192.9\n",
+ "-193.9\n",
+ "-194.9\n",
+ "-195.9\n",
+ "-196.9\n",
+ "-197.9\n",
+ "-198.9\n",
+ "-199.9\n",
+ "-200.9\n",
+ "-201.9\n",
+ "-202.9\n",
+ "-203.9\n",
+ "-204.9\n",
+ "-205.9\n",
+ "-206.9\n",
+ "-207.9\n",
+ "-208.9\n",
+ "-209.9\n",
+ "-210.9\n",
+ "-211.9\n",
+ "-212.9\n",
+ "-213.9\n",
+ "-214.9\n",
+ "-215.9\n",
+ "-216.9\n",
+ "-217.9\n",
+ "-218.9\n",
+ "-219.9\n",
+ "-220.9\n",
+ "-221.9\n",
+ "-222.9\n",
+ "-223.9\n",
+ "-224.9\n",
+ "-225.9\n",
+ "-226.9\n",
+ "-227.9\n",
+ "-228.9\n",
+ "-229.9\n",
+ "-230.9\n",
+ "-231.9\n",
+ "-232.9\n",
+ "-233.9\n",
+ "-234.9\n",
+ "-235.9\n",
+ "-236.9\n",
+ "-237.9\n",
+ "-238.9\n",
+ "-239.9\n",
+ "-240.9\n",
+ "-241.9\n",
+ "-242.9\n",
+ "-243.9\n",
+ "-244.9\n",
+ "-245.9\n",
+ "-246.9\n",
+ "-247.9\n",
+ "-248.9\n",
+ "-249.9\n",
+ "-250.9\n",
+ "-251.9\n",
+ "-252.9\n",
+ "-253.9\n",
+ "-254.9\n",
+ "-255.9\n",
+ "-256.9\n",
+ "-257.9\n",
+ "-258.9\n",
+ "-259.9\n",
+ "-260.9\n",
+ "-261.9\n",
+ "-262.9\n",
+ "-263.9\n",
+ "-264.9\n",
+ "-265.9\n",
+ "-266.9\n",
+ "-267.9\n",
+ "-268.9\n",
+ "-269.9\n",
+ "-270.9\n",
+ "-271.9\n",
+ "-272.9\n",
+ "-273.9\n",
+ "-274.9\n",
+ "-275.9\n",
+ "-276.9\n",
+ "-277.9\n",
+ "-278.9\n",
+ "-279.9\n",
+ "-280.9\n",
+ "-281.9\n",
+ "-282.9\n",
+ "-283.9\n",
+ "-284.9\n",
+ "-285.9\n",
+ "-286.9\n",
+ "-287.9\n",
+ "-288.9\n",
+ "-289.9\n",
+ "-290.9\n",
+ "-291.9\n",
+ "-292.9\n",
+ "-293.9\n",
+ "-294.9\n",
+ "-295.9\n",
+ "-296.9\n",
+ "-297.9\n",
+ "-298.9\n",
+ "-299.9\n",
+ "-300.9\n",
+ "-301.9\n",
+ "-302.9\n",
+ "-303.9\n",
+ "-304.9\n",
+ "-305.9\n",
+ "-306.9\n",
+ "-307.9\n",
+ "-308.9\n",
+ "-309.9\n",
+ "-310.9\n",
+ "-311.9\n",
+ "-312.9\n",
+ "-313.9\n",
+ "-314.9\n",
+ "-315.9\n",
+ "-316.9\n",
+ "-317.9\n",
+ "-318.9\n",
+ "-319.9\n",
+ "-320.9\n",
+ "-321.9\n",
+ "-322.9\n",
+ "-323.9\n",
+ "-324.9\n",
+ "-325.9\n",
+ "-326.9\n",
+ "-327.9\n",
+ "-328.9\n",
+ "-329.9\n",
+ "-330.9\n",
+ "-331.9\n",
+ "-332.9\n",
+ "-333.9\n",
+ "-334.9\n",
+ "-335.9\n",
+ "-336.9\n",
+ "-337.9\n",
+ "-338.9\n",
+ "-339.9\n",
+ "-340.9\n",
+ "-341.9\n",
+ "-342.9\n",
+ "-343.9\n",
+ "-344.9\n",
+ "-345.9\n",
+ "-346.9\n",
+ "-347.9\n",
+ "-348.9\n",
+ "-349.9\n",
+ "-350.9\n",
+ "-351.9\n",
+ "-352.9\n",
+ "-353.9\n",
+ "-354.9\n",
+ "-355.9\n",
+ "-356.9\n",
+ "-357.9\n",
+ "-358.9\n",
+ "-359.9\n",
+ "-360.9\n",
+ "-361.9\n",
+ "-362.9\n",
+ "-363.9\n",
+ "-364.9\n",
+ "-365.9\n",
+ "-366.9\n",
+ "-367.9\n",
+ "-368.9\n",
+ "-369.9\n",
+ "-370.9\n",
+ "-371.9\n",
+ "-372.9\n",
+ "-373.9\n",
+ "-374.9\n",
+ "-375.9\n",
+ "-376.9\n",
+ "-377.9\n",
+ "-378.9\n",
+ "-379.9\n",
+ "-380.9\n",
+ "-381.9\n",
+ "-382.9\n",
+ "-383.9\n",
+ "-384.9\n",
+ "-385.9\n",
+ "-386.9\n",
+ "-387.9\n",
+ "-388.9\n",
+ "-389.9\n",
+ "-390.9\n",
+ "-391.9\n",
+ "-392.9\n",
+ "-393.9\n",
+ "-394.9\n",
+ "-395.9\n",
+ "-396.9\n",
+ "-397.9\n",
+ "-398.9\n",
+ "-399.9\n",
+ "-400.9\n",
+ "-401.9\n",
+ "-402.9\n",
+ "-403.9\n",
+ "-404.9\n",
+ "-405.9\n",
+ "-406.9\n",
+ "-407.9\n",
+ "-408.9\n",
+ "-409.9\n",
+ "-410.9\n",
+ "-411.9\n",
+ "-412.9\n",
+ "-413.9\n",
+ "-414.9\n",
+ "-415.9\n",
+ "-416.9\n",
+ "-417.9\n",
+ "-418.9\n",
+ "-419.9\n",
+ "-420.9\n",
+ "-421.9\n",
+ "-422.9\n",
+ "-423.9\n",
+ "-424.9\n",
+ "-425.9\n",
+ "-426.9\n",
+ "-427.9\n",
+ "-428.9\n",
+ "-429.9\n",
+ "-430.9\n",
+ "-431.9\n",
+ "-432.9\n",
+ "-433.9\n",
+ "-434.9\n",
+ "-435.9\n",
+ "-436.9\n",
+ "-437.9\n",
+ "-438.9\n",
+ "-439.9\n",
+ "-440.9\n",
+ "-441.9\n",
+ "-442.9\n",
+ "-443.9\n",
+ "-444.9\n",
+ "-445.9\n",
+ "-446.9\n",
+ "-447.9\n",
+ "-448.9\n",
+ "-449.9\n",
+ "-450.9\n",
+ "-451.9\n",
+ "-452.9\n",
+ "-453.9\n",
+ "-454.9\n",
+ "-455.9\n",
+ "-456.9\n",
+ "-457.9\n",
+ "-458.9\n",
+ "-459.9\n",
+ "-460.9\n",
+ "-461.9\n",
+ "-462.9\n",
+ "-463.9\n",
+ "-464.9\n",
+ "-465.9\n",
+ "-466.9\n",
+ "-467.9\n",
+ "-468.9\n",
+ "-469.9\n",
+ "-470.9\n",
+ "-471.9\n",
+ "-472.9\n",
+ "-473.9\n",
+ "-474.9\n",
+ "-475.9\n",
+ "-476.9\n",
+ "-477.9\n",
+ "-478.9\n",
+ "-479.9\n",
+ "-480.9\n",
+ "-481.9\n",
+ "-482.9\n",
+ "-483.9\n",
+ "-484.9\n",
+ "-485.9\n",
+ "-486.9\n",
+ "-487.9\n",
+ "-488.9\n",
+ "-489.9\n",
+ "-490.9\n",
+ "-491.9\n",
+ "-492.9\n",
+ "-493.9\n",
+ "-494.9\n",
+ "-495.9\n",
+ "-496.9\n",
+ "-497.9\n",
+ "-498.9\n",
+ "-499.9\n",
+ "-500.9\n",
+ "-501.9\n",
+ "-502.9\n",
+ "-503.9\n",
+ "-504.9\n",
+ "-505.9\n",
+ "-506.9\n",
+ "-507.9\n",
+ "-508.9\n",
+ "-509.9\n",
+ "-510.9\n",
+ "-511.9\n",
+ "-512.9\n",
+ "-513.9\n",
+ "-514.9\n",
+ "-515.9\n",
+ "-516.9\n",
+ "-517.9\n",
+ "-518.9\n",
+ "-519.9\n",
+ "-520.9\n",
+ "-521.9\n",
+ "-522.9\n",
+ "-523.9\n",
+ "-524.9\n",
+ "-525.9\n",
+ "-526.9\n",
+ "-527.9\n",
+ "-528.9\n",
+ "-529.9\n",
+ "-530.9\n",
+ "-531.9\n",
+ "-532.9\n",
+ "-533.9\n",
+ "-534.9\n",
+ "-535.9\n",
+ "-536.9\n",
+ "-537.9\n",
+ "-538.9\n",
+ "-539.9\n",
+ "-540.9\n",
+ "-541.9\n",
+ "-542.9\n",
+ "-543.9\n",
+ "-544.9\n",
+ "-545.9\n",
+ "-546.9\n",
+ "-547.9\n",
+ "-548.9\n",
+ "-549.9\n",
+ "-550.9\n",
+ "-551.9\n",
+ "-552.9\n",
+ "-553.9\n",
+ "-554.9\n",
+ "-555.9\n",
+ "-556.9\n",
+ "-557.9\n",
+ "-558.9\n",
+ "-559.9\n",
+ "-560.9\n",
+ "-561.9\n",
+ "-562.9\n",
+ "-563.9\n",
+ "-564.9\n",
+ "-565.9\n",
+ "-566.9\n",
+ "-567.9\n",
+ "-568.9\n",
+ "-569.9\n",
+ "-570.9\n",
+ "-571.9\n",
+ "-572.9\n",
+ "-573.9\n",
+ "-574.9\n",
+ "-575.9\n",
+ "-576.9\n",
+ "-577.9\n",
+ "-578.9\n",
+ "-579.9\n",
+ "-580.9\n",
+ "-581.9\n",
+ "-582.9\n",
+ "-583.9\n",
+ "-584.9\n",
+ "-585.9\n",
+ "-586.9\n",
+ "-587.9\n",
+ "-588.9\n",
+ "-589.9\n",
+ "-590.9\n",
+ "-591.9\n",
+ "-592.9\n",
+ "-593.9\n",
+ "-594.9\n",
+ "-595.9\n",
+ "-596.9\n",
+ "-597.9\n",
+ "-598.9\n",
+ "-599.9\n",
+ "-600.9\n",
+ "-601.9\n",
+ "-602.9\n",
+ "-603.9\n",
+ "-604.9\n",
+ "-605.9\n",
+ "-606.9\n",
+ "-607.9\n",
+ "-608.9\n",
+ "-609.9\n",
+ "-610.9\n",
+ "-611.9\n",
+ "-612.9\n",
+ "-613.9\n",
+ "-614.9\n",
+ "-615.9\n",
+ "-616.9\n",
+ "-617.9\n",
+ "-618.9\n",
+ "-619.9\n",
+ "-620.9\n",
+ "-621.9\n",
+ "-622.9\n",
+ "-623.9\n",
+ "-624.9\n",
+ "-625.9\n",
+ "-626.9\n",
+ "-627.9\n",
+ "-628.9\n",
+ "-629.9\n",
+ "-630.9\n",
+ "-631.9\n",
+ "-632.9\n",
+ "-633.9\n",
+ "-634.9\n",
+ "-635.9\n",
+ "-636.9\n",
+ "-637.9\n",
+ "-638.9\n",
+ "-639.9\n",
+ "-640.9\n",
+ "-641.9\n",
+ "-642.9\n",
+ "-643.9\n",
+ "-644.9\n",
+ "-645.9\n",
+ "-646.9\n",
+ "-647.9\n",
+ "-648.9\n",
+ "-649.9\n",
+ "-650.9\n",
+ "-651.9\n",
+ "-652.9\n",
+ "-653.9\n",
+ "-654.9\n",
+ "-655.9\n",
+ "-656.9\n",
+ "-657.9\n",
+ "-658.9\n",
+ "-659.9\n",
+ "-660.9\n",
+ "-661.9\n",
+ "-662.9\n",
+ "-663.9\n",
+ "-664.9\n",
+ "-665.9\n",
+ "-666.9\n",
+ "-667.9\n",
+ "-668.9\n",
+ "-669.9\n",
+ "-670.9\n",
+ "-671.9\n",
+ "-672.9\n",
+ "-673.9\n",
+ "-674.9\n",
+ "-675.9\n",
+ "-676.9\n",
+ "-677.9\n",
+ "-678.9\n",
+ "-679.9\n",
+ "-680.9\n",
+ "-681.9\n",
+ "-682.9\n",
+ "-683.9\n",
+ "-684.9\n",
+ "-685.9\n",
+ "-686.9\n",
+ "-687.9\n",
+ "-688.9\n",
+ "-689.9\n",
+ "-690.9\n",
+ "-691.9\n",
+ "-692.9\n",
+ "-693.9\n",
+ "-694.9\n",
+ "-695.9\n",
+ "-696.9\n",
+ "-697.9\n",
+ "-698.9\n",
+ "-699.9\n",
+ "-700.9\n",
+ "-701.9\n",
+ "-702.9\n",
+ "-703.9\n",
+ "-704.9\n",
+ "-705.9\n",
+ "-706.9\n",
+ "-707.9\n",
+ "-708.9\n",
+ "-709.9\n",
+ "-710.9\n",
+ "-711.9\n",
+ "-712.9\n",
+ "-713.9\n",
+ "-714.9\n",
+ "-715.9\n",
+ "-716.9\n",
+ "-717.9\n",
+ "-718.9\n",
+ "-719.9\n",
+ "-720.9\n",
+ "-721.9\n",
+ "-722.9\n",
+ "-723.9\n",
+ "-724.9\n",
+ "-725.9\n",
+ "-726.9\n",
+ "-727.9\n",
+ "-728.9\n",
+ "-729.9\n",
+ "-730.9\n",
+ "-731.9\n",
+ "-732.9\n",
+ "-733.9\n",
+ "-734.9\n",
+ "-735.9\n",
+ "-736.9\n",
+ "-737.9\n",
+ "-738.9\n",
+ "-739.9\n",
+ "-740.9\n",
+ "-741.9\n",
+ "-742.9\n",
+ "-743.9\n",
+ "-744.9\n",
+ "-745.9\n",
+ "-746.9\n",
+ "-747.9\n",
+ "-748.9\n",
+ "-749.9\n",
+ "-750.9\n",
+ "-751.9\n",
+ "-752.9\n",
+ "-753.9\n",
+ "-754.9\n",
+ "-755.9\n",
+ "-756.9\n",
+ "-757.9\n",
+ "-758.9\n",
+ "-759.9\n",
+ "-760.9\n",
+ "-761.9\n",
+ "-762.9\n",
+ "-763.9\n",
+ "-764.9\n",
+ "-765.9\n",
+ "-766.9\n",
+ "-767.9\n",
+ "-768.9\n",
+ "-769.9\n",
+ "-770.9\n",
+ "-771.9\n",
+ "-772.9\n",
+ "-773.9\n",
+ "-774.9\n",
+ "-775.9\n",
+ "-776.9\n",
+ "-777.9\n",
+ "-778.9\n",
+ "-779.9\n",
+ "-780.9\n",
+ "-781.9\n",
+ "-782.9\n",
+ "-783.9\n",
+ "-784.9\n",
+ "-785.9\n",
+ "-786.9\n",
+ "-787.9\n",
+ "-788.9\n",
+ "-789.9\n",
+ "-790.9\n",
+ "-791.9\n",
+ "-792.9\n",
+ "-793.9\n",
+ "-794.9\n",
+ "-795.9\n",
+ "-796.9\n",
+ "-797.9\n",
+ "-798.9\n",
+ "-799.9\n",
+ "-800.9\n",
+ "-801.9\n",
+ "-802.9\n",
+ "-803.9\n",
+ "-804.9\n",
+ "-805.9\n",
+ "-806.9\n",
+ "-807.9\n",
+ "-808.9\n",
+ "-809.9\n",
+ "-810.9\n",
+ "-811.9\n",
+ "-812.9\n",
+ "-813.9\n",
+ "-814.9\n",
+ "-815.9\n",
+ "-816.9\n",
+ "-817.9\n",
+ "-818.9\n",
+ "-819.9\n",
+ "-820.9\n",
+ "-821.9\n",
+ "-822.9\n",
+ "-823.9\n",
+ "-824.9\n",
+ "-825.9\n",
+ "-826.9\n",
+ "-827.9\n",
+ "-828.9\n",
+ "-829.9\n",
+ "-830.9\n",
+ "-831.9\n",
+ "-832.9\n",
+ "-833.9\n",
+ "-834.9\n",
+ "-835.9\n",
+ "-836.9\n",
+ "-837.9\n",
+ "-838.9\n",
+ "-839.9\n",
+ "-840.9\n",
+ "-841.9\n",
+ "-842.9\n",
+ "-843.9\n",
+ "-844.9\n",
+ "-845.9\n",
+ "-846.9\n",
+ "-847.9\n",
+ "-848.9\n",
+ "-849.9\n",
+ "-850.9\n",
+ "-851.9\n",
+ "-852.9\n",
+ "-853.9\n",
+ "-854.9\n",
+ "-855.9\n",
+ "-856.9\n",
+ "-857.9\n",
+ "-858.9\n",
+ "-859.9\n",
+ "-860.9\n",
+ "-861.9\n",
+ "-862.9\n",
+ "-863.9\n",
+ "-864.9\n",
+ "-865.9\n",
+ "-866.9\n",
+ "-867.9\n",
+ "-868.9\n",
+ "-869.9\n",
+ "-870.9\n",
+ "-871.9\n",
+ "-872.9\n",
+ "-873.9\n",
+ "-874.9\n",
+ "-875.9\n",
+ "-876.9\n",
+ "-877.9\n",
+ "-878.9\n",
+ "-879.9\n",
+ "-880.9\n",
+ "-881.9\n",
+ "-882.9\n",
+ "-883.9\n",
+ "-884.9\n",
+ "-885.9\n",
+ "-886.9\n",
+ "-887.9\n",
+ "-888.9\n",
+ "-889.9\n",
+ "-890.9\n",
+ "-891.9\n",
+ "-892.9\n",
+ "-893.9\n",
+ "-894.9\n",
+ "-895.9\n",
+ "-896.9\n",
+ "-897.9\n",
+ "-898.9\n",
+ "-899.9\n",
+ "-900.9\n",
+ "-901.9\n",
+ "-902.9\n",
+ "-903.9\n",
+ "-904.9\n",
+ "-905.9\n",
+ "-906.9\n",
+ "-907.9\n",
+ "-908.9\n",
+ "-909.9\n",
+ "-910.9\n",
+ "-911.9\n",
+ "-912.9\n",
+ "-913.9\n",
+ "-914.9\n",
+ "-915.9\n",
+ "-916.9\n",
+ "-917.9\n",
+ "-918.9\n",
+ "-919.9\n",
+ "-920.9\n",
+ "-921.9\n",
+ "-922.9\n",
+ "-923.9\n",
+ "-924.9\n",
+ "-925.9\n",
+ "-926.9\n",
+ "-927.9\n",
+ "-928.9\n",
+ "-929.9\n",
+ "-930.9\n",
+ "-931.9\n",
+ "-932.9\n",
+ "-933.9\n",
+ "-934.9\n",
+ "-935.9\n",
+ "-936.9\n",
+ "-937.9\n",
+ "-938.9\n",
+ "-939.9\n",
+ "-940.9\n",
+ "-941.9\n",
+ "-942.9\n",
+ "-943.9\n",
+ "-944.9\n",
+ "-945.9\n",
+ "-946.9\n",
+ "-947.9\n",
+ "-948.9\n",
+ "-949.9\n",
+ "-950.9\n",
+ "-951.9\n",
+ "-952.9\n",
+ "-953.9\n",
+ "-954.9\n",
+ "-955.9\n",
+ "-956.9\n",
+ "-957.9\n",
+ "-958.9\n",
+ "-959.9\n",
+ "-960.9\n",
+ "-961.9\n",
+ "-962.9\n",
+ "-963.9\n",
+ "-964.9\n",
+ "-965.9\n",
+ "-966.9\n",
+ "-967.9\n",
+ "-968.9\n",
+ "-969.9\n",
+ "-970.9\n",
+ "-971.9\n",
+ "-972.9\n",
+ "-973.9\n",
+ "-974.9\n",
+ "-975.9\n",
+ "-976.9\n",
+ "-977.9\n",
+ "-978.9\n",
+ "-979.9\n",
+ "-980.9\n",
+ "-981.9\n",
+ "-982.9\n",
+ "-983.9\n",
+ "-984.9\n",
+ "-985.9\n",
+ "-986.9\n",
+ "-987.9\n",
+ "-988.9\n",
+ "-989.9\n",
+ "-990.9\n",
+ "-991.9\n",
+ "-992.9\n",
+ "-993.9\n",
+ "-994.9\n",
+ "-995.9\n",
+ "-996.9\n",
+ "-997.9\n",
+ "-998.9\n",
+ "-999.9\n",
+ "-1000.9\n",
+ "-1001.9\n",
+ "-1002.9\n",
+ "-1003.9\n",
+ "-1004.9\n",
+ "-1005.9\n",
+ "-1006.9\n",
+ "-1007.9\n",
+ "-1008.9\n",
+ "-1009.9\n",
+ "-1010.9\n",
+ "-1011.9\n",
+ "-1012.9\n",
+ "-1013.9\n",
+ "-1014.9\n",
+ "-1015.9\n",
+ "-1016.9\n",
+ "-1017.9\n",
+ "-1018.9\n",
+ "-1019.9\n",
+ "-1020.9\n",
+ "-1021.9\n",
+ "-1022.9\n",
+ "-1023.9\n",
+ "-1024.9\n",
+ "-1025.9\n",
+ "-1026.9\n",
+ "-1027.9\n",
+ "-1028.9\n",
+ "-1029.9\n",
+ "-1030.9\n",
+ "-1031.9\n",
+ "-1032.9\n",
+ "-1033.9\n",
+ "-1034.9\n",
+ "-1035.9\n",
+ "-1036.9\n",
+ "-1037.9\n",
+ "-1038.9\n",
+ "-1039.9\n",
+ "-1040.9\n",
+ "-1041.9\n",
+ "-1042.9\n",
+ "-1043.9\n",
+ "-1044.9\n",
+ "-1045.9\n",
+ "-1046.9\n",
+ "-1047.9\n",
+ "-1048.9\n",
+ "-1049.9\n",
+ "-1050.9\n",
+ "-1051.9\n",
+ "-1052.9\n",
+ "-1053.9\n",
+ "-1054.9\n",
+ "-1055.9\n",
+ "-1056.9\n",
+ "-1057.9\n",
+ "-1058.9\n",
+ "-1059.9\n",
+ "-1060.9\n",
+ "-1061.9\n",
+ "-1062.9\n",
+ "-1063.9\n",
+ "-1064.9\n",
+ "-1065.9\n",
+ "-1066.9\n",
+ "-1067.9\n",
+ "-1068.9\n",
+ "-1069.9\n",
+ "-1070.9\n",
+ "-1071.9\n",
+ "-1072.9\n",
+ "-1073.9\n",
+ "-1074.9\n",
+ "-1075.9\n",
+ "-1076.9\n",
+ "-1077.9\n",
+ "-1078.9\n",
+ "-1079.9\n",
+ "-1080.9\n",
+ "-1081.9\n",
+ "-1082.9\n",
+ "-1083.9\n",
+ "-1084.9\n",
+ "-1085.9\n",
+ "-1086.9\n",
+ "-1087.9\n",
+ "-1088.9\n",
+ "-1089.9\n",
+ "-1090.9\n",
+ "-1091.9\n",
+ "-1092.9\n",
+ "-1093.9\n",
+ "-1094.9\n",
+ "-1095.9\n",
+ "-1096.9\n",
+ "-1097.9\n",
+ "-1098.9\n",
+ "-1099.9\n",
+ "-1100.9\n",
+ "-1101.9\n",
+ "-1102.9\n",
+ "-1103.9\n",
+ "-1104.9\n",
+ "-1105.9\n",
+ "-1106.9\n",
+ "-1107.9\n",
+ "-1108.9\n",
+ "-1109.9\n",
+ "-1110.9\n",
+ "-1111.9\n",
+ "-1112.9\n",
+ "-1113.9\n",
+ "-1114.9\n",
+ "-1115.9\n",
+ "-1116.9\n",
+ "-1117.9\n",
+ "-1118.9\n",
+ "-1119.9\n",
+ "-1120.9\n",
+ "-1121.9\n",
+ "-1122.9\n",
+ "-1123.9\n",
+ "-1124.9\n",
+ "-1125.9\n",
+ "-1126.9\n",
+ "-1127.9\n",
+ "-1128.9\n",
+ "-1129.9\n",
+ "-1130.9\n",
+ "-1131.9\n",
+ "-1132.9\n",
+ "-1133.9\n",
+ "-1134.9\n",
+ "-1135.9\n",
+ "-1136.9\n",
+ "-1137.9\n",
+ "-1138.9\n",
+ "-1139.9\n",
+ "-1140.9\n",
+ "-1141.9\n",
+ "-1142.9\n",
+ "-1143.9\n",
+ "-1144.9\n",
+ "-1145.9\n",
+ "-1146.9\n",
+ "-1147.9\n",
+ "-1148.9\n",
+ "-1149.9\n",
+ "-1150.9\n",
+ "-1151.9\n",
+ "-1152.9\n",
+ "-1153.9\n",
+ "-1154.9\n",
+ "-1155.9\n",
+ "-1156.9\n",
+ "-1157.9\n",
+ "-1158.9\n",
+ "-1159.9\n",
+ "-1160.9\n",
+ "-1161.9\n",
+ "-1162.9\n",
+ "-1163.9\n",
+ "-1164.9\n",
+ "-1165.9\n",
+ "-1166.9\n",
+ "-1167.9\n",
+ "-1168.9\n",
+ "-1169.9\n",
+ "-1170.9\n",
+ "-1171.9\n",
+ "-1172.9\n",
+ "-1173.9\n",
+ "-1174.9\n",
+ "-1175.9\n",
+ "-1176.9\n",
+ "-1177.9\n",
+ "-1178.9\n",
+ "-1179.9\n",
+ "-1180.9\n",
+ "-1181.9\n",
+ "-1182.9\n",
+ "-1183.9\n",
+ "-1184.9\n",
+ "-1185.9\n",
+ "-1186.9\n",
+ "-1187.9\n",
+ "-1188.9\n",
+ "-1189.9\n",
+ "-1190.9\n",
+ "-1191.9\n",
+ "-1192.9\n",
+ "-1193.9\n",
+ "-1194.9\n",
+ "-1195.9\n",
+ "-1196.9\n",
+ "-1197.9\n",
+ "-1198.9\n",
+ "-1199.9\n",
+ "-1200.9\n",
+ "-1201.9\n",
+ "-1202.9\n",
+ "-1203.9\n",
+ "-1204.9\n",
+ "-1205.9\n",
+ "-1206.9\n",
+ "-1207.9\n",
+ "-1208.9\n",
+ "-1209.9\n",
+ "-1210.9\n",
+ "-1211.9\n",
+ "-1212.9\n",
+ "-1213.9\n",
+ "-1214.9\n",
+ "-1215.9\n",
+ "-1216.9\n",
+ "-1217.9\n",
+ "-1218.9\n",
+ "-1219.9\n",
+ "-1220.9\n",
+ "-1221.9\n",
+ "-1222.9\n",
+ "-1223.9\n",
+ "-1224.9\n",
+ "-1225.9\n",
+ "-1226.9\n",
+ "-1227.9\n",
+ "-1228.9\n",
+ "-1229.9\n",
+ "-1230.9\n",
+ "-1231.9\n",
+ "-1232.9\n",
+ "-1233.9\n",
+ "-1234.9\n",
+ "-1235.9\n",
+ "-1236.9\n",
+ "-1237.9\n",
+ "-1238.9\n",
+ "-1239.9\n",
+ "-1240.9\n",
+ "-1241.9\n",
+ "-1242.9\n",
+ "-1243.9\n",
+ "-1244.9\n",
+ "-1245.9\n",
+ "-1246.9\n",
+ "-1247.9\n",
+ "-1248.9\n",
+ "-1249.9\n",
+ "-1250.9\n",
+ "-1251.9\n",
+ "-1252.9\n",
+ "-1253.9\n",
+ "-1254.9\n",
+ "-1255.9\n",
+ "-1256.9\n",
+ "-1257.9\n",
+ "-1258.9\n",
+ "-1259.9\n",
+ "-1260.9\n",
+ "-1261.9\n",
+ "-1262.9\n",
+ "-1263.9\n",
+ "-1264.9\n",
+ "-1265.9\n",
+ "-1266.9\n",
+ "-1267.9\n",
+ "-1268.9\n",
+ "-1269.9\n",
+ "-1270.9\n",
+ "-1271.9\n",
+ "-1272.9\n",
+ "-1273.9\n",
+ "-1274.9\n",
+ "-1275.9\n",
+ "-1276.9\n",
+ "-1277.9\n",
+ "-1278.9\n",
+ "-1279.9\n",
+ "-1280.9\n",
+ "-1281.9\n",
+ "-1282.9\n",
+ "-1283.9\n",
+ "-1284.9\n",
+ "-1285.9\n",
+ "-1286.9\n",
+ "-1287.9\n",
+ "-1288.9\n",
+ "-1289.9\n",
+ "-1290.9\n",
+ "-1291.9\n",
+ "-1292.9\n",
+ "-1293.9\n",
+ "-1294.9\n",
+ "-1295.9\n",
+ "-1296.9\n",
+ "-1297.9\n",
+ "-1298.9\n",
+ "-1299.9\n",
+ "-1300.9\n",
+ "-1301.9\n",
+ "-1302.9\n",
+ "-1303.9\n",
+ "-1304.9\n",
+ "-1305.9\n",
+ "-1306.9\n",
+ "-1307.9\n",
+ "-1308.9\n",
+ "-1309.9\n",
+ "-1310.9\n",
+ "-1311.9\n",
+ "-1312.9\n",
+ "-1313.9\n",
+ "-1314.9\n",
+ "-1315.9\n",
+ "-1316.9\n",
+ "-1317.9\n",
+ "-1318.9\n",
+ "-1319.9\n",
+ "-1320.9\n",
+ "-1321.9\n",
+ "-1322.9\n",
+ "-1323.9\n",
+ "-1324.9\n",
+ "-1325.9\n",
+ "-1326.9\n",
+ "-1327.9\n",
+ "-1328.9\n",
+ "-1329.9\n",
+ "-1330.9\n",
+ "-1331.9\n",
+ "-1332.9\n",
+ "-1333.9\n",
+ "-1334.9\n",
+ "-1335.9\n",
+ "-1336.9\n",
+ "-1337.9\n",
+ "-1338.9\n",
+ "-1339.9\n",
+ "-1340.9\n",
+ "-1341.9\n",
+ "-1342.9\n",
+ "-1343.9\n",
+ "-1344.9\n",
+ "-1345.9\n",
+ "-1346.9\n",
+ "-1347.9\n",
+ "-1348.9\n",
+ "-1349.9\n",
+ "-1350.9\n",
+ "-1351.9\n",
+ "-1352.9\n",
+ "-1353.9\n",
+ "-1354.9\n",
+ "-1355.9\n",
+ "-1356.9\n",
+ "-1357.9\n",
+ "-1358.9\n",
+ "-1359.9\n",
+ "-1360.9\n",
+ "-1361.9\n",
+ "-1362.9\n",
+ "-1363.9\n",
+ "-1364.9\n",
+ "-1365.9\n",
+ "-1366.9\n",
+ "-1367.9\n",
+ "-1368.9\n",
+ "-1369.9\n",
+ "-1370.9\n",
+ "-1371.9\n",
+ "-1372.9\n",
+ "-1373.9\n",
+ "-1374.9\n",
+ "-1375.9\n",
+ "-1376.9\n",
+ "-1377.9\n",
+ "-1378.9\n",
+ "-1379.9\n",
+ "-1380.9\n",
+ "-1381.9\n",
+ "-1382.9\n",
+ "-1383.9\n",
+ "-1384.9\n",
+ "-1385.9\n",
+ "-1386.9\n",
+ "-1387.9\n",
+ "-1388.9\n",
+ "-1389.9\n",
+ "-1390.9\n",
+ "-1391.9\n",
+ "-1392.9\n",
+ "-1393.9\n",
+ "-1394.9\n",
+ "-1395.9\n",
+ "-1396.9\n",
+ "-1397.9\n",
+ "-1398.9\n",
+ "-1399.9\n",
+ "-1400.9\n",
+ "-1401.9\n",
+ "-1402.9\n",
+ "-1403.9\n",
+ "-1404.9\n",
+ "-1405.9\n",
+ "-1406.9\n",
+ "-1407.9\n",
+ "-1408.9\n",
+ "-1409.9\n",
+ "-1410.9\n",
+ "-1411.9\n",
+ "-1412.9\n",
+ "-1413.9\n",
+ "-1414.9\n",
+ "-1415.9\n",
+ "-1416.9\n",
+ "-1417.9\n",
+ "-1418.9\n",
+ "-1419.9\n",
+ "-1420.9\n",
+ "-1421.9\n",
+ "-1422.9\n",
+ "-1423.9\n",
+ "-1424.9\n",
+ "-1425.9\n",
+ "-1426.9\n",
+ "-1427.9\n",
+ "-1428.9\n",
+ "-1429.9\n",
+ "-1430.9\n",
+ "-1431.9\n",
+ "-1432.9\n",
+ "-1433.9\n",
+ "-1434.9\n",
+ "-1435.9\n",
+ "-1436.9\n",
+ "-1437.9\n",
+ "-1438.9\n",
+ "-1439.9\n",
+ "-1440.9\n",
+ "-1441.9\n",
+ "-1442.9\n",
+ "-1443.9\n",
+ "-1444.9\n",
+ "-1445.9\n",
+ "-1446.9\n",
+ "-1447.9\n",
+ "-1448.9\n",
+ "-1449.9\n",
+ "-1450.9\n",
+ "-1451.9\n",
+ "-1452.9\n",
+ "-1453.9\n",
+ "-1454.9\n",
+ "-1455.9\n",
+ "-1456.9\n",
+ "-1457.9\n",
+ "-1458.9\n",
+ "-1459.9\n",
+ "-1460.9\n",
+ "-1461.9\n",
+ "-1462.9\n",
+ "-1463.9\n",
+ "-1464.9\n",
+ "-1465.9\n",
+ "-1466.9\n",
+ "-1467.9\n",
+ "-1468.9\n",
+ "-1469.9\n",
+ "-1470.9\n",
+ "-1471.9\n",
+ "-1472.9\n",
+ "-1473.9\n",
+ "-1474.9\n",
+ "-1475.9\n",
+ "-1476.9\n",
+ "-1477.9\n",
+ "-1478.9\n",
+ "-1479.9\n",
+ "-1480.9\n",
+ "-1481.9\n",
+ "-1482.9\n",
+ "-1483.9\n",
+ "-1484.9\n",
+ "-1485.9\n",
+ "-1486.9\n",
+ "-1487.9\n",
+ "-1488.9\n",
+ "-1489.9\n",
+ "-1490.9\n",
+ "-1491.9\n",
+ "-1492.9\n",
+ "-1493.9\n",
+ "-1494.9\n",
+ "-1495.9\n",
+ "-1496.9\n",
+ "-1497.9\n",
+ "-1498.9\n",
+ "-1499.9\n",
+ "-1500.9\n",
+ "-1501.9\n",
+ "-1502.9\n",
+ "-1503.9\n",
+ "-1504.9\n",
+ "-1505.9\n",
+ "-1506.9\n",
+ "-1507.9\n",
+ "-1508.9\n",
+ "-1509.9\n",
+ "-1510.9\n",
+ "-1511.9\n",
+ "-1512.9\n",
+ "-1513.9\n",
+ "-1514.9\n",
+ "-1515.9\n",
+ "-1516.9\n",
+ "-1517.9\n",
+ "-1518.9\n",
+ "-1519.9\n",
+ "-1520.9\n",
+ "-1521.9\n",
+ "-1522.9\n",
+ "-1523.9\n",
+ "-1524.9\n",
+ "-1525.9\n",
+ "-1526.9\n",
+ "-1527.9\n",
+ "-1528.9\n",
+ "-1529.9\n",
+ "-1530.9\n",
+ "-1531.9\n",
+ "-1532.9\n",
+ "-1533.9\n",
+ "-1534.9\n",
+ "-1535.9\n",
+ "-1536.9\n",
+ "-1537.9\n",
+ "-1538.9\n",
+ "-1539.9\n",
+ "-1540.9\n",
+ "-1541.9\n",
+ "-1542.9\n",
+ "-1543.9\n",
+ "-1544.9\n",
+ "-1545.9\n",
+ "-1546.9\n",
+ "-1547.9\n",
+ "-1548.9\n",
+ "-1549.9\n",
+ "-1550.9\n",
+ "-1551.9\n",
+ "-1552.9\n",
+ "-1553.9\n",
+ "-1554.9\n",
+ "-1555.9\n",
+ "-1556.9\n",
+ "-1557.9\n",
+ "-1558.9\n",
+ "-1559.9\n",
+ "-1560.9\n",
+ "-1561.9\n",
+ "-1562.9\n",
+ "-1563.9\n",
+ "-1564.9\n",
+ "-1565.9\n",
+ "-1566.9\n",
+ "-1567.9\n",
+ "-1568.9\n",
+ "-1569.9\n",
+ "-1570.9\n",
+ "-1571.9\n",
+ "-1572.9\n",
+ "-1573.9\n",
+ "-1574.9\n",
+ "-1575.9\n",
+ "-1576.9\n",
+ "-1577.9\n",
+ "-1578.9\n",
+ "-1579.9\n",
+ "-1580.9\n",
+ "-1581.9\n",
+ "-1582.9\n",
+ "-1583.9\n",
+ "-1584.9\n",
+ "-1585.9\n",
+ "-1586.9\n",
+ "-1587.9\n",
+ "-1588.9\n",
+ "-1589.9\n",
+ "-1590.9\n",
+ "-1591.9\n",
+ "-1592.9\n",
+ "-1593.9\n",
+ "-1594.9\n",
+ "-1595.9\n",
+ "-1596.9\n",
+ "-1597.9\n",
+ "-1598.9\n",
+ "-1599.9\n",
+ "-1600.9\n",
+ "-1601.9\n",
+ "-1602.9\n",
+ "-1603.9\n",
+ "-1604.9\n",
+ "-1605.9\n",
+ "-1606.9\n",
+ "-1607.9\n",
+ "-1608.9\n",
+ "-1609.9\n",
+ "-1610.9\n",
+ "-1611.9\n",
+ "-1612.9\n",
+ "-1613.9\n",
+ "-1614.9\n",
+ "-1615.9\n",
+ "-1616.9\n",
+ "-1617.9\n",
+ "-1618.9\n",
+ "-1619.9\n",
+ "-1620.9\n",
+ "-1621.9\n",
+ "-1622.9\n",
+ "-1623.9\n",
+ "-1624.9\n",
+ "-1625.9\n",
+ "-1626.9\n",
+ "-1627.9\n",
+ "-1628.9\n",
+ "-1629.9\n",
+ "-1630.9\n",
+ "-1631.9\n",
+ "-1632.9\n",
+ "-1633.9\n",
+ "-1634.9\n",
+ "-1635.9\n",
+ "-1636.9\n",
+ "-1637.9\n",
+ "-1638.9\n",
+ "-1639.9\n",
+ "-1640.9\n",
+ "-1641.9\n",
+ "-1642.9\n",
+ "-1643.9\n",
+ "-1644.9\n",
+ "-1645.9\n",
+ "-1646.9\n",
+ "-1647.9\n",
+ "-1648.9\n",
+ "-1649.9\n",
+ "-1650.9\n",
+ "-1651.9\n",
+ "-1652.9\n",
+ "-1653.9\n",
+ "-1654.9\n",
+ "-1655.9\n",
+ "-1656.9\n",
+ "-1657.9\n",
+ "-1658.9\n",
+ "-1659.9\n",
+ "-1660.9\n",
+ "-1661.9\n",
+ "-1662.9\n",
+ "-1663.9\n",
+ "-1664.9\n",
+ "-1665.9\n",
+ "-1666.9\n",
+ "-1667.9\n",
+ "-1668.9\n",
+ "-1669.9\n",
+ "-1670.9\n",
+ "-1671.9\n",
+ "-1672.9\n",
+ "-1673.9\n",
+ "-1674.9\n",
+ "-1675.9\n",
+ "-1676.9\n",
+ "-1677.9\n",
+ "-1678.9\n",
+ "-1679.9\n",
+ "-1680.9\n",
+ "-1681.9\n",
+ "-1682.9\n",
+ "-1683.9\n",
+ "-1684.9\n",
+ "-1685.9\n",
+ "-1686.9\n",
+ "-1687.9\n",
+ "-1688.9\n",
+ "-1689.9\n",
+ "-1690.9\n",
+ "-1691.9\n",
+ "-1692.9\n",
+ "-1693.9\n",
+ "-1694.9\n",
+ "-1695.9\n",
+ "-1696.9\n",
+ "-1697.9\n",
+ "-1698.9\n",
+ "-1699.9\n",
+ "-1700.9\n",
+ "-1701.9\n",
+ "-1702.9\n",
+ "-1703.9\n",
+ "-1704.9\n",
+ "-1705.9\n",
+ "-1706.9\n",
+ "-1707.9\n",
+ "-1708.9\n",
+ "-1709.9\n",
+ "-1710.9\n",
+ "-1711.9\n",
+ "-1712.9\n",
+ "-1713.9\n",
+ "-1714.9\n",
+ "-1715.9\n",
+ "-1716.9\n",
+ "-1717.9\n",
+ "-1718.9\n",
+ "-1719.9\n",
+ "-1720.9\n",
+ "-1721.9\n",
+ "-1722.9\n",
+ "-1723.9\n",
+ "-1724.9\n",
+ "-1725.9\n",
+ "-1726.9\n",
+ "-1727.9\n",
+ "-1728.9\n",
+ "-1729.9\n",
+ "-1730.9\n",
+ "-1731.9\n",
+ "-1732.9\n",
+ "-1733.9\n",
+ "-1734.9\n",
+ "-1735.9\n",
+ "-1736.9\n",
+ "-1737.9\n",
+ "-1738.9\n",
+ "-1739.9\n",
+ "-1740.9\n",
+ "-1741.9\n",
+ "-1742.9\n",
+ "-1743.9\n",
+ "-1744.9\n",
+ "-1745.9\n",
+ "-1746.9\n",
+ "-1747.9\n",
+ "-1748.9\n",
+ "-1749.9\n",
+ "-1750.9\n",
+ "-1751.9\n",
+ "-1752.9\n",
+ "-1753.9\n",
+ "-1754.9\n",
+ "-1755.9\n",
+ "-1756.9\n",
+ "-1757.9\n",
+ "-1758.9\n",
+ "-1759.9\n",
+ "-1760.9\n",
+ "-1761.9\n",
+ "-1762.9\n",
+ "-1763.9\n",
+ "-1764.9\n",
+ "-1765.9\n",
+ "-1766.9\n",
+ "-1767.9\n",
+ "-1768.9\n",
+ "-1769.9\n",
+ "-1770.9\n",
+ "-1771.9\n",
+ "-1772.9\n",
+ "-1773.9\n",
+ "-1774.9\n",
+ "-1775.9\n",
+ "-1776.9\n",
+ "-1777.9\n",
+ "-1778.9\n",
+ "-1779.9\n",
+ "-1780.9\n",
+ "-1781.9\n",
+ "-1782.9\n",
+ "-1783.9\n",
+ "-1784.9\n",
+ "-1785.9\n",
+ "-1786.9\n",
+ "-1787.9\n",
+ "-1788.9\n",
+ "-1789.9\n",
+ "-1790.9\n",
+ "-1791.9\n",
+ "-1792.9\n",
+ "-1793.9\n",
+ "-1794.9\n",
+ "-1795.9\n",
+ "-1796.9\n",
+ "-1797.9\n",
+ "-1798.9\n",
+ "-1799.9\n",
+ "-1800.9\n",
+ "-1801.9\n",
+ "-1802.9\n",
+ "-1803.9\n",
+ "-1804.9\n",
+ "-1805.9\n",
+ "-1806.9\n",
+ "-1807.9\n",
+ "-1808.9\n",
+ "-1809.9\n",
+ "-1810.9\n",
+ "-1811.9\n",
+ "-1812.9\n",
+ "-1813.9\n",
+ "-1814.9\n",
+ "-1815.9\n",
+ "-1816.9\n",
+ "-1817.9\n",
+ "-1818.9\n",
+ "-1819.9\n",
+ "-1820.9\n",
+ "-1821.9\n",
+ "-1822.9\n",
+ "-1823.9\n",
+ "-1824.9\n",
+ "-1825.9\n",
+ "-1826.9\n",
+ "-1827.9\n",
+ "-1828.9\n",
+ "-1829.9\n",
+ "-1830.9\n",
+ "-1831.9\n",
+ "-1832.9\n",
+ "-1833.9\n",
+ "-1834.9\n",
+ "-1835.9\n",
+ "-1836.9\n",
+ "-1837.9\n",
+ "-1838.9\n",
+ "-1839.9\n",
+ "-1840.9\n",
+ "-1841.9\n",
+ "-1842.9\n",
+ "-1843.9\n",
+ "-1844.9\n",
+ "-1845.9\n",
+ "-1846.9\n",
+ "-1847.9\n",
+ "-1848.9\n",
+ "-1849.9\n",
+ "-1850.9\n",
+ "-1851.9\n",
+ "-1852.9\n",
+ "-1853.9\n",
+ "-1854.9\n",
+ "-1855.9\n",
+ "-1856.9\n",
+ "-1857.9\n",
+ "-1858.9\n",
+ "-1859.9\n",
+ "-1860.9\n",
+ "-1861.9\n",
+ "-1862.9\n",
+ "-1863.9\n",
+ "-1864.9\n",
+ "-1865.9\n",
+ "-1866.9\n",
+ "-1867.9\n",
+ "-1868.9\n",
+ "-1869.9\n",
+ "-1870.9\n",
+ "-1871.9\n",
+ "-1872.9\n",
+ "-1873.9\n",
+ "-1874.9\n",
+ "-1875.9\n",
+ "-1876.9\n",
+ "-1877.9\n",
+ "-1878.9\n",
+ "-1879.9\n",
+ "-1880.9\n",
+ "-1881.9\n",
+ "-1882.9\n",
+ "-1883.9\n",
+ "-1884.9\n",
+ "-1885.9\n",
+ "-1886.9\n",
+ "-1887.9\n",
+ "-1888.9\n",
+ "-1889.9\n",
+ "-1890.9\n",
+ "-1891.9\n",
+ "-1892.9\n",
+ "-1893.9\n",
+ "-1894.9\n",
+ "-1895.9\n",
+ "-1896.9\n",
+ "-1897.9\n",
+ "-1898.9\n",
+ "-1899.9\n",
+ "-1900.9\n",
+ "-1901.9\n",
+ "-1902.9\n",
+ "-1903.9\n",
+ "-1904.9\n",
+ "-1905.9\n",
+ "-1906.9\n",
+ "-1907.9\n",
+ "-1908.9\n",
+ "-1909.9\n",
+ "-1910.9\n",
+ "-1911.9\n",
+ "-1912.9\n",
+ "-1913.9\n",
+ "-1914.9\n",
+ "-1915.9\n",
+ "-1916.9\n",
+ "-1917.9\n",
+ "-1918.9\n",
+ "-1919.9\n",
+ "-1920.9\n",
+ "-1921.9\n",
+ "-1922.9\n",
+ "-1923.9\n",
+ "-1924.9\n",
+ "-1925.9\n",
+ "-1926.9\n",
+ "-1927.9\n",
+ "-1928.9\n",
+ "-1929.9\n",
+ "-1930.9\n",
+ "-1931.9\n",
+ "-1932.9\n",
+ "-1933.9\n",
+ "-1934.9\n",
+ "-1935.9\n",
+ "-1936.9\n",
+ "-1937.9\n",
+ "-1938.9\n",
+ "-1939.9\n",
+ "-1940.9\n",
+ "-1941.9\n",
+ "-1942.9\n",
+ "-1943.9\n",
+ "-1944.9\n",
+ "-1945.9\n",
+ "-1946.9\n",
+ "-1947.9\n",
+ "-1948.9\n",
+ "-1949.9\n",
+ "-1950.9\n",
+ "-1951.9\n",
+ "-1952.9\n",
+ "-1953.9\n",
+ "-1954.9\n",
+ "-1955.9\n",
+ "-1956.9\n",
+ "-1957.9\n",
+ "-1958.9\n",
+ "-1959.9\n",
+ "-1960.9\n",
+ "-1961.9\n",
+ "-1962.9\n",
+ "-1963.9\n",
+ "-1964.9\n",
+ "-1965.9\n",
+ "-1966.9\n",
+ "-1967.9\n",
+ "-1968.9\n",
+ "-1969.9\n",
+ "-1970.9\n",
+ "-1971.9\n",
+ "-1972.9\n",
+ "-1973.9\n",
+ "-1974.9\n",
+ "-1975.9\n",
+ "-1976.9\n",
+ "-1977.9\n",
+ "-1978.9\n",
+ "-1979.9\n",
+ "-1980.9\n",
+ "-1981.9\n",
+ "-1982.9\n",
+ "-1983.9\n",
+ "-1984.9\n",
+ "-1985.9\n",
+ "-1986.9\n",
+ "-1987.9\n",
+ "-1988.9\n",
+ "-1989.9\n",
+ "-1990.9\n",
+ "-1991.9\n",
+ "-1992.9\n",
+ "-1993.9\n",
+ "-1994.9\n",
+ "-1995.9\n",
+ "-1996.9\n",
+ "-1997.9\n",
+ "-1998.9\n",
+ "-1999.9\n",
+ "-2000.9\n",
+ "-2001.9\n",
+ "-2002.9\n",
+ "-2003.9\n",
+ "-2004.9\n",
+ "-2005.9\n",
+ "-2006.9\n",
+ "-2007.9\n",
+ "-2008.9\n",
+ "-2009.9\n",
+ "-2010.9\n",
+ "-2011.9\n",
+ "-2012.9\n",
+ "-2013.9\n",
+ "-2014.9\n",
+ "-2015.9\n",
+ "-2016.9\n",
+ "-2017.9\n",
+ "-2018.9\n",
+ "-2019.9\n",
+ "-2020.9\n",
+ "-2021.9\n",
+ "-2022.9\n",
+ "-2023.9\n",
+ "-2024.9\n",
+ "-2025.9\n",
+ "-2026.9\n",
+ "-2027.9\n",
+ "-2028.9\n",
+ "-2029.9\n",
+ "-2030.9\n",
+ "-2031.9\n",
+ "-2032.9\n",
+ "-2033.9\n",
+ "-2034.9\n",
+ "-2035.9\n",
+ "-2036.9\n",
+ "-2037.9\n",
+ "-2038.9\n",
+ "-2039.9\n",
+ "-2040.9\n",
+ "-2041.9\n",
+ "-2042.9\n",
+ "-2043.9\n",
+ "-2044.9\n",
+ "-2045.9\n",
+ "-2046.9\n",
+ "-2047.9\n",
+ "-2048.9\n",
+ "-2049.9\n",
+ "-2050.9\n",
+ "-2051.9\n",
+ "-2052.9\n",
+ "-2053.9\n",
+ "-2054.9\n",
+ "-2055.9\n",
+ "-2056.9\n",
+ "-2057.9\n",
+ "-2058.9\n",
+ "-2059.9\n",
+ "-2060.9\n",
+ "-2061.9\n",
+ "-2062.9\n",
+ "-2063.9\n",
+ "-2064.9\n",
+ "-2065.9\n",
+ "-2066.9\n",
+ "-2067.9\n",
+ "-2068.9\n",
+ "-2069.9\n",
+ "-2070.9\n",
+ "-2071.9\n",
+ "-2072.9\n",
+ "-2073.9\n",
+ "-2074.9\n",
+ "-2075.9\n",
+ "-2076.9\n",
+ "-2077.9\n",
+ "-2078.9\n",
+ "-2079.9\n",
+ "-2080.9\n",
+ "-2081.9\n",
+ "-2082.9\n",
+ "-2083.9\n",
+ "-2084.9\n",
+ "-2085.9\n",
+ "-2086.9\n",
+ "-2087.9\n",
+ "-2088.9\n",
+ "-2089.9\n",
+ "-2090.9\n",
+ "-2091.9\n",
+ "-2092.9\n",
+ "-2093.9\n",
+ "-2094.9\n",
+ "-2095.9\n",
+ "-2096.9\n",
+ "-2097.9\n",
+ "-2098.9\n",
+ "-2099.9\n",
+ "-2100.9\n",
+ "-2101.9\n",
+ "-2102.9\n",
+ "-2103.9\n",
+ "-2104.9\n",
+ "-2105.9\n",
+ "-2106.9\n",
+ "-2107.9\n",
+ "-2108.9\n",
+ "-2109.9\n",
+ "-2110.9\n",
+ "-2111.9\n",
+ "-2112.9\n",
+ "-2113.9\n",
+ "-2114.9\n",
+ "-2115.9\n",
+ "-2116.9\n",
+ "-2117.9\n",
+ "-2118.9\n",
+ "-2119.9\n",
+ "-2120.9\n",
+ "-2121.9\n",
+ "-2122.9\n",
+ "-2123.9\n",
+ "-2124.9\n",
+ "-2125.9\n",
+ "-2126.9\n",
+ "-2127.9\n",
+ "-2128.9\n",
+ "-2129.9\n",
+ "-2130.9\n",
+ "-2131.9\n",
+ "-2132.9\n",
+ "-2133.9\n",
+ "-2134.9\n",
+ "-2135.9\n",
+ "-2136.9\n",
+ "-2137.9\n",
+ "-2138.9\n",
+ "-2139.9\n",
+ "-2140.9\n",
+ "-2141.9\n",
+ "-2142.9\n",
+ "-2143.9\n",
+ "-2144.9\n",
+ "-2145.9\n",
+ "-2146.9\n",
+ "-2147.9\n",
+ "-2148.9\n",
+ "-2149.9\n",
+ "-2150.9\n",
+ "-2151.9\n",
+ "-2152.9\n",
+ "-2153.9\n",
+ "-2154.9\n",
+ "-2155.9\n",
+ "-2156.9\n",
+ "-2157.9\n",
+ "-2158.9\n",
+ "-2159.9\n",
+ "-2160.9\n",
+ "-2161.9\n",
+ "-2162.9\n",
+ "-2163.9\n",
+ "-2164.9\n",
+ "-2165.9\n",
+ "-2166.9\n",
+ "-2167.9\n",
+ "-2168.9\n",
+ "-2169.9\n",
+ "-2170.9\n",
+ "-2171.9\n",
+ "-2172.9\n",
+ "-2173.9\n",
+ "-2174.9\n",
+ "-2175.9\n",
+ "-2176.9\n",
+ "-2177.9\n",
+ "-2178.9\n",
+ "-2179.9\n",
+ "-2180.9\n",
+ "-2181.9\n",
+ "-2182.9\n",
+ "-2183.9\n",
+ "-2184.9\n",
+ "-2185.9\n",
+ "-2186.9\n",
+ "-2187.9\n",
+ "-2188.9\n",
+ "-2189.9\n",
+ "-2190.9\n",
+ "-2191.9\n",
+ "-2192.9\n",
+ "-2193.9\n",
+ "-2194.9\n",
+ "-2195.9\n",
+ "-2196.9\n",
+ "-2197.9\n",
+ "-2198.9\n",
+ "-2199.9\n",
+ "-2200.9\n",
+ "-2201.9\n",
+ "-2202.9\n",
+ "-2203.9\n",
+ "-2204.9\n",
+ "-2205.9\n",
+ "-2206.9\n",
+ "-2207.9\n",
+ "-2208.9\n",
+ "-2209.9\n",
+ "-2210.9\n",
+ "-2211.9\n",
+ "-2212.9\n",
+ "-2213.9\n",
+ "-2214.9\n",
+ "-2215.9\n",
+ "-2216.9\n",
+ "-2217.9\n",
+ "-2218.9\n",
+ "-2219.9\n",
+ "-2220.9\n",
+ "-2221.9\n",
+ "-2222.9\n",
+ "-2223.9\n",
+ "-2224.9\n",
+ "-2225.9\n",
+ "-2226.9\n",
+ "-2227.9\n",
+ "-2228.9\n",
+ "-2229.9\n",
+ "-2230.9\n",
+ "-2231.9\n",
+ "-2232.9\n",
+ "-2233.9\n",
+ "-2234.9\n",
+ "-2235.9\n",
+ "-2236.9\n",
+ "-2237.9\n",
+ "-2238.9\n",
+ "-2239.9\n",
+ "-2240.9\n",
+ "-2241.9\n",
+ "-2242.9\n",
+ "-2243.9\n",
+ "-2244.9\n",
+ "-2245.9\n",
+ "-2246.9\n",
+ "-2247.9\n",
+ "-2248.9\n",
+ "-2249.9\n",
+ "-2250.9\n",
+ "-2251.9\n",
+ "-2252.9\n",
+ "-2253.9\n",
+ "-2254.9\n",
+ "-2255.9\n",
+ "-2256.9\n",
+ "-2257.9\n",
+ "-2258.9\n",
+ "-2259.9\n",
+ "-2260.9\n",
+ "-2261.9\n",
+ "-2262.9\n",
+ "-2263.9\n",
+ "-2264.9\n",
+ "-2265.9\n",
+ "-2266.9\n",
+ "-2267.9\n",
+ "-2268.9\n",
+ "-2269.9\n",
+ "-2270.9\n",
+ "-2271.9\n",
+ "-2272.9\n",
+ "-2273.9\n",
+ "-2274.9\n",
+ "-2275.9\n",
+ "-2276.9\n",
+ "-2277.9\n",
+ "-2278.9\n",
+ "-2279.9\n",
+ "-2280.9\n",
+ "-2281.9\n",
+ "-2282.9\n",
+ "-2283.9\n",
+ "-2284.9\n",
+ "-2285.9\n",
+ "-2286.9\n",
+ "-2287.9\n",
+ "-2288.9\n",
+ "-2289.9\n",
+ "-2290.9\n",
+ "-2291.9\n",
+ "-2292.9\n",
+ "-2293.9\n",
+ "-2294.9\n",
+ "-2295.9\n",
+ "-2296.9\n",
+ "-2297.9\n",
+ "-2298.9\n",
+ "-2299.9\n",
+ "-2300.9\n",
+ "-2301.9\n",
+ "-2302.9\n",
+ "-2303.9\n",
+ "-2304.9\n",
+ "-2305.9\n",
+ "-2306.9\n",
+ "-2307.9\n",
+ "-2308.9\n",
+ "-2309.9\n",
+ "-2310.9\n",
+ "-2311.9\n",
+ "-2312.9\n",
+ "-2313.9\n",
+ "-2314.9\n",
+ "-2315.9\n",
+ "-2316.9\n",
+ "-2317.9\n",
+ "-2318.9\n",
+ "-2319.9\n",
+ "-2320.9\n",
+ "-2321.9\n",
+ "-2322.9\n",
+ "-2323.9\n",
+ "-2324.9\n",
+ "-2325.9\n",
+ "-2326.9\n",
+ "-2327.9\n",
+ "-2328.9\n",
+ "-2329.9\n",
+ "-2330.9\n",
+ "-2331.9\n",
+ "-2332.9\n",
+ "-2333.9\n",
+ "-2334.9\n",
+ "-2335.9\n",
+ "-2336.9\n",
+ "-2337.9\n",
+ "-2338.9\n",
+ "-2339.9\n",
+ "-2340.9\n",
+ "-2341.9\n",
+ "-2342.9\n",
+ "-2343.9\n",
+ "-2344.9\n",
+ "-2345.9\n",
+ "-2346.9\n",
+ "-2347.9\n",
+ "-2348.9\n",
+ "-2349.9\n",
+ "-2350.9\n",
+ "-2351.9\n",
+ "-2352.9\n",
+ "-2353.9\n",
+ "-2354.9\n",
+ "-2355.9\n",
+ "-2356.9\n",
+ "-2357.9\n",
+ "-2358.9\n",
+ "-2359.9\n",
+ "-2360.9\n",
+ "-2361.9\n",
+ "-2362.9\n",
+ "-2363.9\n",
+ "-2364.9\n",
+ "-2365.9\n",
+ "-2366.9\n",
+ "-2367.9\n",
+ "-2368.9\n",
+ "-2369.9\n",
+ "-2370.9\n",
+ "-2371.9\n",
+ "-2372.9\n",
+ "-2373.9\n",
+ "-2374.9\n",
+ "-2375.9\n",
+ "-2376.9\n",
+ "-2377.9\n",
+ "-2378.9\n",
+ "-2379.9\n",
+ "-2380.9\n",
+ "-2381.9\n",
+ "-2382.9\n",
+ "-2383.9\n",
+ "-2384.9\n",
+ "-2385.9\n",
+ "-2386.9\n",
+ "-2387.9\n",
+ "-2388.9\n",
+ "-2389.9\n",
+ "-2390.9\n",
+ "-2391.9\n",
+ "-2392.9\n",
+ "-2393.9\n",
+ "-2394.9\n",
+ "-2395.9\n",
+ "-2396.9\n",
+ "-2397.9\n",
+ "-2398.9\n",
+ "-2399.9\n",
+ "-2400.9\n",
+ "-2401.9\n",
+ "-2402.9\n",
+ "-2403.9\n",
+ "-2404.9\n",
+ "-2405.9\n",
+ "-2406.9\n",
+ "-2407.9\n",
+ "-2408.9\n",
+ "-2409.9\n",
+ "-2410.9\n",
+ "-2411.9\n",
+ "-2412.9\n",
+ "-2413.9\n",
+ "-2414.9\n",
+ "-2415.9\n",
+ "-2416.9\n",
+ "-2417.9\n",
+ "-2418.9\n",
+ "-2419.9\n",
+ "-2420.9\n",
+ "-2421.9\n",
+ "-2422.9\n",
+ "-2423.9\n",
+ "-2424.9\n",
+ "-2425.9\n",
+ "-2426.9\n",
+ "-2427.9\n",
+ "-2428.9\n",
+ "-2429.9\n",
+ "-2430.9\n",
+ "-2431.9\n",
+ "-2432.9\n",
+ "-2433.9\n",
+ "-2434.9\n",
+ "-2435.9\n",
+ "-2436.9\n",
+ "-2437.9\n",
+ "-2438.9\n",
+ "-2439.9\n",
+ "-2440.9\n",
+ "-2441.9\n",
+ "-2442.9\n",
+ "-2443.9\n",
+ "-2444.9\n",
+ "-2445.9\n",
+ "-2446.9\n",
+ "-2447.9\n",
+ "-2448.9\n",
+ "-2449.9\n",
+ "-2450.9\n",
+ "-2451.9\n",
+ "-2452.9\n",
+ "-2453.9\n",
+ "-2454.9\n",
+ "-2455.9\n",
+ "-2456.9\n",
+ "-2457.9\n",
+ "-2458.9\n",
+ "-2459.9\n",
+ "-2460.9\n",
+ "-2461.9\n",
+ "-2462.9\n",
+ "-2463.9\n",
+ "-2464.9\n",
+ "-2465.9\n",
+ "-2466.9\n",
+ "-2467.9\n",
+ "-2468.9\n",
+ "-2469.9\n",
+ "-2470.9\n",
+ "-2471.9\n",
+ "-2472.9\n",
+ "-2473.9\n",
+ "-2474.9\n",
+ "-2475.9\n",
+ "-2476.9\n",
+ "-2477.9\n",
+ "-2478.9\n",
+ "-2479.9\n",
+ "-2480.9\n",
+ "-2481.9\n",
+ "-2482.9\n",
+ "-2483.9\n",
+ "-2484.9\n",
+ "-2485.9\n",
+ "-2486.9\n",
+ "-2487.9\n",
+ "-2488.9\n",
+ "-2489.9\n",
+ "-2490.9\n",
+ "-2491.9\n",
+ "-2492.9\n",
+ "-2493.9\n",
+ "-2494.9\n",
+ "-2495.9\n",
+ "-2496.9\n",
+ "-2497.9\n",
+ "-2498.9\n",
+ "-2499.9\n",
+ "-2500.9\n",
+ "-2501.9\n",
+ "-2502.9\n",
+ "-2503.9\n",
+ "-2504.9\n",
+ "-2505.9\n",
+ "-2506.9\n",
+ "-2507.9\n",
+ "-2508.9\n",
+ "-2509.9\n",
+ "-2510.9\n",
+ "-2511.9\n",
+ "-2512.9\n",
+ "-2513.9\n",
+ "-2514.9\n",
+ "-2515.9\n",
+ "-2516.9\n",
+ "-2517.9\n",
+ "-2518.9\n",
+ "-2519.9\n",
+ "-2520.9\n",
+ "-2521.9\n",
+ "-2522.9\n",
+ "-2523.9\n",
+ "-2524.9\n",
+ "-2525.9\n",
+ "-2526.9\n",
+ "-2527.9\n",
+ "-2528.9\n",
+ "-2529.9\n",
+ "-2530.9\n",
+ "-2531.9\n",
+ "-2532.9\n",
+ "-2533.9\n",
+ "-2534.9\n",
+ "-2535.9\n",
+ "-2536.9\n",
+ "-2537.9\n",
+ "-2538.9\n",
+ "-2539.9\n",
+ "-2540.9\n",
+ "-2541.9\n",
+ "-2542.9\n",
+ "-2543.9\n",
+ "-2544.9\n",
+ "-2545.9\n",
+ "-2546.9\n",
+ "-2547.9\n",
+ "-2548.9\n",
+ "-2549.9\n",
+ "-2550.9\n",
+ "-2551.9\n",
+ "-2552.9\n",
+ "-2553.9\n",
+ "-2554.9\n",
+ "-2555.9\n",
+ "-2556.9\n",
+ "-2557.9\n",
+ "-2558.9\n",
+ "-2559.9\n",
+ "-2560.9\n",
+ "-2561.9\n",
+ "-2562.9\n",
+ "-2563.9\n",
+ "-2564.9\n",
+ "-2565.9\n",
+ "-2566.9\n",
+ "-2567.9\n",
+ "-2568.9\n",
+ "-2569.9\n",
+ "-2570.9\n",
+ "-2571.9\n",
+ "-2572.9\n",
+ "-2573.9\n",
+ "-2574.9\n",
+ "-2575.9\n",
+ "-2576.9\n",
+ "-2577.9\n",
+ "-2578.9\n",
+ "-2579.9\n",
+ "-2580.9\n",
+ "-2581.9\n",
+ "-2582.9\n",
+ "-2583.9\n",
+ "-2584.9\n",
+ "-2585.9\n",
+ "-2586.9\n",
+ "-2587.9\n",
+ "-2588.9\n",
+ "-2589.9\n",
+ "-2590.9\n",
+ "-2591.9\n",
+ "-2592.9\n",
+ "-2593.9\n",
+ "-2594.9\n",
+ "-2595.9\n",
+ "-2596.9\n",
+ "-2597.9\n",
+ "-2598.9\n",
+ "-2599.9\n",
+ "-2600.9\n",
+ "-2601.9\n",
+ "-2602.9\n",
+ "-2603.9\n",
+ "-2604.9\n",
+ "-2605.9\n",
+ "-2606.9\n",
+ "-2607.9\n",
+ "-2608.9\n",
+ "-2609.9\n",
+ "-2610.9\n",
+ "-2611.9\n",
+ "-2612.9\n",
+ "-2613.9\n",
+ "-2614.9\n",
+ "-2615.9\n",
+ "-2616.9\n",
+ "-2617.9\n",
+ "-2618.9\n",
+ "-2619.9\n",
+ "-2620.9\n",
+ "-2621.9\n",
+ "-2622.9\n",
+ "-2623.9\n",
+ "-2624.9\n",
+ "-2625.9\n",
+ "-2626.9\n",
+ "-2627.9\n",
+ "-2628.9\n",
+ "-2629.9\n",
+ "-2630.9\n",
+ "-2631.9\n",
+ "-2632.9\n",
+ "-2633.9\n",
+ "-2634.9\n",
+ "-2635.9\n",
+ "-2636.9\n",
+ "-2637.9\n",
+ "-2638.9\n",
+ "-2639.9\n",
+ "-2640.9\n",
+ "-2641.9\n",
+ "-2642.9\n",
+ "-2643.9\n",
+ "-2644.9\n",
+ "-2645.9\n",
+ "-2646.9\n",
+ "-2647.9\n",
+ "-2648.9\n",
+ "-2649.9\n",
+ "-2650.9\n",
+ "-2651.9\n",
+ "-2652.9\n",
+ "-2653.9\n",
+ "-2654.9\n",
+ "-2655.9\n",
+ "-2656.9\n",
+ "-2657.9\n",
+ "-2658.9\n",
+ "-2659.9\n",
+ "-2660.9\n",
+ "-2661.9\n",
+ "-2662.9\n",
+ "-2663.9\n",
+ "-2664.9\n",
+ "-2665.9\n",
+ "-2666.9\n",
+ "-2667.9\n",
+ "-2668.9\n",
+ "-2669.9\n",
+ "-2670.9\n",
+ "-2671.9\n",
+ "-2672.9\n",
+ "-2673.9\n",
+ "-2674.9\n",
+ "-2675.9\n",
+ "-2676.9\n",
+ "-2677.9\n",
+ "-2678.9\n",
+ "-2679.9\n",
+ "-2680.9\n",
+ "-2681.9\n",
+ "-2682.9\n",
+ "-2683.9\n",
+ "-2684.9\n",
+ "-2685.9\n",
+ "-2686.9\n",
+ "-2687.9\n",
+ "-2688.9\n",
+ "-2689.9\n",
+ "-2690.9\n",
+ "-2691.9\n",
+ "-2692.9\n",
+ "-2693.9\n",
+ "-2694.9\n",
+ "-2695.9\n",
+ "-2696.9\n",
+ "-2697.9\n",
+ "-2698.9\n",
+ "-2699.9\n",
+ "-2700.9\n",
+ "-2701.9\n",
+ "-2702.9\n",
+ "-2703.9\n",
+ "-2704.9\n",
+ "-2705.9\n",
+ "-2706.9\n",
+ "-2707.9\n",
+ "-2708.9\n",
+ "-2709.9\n",
+ "-2710.9\n",
+ "-2711.9\n",
+ "-2712.9\n",
+ "-2713.9\n",
+ "-2714.9\n",
+ "-2715.9\n",
+ "-2716.9\n",
+ "-2717.9\n",
+ "-2718.9\n",
+ "-2719.9\n",
+ "-2720.9\n",
+ "-2721.9\n",
+ "-2722.9\n",
+ "-2723.9\n",
+ "-2724.9\n",
+ "-2725.9\n",
+ "-2726.9\n",
+ "-2727.9\n",
+ "-2728.9\n",
+ "-2729.9\n",
+ "-2730.9\n",
+ "-2731.9\n",
+ "-2732.9\n",
+ "-2733.9\n",
+ "-2734.9\n",
+ "-2735.9\n",
+ "-2736.9\n",
+ "-2737.9\n",
+ "-2738.9\n",
+ "-2739.9\n",
+ "-2740.9\n",
+ "-2741.9\n",
+ "-2742.9\n",
+ "-2743.9\n",
+ "-2744.9\n",
+ "-2745.9\n",
+ "-2746.9\n",
+ "-2747.9\n",
+ "-2748.9\n",
+ "-2749.9\n",
+ "-2750.9\n",
+ "-2751.9\n",
+ "-2752.9\n",
+ "-2753.9\n",
+ "-2754.9\n",
+ "-2755.9\n",
+ "-2756.9\n",
+ "-2757.9\n",
+ "-2758.9\n",
+ "-2759.9\n",
+ "-2760.9\n",
+ "-2761.9\n",
+ "-2762.9\n",
+ "-2763.9\n",
+ "-2764.9\n",
+ "-2765.9\n",
+ "-2766.9\n",
+ "-2767.9\n",
+ "-2768.9\n",
+ "-2769.9\n",
+ "-2770.9\n",
+ "-2771.9\n",
+ "-2772.9\n",
+ "-2773.9\n",
+ "-2774.9\n",
+ "-2775.9\n",
+ "-2776.9\n",
+ "-2777.9\n",
+ "-2778.9\n",
+ "-2779.9\n",
+ "-2780.9\n",
+ "-2781.9\n",
+ "-2782.9\n",
+ "-2783.9\n",
+ "-2784.9\n",
+ "-2785.9\n",
+ "-2786.9\n",
+ "-2787.9\n",
+ "-2788.9\n",
+ "-2789.9\n",
+ "-2790.9\n",
+ "-2791.9\n",
+ "-2792.9\n",
+ "-2793.9\n",
+ "-2794.9\n",
+ "-2795.9\n",
+ "-2796.9\n",
+ "-2797.9\n",
+ "-2798.9\n",
+ "-2799.9\n",
+ "-2800.9\n",
+ "-2801.9\n",
+ "-2802.9\n",
+ "-2803.9\n",
+ "-2804.9\n",
+ "-2805.9\n",
+ "-2806.9\n",
+ "-2807.9\n",
+ "-2808.9\n",
+ "-2809.9\n",
+ "-2810.9\n",
+ "-2811.9\n",
+ "-2812.9\n",
+ "-2813.9\n",
+ "-2814.9\n",
+ "-2815.9\n",
+ "-2816.9\n",
+ "-2817.9\n",
+ "-2818.9\n",
+ "-2819.9\n",
+ "-2820.9\n",
+ "-2821.9\n",
+ "-2822.9\n",
+ "-2823.9\n",
+ "-2824.9\n",
+ "-2825.9\n",
+ "-2826.9\n",
+ "-2827.9\n",
+ "-2828.9\n",
+ "-2829.9\n",
+ "-2830.9\n",
+ "-2831.9\n",
+ "-2832.9\n",
+ "-2833.9\n",
+ "-2834.9\n",
+ "-2835.9\n",
+ "-2836.9\n",
+ "-2837.9\n",
+ "-2838.9\n",
+ "-2839.9\n",
+ "-2840.9\n",
+ "-2841.9\n",
+ "-2842.9\n",
+ "-2843.9\n",
+ "-2844.9\n",
+ "-2845.9\n",
+ "-2846.9\n",
+ "-2847.9\n",
+ "-2848.9\n",
+ "-2849.9\n",
+ "-2850.9\n",
+ "-2851.9\n",
+ "-2852.9\n",
+ "-2853.9\n",
+ "-2854.9\n",
+ "-2855.9\n",
+ "-2856.9\n",
+ "-2857.9\n",
+ "-2858.9\n",
+ "-2859.9\n",
+ "-2860.9\n",
+ "-2861.9\n",
+ "-2862.9\n",
+ "-2863.9\n",
+ "-2864.9\n",
+ "-2865.9\n",
+ "-2866.9\n",
+ "-2867.9\n",
+ "-2868.9\n",
+ "-2869.9\n",
+ "-2870.9\n",
+ "-2871.9\n",
+ "-2872.9\n",
+ "-2873.9\n",
+ "-2874.9\n",
+ "-2875.9\n",
+ "-2876.9\n",
+ "-2877.9\n",
+ "-2878.9\n",
+ "-2879.9\n",
+ "-2880.9\n",
+ "-2881.9\n",
+ "-2882.9\n",
+ "-2883.9\n",
+ "-2884.9\n",
+ "-2885.9\n",
+ "-2886.9\n",
+ "-2887.9\n",
+ "-2888.9\n",
+ "-2889.9\n",
+ "-2890.9\n",
+ "-2891.9\n",
+ "-2892.9\n",
+ "-2893.9\n",
+ "-2894.9\n",
+ "-2895.9\n",
+ "-2896.9\n",
+ "-2897.9\n",
+ "-2898.9\n",
+ "-2899.9\n",
+ "-2900.9\n",
+ "-2901.9\n",
+ "-2902.9\n",
+ "-2903.9\n",
+ "-2904.9\n",
+ "-2905.9\n",
+ "-2906.9\n",
+ "-2907.9\n",
+ "-2908.9\n",
+ "-2909.9\n",
+ "-2910.9\n",
+ "-2911.9\n",
+ "-2912.9\n",
+ "-2913.9\n",
+ "-2914.9\n",
+ "-2915.9\n",
+ "-2916.9\n",
+ "-2917.9\n",
+ "-2918.9\n",
+ "-2919.9\n",
+ "-2920.9\n",
+ "-2921.9\n",
+ "-2922.9\n",
+ "-2923.9\n",
+ "-2924.9\n",
+ "-2925.9\n",
+ "-2926.9\n",
+ "-2927.9\n",
+ "-2928.9\n",
+ "-2929.9\n",
+ "-2930.9\n",
+ "-2931.9\n",
+ "-2932.9\n",
+ "-2933.9\n",
+ "-2934.9\n",
+ "-2935.9\n",
+ "-2936.9\n",
+ "-2937.9\n",
+ "-2938.9\n",
+ "-2939.9\n",
+ "-2940.9\n",
+ "-2941.9\n",
+ "-2942.9\n",
+ "-2943.9\n",
+ "-2944.9\n",
+ "-2945.9\n",
+ "-2946.9\n",
+ "-2947.9\n",
+ "-2948.9\n",
+ "-2949.9\n",
+ "-2950.9\n",
+ "-2951.9\n",
+ "-2952.9\n",
+ "-2953.9\n",
+ "-2954.9\n",
+ "-2955.9\n",
+ "-2956.9\n",
+ "-2957.9\n",
+ "-2958.9\n",
+ "-2959.9\n",
+ "-2960.9\n",
+ "-2961.9\n",
+ "-2962.9\n",
+ "-2963.9\n",
+ "-2964.9\n",
+ "-2965.9\n",
+ "-2966.9\n",
+ "-2967.9\n",
+ "-2968.9\n",
+ "-2969.9\n",
+ "-2970.9\n"
+ ]
+ },
+ {
+ "ename": "RecursionError",
+ "evalue": "maximum recursion depth exceeded",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mRecursionError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[29], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mcountdown\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3.1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[1], line 11\u001b[0m, in \u001b[0;36mcountdown\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28mprint\u001b[39m(n)\n\u001b[0;32m---> 11\u001b[0m \u001b[43mcountdown\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[1], line 11\u001b[0m, in \u001b[0;36mcountdown\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28mprint\u001b[39m(n)\n\u001b[0;32m---> 11\u001b[0m \u001b[43mcountdown\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ " \u001b[0;31m[... skipping similar frames: countdown at line 11 (2972 times)]\u001b[0m\n",
+ "Cell \u001b[0;32mIn[1], line 11\u001b[0m, in \u001b[0;36mcountdown\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28mprint\u001b[39m(n)\n\u001b[0;32m---> 11\u001b[0m \u001b[43mcountdown\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[1], line 10\u001b[0m, in \u001b[0;36mcountdown\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHappy New Year!\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 10\u001b[0m \u001b[38;5;28;43mprint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m countdown(n \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m)\n",
+ "File \u001b[0;32m~/Repositories/intro-to-python/.venv/lib/python3.12/site-packages/ipykernel/iostream.py:664\u001b[0m, in \u001b[0;36mOutStream.write\u001b[0;34m(self, string)\u001b[0m\n\u001b[1;32m 655\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrite\u001b[39m(\u001b[38;5;28mself\u001b[39m, string: \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Optional[\u001b[38;5;28mint\u001b[39m]: \u001b[38;5;66;03m# type:ignore[override]\u001b[39;00m\n\u001b[1;32m 656\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Write to current stream after encoding if necessary\u001b[39;00m\n\u001b[1;32m 657\u001b[0m \n\u001b[1;32m 658\u001b[0m \u001b[38;5;124;03m Returns\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 662\u001b[0m \n\u001b[1;32m 663\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 664\u001b[0m parent \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparent_header\u001b[49m\n\u001b[1;32m 666\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(string, \u001b[38;5;28mstr\u001b[39m):\n\u001b[1;32m 667\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwrite() argument must be str, not \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(string)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;66;03m# type:ignore[unreachable]\u001b[39;00m\n",
+ "\u001b[0;31mRecursionError\u001b[0m: maximum recursion depth exceeded"
+ ]
+ }
+ ],
+ "source": [
+ "countdown(3.1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In the same way, a `RecursionError` occurs if we call `factorial()` with `3.1` instead of `3`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "RecursionError",
+ "evalue": "maximum recursion depth exceeded",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mRecursionError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[30], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3.1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[6], line 12\u001b[0m, in \u001b[0;36mfactorial\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m n \u001b[38;5;241m*\u001b[39m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[6], line 12\u001b[0m, in \u001b[0;36mfactorial\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m n \u001b[38;5;241m*\u001b[39m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ " \u001b[0;31m[... skipping similar frames: factorial at line 12 (2974 times)]\u001b[0m\n",
+ "Cell \u001b[0;32mIn[6], line 12\u001b[0m, in \u001b[0;36mfactorial\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m n \u001b[38;5;241m*\u001b[39m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mRecursionError\u001b[0m: maximum recursion depth exceeded"
+ ]
+ }
+ ],
+ "source": [
+ "factorial(3.1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The infinite recursions could easily be avoided by replacing `n == 0` with `n <= 0` in both functions and thereby **generalizing** them. However, even then, calling either `countdown()` or `factorial()` with a non-integer number is still *semantically* wrong.\n",
+ "\n",
+ "Errors as above are a symptom of missing **type checking**: By design, Python allows us to pass in not only integers but objects of any type as arguments to the `countdown()` and `factorial()` functions. As long as the arguments \"behave\" like integers, we do not encounter any *runtime* errors. This is the case here as the two example functions only use the `-` and `*` operators internally, and, in the context of arithmetic, a `float` object behaves like an `int` object. So, the functions keep calling themselves until Python decides with a built-in heuristic that the recursion is likely not going to end and aborts the computations with a `RecursionError`. Strictly speaking, a `RecursionError` is, of course, a *runtime* error as well."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Duck Typing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The missing type checking is *100% intentional* and considered a **[feature of rather than a bug](https://www.urbandictionary.com/define.php?term=It%27s%20not%20a%20bug%2C%20it%27s%20a%20feature)** in Python!\n",
+ "\n",
+ "Pythonistas use the \"technical\" term **[duck typing ](https://en.wikipedia.org/wiki/Duck_typing)** to express the idea of two objects of *different* types behaving in the *same* way in a given context. The colloquial saying goes, \"If it walks like a duck and it quacks like a duck, it must be a duck.\"\n",
+ "\n",
+ "For example, we could call `factorial()` with the `float` object `3.0`, and the recursion works out fine. So, because the `3.0` \"walks\" and \"quacks\" like a `3`, it \"must be\" a `3`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6.0"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3.0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We see similar behavior when we mix objects of types `int` and `float` with arithmetic operators. For example, `1 + 2.0` works because Python implicitly views the `1` as a `1.0` at runtime and then knows how to do floating-point arithmetic: Here, the `int` \"walks\" and \"quacks\" like a `float`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3.0"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 + 2.0"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3.0"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1.0 + 2.0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The important lesson is that we must expect our functions to be called with objects of *any* type at runtime, as opposed to the one type we had in mind when defining the function.\n",
+ "\n",
+ "Duck typing is possible because Python is a dynamically typed language. On the contrary, in statically typed languages like C, we *must* declare (i.e., \"specify\") the data type of every parameter in a function definition. Then, a `RecursionError` as for `countdown(3.1)` or `factorial(3.1)` above could not occur. For example, if we declared the `countdown()` and `factorial()` functions to only accept `int` objects, calling the functions with a `float` argument would immediately fail *syntactically*. As a downside, we would then lose the ability to call `factorial()` with `3.0`, which is *semantically* correct nevertheless.\n",
+ "\n",
+ "So, there is no black or white answer as to which of the two language designs is better. Yet, most professional programmers have strong opinions concerning duck typing, reaching from \"love\" to \"hate.\" This is another example of how programming is a subjective art rather than \"objective\" science. Python's design is probably more appealing to beginners who intuitively regard `3` and `3.0` as interchangeable."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Type Checking & Input Validation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We use the built-in [isinstance() ](https://docs.python.org/3/library/functions.html#isinstance) function to make sure `factorial()` is called with an `int` object as the argument. We further **validate** the **input** by verifying that the integer is non-negative.\n",
+ "\n",
+ "Meanwhile, we also see how we manually raise exceptions with the `raise` statement (cf., [reference ](https://docs.python.org/3/reference/simple_stmts.html#the-raise-statement)), another way of controlling the flow of execution.\n",
+ "\n",
+ "The first two branches in the revised `factorial()` function act as **guardians** ensuring that the code does not produce *unexpected* runtime errors: Errors may be expected when mentioned in the docstring.\n",
+ "\n",
+ "So, in essence, we are doing *two* things here: Besides checking the type, we also enforce **domain-specific** (i.e., mathematical here) rules concerning the non-negativity of `n`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def factorial(n):\n",
+ " \"\"\"Calculate the factorial of a number.\n",
+ "\n",
+ " Args:\n",
+ " n (int): number to calculate the factorial for; must be positive\n",
+ "\n",
+ " Returns:\n",
+ " factorial (int)\n",
+ "\n",
+ " Raises:\n",
+ " TypeError: if n is not an integer\n",
+ " ValueError: if n is negative\n",
+ " \"\"\"\n",
+ " if not isinstance(n, int):\n",
+ " raise TypeError(\"Factorial is only defined for integers\")\n",
+ " elif n < 0:\n",
+ " raise ValueError(\"Factorial is not defined for negative integers\")\n",
+ " elif n == 0:\n",
+ " return 1\n",
+ " return n * factorial(n - 1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The revised `factorial()` function works like the old one."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 37,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Instead of running into a situation of infinite recursion, we now receive specific error messages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "Factorial is only defined for integers",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[38], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3.1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[35], line 15\u001b[0m, in \u001b[0;36mfactorial\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Calculate the factorial of a number.\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \n\u001b[1;32m 4\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;124;03m ValueError: if n is negative\u001b[39;00m\n\u001b[1;32m 13\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(n, \u001b[38;5;28mint\u001b[39m):\n\u001b[0;32m---> 15\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFactorial is only defined for integers\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m n \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 17\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFactorial is not defined for negative integers\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+ "\u001b[0;31mTypeError\u001b[0m: Factorial is only defined for integers"
+ ]
+ }
+ ],
+ "source": [
+ "factorial(3.1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "Factorial is not defined for negative integers",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[39], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m42\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[35], line 17\u001b[0m, in \u001b[0;36mfactorial\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFactorial is only defined for integers\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m n \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m---> 17\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFactorial is not defined for negative integers\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m n \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m1\u001b[39m\n",
+ "\u001b[0;31mValueError\u001b[0m: Factorial is not defined for negative integers"
+ ]
+ }
+ ],
+ "source": [
+ "factorial(-42)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Forcing `n` to be an `int` is a very puritan way of handling the issues discussed above. So, we can *not* call `factorial()` with, for example, `3.0`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "Factorial is only defined for integers",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[40], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3.0\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[35], line 15\u001b[0m, in \u001b[0;36mfactorial\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Calculate the factorial of a number.\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \n\u001b[1;32m 4\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;124;03m ValueError: if n is negative\u001b[39;00m\n\u001b[1;32m 13\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(n, \u001b[38;5;28mint\u001b[39m):\n\u001b[0;32m---> 15\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFactorial is only defined for integers\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m n \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 17\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFactorial is not defined for negative integers\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+ "\u001b[0;31mTypeError\u001b[0m: Factorial is only defined for integers"
+ ]
+ }
+ ],
+ "source": [
+ "factorial(3.0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Type Casting"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A similar way to prevent an infinite recursion is to **cast** the **type** of the `n` argument with the built-in [int() ](https://docs.python.org/3/library/functions.html#int) constructor."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def factorial(n):\n",
+ " \"\"\"Calculate the factorial of a number.\n",
+ "\n",
+ " Args:\n",
+ " n (int): number to calculate the factorial for; must be positive\n",
+ "\n",
+ " Returns:\n",
+ " factorial (int)\n",
+ "\n",
+ " Raises:\n",
+ " TypeError: if n cannot be cast as an integer\n",
+ " ValueError: if n is negative\n",
+ " \"\"\"\n",
+ " n = int(n)\n",
+ " if n < 0:\n",
+ " raise ValueError(\"Factorial is not defined for negative integers\")\n",
+ " elif n == 0:\n",
+ " return 1\n",
+ " return n * factorial(n - 1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The not so strict type casting implements duck typing for `factorial()` as, for example, `3.0` \"walks\" and \"quacks\" like a `3`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 43,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3.0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, if we now call `factorial()` with a non-integer `float` object like `3.1`, *no* error is raised. This is a potential source for *semantic* errors as the function runs for invalid input."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 44,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3.1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We could adjust the type casting logic such that a `TypeError` is raised for `n` arguments with non-zero decimals. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "code_folding": [],
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def factorial(n):\n",
+ " \"\"\"Calculate the factorial of a number.\n",
+ "\n",
+ " Args:\n",
+ " n (int): number to calculate the factorial for; must be positive\n",
+ "\n",
+ " Returns:\n",
+ " factorial (int)\n",
+ "\n",
+ " Raises:\n",
+ " TypeError: if n cannot be cast as an integer\n",
+ " ValueError: if n is negative\n",
+ " \"\"\"\n",
+ " if n != int(n):\n",
+ " raise TypeError(\"n is not integer-like; it has non-zero decimals\")\n",
+ " n = int(n)\n",
+ "\n",
+ " if n < 0:\n",
+ " raise ValueError(\"Factorial is not defined for negative integers\")\n",
+ " elif n == 0:\n",
+ " return 1\n",
+ " return n * factorial(n - 1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 46,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3.0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "n is not integer-like; it has non-zero decimals",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[47], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3.1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[45], line 15\u001b[0m, in \u001b[0;36mfactorial\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Calculate the factorial of a number.\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \n\u001b[1;32m 4\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;124;03m ValueError: if n is negative\u001b[39;00m\n\u001b[1;32m 13\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mint\u001b[39m(n):\n\u001b[0;32m---> 15\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mn is not integer-like; it has non-zero decimals\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 16\u001b[0m n \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(n)\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m:\n",
+ "\u001b[0;31mTypeError\u001b[0m: n is not integer-like; it has non-zero decimals"
+ ]
+ }
+ ],
+ "source": [
+ "factorial(3.1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, using built-in constructors for type casting leads to another subtle inconsistency. As constructors are designed to take *any* object as their argument, they do not raise a `TypeError` when called with invalid input but a `ValueError` instead. So, if we, for example, called `factorial()` with `\"text\"` as the `n` argument, we see the `ValueError` raised by [int() ](https://docs.python.org/3/library/functions.html#int) in a situation where a `TypeError` would be more appropriate."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "invalid literal for int() with base 10: 'text'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[48], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtext\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[45], line 14\u001b[0m, in \u001b[0;36mfactorial\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfactorial\u001b[39m(n):\n\u001b[1;32m 2\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Calculate the factorial of a number.\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \n\u001b[1;32m 4\u001b[0m \u001b[38;5;124;03m Args:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;124;03m ValueError: if n is negative\u001b[39;00m\n\u001b[1;32m 13\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m---> 14\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m)\u001b[49m:\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mn is not integer-like; it has non-zero decimals\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 16\u001b[0m n \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(n)\n",
+ "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'text'"
+ ]
+ }
+ ],
+ "source": [
+ "factorial(\"text\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We could, of course, use a `try` statement to suppress the exceptions raised by [int() ](https://docs.python.org/3/library/functions.html#int) and replace them with a custom `TypeError`. However, now the implementation as a whole is more about type checking than about the actual logic solving the problem. We took this example to the extreme on purpose. In practice, we rarely see such code!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def factorial(n):\n",
+ " \"\"\"Calculate the factorial of a number.\n",
+ "\n",
+ " Args:\n",
+ " n (int): number to calculate the factorial for; must be positive\n",
+ "\n",
+ " Returns:\n",
+ " factorial (int)\n",
+ "\n",
+ " Raises:\n",
+ " TypeError: if n cannot be cast as an integer\n",
+ " ValueError: if n is negative\n",
+ " \"\"\"\n",
+ " try:\n",
+ " casted_n = int(n)\n",
+ " except ValueError:\n",
+ " raise TypeError(\"n cannot be casted as an integer\") from None\n",
+ " else:\n",
+ " if n != casted_n:\n",
+ " raise TypeError(\"n is not integer-like; it has non-zero decimals\")\n",
+ " n = casted_n\n",
+ "\n",
+ " if n < 0:\n",
+ " raise ValueError(\"Factorial is not defined for negative integers\")\n",
+ " elif n == 0:\n",
+ " return 1\n",
+ " return n * factorial(n - 1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "n cannot be casted as an integer",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[50], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtext\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[49], line 17\u001b[0m, in \u001b[0;36mfactorial\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 15\u001b[0m casted_n \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(n)\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m:\n\u001b[0;32m---> 17\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mn cannot be casted as an integer\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m!=\u001b[39m casted_n:\n",
+ "\u001b[0;31mTypeError\u001b[0m: n cannot be casted as an integer"
+ ]
+ }
+ ],
+ "source": [
+ "factorial(\"text\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "n is not integer-like; it has non-zero decimals",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[51], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3.1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[49], line 20\u001b[0m, in \u001b[0;36mfactorial\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m!=\u001b[39m casted_n:\n\u001b[0;32m---> 20\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mn is not integer-like; it has non-zero decimals\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 21\u001b[0m n \u001b[38;5;241m=\u001b[39m casted_n\n\u001b[1;32m 23\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m:\n",
+ "\u001b[0;31mTypeError\u001b[0m: n is not integer-like; it has non-zero decimals"
+ ]
+ }
+ ],
+ "source": [
+ "factorial(3.1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Which way we choose for **hardening** the `factorial()` function depends on the concrete circumstances. If we are the main caller of the function ourselves, we may choose to *not* do any of the approaches at all. After all, we should be able to call our own function in the correct way. The lesson is that just because Python has no static typing, this does *not* mean that we cannot do this \"manually.\" Yet, the idea behind a dynamically typed language is to *not* deal with the types too much at all."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "## Theory of Computation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With everything *officially* introduced so far, Python would be what is called **[Turing complete ](https://en.wikipedia.org/wiki/Turing_completeness)**. That means that anything that could be formulated as an algorithm could be expressed with all the language features we have seen. Note that, in particular, we have *not* yet formally *introduced* the `for` and `while` statements!"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/04_iteration/01_exercises_hanoi-towers.ipynb b/04_iteration/01_exercises_hanoi-towers.ipynb
new file mode 100644
index 0000000..b29212e
--- /dev/null
+++ b/04_iteration/01_exercises_hanoi-towers.ipynb
@@ -0,0 +1,610 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Run All*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *after* finishing the exercises to ensure that your solution runs top to bottom *without* any errors. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/04_iteration/01_exercises.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 4: Recursion & Looping (Coding Exercises)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The exercises below assume that you have read the [first part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/00_content.ipynb) of Chapter 4.\n",
+ "\n",
+ "The `...`'s in the code cells indicate where you need to fill in code snippets. The number of `...`'s within a code cell give you a rough idea of how many lines of code are needed to solve the task. You should not need to create any additional code cells for your final solution. However, you may want to use temporary code cells to try out some ideas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Towers of Hanoi"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "A popular example of a problem that is solved by recursion art the **[Towers of Hanoi ](https://en.wikipedia.org/wiki/Tower_of_Hanoi)**.\n",
+ "\n",
+ "In its basic version, a tower consisting of, for example, four disks with increasing radii, is placed on the left-most of **three** adjacent spots. In the following, we refer to the number of disks as $n$, so here $n = 4$.\n",
+ "\n",
+ "The task is to move the entire tower to the right-most spot whereby **two rules** must be obeyed:\n",
+ "\n",
+ "1. Disks can only be moved individually, and\n",
+ "2. a disk with a larger radius must *never* be placed on a disk with a smaller one.\n",
+ "\n",
+ "Although the **[Towers of Hanoi ](https://en.wikipedia.org/wiki/Tower_of_Hanoi)** are a **classic** example, introduced by the mathematician [Édouard Lucas ](https://en.wikipedia.org/wiki/%C3%89douard_Lucas) already in 1883, it is still **actively** researched as this scholarly [article](https://www.worldscientific.com/doi/abs/10.1142/S1793830919300017?journalCode=dmaa&) published in January 2019 shows.\n",
+ "\n",
+ "Despite being so easy to formulate, the game is quite hard to solve.\n",
+ "\n",
+ "Below is an interactive illustration of the solution with the minimal number of moves for $n = 4$."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "![](\"static/towers_of_hanoi.gif\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Watch the following video by [MIT](https://www.mit.edu/)'s professor [Richard Larson](https://idss.mit.edu/staff/richard-larson/) for a comprehensive introduction.\n",
+ "\n",
+ "The [MIT Blossoms Initiative](https://blossoms.mit.edu/) is primarily aimed at high school students and does not have any prerequisites.\n",
+ "\n",
+ "The video consists of three segments, the last of which is *not* necessary to have watched to solve the tasks below. So, watch the video until 37:55."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from IPython.display import YouTubeVideo\n",
+ "YouTubeVideo(\"UuIneNBbscc\", width=\"60%\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Video Review Questions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: Explain for the $n = 3$ case why it can be solved as a **recursion**!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: How does the number of minimal moves needed to solve a problem with three spots and $n$ disks grow as a function of $n$? How does this relate to the answer to **Q1**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: The **[Towers of Hanoi ](https://en.wikipedia.org/wiki/Tower_of_Hanoi)** problem is of **exponential growth**. What does that mean? What does that imply for large $n$?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: The video introduces the recursive relationship $Sol(4, 1, 3) = Sol(3, 1, 2) ~ \\bigoplus ~ Sol(1, 1, 3) ~ \\bigoplus ~ Sol(3, 2, 3)$. The $\\bigoplus$ is to be interpreted as some sort of \"plus\" operation. How does this \"plus\" operation work? How does this way of expressing the problem relate to the answer to **Q1**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Naive Translation to Python"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "As most likely the first couple of tries will result in *semantic* errors, it is advisable to have some sort of **visualization tool** for the program's output: For example, an online version of the game can be found [here](https://www.mathsisfun.com/games/towerofhanoi.html)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's first **generalize** the mathematical relationship from above and then introduce the variable names used in our `sol()` implementation below.\n",
+ "\n",
+ "Unsurprisingly, the recursive relationship in the video may be generalized into:\n",
+ "\n",
+ "$Sol(n, o, d) = Sol(n-1, o, i) ~ \\bigoplus ~ Sol(1, o, d) ~ \\bigoplus ~ Sol(n-1, i, d)$\n",
+ "\n",
+ "$Sol(\\cdot)$ takes three \"arguments\" $n$, $o$, and $d$ and is defined with *three* references to itself that take modified versions of $n$, $o$, and $d$ in different orders. The middle reference, Sol(1, o, d), constitutes the \"end\" of the recursive definition: It is the problem of solving Towers of Hanoi for a \"tower\" of only one disk.\n",
+ "\n",
+ "While the first \"argument\" of $Sol(\\cdot)$ is a number that we refer to as `n_disks` below, the second and third \"arguments\" are merely **labels** for the spots, and we refer to the **roles** they take in a given problem as `origin` and `destination` below. Instead of labeling individual spots with the numbers `1`, `2`, and `3` as in the video, we may also call them `\"left\"`, `\"center\"`, and `\"right\"`. Both ways are equally correct! So, only the first \"argument\" of $Sol(\\cdot)$ is really a number!\n",
+ "\n",
+ "As an example, the notation $Sol(4, 1, 3)$ from above can then be \"translated\" into Python as either the function call `sol(4, 1, 3)` or `sol(4, \"left\", \"right\")`. This describes the problem of moving a tower consisting of `n_disks=4` disks from either the `origin=1` spot to the `destination=3` spot or from the `origin=\"left\"` spot to the `destination=\"right\"` spot.\n",
+ "\n",
+ "To adhere to the rules, an `intermediate` spot $i$ is needed. In `sol()` below, this is a temporary variable within a function call and *not* a parameter of the function itself."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In summary, to move a tower consisting of `n_disks` (= $n$) disks from an `origin` (= $o$) to a `destination` (= $d$), three steps must be executed:\n",
+ "\n",
+ "1. Move the tower's topmost `n_disks - 1` (= $n - 1$) disks from the `origin` (= $o$) to an `intermediate` (= $i$) spot (= **Sub-Problem 1**),\n",
+ "2. move the remaining and largest disk from the `origin` (= $o$) to the `destination` (= $d$), and\n",
+ "3. move the `n_disks - 1` (= $n - 1$) disks from the `intermediate` (= $i$) spot to the `destination` (= $d$) spot (= **Sub-Problem 2**).\n",
+ "\n",
+ "The two sub-problems themselves are solved via the same *recursive* logic."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Write your answers to **Q5** to **Q7** into the skeleton of `sol()` below.\n",
+ "\n",
+ "`sol()` takes three arguments `n_disks`, `origin`, and `destination` that mirror $n$, $o$, and $d$ above.\n",
+ "\n",
+ "For now, assume that all arguments to `sol()` are `int` objects! We generalize this into real labels further below in the `hanoi()` function.\n",
+ "\n",
+ "Once completed, `sol()` should *print* out all the moves in the correct order. For example, *print* `\"1 -> 3\"` to mean \"Move the top-most `n_disks - 1` disks from spot `1` to spot `3`.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def sol(n_disks, origin, destination):\n",
+ " \"\"\"A naive implementation of Towers of Hanoi.\n",
+ "\n",
+ " This function prints out the moves to solve a Towers of Hanoi problem.\n",
+ "\n",
+ " Args:\n",
+ " n_disks (int): number of disks in the tower\n",
+ " origin (int): spot of the tower at the start; 1, 2, or 3\n",
+ " destination (int): spot of the tower at the end; 1, 2, or 3\n",
+ " \"\"\"\n",
+ " # answer to Q5\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " # answer to Q6\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " # answer to Q7\n",
+ " ...\n",
+ " ...\n",
+ " ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: What is the `n_disks` argument when the function reaches its **base case**? Check for the base case with a simple `if` statement and return from the function using the **early exit** pattern!\n",
+ "\n",
+ "Hint: The base case in the Python implementation may be slightly different than the one shown in the generalized mathematical relationship above!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: If not in the base case, `sol()` determines the `intermediate` spot given concrete `origin` and `destination` arguments. For example, if called with `origin=1` and `destination=2`, `intermediate` must be `3`.\n",
+ "\n",
+ "Add *one* compound `if` statement to `sol()` that has a branch for *every* possible `origin`-`destination`-pair that assigns the correct temporary spot to a variable `intermediate`.\n",
+ "\n",
+ "Hint: How many 2-tuples of 3 elements can there be if the order matters?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7**: `sol()` calls itself *two* more times with the correct 2-tuples chosen from the three available spots `origin`, `intermediate`, and `destination`.\n",
+ "\n",
+ "*In between* the two recursive function calls, use [print() ](https://docs.python.org/3/library/functions.html#print) to print out from where to where the \"remaining and largest\" disk has to be moved!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q8**: Execute the code cells below and confirm that the moves are correct!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sol(1, 1, 3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sol(2, 1, 3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sol(3, 1, 3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sol(4, 1, 3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Pythonic Refactoring"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The previous `sol()` implementation does the job, but the conditional statement is unnecessarily tedious. \n",
+ "\n",
+ "Let's create a concise `hanoi()` function that, in addition to a positional `n_disks` argument, takes three keyword-only arguments `origin`, `intermediate`, and `destination` with default values `\"left\"`, `\"center\"`, and `\"right\"`.\n",
+ "\n",
+ "Write your answers to **Q9** and **Q10** into the subsequent code cell and finalize `hanoi()`!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def hanoi(n_disks, *, origin=\"left\", intermediate=\"center\", destination=\"right\"):\n",
+ " \"\"\"A Pythonic implementation of Towers of Hanoi.\n",
+ "\n",
+ " This function prints out the moves to solve a Towers of Hanoi problem.\n",
+ "\n",
+ " Args:\n",
+ " n_disks (int): number of disks in the tower\n",
+ " origin (str, optional): label for the spot of the tower at the start\n",
+ " intermediate (str, optional): label for the intermediate spot\n",
+ " destination (str, optional): label for the spot of the tower at the end\n",
+ " \"\"\"\n",
+ " # answer to Q9\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " # answer to Q10\n",
+ " ...\n",
+ " ...\n",
+ " ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q9**: Copy the base case from `sol()`!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q10**: Instead of conditional logic, `hanoi()` calls itself *two* times with the *three* arguments `origin`, `intermediate`, and `destination` passed on in a *different* order.\n",
+ "\n",
+ "Figure out how the arguments are passed on in the two recursive `hanoi()` calls and finish `hanoi()`.\n",
+ "\n",
+ "Hint: Do not forget to use [print() ](https://docs.python.org/3/library/functions.html#print) to print out the moves!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q11**: Execute the code cells below and confirm that the moves are correct!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hanoi(1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hanoi(2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hanoi(3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hanoi(4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We could, of course, also use *numeric* labels for the three steps like so."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hanoi(3, origin=1, intermediate=2, destination=3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Passing a Value \"down\" the Recursion Tree"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The above `hanoi()` prints the optimal solution's moves in the correct order but fails to label each move with an order number. This is built in the `hanoi_ordered()` function below by passing on a \"private\" `_offset` argument \"down\" the recursion tree. The leading underscore `_` in the parameter name indicates that it is *not* to be used by the caller of the function. That is also why the parameter is *not* mentioned in the docstring.\n",
+ "\n",
+ "Write your answers to **Q12** and **Q13** into the subsequent code cell and finalize `hanoi_ordered()`! As the logic gets a bit \"involved,\" `hanoi_ordered()` below is almost finished."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def hanoi_ordered(n_disks, *, origin=\"left\", intermediate=\"center\", destination=\"right\", _offset=None):\n",
+ " \"\"\"A Pythonic implementation of Towers of Hanoi.\n",
+ "\n",
+ " This function prints out the moves to solve a Towers of Hanoi problem.\n",
+ " Each move is labeled with an order number.\n",
+ "\n",
+ " Args:\n",
+ " n_disks (int): number of disks in the tower\n",
+ " origin (str, optional): label for the spot of the tower at the start\n",
+ " intermediate (str, optional): label for the intermediate spot\n",
+ " destination (str, optional): label for the spot of the tower at the end\n",
+ " \"\"\"\n",
+ " # answer to Q12\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " total = (2 ** n_disks - 1)\n",
+ " half = (2 ** (n_disks - 1) - 1)\n",
+ " count = total - half\n",
+ "\n",
+ " if _offset is not None:\n",
+ " count += _offset\n",
+ "\n",
+ " # answer to Q18\n",
+ " hanoi_ordered(..., _offset=_offset)\n",
+ " ...\n",
+ " hanoi_ordered(..., _offset=count)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q12**: Copy the base case from the original `hanoi()`!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q13**: Complete the two recursive function calls with the same arguments as in `hanoi()`! Do *not* change the already filled in `offset` arguments!\n",
+ "\n",
+ "Then, adjust the use of [print() ](https://docs.python.org/3/library/functions.html#print) from above to print out the moves with their order number!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q14**: Execute the code cells below and confirm that the order numbers are correct!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hanoi_ordered(1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hanoi_ordered(2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hanoi_ordered(3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hanoi_ordered(4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Lastly, it is to be mentioned that for problem instances with a small `n_disks` argument, it is easier to collect all the moves first in a `list` object and then add the order number with the [enumerate() ](https://docs.python.org/3/library/functions.html#enumerate) built-in."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Open Question"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q15**: Conducting your own research on the internet, what can you say about generalizing the **[Towers of Hanoi ](https://en.wikipedia.org/wiki/Tower_of_Hanoi)** problem to a setting with *more than three* landing spots?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/04_iteration/02_content.ipynb b/04_iteration/02_content.ipynb
new file mode 100644
index 0000000..1d41ed7
--- /dev/null
+++ b/04_iteration/02_content.ipynb
@@ -0,0 +1,1300 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/04_iteration/02_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 4: Recursion & Looping (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "After learning about the concept of **recursion** in the [first part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/00_content.ipynb) of this chapter, we look at other ways of running code repeatedly, namely **looping** with the `for` and `while` statements. We start with the latter as it is more generic. Throughout this second part of the chapter, we revisit the same examples from the first part to show how recursion and looping are really two sides of the same coin."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `while` Statement"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Whereas functions combined with `if` statements suffice to model any repetitive logic, Python comes with a compound `while` statement (cf., [reference ](https://docs.python.org/3/reference/compound_stmts.html#the-while-statement)) that often makes it easier to implement iterative ideas.\n",
+ "\n",
+ "It consists of a header line with a boolean expression followed by an indented code block. Before the first and after every execution of the code block, the boolean expression is evaluated, and if it is (still) equal to `True`, the code block runs (again). Eventually, some variable referenced in the boolean expression is changed in the code block such that the condition becomes `False`.\n",
+ "\n",
+ "If the condition is `False` before the first iteration, the entire code block is *never* executed. As the flow of control keeps \"looping\" (i.e., more formally, **iterating**) back to the beginning of the code block, this concept is also called a `while`-loop and each pass through the loop an **iteration**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Trivial Example: Countdown (revisited)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Let's rewrite the `countdown()` example in an iterative style. We also build in **input validation** by allowing the function only to be called with strictly positive integers. As any positive integer hits $0$ at some point when iteratively decremented by $1$, `countdown()` is guaranteed to **terminate**. Also, the base case is now handled at the end of the function, which commonly happens with iterative solutions to problems."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "code_folding": [],
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def countdown(n):\n",
+ " \"\"\"Print a countdown until the party starts.\n",
+ "\n",
+ " Args:\n",
+ " n (int): seconds until the party begins; must be positive\n",
+ " \"\"\"\n",
+ " while n != 0:\n",
+ " print(n)\n",
+ " n -= 1\n",
+ "\n",
+ " print(\"Happy new Year!\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3\n",
+ "2\n",
+ "1\n",
+ "Happy new Year!\n"
+ ]
+ }
+ ],
+ "source": [
+ "countdown(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As [PythonTutor ](http://pythontutor.com/visualize.html#code=def%20countdown%28n%29%3A%0A%20%20%20%20while%20n%20!%3D%200%3A%0A%20%20%20%20%20%20%20%20print%28n%29%0A%20%20%20%20%20%20%20%20n%20-%3D%201%0A%0A%20%20%20%20print%28%22Happy%20new%20Year!%22%29%0A%0Acountdown%283%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) shows, there is a subtle but essential difference in the way a `while` statement is treated in memory: In short, `while` statements can *not* run into a `RecursionError` as only *one* frame is needed to manage the names. After all, there is only *one* function call to be made. For typical day-to-day applications, this difference is, however, not so important *unless* a problem instance becomes so big that a large (i.e., $> 3.000$) number of recursive calls must be made."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### \"Still involved\" Example: [Euclid's Algorithm ](https://en.wikipedia.org/wiki/Euclidean_algorithm) (revisited)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Finding the greatest common divisor of two numbers is still not so obvious when using a `while`-loop instead of a recursive formulation.\n",
+ "\n",
+ "The iterative implementation of `gcd()` below accepts any two strictly positive integers. As in any iteration through the loop, the smaller number is subtracted from the larger one, the two decremented values of `a` and `b` eventually become equal. Thus, this algorithm is also guaranteed to terminate. If one of the two numbers were negative or $0$ in the first place, `gcd()` would run forever, and not even Python could detect this. Try this out by removing the input validation and running the function with negative arguments!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "code_folding": [],
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def gcd(a, b):\n",
+ " \"\"\"Calculate the greatest common divisor of two numbers.\n",
+ "\n",
+ " Args:\n",
+ " a (int): first number; must be positive\n",
+ " b (int): second number; must be positive\n",
+ "\n",
+ " Returns:\n",
+ " gcd (int)\n",
+ " \"\"\"\n",
+ " while a != b:\n",
+ " if a > b:\n",
+ " a -= b\n",
+ " else:\n",
+ " b -= a\n",
+ "\n",
+ " return a"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "gcd(12, 4)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "gcd(7, 7919)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "#### Efficiency of Algorithms (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We also see that this implementation is a lot *less* efficient than its recursive counterpart which solves `gcd()` for the same two numbers `112233445566778899` and `987654321` within microseconds."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "5.32 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%timeit -n 1 -r 1\n",
+ "gcd(112233445566778899, 987654321)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Infinite Loops"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As with recursion, we must ensure that the iteration ends. For the above `countdown()` and `gcd()` examples, we could \"prove\" (i.e., at least argue in favor) that some pre-defined **termination criterion** is reached eventually. However, this cannot be done in all cases, as the following example shows."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### \"Mystery\" Example: [Collatz Conjecture ](https://en.wikipedia.org/wiki/Collatz_conjecture)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "Let's play the following game:\n",
+ "- Think of any positive integer $n$.\n",
+ "- If $n$ is even, the next $n$ is half the old $n$.\n",
+ "- If $n$ is odd, multiply the old $n$ by $3$ and add $1$ to obtain the next $n$.\n",
+ "- Repeat these steps until you reach $1$.\n",
+ "\n",
+ "**Do we always reach the final $1$?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The function below implements this game. Does it always reach $1$? No one has proven it so far! We include some input validation as before because `collatz()` would for sure not terminate if we called it with a negative number. Further, the Collatz sequence also works for real numbers, but then we would have to study fractals (cf., [this ](https://en.wikipedia.org/wiki/Collatz_conjecture#Iterating_on_real_or_complex_numbers)). So we restrict our example to integers only."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "code_folding": [],
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def collatz(n):\n",
+ " \"\"\"Print a Collatz sequence in descending order.\n",
+ "\n",
+ " Given a positive integer n, modify it according to these rules:\n",
+ " - if n is even, the next n is half the previous one\n",
+ " - if n is odd, the next n is 3 times the previous one plus 1\n",
+ " - if n is 1, stop the iteration\n",
+ "\n",
+ " Args:\n",
+ " n (int): a positive number to start the Collatz sequence at\n",
+ " \"\"\"\n",
+ " while n != 1:\n",
+ " print(n, end=\" \")\n",
+ " if n % 2 == 0:\n",
+ " n //= 2 # //= to preserve the int type\n",
+ " else:\n",
+ " n = 3 * n + 1\n",
+ "\n",
+ " print(1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Collatz sequences do not necessarily become longer with a larger initial `n`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "100 50 25 76 38 19 58 29 88 44 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1\n"
+ ]
+ }
+ ],
+ "source": [
+ "collatz(100)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1000 500 250 125 376 188 94 47 142 71 214 107 322 161 484 242 121 364 182 91 274 137 412 206 103 310 155 466 233 700 350 175 526 263 790 395 1186 593 1780 890 445 1336 668 334 167 502 251 754 377 1132 566 283 850 425 1276 638 319 958 479 1438 719 2158 1079 3238 1619 4858 2429 7288 3644 1822 911 2734 1367 4102 2051 6154 3077 9232 4616 2308 1154 577 1732 866 433 1300 650 325 976 488 244 122 61 184 92 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1\n"
+ ]
+ }
+ ],
+ "source": [
+ "collatz(1000)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "10000 5000 2500 1250 625 1876 938 469 1408 704 352 176 88 44 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1\n"
+ ]
+ }
+ ],
+ "source": [
+ "collatz(10000)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "100000 50000 25000 12500 6250 3125 9376 4688 2344 1172 586 293 880 440 220 110 55 166 83 250 125 376 188 94 47 142 71 214 107 322 161 484 242 121 364 182 91 274 137 412 206 103 310 155 466 233 700 350 175 526 263 790 395 1186 593 1780 890 445 1336 668 334 167 502 251 754 377 1132 566 283 850 425 1276 638 319 958 479 1438 719 2158 1079 3238 1619 4858 2429 7288 3644 1822 911 2734 1367 4102 2051 6154 3077 9232 4616 2308 1154 577 1732 866 433 1300 650 325 976 488 244 122 61 184 92 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1\n"
+ ]
+ }
+ ],
+ "source": [
+ "collatz(100000)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `for` Statement"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Recursion and the `while` statement are two sides of the same coin. Disregarding that in the case of recursion Python internally faces some additional burden for managing the stack of frames in memory, both approaches lead to the *same* computational steps in memory. More importantly, we can formulate any recursive implementation in an iterative way and vice versa despite one of the two ways often \"feeling\" a lot more natural given a particular problem.\n",
+ "\n",
+ "So how does the compound `for` statement (cf., [reference ](https://docs.python.org/3/reference/compound_stmts.html#the-for-statement)) in this book's very first example fit into this picture? It is a *redundant* language construct to provide a *shorter* and more *convenient* syntax for common applications of the `while` statement. In programming, such additions to a language are called **syntactic sugar**. A cup of tea tastes better with sugar, but we may drink tea without sugar too.\n",
+ "\n",
+ "Consider `elements` below. Without the `for` statement, we must manage a temporary **index variable**, `index`, to loop over all the elements and also obtain the individual elements with the `[]` operator in each iteration of the loop."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "elements = [0, 1, 2, 3, 4]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0 1 2 3 4 "
+ ]
+ }
+ ],
+ "source": [
+ "index = 0\n",
+ "\n",
+ "while index < len(elements):\n",
+ " element = elements[index]\n",
+ " print(element, end=\" \")\n",
+ " index += 1\n",
+ "\n",
+ "del index"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `for` statement, on the contrary, makes the actual business logic more apparent by stripping all the **[boilerplate code ](https://en.wikipedia.org/wiki/Boilerplate_code)** away. The variable that is automatically set by Python in each iteration of the loop (i.e., `element` in the example) is called the **target variable**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0 1 2 3 4 "
+ ]
+ }
+ ],
+ "source": [
+ "for element in elements:\n",
+ " print(element, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For sequences of integers, the [range() ](https://docs.python.org/3/library/functions.html#func-range) built-in makes the `for` statement even more convenient: It creates a `list`-like object of type `range` that generates integers \"on the fly,\" and we look closely at the underlying effects in memory in [Chapter 8 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/08_mfr/00_content.ipynb#Mapping)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0 1 2 3 4 "
+ ]
+ }
+ ],
+ "source": [
+ "for element in range(5):\n",
+ " print(element, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "range"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(range(5))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[range() ](https://docs.python.org/3/library/functions.html#func-range) takes optional `start` and `step` arguments that we use to customize the sequence of integers even more."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1 3 5 7 9 "
+ ]
+ }
+ ],
+ "source": [
+ "for element in [1, 3, 5, 7, 9]:\n",
+ " print(element, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1 3 5 7 9 "
+ ]
+ }
+ ],
+ "source": [
+ "for element in range(1, 10, 2):\n",
+ " print(element, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Containers vs. Iterables"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The essential difference between the above `list` objects, `[0, 1, 2, 3, 4]` and `[1, 3, 5, 7, 9]`, and the `range` objects, `range(5)` and `range(1, 10, 2)`, is that in the former case *six* objects are created in memory *before* the `for` statement starts running, *one* `list` holding references to *five* `int` objects, whereas in the latter case only *one* `range` object is created that **generates** `int` objects one at a time *while* the `for`-loop runs.\n",
+ "\n",
+ "However, we can loop over both of them. So a natural question to ask is why Python treats objects of *different* types in the *same* way when used with a `for` statement.\n",
+ "\n",
+ "So far, the overarching storyline in this book goes like this: In Python, *everything* is an object. Besides its *identity* and *value*, every object is characterized by \"belonging\" to *one* data type that determines how the object behaves and what we may do with it.\n",
+ "\n",
+ "Now, just as we classify objects by data type, we also classify these data types (e.g., `int`, `float`, `str`, or `list`) into **abstract concepts**.\n",
+ "\n",
+ "We did this already in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/03_content.ipynb#Who-am-I?-And-how-many?) when we described a `list` object as \"some sort of container that holds [...] references to other objects\". So, abstractly speaking, **containers** are any objects that are \"composed\" of other objects and also \"manage\" how these objects are organized. `list` objects, for example, have the property that they model an order associated with their elements. There exist, however, other container types, many of which do *not* come with an order. So, containers primarily \"contain\" other objects and have *nothing* to do with looping.\n",
+ "\n",
+ "On the contrary, the abstract concept of **iterables** is all about looping: Any object that we can loop over is, by definition, an iterable. So, `range` objects, for example, are iterables, even though they hold no references to other objects. Moreover, looping does *not* have to occur in a *predictable* order, although this is the case for both `list` and `range` objects.\n",
+ "\n",
+ "Typically, containers are iterables, and iterables are containers. Yet, only because these two concepts coincide often, we must not think of them as the same. In [Chapter 7 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/00_content.ipynb#Collections-vs.-Sequences), we formalize these two concepts and introduce many more. Finally, [Chapter 11 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/00_content.ipynb) gives an explanation how abstract concepts are implemented and play together.\n",
+ "\n",
+ "Let's continue with `first_names` below as an example an illustrate what iterable containers are."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "first_names = [\"Achim\", \"Berthold\", \"Carl\", \"Diedrich\", \"Eckardt\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The characteristic operator associated with container types is the `in` operator: It checks if a given object evaluates equal to at least one of the objects in the container. Colloquially, it checks if an object is \"contained\" in the container. Formally, this operation is called **membership testing**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Achim\" in first_names"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Alexander\" in first_names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The cell below shows the *exact* workings of the `in` operator: Although `3.0` is *not* contained in `elements`, it evaluates equal to the `3` that is, which is why the following expression evaluates to `True`. So, while we could colloquially say that `elements` \"contains\" `3.0`, it actually does not."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[0, 1, 2, 3, 4]"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "elements"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "3.0 in elements"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Similarly, the characteristic operation of an iterable type is that it supports being looped over, for example, with the `for` statement."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Achim Berthold Carl Diedrich Eckardt "
+ ]
+ }
+ ],
+ "source": [
+ "for name in first_names:\n",
+ " print(name, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If we must have an index variable in the loop's body, we use the [enumerate() ](https://docs.python.org/3/library/functions.html#enumerate) built-in that takes an *iterable* as its argument and then generates a \"stream\" of \"pairs\" of an index variable, `i` below, and an object provided by the iterable, `name`, separated by a `,`. There is *no* need to ever revert to the `while` statement with an explicitly managed index variable to loop over an iterable object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1 > Achim 2 > Berthold 3 > Carl 4 > Diedrich 5 > Eckardt "
+ ]
+ }
+ ],
+ "source": [
+ "for i, name in enumerate(first_names, start=1):\n",
+ " print(i, \">\", name, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[enumerate() ](https://docs.python.org/3/library/functions.html#enumerate) takes an optional `start` argument."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1 > Achim 2 > Berthold 3 > Carl 4 > Diedrich 5 > Eckardt "
+ ]
+ }
+ ],
+ "source": [
+ "for i, name in enumerate(first_names, start=1):\n",
+ " print(i, \">\", name, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [zip() ](https://docs.python.org/3/library/functions.html#zip) built-in allows us to combine the elements of two or more iterables in a *pairwise* fashion: It conceptually works like a zipper for a jacket."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "last_names = [\"Müller\", \"Meyer\", \"Mayer\", \"Schmitt\", \"Schmidt\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Achim Müller Berthold Meyer Carl Mayer Diedrich Schmitt Eckardt Schmidt "
+ ]
+ }
+ ],
+ "source": [
+ "for first_name, last_name in zip(first_names, last_names):\n",
+ " print(first_name, last_name, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### \"Hard at first Glance\" Example: [Fibonacci Numbers ](https://en.wikipedia.org/wiki/Fibonacci_number) (revisited)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In contrast to its recursive counterpart, the iterative `fibonacci()` function below is somewhat harder to read. For example, it is not so obvious as to how many iterations through the `for`-loop we need to make when implementing it. There is an increased risk of making an *off-by-one* error. Moreover, we need to track a `temp` variable along.\n",
+ "\n",
+ "However, one advantage of calculating Fibonacci numbers in a **forward** fashion with a `for` statement is that we could list the entire sequence in ascending order as we calculate the desired number. To show this, we added `print()` statements in `fibonacci()` below.\n",
+ "\n",
+ "We do *not* need to store the index variable in the `for`-loop's header line: That is what the underscore variable `_` indicates; we \"throw it away.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "code_folding": [],
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def fibonacci(i):\n",
+ " \"\"\"Calculate the ith Fibonacci number.\n",
+ "\n",
+ " Args:\n",
+ " i (int): index of the Fibonacci number to calculate\n",
+ "\n",
+ " Returns:\n",
+ " ith_fibonacci (int)\n",
+ " \"\"\"\n",
+ " a = 0\n",
+ " b = 1\n",
+ " print(a, b, sep=\" \", end=\" \") # added for didactical purposes\n",
+ " for _ in range(i - 1):\n",
+ " temp = a + b\n",
+ " a = b\n",
+ " b = temp\n",
+ " print(b, end=\" \") # added for didactical purposes\n",
+ "\n",
+ " return b"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0 1 1 2 3 5 8 13 21 34 55 89 144 "
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "144"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "fibonacci(12) # = 13th number"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "##### Efficiency of Algorithms (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Another more important advantage is that now we may calculate even big Fibonacci numbers *efficiently*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170 1836311903 2971215073 4807526976 7778742049 12586269025 20365011074 32951280099 53316291173 86267571272 139583862445 225851433717 365435296162 591286729879 956722026041 1548008755920 2504730781961 4052739537881 6557470319842 10610209857723 17167680177565 27777890035288 44945570212853 72723460248141 117669030460994 190392490709135 308061521170129 498454011879264 806515533049393 1304969544928657 2111485077978050 3416454622906707 5527939700884757 8944394323791464 14472334024676221 23416728348467685 37889062373143906 61305790721611591 99194853094755497 160500643816367088 259695496911122585 420196140727489673 679891637638612258 1100087778366101931 1779979416004714189 2880067194370816120 4660046610375530309 7540113804746346429 12200160415121876738 19740274219868223167 31940434634990099905 51680708854858323072 83621143489848422977 135301852344706746049 218922995834555169026 "
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "218922995834555169026"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "fibonacci(99) # = 100th number"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Easy Example: [Factorial ](https://en.wikipedia.org/wiki/Factorial) (revisited)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The iterative `factorial()` implementation is comparable to its recursive counterpart when it comes to readability. One advantage of calculating the factorial in a forward fashion is that we could track the intermediate `product` as it grows."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def factorial(n):\n",
+ " \"\"\"Calculate the factorial of a number.\n",
+ "\n",
+ " Args:\n",
+ " n (int): number to calculate the factorial for, must be positive\n",
+ "\n",
+ " Returns:\n",
+ " factorial (int)\n",
+ " \"\"\"\n",
+ " product = 1 # because 0! = 1\n",
+ " for i in range(1, n + 1):\n",
+ " product *= i\n",
+ " print(product, end=\" \") # added for didactical purposes\n",
+ "\n",
+ " return product"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1 2 6 "
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1 2 6 24 120 720 5040 40320 362880 3628800 "
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "3628800"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(10)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/04_iteration/03_content.ipynb b/04_iteration/03_content.ipynb
new file mode 100644
index 0000000..0eb9d25
--- /dev/null
+++ b/04_iteration/03_content.ipynb
@@ -0,0 +1,991 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/04_iteration/03_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 4: Recursion & Looping (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While what we learned about the `for` and `while` statements in the [second part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/02_content.ipynb) of this chapter suffices to translate any iterative algorithm into code, both come with some syntactic sugar to make life easier for the developer. This last part of the chapter shows how we can further customize the looping logic and introduces as \"trick\" for situations where we cannot come up with a stopping criterion in a `while`-loop."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Stopping Loops prematurely"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This section introduces additional syntax to customize `for` and `while` statements in our code even further. They are mostly syntactic sugar in that they do not change how a program runs but make its code more readable. We illustrate them for the `for` statement only. However, everything presented in this section also works for the `while` statement."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Example: Is the square of a number in `[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]` greater than `100`?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Let's say we have a list of `numbers` and want to check if the square of at least one of its elements is greater than `100`. So, conceptually, we are asking the question if a list of numbers as a whole satisfies a certain condition."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "numbers = [7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A first naive implementation could look like this: We loop over *every* element in `numbers` and set an **indicator variable** `is_above`, initialized as `False`, to `True` once we encounter an element satisfying the condition.\n",
+ "\n",
+ "This implementation is *inefficient* as even if the *first* element in `numbers` has a square greater than `100`, we loop until the last element: This could take a long time for a big list.\n",
+ "\n",
+ "Moreover, we must initialize `is_above` *before* the `for`-loop and write an `if`-`else`-logic *after* it to check for the result. The actual business logic is *not* conveyed in a clear way."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "7 11 8 5 3 12 2 6 9 10 1 4 => at least one number satisfies the condition\n"
+ ]
+ }
+ ],
+ "source": [
+ "is_above = False\n",
+ "\n",
+ "for number in numbers:\n",
+ " print(number, end=\" \") # added for didactical purposes\n",
+ " if number ** 2 > 100:\n",
+ " is_above = True\n",
+ "\n",
+ "if is_above:\n",
+ " print(\"=> at least one number satisfies the condition\")\n",
+ "else:\n",
+ " print(\"=> no number satisfies the condition\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### The `break` Statement"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Python provides the `break` statement (cf., [reference ](https://docs.python.org/3/reference/simple_stmts.html#the-break-statement)) that lets us stop a loop prematurely at any iteration. It is yet another means of controlling the flow of execution, and we say that we \"break out of a loop.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "7 11 => at least one number satisfies the condition\n"
+ ]
+ }
+ ],
+ "source": [
+ "is_above = False\n",
+ "\n",
+ "for number in numbers:\n",
+ " print(number, end=\" \") # added for didactical purposes\n",
+ " if number ** 2 > 100:\n",
+ " is_above = True\n",
+ " break\n",
+ "\n",
+ "if is_above:\n",
+ " print(\"=> at least one number satisfies the condition\")\n",
+ "else:\n",
+ " print(\"=> no number satisfies the condition\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This is a computational improvement. However, the code still consists of *three* sections: Some initialization *before* the `for`-loop, the loop itself, and some finalizing logic. We prefer to convey the program's idea in *one* compound statement instead."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### The `else`-clause"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To express the logic in a prettier way, we add an `else`-clause at the end of the `for`-loop (cf., [reference ](https://docs.python.org/3/reference/compound_stmts.html#the-for-statement)). The `else`-clause is executed *only if* the `for`-loop is *not* stopped with a `break` statement *prematurely* (i.e., *before* reaching the *last* iteration in the loop). The word \"else\" implies a somewhat unintuitive meaning and may have better been named a `then`-clause. In most use cases, however, the `else`-clause logically goes together with some `if` statement in the loop's body.\n",
+ "\n",
+ "Overall, the code's expressive power increases. Not many programming languages support an optional `else`-branching for the `for` and `while` statements, which turns out to be very useful in practice."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "7 11 => at least one number satisfies the condition\n"
+ ]
+ }
+ ],
+ "source": [
+ "for number in numbers:\n",
+ " print(number, end=\" \") # added for didactical purposes\n",
+ " if number ** 2 > 100:\n",
+ " is_above = True\n",
+ " break\n",
+ "else:\n",
+ " is_above = False\n",
+ "\n",
+ "if is_above:\n",
+ " print(\"=> at least one number satisfies the condition\")\n",
+ "else:\n",
+ " print(\"=> no number satisfies the condition\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Lastly, we incorporate the finalizing `if`-`else` logic into the `for`-loop, avoiding the `is_above` variable altogether."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "7 11 => at least one number satisfies the condition\n"
+ ]
+ }
+ ],
+ "source": [
+ "for number in numbers:\n",
+ " print(number, end=\" \") # added for didactical purposes\n",
+ " if number ** 2 > 100:\n",
+ " print(\"=> at least one number satisfies the condition\")\n",
+ " break\n",
+ "else:\n",
+ " print(\"=> no number satisfies the condition\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Of course, if we choose the number an element's square has to pass to be larger, for example, to `200`, we have to loop over all `numbers`. There is *no way* to optimize this **[linear search ](https://en.wikipedia.org/wiki/Linear_search)** further."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "7 11 8 5 3 12 2 6 9 10 1 4 => no number satisfies the condition\n"
+ ]
+ }
+ ],
+ "source": [
+ "for number in numbers:\n",
+ " print(number, end=\" \") # added for didactical purposes\n",
+ " if number ** 2 > 200:\n",
+ " print(\"=> at least one number satisfies the condition\")\n",
+ " break\n",
+ "else:\n",
+ " print(\"=> no number satisfies the condition\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## A first Glance at the **Map-Filter-Reduce** Paradigm"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Often, we process some iterable with numeric data, for example, a list of `numbers` as in this book's introductory example in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#Example:-Averaging-all-even-Numbers-in-a-List) or, more realistically, data from a CSV file with many rows and columns.\n",
+ "\n",
+ "Processing numeric data usually comes down to operations that may be grouped into one of the following three categories:\n",
+ "\n",
+ "- **mapping**: transform a number according to some functional relationship $y = f(x)$\n",
+ "- **filtering**: throw away individual numbers (e.g., statistical outliers in a sample)\n",
+ "- **reducing**: collect individual numbers into summary statistics\n",
+ "\n",
+ "We study this **map-filter-reduce** paradigm extensively in [Chapter 8 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/08_mfr/00_content.ipynb) after introducing more advanced data types that are needed to work with \"big\" data.\n",
+ "\n",
+ "Here, we focus on *filtering out* some numbers in a `for`-loop."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Example: A simple Filter"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "Calculate the sum of all even numbers in `[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]` after squaring them and adding `1` to the squares:\n",
+ "\n",
+ "- \"*all*\" => **loop** over an iterable\n",
+ "- \"*even*\" => **filter** out the odd numbers\n",
+ "- \"*square and add $1$*\" => apply the **map** $y = f(x) = x^2 + 1$\n",
+ "- \"*sum*\" => **reduce** the remaining and mapped numbers to their sum"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "numbers = [7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "8 -> 65 12 -> 145 2 -> 5 6 -> 37 10 -> 101 4 -> 17 "
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "370"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "total = 0\n",
+ "\n",
+ "for number in numbers:\n",
+ " if number % 2 == 0: # only keep even numbers\n",
+ " square = (number ** 2) + 1\n",
+ " print(number, \"->\", square, end=\" \") # added for didactical purposes\n",
+ " total += square\n",
+ "\n",
+ "total"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The above code is easy to read as it involves only two levels of indentation.\n",
+ "\n",
+ "In general, code gets harder to comprehend the more **horizontal space** it occupies. It is commonly considered good practice to grow a program **vertically** rather than horizontally. Code compliant with [PEP 8 ](https://www.python.org/dev/peps/pep-0008/#maximum-line-length) requires us to use *at most* 79 characters in a line!\n",
+ "\n",
+ "Consider the next example, whose implementation in code already starts to look unbalanced."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Example: Several Filters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "Calculate the sum of every third and even number in `[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]` after squaring them and adding `1` to the squares:\n",
+ "\n",
+ "- \"*every*\" => **loop** over an iterable\n",
+ "- \"*third*\" => **filter** out all numbers except every third\n",
+ "- \"*even*\" => **filter** out the odd numbers\n",
+ "- \"*square and add $1$*\" => apply the **map** $y = f(x) = x^2 + 1$\n",
+ "- \"*sum*\" => **reduce** the remaining and mapped numbers to their sum"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "8 -> 65 12 -> 145 4 -> 17 "
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "227"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "total = 0\n",
+ "\n",
+ "for i, number in enumerate(numbers, start=1):\n",
+ " if i % 3 == 0: # only keep every third number\n",
+ " if number % 2 == 0: # only keep even numbers\n",
+ " square = (number ** 2) + 1\n",
+ " print(number, \"->\", square, end=\" \") # added for didactical purposes \n",
+ " total += square\n",
+ "\n",
+ "total"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With already three levels of indentation, less horizontal space is available for the actual code block. Of course, one could flatten the two `if` statements with the logical `and` operator, as shown in [Chapter 3 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/03_conditionals/00_content.ipynb#The-if-Statement). Then, however, we trade off horizontal space against a more \"complex\" `if` logic, and this is *not* a real improvement."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "### The `continue` Statement"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A Pythonista would instead make use of the `continue` statement (cf., [reference ](https://docs.python.org/3/reference/simple_stmts.html#the-continue-statement)) that causes a loop to jump into the next iteration skipping the rest of the code block.\n",
+ "\n",
+ "The revised code fragment below occupies more vertical space and less horizontal space: A *good* trade-off.\n",
+ "\n",
+ "One caveat is that we need to negate the conditions in the `if` statements. Conceptually, we are now filtering \"out\" and not \"in.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "8 -> 65 12 -> 145 4 -> 17 "
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "227"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "total = 0\n",
+ "\n",
+ "for i, number in enumerate(numbers, start=1):\n",
+ " if i % 3 != 0: # only keep every third number\n",
+ " continue\n",
+ " elif number % 2 != 0: # only keep even numbers\n",
+ " continue\n",
+ "\n",
+ " square = (number ** 2) + 1\n",
+ " print(number, \"->\", square, end=\" \") # added for didactical purposes \n",
+ " total += square\n",
+ "\n",
+ "total"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This is yet another illustration of why programming is an art. The two preceding code cells do the *same* with *identical* time complexity. However, the latter is arguably easier to read for a human, even more so when the business logic grows beyond two filters."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Indefinite Loops"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Sometimes we find ourselves in situations where we *cannot* know ahead of time how often or until which point in time a code block is to be executed."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Example: Guessing a Coin Toss"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Let's consider a game where we randomly choose a variable to be either \"Heads\" or \"Tails\" and the user of our program has to guess it.\n",
+ "\n",
+ "Python provides the built-in [input() ](https://docs.python.org/3/library/functions.html#input) function that prints a message to the user, called the **prompt**, and reads in what was typed in response as a `str` object. We use it to process a user's \"unreliable\" input to our program (i.e., a user might type in some invalid response). Further, we use the [random() ](https://docs.python.org/3/library/random.html#random.random) function in the [random ](https://docs.python.org/3/library/random.html) module to model the coin toss.\n",
+ "\n",
+ "A popular pattern to approach such **indefinite loops** is to go with a `while True` statement, which on its own would cause Python to enter into an infinite loop. Then, once a particular event occurs, we `break` out of the loop.\n",
+ "\n",
+ "Let's look at a first and naive implementation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import random"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "code_folding": [],
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdin",
+ "output_type": "stream",
+ "text": [
+ "Guess if the coin comes up as heads or tails: heads\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Ooops, it was tails\n"
+ ]
+ },
+ {
+ "name": "stdin",
+ "output_type": "stream",
+ "text": [
+ "Guess if the coin comes up as heads or tails: heads\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Yes, it was heads\n"
+ ]
+ }
+ ],
+ "source": [
+ "while True:\n",
+ " guess = input(\"Guess if the coin comes up as heads or tails: \")\n",
+ "\n",
+ " if random.random() < 0.5:\n",
+ " if guess == \"heads\":\n",
+ " print(\"Yes, it was heads\")\n",
+ " break\n",
+ " else:\n",
+ " print(\"Ooops, it was heads\")\n",
+ " else:\n",
+ " if guess == \"tails\":\n",
+ " print(\"Yes, it was tails\")\n",
+ " break\n",
+ " else:\n",
+ " print(\"Ooops, it was tails\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This version exhibits two *severe* issues where we should improve on:\n",
+ "\n",
+ "1. If a user enters *anything* other than `\"heads\"` or `\"tails\"`, for example, `\"Heads\"` or `\"Tails\"`, the program keeps running *without* the user knowing about the mistake!\n",
+ "2. The code *intermingles* the coin tossing with the processing of the user's input: Mixing *unrelated* business logic in the *same* code block makes a program harder to read and, more importantly, maintain in the long run."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Example: Guessing a Coin Toss (revisited)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Let's refactor the code and make it *modular*.\n",
+ "\n",
+ "First, we divide the business logic into two functions `get_guess()` and `toss_coin()` that are controlled from within a `while`-loop.\n",
+ "\n",
+ "`get_guess()` not only reads in the user's input but also implements a simple input validation pattern in that the [.strip() ](https://docs.python.org/3/library/stdtypes.html?highlight=__contains__#str.strip) and [.lower() ](https://docs.python.org/3/library/stdtypes.html?highlight=__contains__#str.lower) methods remove preceding and trailing whitespace and lower case the input ensuring that the user may spell the input in any possible way (e.g., all upper or lower case). Also, `get_guess()` checks if the user entered one of the two valid options. If so, it returns either `\"heads\"` or `\"tails\"`; if not, it returns `None`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def get_guess():\n",
+ " \"\"\"Process the user's input.\n",
+ " \n",
+ " Returns:\n",
+ " guess (str / NoneType): either \"heads\" or \"tails\"\n",
+ " if the input can be parsed and None otherwise\n",
+ " \"\"\"\n",
+ " guess = input(\"Guess if the coin comes up as heads or tails: \")\n",
+ " # handle frequent cases of \"misspelled\" user input\n",
+ " guess = guess.strip().lower()\n",
+ "\n",
+ " if guess in [\"heads\", \"tails\"]:\n",
+ " return guess\n",
+ " return None"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`toss_coin()` models a fair coin toss when called with default arguments."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def toss_coin(p_heads=0.5):\n",
+ " \"\"\"Simulate the tossing of a coin.\n",
+ "\n",
+ " Args:\n",
+ " p_heads (optional, float): probability that the coin comes up \"heads\";\n",
+ " defaults to 0.5 resembling a fair coin\n",
+ "\n",
+ " Returns:\n",
+ " side_on_top (str): \"heads\" or \"tails\"\n",
+ " \"\"\"\n",
+ " if random.random() < p_heads:\n",
+ " return \"heads\"\n",
+ " return \"tails\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Second, we rewrite the `if`-`else`-logic to handle the case where `get_guess()` returns `None` explicitly: Whenever the user enters something invalid, a warning is shown, and another try is granted. We use the `is` operator and not the `==` operator as `None` is a singleton object.\n",
+ "\n",
+ "The `while`-loop takes on the role of **glue code** that manages how other parts of the program interact with each other."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "random.seed(42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdin",
+ "output_type": "stream",
+ "text": [
+ "Guess if the coin comes up as heads or tails: invalid\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Make sure to enter your guess correctly!\n"
+ ]
+ },
+ {
+ "name": "stdin",
+ "output_type": "stream",
+ "text": [
+ "Guess if the coin comes up as heads or tails: Heads\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Yes, it was heads\n"
+ ]
+ }
+ ],
+ "source": [
+ "while True:\n",
+ " guess = get_guess()\n",
+ " result = toss_coin()\n",
+ "\n",
+ " if guess is None:\n",
+ " print(\"Make sure to enter your guess correctly!\")\n",
+ " elif guess == result:\n",
+ " print(\"Yes, it was\", result)\n",
+ " break\n",
+ " else:\n",
+ " print(\"Ooops, it was\", result)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Now, the program's business logic is expressed in a clearer way. More importantly, we can now change it more easily. For example, we could make the `toss_coin()` function base the tossing on a probability distribution other than the uniform (i.e., replace the [random.random() ](https://docs.python.org/3/library/random.html#random.random) function with another one). In general, modular architecture leads to improved software maintenance."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/04_iteration/04_exercises_dice.ipynb b/04_iteration/04_exercises_dice.ipynb
new file mode 100644
index 0000000..9c3feae
--- /dev/null
+++ b/04_iteration/04_exercises_dice.ipynb
@@ -0,0 +1,403 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Run All*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *after* finishing the exercises to ensure that your solution runs top to bottom *without* any errors. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/04_iteration/04_exercises.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 4: Recursion & Looping (Coding Exercises)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The exercises below assume that you have read the [third part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/03_content.ipynb) of Chapter 4.\n",
+ "\n",
+ "The `...`'s in the code cells indicate where you need to fill in code snippets. The number of `...`'s within a code cell give you a rough idea of how many lines of code are needed to solve the task. You should not need to create any additional code cells for your final solution. However, you may want to use temporary code cells to try out some ideas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Throwing Dice"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this exercise, you will model the throwing of dice within the context of a guessing game similar to the one shown in the \"*Example: Guessing a Coin Toss*\" section in [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/03_content.ipynb#Example:-Guessing-a-Coin-Toss).\n",
+ "\n",
+ "As the game involves randomness, we import the [random ](https://docs.python.org/3/library/random.html) module from the [standard library ](https://docs.python.org/3/library/index.html). To follow best practices, we set the random seed as well."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import random"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "random.seed(42)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "A die has six sides that we labeled with integers `1` to `6` in this exercise. For a fair die, the probability for each side is the same.\n",
+ "\n",
+ "**Q1**: Model a `fair_die` as a `list` object!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fair_die = ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: What function from the [random ](https://docs.python.org/3/library/random.html) module that we have seen already is useful for modeling a single throw of the `fair_die`? Write a simple expression (i.e., one function call) that draws one of the equally likely sides! Execute the cell a couple of times to \"see\" the probability distribution!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's check if the `fair_die` is indeed fair. To do so, we create a little numerical experiment and throw the `fair_die` `100000` times. We track the six different outcomes in a `list` object called `throws` that we initialize with all `0`s for each outcome.\n",
+ "\n",
+ "**Q3**: Complete the `for`-loop below such that it runs `100000` times! In the body, use your answer to **Q2** to simulate a single throw of the `fair_die` and update the corresponding count in `throws`!\n",
+ "\n",
+ "Hints: You need to use the indexing operator `[]` and calculate an `index` in each iteration of the loop. Do do not actually need the target variable provided by the `for`-loop and may want to indicate that with an underscore `_`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "throws = [0, 0, 0, 0, 0, 0]\n",
+ "\n",
+ "for ... in ...:\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ "throws"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "`throws` contains the simulation results as absolute counts.\n",
+ "\n",
+ "**Q4**: Complete the `for`-loop below to convert the counts in `throws` to relative frequencies stored in a `list` called `frequencies`! Round the frequencies to three decimals with the built-in [round() ](https://docs.python.org/3/library/functions.html#round) function!\n",
+ "\n",
+ "Hints: Initialize `frequencies` just as `throws` above. How many iterations does the `for`-loop have? `6` or `100000`? You may want to obtain an `index` variable with the [enumerate() ](https://docs.python.org/3/library/functions.html#enumerate) built-in."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "frequencies = [0, 0, 0, 0, 0, 0]\n",
+ "\n",
+ "for ... in ...:\n",
+ " ...\n",
+ "\n",
+ "frequencies"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: How could we adapt the `list` object used above to model an `unfair_die` where `1` is as likely as `2`, `2` is twice as likely as `3`, and `3` is twice as likely as `4`, `5`, or `6`, who are all equally likely?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "unfair_die = ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: Copy your solution to **Q2** for the `unfair_die`! Execute the cell a couple of times to \"see\" the probability distribution!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7**: Copy and adapt your solutions to **Q3** and **Q4** to calculate the `frequencies` for the `unfair_die`!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "throws = [0, 0, 0, 0, 0, 0]\n",
+ "frequencies = [0, 0, 0, 0, 0, 0]\n",
+ "\n",
+ "for ... in ...:\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ "for ... in ...:\n",
+ " ...\n",
+ "\n",
+ "frequencies"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q8**: The built-in [input() ](https://docs.python.org/3/library/functions.html#input) allows us to ask the user to enter a `guess`. What is the data type of the object returned by [input() ](https://docs.python.org/3/library/functions.html#input)? Assume the user enters the `guess` as a number (i.e., \"1\", \"2\", ...) and not as a text (e.g., \"one\")."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "guess = input(\"Guess the side of the die: \")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "guess"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q9**: Use a built-in constructor to cast `guess` as an `int` object!\n",
+ "\n",
+ "Hint: Simply wrap `guess` or `input(\"Guess the side of the die: \")` with the constructor you choose."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q10**: What type of error is raised if `guess` cannot be cast as an `int` object?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q11**: Write a `try` statement that catches the type of error (i.e., your answer to **Q10**) raised if the user's input cannot be cast as an `int` object! Print out some nice error message notifying the user of the bad input!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "try:\n",
+ " ...\n",
+ "except ...:\n",
+ " ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q12**: Write a function `get_guess()` that takes a user's input and checks if it is a valid side of the die! The function should *return* either an `int` object between `1` and `6` or `None` if the user enters something invalid.\n",
+ "\n",
+ "Hints: You may want to re-use the `try` statement from **Q11**. Instead of printing out an error message, you can also `return` directly from the `except`-clause (i.e., early exit) with `None`. So, the user can make *two* kinds of input errors and maybe you want to model that with two *distinct* `return None` statements. Also, you may want to allow the user to enter leading and trailing whitespace that gets removed without an error message."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def get_guess():\n",
+ " \"\"\"Process the user's input.\n",
+ " \n",
+ " Returns:\n",
+ " guess (int / NoneType): either 1, 2, 3, 4, 5 or 6\n",
+ " if the input can be parsed and None otherwise\n",
+ " \"\"\"\n",
+ " ...\n",
+ "\n",
+ " # Check if the user entered an integer.\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " # Check if the user entered a valid side.\n",
+ " ...\n",
+ " ...\n",
+ " ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q13** Test your function for all *three* cases!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "get_guess()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q14**: Write an *indefinite* loop where in each iteration a `fair_die` is thrown and the user makes a guess! Print out an error message if the user does not enter something that can be understood as a number between `1` and `6`! The game should continue until the user makes a correct guess."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "...\n",
+ "...\n",
+ "...\n",
+ "\n",
+ "...\n",
+ "...\n",
+ "...\n",
+ "...\n",
+ "...\n",
+ "...\n",
+ "..."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/04_iteration/05_summary.ipynb b/04_iteration/05_summary.ipynb
new file mode 100644
index 0000000..18d287d
--- /dev/null
+++ b/04_iteration/05_summary.ipynb
@@ -0,0 +1,79 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 4: Recursion & Looping (TL;DR)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Iteration** is about **running blocks of code repeatedly**.\n",
+ "\n",
+ "There are two redundant approaches to achieving that.\n",
+ "\n",
+ "First, we combine functions that call themselves with conditional statements. This concept is known as **recursion** and suffices to control the flow of execution in *every* way we desire. For a beginner, this approach of **backward** reasoning might not be intuitive, but it turns out to be a handy tool to have in one's toolbox.\n",
+ "\n",
+ "Second, the `while` and `for` statements are alternative and potentially more intuitive ways to express iteration as they correspond to a **forward** reasoning. The `for` statement is **syntactic sugar** that allows rewriting common occurrences of the `while` statement concisely. Python provides the `break` and `continue` statements as well as an optional `else`-clause that make working with the `for` and `while` statements even more convenient.\n",
+ "\n",
+ "**Iterables** are any **concrete data types** that support being looped over, for example, with the `for` statement. The idea behind iterables is an **abstract concept** that may or may not be implemented by any given concrete data type. For example, both `list` and `range` objects can be looped over. The `list` type is also a **container** as any given `list` objects \"contains\" references to other objects in memory. On the contrary, the `range` type does not reference any other object but instead creates *new* `int` objects \"on the fly\" (i.e., when being looped over)."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/04_iteration/06_review.ipynb b/04_iteration/06_review.ipynb
new file mode 100644
index 0000000..eeb19a5
--- /dev/null
+++ b/04_iteration/06_review.ipynb
@@ -0,0 +1,268 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 4: Recursion & Looping (Review Questions)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The questions below assume that you have read the [first ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/00_content.ipynb), [second ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/02_content.ipynb), and the [third ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/03_content.ipynb) part of Chapter 4.\n",
+ "\n",
+ "Be concise in your answers! Most questions can be answered in *one* sentence."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Essay Questions "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: Solving a problem by **recursion** is not only popular in computer science and math. Name some examples from the fields of business or economics where problems are also solved in a **backward** fashion!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: Explain what **duck typing** means! Why can it cause problems? Why is it [not a bug but a feature](https://www.urbandictionary.com/define.php?term=It%27s%20not%20a%20bug%2C%20it%27s%20a%20feature)?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: What is **syntactic sugar**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: Describe in your own words why the **recursive** version of `fibonacci()`, the \"Easy at first Glance\" example in the chapter, is computationally **inefficient**! Why does the **iterative** version of `fibonacci()`, the \"Hard at first Glance\" example, run so much faster?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: What is the conceptual difference between a **container** and a **list**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: What is a good use case for the `for`-loop's optional `else`-clause?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## True / False Questions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Motivate your answer with *one short* sentence!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7**: When a **recursion** does **not** reach the base case, this is an example of the **early exit** strategy."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q8**: Any programming language **without** looping constructs like the `for` or `while` statements is **not** Turing complete."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q9**: A **recursive** formulation is the same as a **circular** one: The terms are **synonyms**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q10**: Formulating a computational problem as a **recursion** results in an **efficient** implementation."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q11**: Whereas a **recursion** may accidentally result in a **never-ending** program, `while`-loops and `for`-loops are guaranteed to **terminate**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q12**: Before writing **any** kind of **loop**, we **always** need to think about a **stopping criterion** ahead of time."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q13**: **Container** types such as `list` objects are characterized by their **support** for **being looped over**, for example as in:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```python\n",
+ "for element in container:\n",
+ " # do something for every element\n",
+ " ...\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/04_iteration/static/towers_of_hanoi.gif b/04_iteration/static/towers_of_hanoi.gif
new file mode 100644
index 0000000..7ab13d4
Binary files /dev/null and b/04_iteration/static/towers_of_hanoi.gif differ
diff --git a/05_numbers/00_content.ipynb b/05_numbers/00_content.ipynb
new file mode 100644
index 0000000..405c540
--- /dev/null
+++ b/05_numbers/00_content.ipynb
@@ -0,0 +1,2454 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/05_numbers/00_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 5: Numbers & Bits"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "After learning about the basic building blocks of expressing and structuring the business logic in programs, we focus our attention on the **data types** Python offers us, both built-in and available via the [standard library ](https://docs.python.org/3/library/index.html) or third-party packages.\n",
+ "\n",
+ "We start with the \"simple\" ones: Numeric types in this chapter and textual data in [Chapter 6 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/00_content.ipynb). An important fact that holds for all objects of these types is that they are **immutable**. To reuse the bag analogy from [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#Objects-vs.-Types-vs.-Values), this means that the $0$s and $1$s making up an object's *value* cannot be changed once the bag is created in memory, implying that any operation with or method on the object creates a *new* object in a *different* memory location.\n",
+ "\n",
+ "[Chapter 7 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/00_content.ipynb), [Chapter 8 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/08_mfr/00_content.ipynb), [Chapter 9 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/09_mappings/00_content.ipynb), [Chapter 10 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/10_arrarys/00_content.ipynb) then cover the more \"complex\" data types, including, for example, the `list` type. Finally, [Chapter 11 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/00_content.ipynb) completes the picture by introducing language constructs to create custom types.\n",
+ "\n",
+ "We have already seen many hints indicating that numbers are not as trivial to work with as it seems at first sight:\n",
+ "\n",
+ "- [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#%28Data%29-Type-%2F-%22Behavior%22) reveals that numbers may come in *different* data types (i.e., `int` vs. `float` so far),\n",
+ "- [Chapter 3 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/03_conditionals/00_content.ipynb#Boolean-Expressions) raises questions regarding the **limited precision** of `float` numbers (e.g., `42 == 42.000000000000001` evaluates to `True`), and\n",
+ "- [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/00_content.ipynb#Infinite-Recursion) shows that sometimes a `float` \"walks\" and \"quacks\" like an `int`, whereas the reverse is true in other cases.\n",
+ "\n",
+ "This chapter introduces all the [built-in numeric types ](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex): `int`, `float`, and `complex`. To mitigate the limited precision of floating-point numbers, we also add an [Appendix ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/03_appendix.ipynb) where we look at two replacements for the `float` type in the [standard library ](https://docs.python.org/3/library/index.html), namely the `Decimal` type in the [decimals ](https://docs.python.org/3/library/decimal.html#decimal.Decimal) and the `Fraction` type in the [fractions ](https://docs.python.org/3/library/fractions.html#fractions.Fraction) module."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `int` Type"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The simplest numeric type is the `int` type: It behaves like an [integer in ordinary math ](https://en.wikipedia.org/wiki/Integer) (i.e., the set $\\mathbb{Z}$) and supports operators in the way we saw in the section on arithmetic operators in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#%28Arithmetic%29-Operators).\n",
+ "\n",
+ "One way to create `int` objects is by simply writing its value as a literal with the digits `0` to `9`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "a = 42"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Just like any other object, the `42` has an identity, a type, and a value."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "94857615440928"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(a)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "int"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(a)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A nice feature in newer Python versions is using underscores `_` as (thousands) separators in numeric literals. For example, `1_000_000` evaluates to `1000000` in memory; the `_`s are ignored by the interpreter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1000000"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1_000_000"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We may place the `_`s anywhere we want."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "123456789"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1_2_3_4_5_6_7_8_9"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "It is syntactically invalid to write out leading `0`s in numeric literals. The reason for that will become apparent in the next section."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers (1481240458.py, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m Cell \u001b[0;32mIn[7], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m 042\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers\n"
+ ]
+ }
+ ],
+ "source": [
+ "042"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Another way to create `int` objects is with the [int() ](https://docs.python.org/3/library/functions.html#int) built-in that casts `float` or properly formatted `str` objects as integers. Then, decimals are truncated (i.e., \"cut off\")."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "int(42.11)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "int(42.87)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Whereas the integer division operator `//` \"rounds\" towards negative infinity (cf., the \"*(Arithmetic) Operators*\" section in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#%28Arithmetic%29-Operators)), the [int() ](https://docs.python.org/3/library/functions.html#int) built-in rounds towards `0`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-42"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "int(-42.87)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When casting `str` objects as `int`s, the [int() ](https://docs.python.org/3/library/functions.html#int) built-in is less forgiving. We must not include any decimals as shown by the `ValueError`. Yet, leading and trailing whitespace is gracefully ignored."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "int(\"42\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "invalid literal for int() with base 10: '42.0'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[12], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m42.0\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: '42.0'"
+ ]
+ }
+ ],
+ "source": [
+ "int(\"42.0\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "int(\" 42 \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `int` type follows all rules we know from math, apart from one exception: Whereas mathematicians to this day argue what the term $0^0$ means (cf., this [article ](https://en.wikipedia.org/wiki/Zero_to_the_power_of_zero)), programmers are pragmatic about this and simply define $0^0 = 1$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0 ** 0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Binary Representations"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As computers can only store $0$s and $1$s, `int` objects are nothing but that in memory as well. Consequently, computer scientists and engineers developed conventions as to how $0$s and $1$s are \"translated\" into integers, and one such convention is the **[binary representation ](https://en.wikipedia.org/wiki/Binary_number)** of **non-negative integers**. Consider the integers from $0$ through $255$ that are encoded into $0$s and $1$s with the help of this table:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "|Bit $i$| 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |\n",
+ "|:------|:----|:----|:----|:----|:----|:----|:----|:----|\n",
+ "| Digit |$2^7$|$2^6$|$2^5$|$2^4$|$2^3$|$2^2$|$2^1$|$2^0$|\n",
+ "| $=$ |$128$| $64$| $32$| $16$| $8$ | $4$ | $2$ | $1$ |"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A number consists of exactly eight $0$s and $1$s that are read from right to left and referred to as the **bits** of the number. Each bit represents a distinct multiple of $2$, the **digit**. For sure, we start counting at $0$ again.\n",
+ "\n",
+ "To encode the integer $3$, for example, we need to find a combination of $0$s and $1$s such that the sum of digits marked with a $1$ is equal to the number we want to encode. In the example, we set all bits to $0$ except for the first ($i=0$) and second ($i=1$) as $2^0 + 2^1 = 1 + 2 = 3$. So the binary representation of $3$ is $00~00~00~11$. To borrow some terminology from linear algebra, the $3$ is a linear combination of the digits where the coefficients are either $0$ or $1$: $3 = 0*128 + 0*64 + 0*32 + 0*16 + 0*8 + 0*4 + 1*2 + 1*1$. It is *guaranteed* that there is exactly *one* such combination for each number between $0$ and $255$.\n",
+ "\n",
+ "As each bit in the binary representation is one of two values, we say that this representation has a base of $2$. Often, the base is indicated with a subscript to avoid confusion. For example, we write $3_{10} = 00000011_2$ or $3_{10} = 11_2$ for short omitting leading $0$s. A subscript of $10$ implies a decimal number as we know it from elementary school.\n",
+ "\n",
+ "We use the built-in [bin() ](https://docs.python.org/3/library/functions.html#bin) function to obtain an `int` object's binary representation: It returns a `str` object starting with `\"0b\"` indicating the binary format and as many $0$s and $1$s as are necessary to encode the integer omitting leading $0$s."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b11'"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We may pass a `str` object formatted this way as the argument to the [int() ](https://docs.python.org/3/library/functions.html#int) built-in, together with `base=2`, to create an `int` object, for example, with the value of `3`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "int(\"0b11\", base=2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Moreover, we may also use the contents of the returned `str` object as a **literal** instead: Just like we type, for example, `3` without quotes (i.e., \"literally\") into a code cell to create the `int` object `3`, we may type `0b11` to obtain an `int` object with the same value."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0b11"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Another example is the integer `123` that is the sum of $64 + 32 + 16 + 8 + 2 + 1$: Thus, its binary representation is the sequence of bits $01~11~10~11$, or to use our new notation, $123_{10} = 1111011_2$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b1111011'"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(123)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Analogous to typing `123` into a code cell, we may write `0b1111011`, or `0b_111_1011` to make use of the underscores, and create an `int` object with the value `123`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "123"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0b_111_1011"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`0` and `255` are the edge cases where we set all the bits to either $0$ or $1$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b0'"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b1'"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b10'"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b11111111'"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(255)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Groups of eight bits are also called a **byte**. As a byte can only represent non-negative integers up to $255$, the table above is extended conceptually with greater digits to the left to model integers beyond $255$. The memory management needed to implement this is built into Python, and we do not need to worry about it.\n",
+ "\n",
+ "For example, `789` is encoded with ten bits and $789_{10} = 1100010101_2$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b1100010101'"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(789)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To contrast this bits encoding with the familiar decimal system, we show an equivalent table with powers of $10$ as the digits:\n",
+ "\n",
+ "|Decimal| 3 | 2 | 1 | 0 |\n",
+ "|-------|------|------|------|------|\n",
+ "| Digit |$10^3$|$10^2$|$10^1$|$10^0$|\n",
+ "| $=$ |$1000$| $100$| $10$ | $1$ |\n",
+ "\n",
+ "Now, an integer is a linear combination of the digits where the coefficients are one of *ten* values, and the base is now $10$. For example, the number $123$ can be expressed as $0*1000 + 1*100 + 2*10 + 3*1$. So, the binary representation follows the same logic as the decimal system taught in elementary school. The decimal system is intuitive to us humans, mostly as we learn to count with our *ten* fingers. The $0$s and $1$s in a computer's memory are therefore no rocket science; they only feel unintuitive for a beginner."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Arithmetic with Bits"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Adding two numbers in their binary representations is straightforward and works just like we all learned addition in elementary school. Going from right to left, we add the individual digits, and ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 + 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b1 + 0b10 = 0b11'"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(1) + \" + \" + bin(2) + \" = \" + bin(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "... if any two digits add up to $2$, the resulting digit is $0$ and a $1$ carries over."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 + 3"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b1 + 0b11 = 0b100'"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(1) + \" + \" + bin(3) + \" = \" + bin(4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Multiplication is also quite easy. All we need to do is to multiply the left operand by all digits of the right operand separately and then add up the individual products, just like in elementary school."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "12"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "4 * 3"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b100 * 0b11 = 0b1100'"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(4) + \" * \" + bin(3) + \" = \" + bin(12)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b100 * 0b1 = 0b100'"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(4) + \" * \" + bin(1) + \" = \" + bin(4) # multiply with first digit"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b100 * 0b10 = 0b1000'"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(4) + \" * \" + bin(2) + \" = \" + bin(8) # multiply with second digit"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [Further Resources ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/06_resources.ipynb) section at the end of this chapter provides video tutorials on addition and multiplication in binary. Subtraction and division are a bit more involved but essentially also easy to understand."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Hexadecimal Representations"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While in the binary and decimal systems there are two and ten distinct coefficients per digit, another convenient representation, the **hexadecimal representation**, uses a base of $16$. It is convenient as one digit stores the same amount of information as *four* bits and the binary representation quickly becomes unreadable for larger numbers. The letters \"a\" through \"f\" are used as digits \"10\" through \"15\".\n",
+ "\n",
+ "The following table summarizes the relationship between the three systems:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "|Decimal|Hexadecimal|Binary|$~~~~~~$|Decimal|Hexadecimal|Binary|$~~~~~~$|Decimal|Hexadecimal|Binary|$~~~~~~$|...|\n",
+ "|-------|-----------|------|--------|-------|-----------|------|--------|-------|-----------|------|--------|---|\n",
+ "| 0 | 0 | 0000 |$~~~~~~$| 16 | 10 | 10000|$~~~~~~$| 32 | 20 |100000|$~~~~~~$|...|\n",
+ "| 1 | 1 | 0001 |$~~~~~~$| 17 | 11 | 10001|$~~~~~~$| 33 | 21 |100001|$~~~~~~$|...|\n",
+ "| 2 | 2 | 0010 |$~~~~~~$| 18 | 12 | 10010|$~~~~~~$| 34 | 22 |100010|$~~~~~~$|...|\n",
+ "| 3 | 3 | 0011 |$~~~~~~$| 19 | 13 | 10011|$~~~~~~$| 35 | 23 |100011|$~~~~~~$|...|\n",
+ "| 4 | 4 | 0100 |$~~~~~~$| 20 | 14 | 10100|$~~~~~~$| 36 | 24 |100100|$~~~~~~$|...|\n",
+ "| 5 | 5 | 0101 |$~~~~~~$| 21 | 15 | 10101|$~~~~~~$| 37 | 25 |100101|$~~~~~~$|...|\n",
+ "| 6 | 6 | 0110 |$~~~~~~$| 22 | 16 | 10110|$~~~~~~$| 38 | 26 |100110|$~~~~~~$|...|\n",
+ "| 7 | 7 | 0111 |$~~~~~~$| 23 | 17 | 10111|$~~~~~~$| 39 | 27 |100111|$~~~~~~$|...|\n",
+ "| 8 | 8 | 1000 |$~~~~~~$| 24 | 18 | 11000|$~~~~~~$| 40 | 28 |101000|$~~~~~~$|...|\n",
+ "| 9 | 9 | 1001 |$~~~~~~$| 25 | 19 | 11001|$~~~~~~$| 41 | 29 |101001|$~~~~~~$|...|\n",
+ "| 10 | a | 1010 |$~~~~~~$| 26 | 1a | 11010|$~~~~~~$| 42 | 2a |101010|$~~~~~~$|...|\n",
+ "| 11 | b | 1011 |$~~~~~~$| 27 | 1b | 11011|$~~~~~~$| 43 | 2b |101011|$~~~~~~$|...|\n",
+ "| 12 | c | 1100 |$~~~~~~$| 28 | 1c | 11100|$~~~~~~$| 44 | 2c |101100|$~~~~~~$|...|\n",
+ "| 13 | d | 1101 |$~~~~~~$| 29 | 1d | 11101|$~~~~~~$| 45 | 2d |101101|$~~~~~~$|...|\n",
+ "| 14 | e | 1110 |$~~~~~~$| 30 | 1e | 11110|$~~~~~~$| 46 | 2e |101110|$~~~~~~$|...|\n",
+ "| 15 | f | 1111 |$~~~~~~$| 31 | 1f | 11111|$~~~~~~$| 47 | 2f |101111|$~~~~~~$|...|"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To show more examples of the above subscript convention, we pick three random entries from the table:\n",
+ "\n",
+ "$11_{10} = \\text{b}_{16} = 1011_2$\n",
+ "\n",
+ "$25_{10} = 19_{16} = 11001_2$\n",
+ "\n",
+ "$46_{10} = 2\\text{e}_{16} = 101110_2$\n",
+ "\n",
+ "The built-in [hex() ](https://docs.python.org/3/library/functions.html#hex) function creates a `str` object starting with `\"0x\"` representing an `int` object's hexadecimal representation. The length depends on how many groups of four bits are implied by the corresponding binary representation.\n",
+ "\n",
+ "For `0` and `1`, the hexadecimal representation is similar to the binary one."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0x0'"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hex(0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0x1'"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hex(1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Whereas `bin(3)` already requires two digits, one is enough for `hex(3)`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0x3'"
+ ]
+ },
+ "execution_count": 35,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hex(3) # bin(3) => \"0b11\"; two digits needed"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For `10` and `15`, we see the letter digits for the first time."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0xa'"
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hex(10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0xf'"
+ ]
+ },
+ "execution_count": 37,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hex(15)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The binary representation of `123`, `0b_111_1011`, can be viewed as *two* groups of four bits, $0111$ and $1011$, that are encoded as $7$ and $\\text{b}$ in hexadecimal (cf., table above)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b1111011'"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(123)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0x7b'"
+ ]
+ },
+ "execution_count": 39,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hex(123)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To obtain a *new* `int` object with the value `123`, we call the [int() ](https://docs.python.org/3/library/functions.html#int) built-in with a properly formatted `str` object and `base=16` as arguments."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "123"
+ ]
+ },
+ "execution_count": 40,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "int(\"0x7b\", base=16)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Alternatively, we could use a literal notation instead."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "123"
+ ]
+ },
+ "execution_count": 41,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0x7b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Hexadecimals between $00_{16}$ and $\\text{ff}_{16}$ (i.e., $0_{10}$ and $255_{10}$) are commonly used to describe colors, for example, in web development but also graphics editors. See this [online tool](https://www.w3schools.com/colors/colors_hexadecimal.asp) for some more background."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0x0'"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hex(0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0xff'"
+ ]
+ },
+ "execution_count": 43,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hex(255)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Just like binary representations, the hexadecimals extend to the left for larger numbers like `789`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0x315'"
+ ]
+ },
+ "execution_count": 44,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hex(789)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For completeness sake, we mention that there is also the [oct() ](https://docs.python.org/3/library/functions.html#oct) built-in to obtain an integer's **octal representation**. The logic is the same as for the hexadecimal representation, and we use *eight* instead of *sixteen* digits. That is the equivalent of viewing the binary representations in groups of three bits. As of today, octal representations have become less important, and the data science practitioner may probably live without them quite well."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "## Negative Values"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While there are conventions that model negative integers with $0$s and $1$s in memory (cf., [Two's Complement ](https://en.wikipedia.org/wiki/Two%27s_complement)), Python manages that for us, and we do not look into the theory here for brevity. We have learned all that a practitioner needs to know about how integers are modeled in a computer. The [Further Resources ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/06_resources.ipynb) section at the end of this chapter provides a video tutorial on how the [Two's Complement ](https://en.wikipedia.org/wiki/Two%27s_complement) idea works.\n",
+ "\n",
+ "The binary and hexadecimal representations of negative integers are identical to their positive counterparts except that they start with a minus sign `-`. However, as the video tutorial at the end of the chapter reveals, that is *not* how the bits are organized in memory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'-0b11'"
+ ]
+ },
+ "execution_count": 45,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(-3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'-0x3'"
+ ]
+ },
+ "execution_count": 46,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hex(-3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'-0b11111111'"
+ ]
+ },
+ "execution_count": 47,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(-255)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'-0xff'"
+ ]
+ },
+ "execution_count": 48,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hex(-255)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Bitwise Operators"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Now that we know how integers are represented with $0$s and $1$s, we look at ways of working with the individual bits, in particular with the so-called **[bitwise operators](https://wiki.python.org/moin/BitwiseOperators)**: As the name suggests, the operators perform some operation on a bit by bit basis. They only work with and always return `int` objects.\n",
+ "\n",
+ "We keep this overview rather short as such \"low-level\" operations are not needed by the data science practitioner regularly. Yet, it is worthwhile to have heard about them as they form the basis of all of arithmetic in computers.\n",
+ "\n",
+ "The first operator is the **bitwise AND** operator `&`: It looks at the bits of its two operands, `11` and `13` in the example, in a pairwise fashion and if *both* operands have a $1$ in the *same* position, the resulting integer will have a $1$ in this position as well. Otherwise, the resulting integer will have a $0$ in this position. The binary representations of `11` and `13` both have $1$s in their respective first and fourth bits, which is why `bin(11 & 13)` evaluates to `Ob_1001` or `9`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "9"
+ ]
+ },
+ "execution_count": 49,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "11 & 13"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b1011 & 0b1101'"
+ ]
+ },
+ "execution_count": 50,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(11) + \" & \" + bin(13) # to show the operands' bits"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b1001'"
+ ]
+ },
+ "execution_count": 51,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(11 & 13)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`0b_1001` is the binary representation of `9`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "9"
+ ]
+ },
+ "execution_count": 52,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0b_1001"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The **bitwise OR** operator `|` evaluates to an `int` object whose bits are set to $1$ if the corresponding bits of either *one* or *both* operands are $1$. So in the example `9 | 13` only the second bit is $0$ for both operands, which is why the expression evaluates to `0b_1101` or `13`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "13"
+ ]
+ },
+ "execution_count": 53,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "9 | 13"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b1001 | 0b1101'"
+ ]
+ },
+ "execution_count": 54,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(9) + \" | \" + bin(13) # to show the operands' bits"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b1101'"
+ ]
+ },
+ "execution_count": 55,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(9 | 13)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`0b_1101` evaluates to an `int` object with the value `13`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "13"
+ ]
+ },
+ "execution_count": 56,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0b_1101"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The **bitwise XOR** operator `^` is a special case of the `|` operator in that it evaluates to an `int` object whose bits are set to $1$ if the corresponding bit of *exactly one* of the two operands is $1$. Colloquially, the \"X\" stands for \"exclusive.\" The `^` operator must *not* be confused with the exponentiation operator `**`! In the example, `9 ^ 13`, only the third bit differs between the two operands, which is why it evaluates to `0b_100` omitting the leading $0$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 57,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "9 ^ 13"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b1001 ^ 0b1101'"
+ ]
+ },
+ "execution_count": 58,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(9) + \" ^ \" + bin(13) # to show the operands' bits"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b100'"
+ ]
+ },
+ "execution_count": 59,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(9 ^ 13)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`0b_100` evaluates to an `int` object with the value `4`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 60,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0b_100"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The **bitwise NOT** operator `~`, sometimes also called **inversion** operator, is said to \"flip\" the $0$s into $1$s and the $1$s into $0$s. However, it is based on the aforementioned [Two's Complement ](https://en.wikipedia.org/wiki/Two%27s_complement) convention and `~x = -(x + 1)` by definition (cf., the [reference ](https://docs.python.org/3/reference/expressions.html#unary-arithmetic-and-bitwise-operations)). The full logic behind this, while actually quite simple, is considered out of scope in this book.\n",
+ "\n",
+ "We can at least verify the definition by comparing the binary representations of `7` and `-8`: They are indeed the same."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-8"
+ ]
+ },
+ "execution_count": 61,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "~7"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 62,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "~7 == -(7 + 1) # = Two's Complement"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'-0b1000'"
+ ]
+ },
+ "execution_count": 63,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(~7)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'-0b1000'"
+ ]
+ },
+ "execution_count": 64,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(-(7 + 1))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`~x = -(x + 1)` can be reformulated as `~x + x = -1`, which is slightly easier to check."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-1"
+ ]
+ },
+ "execution_count": 65,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "~7 + 7"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Lastly, the **bitwise left and right shift** operators, `<<` and `>>`, shift all the bits either to the left or to the right. This corresponds to multiplying or dividing an integer by powers of `2`.\n",
+ "\n",
+ "When shifting left, $0$s are filled in."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "28"
+ ]
+ },
+ "execution_count": 66,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "7 << 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 67,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b111'"
+ ]
+ },
+ "execution_count": 67,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(7)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b11100'"
+ ]
+ },
+ "execution_count": 68,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(7 << 2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 69,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "28"
+ ]
+ },
+ "execution_count": 69,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0b_1_1100"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When shifting right, some bits are always lost."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 70,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 70,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "7 >> 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 71,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b111'"
+ ]
+ },
+ "execution_count": 71,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(7)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 72,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0b11'"
+ ]
+ },
+ "execution_count": 72,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "bin(7 >> 1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 73,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0b_11"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/05_numbers/01_content.ipynb b/05_numbers/01_content.ipynb
new file mode 100644
index 0000000..265ae0b
--- /dev/null
+++ b/05_numbers/01_content.ipynb
@@ -0,0 +1,2180 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/05_numbers/01_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 5: Numbers & Bits (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In this second part of the chapter, we look at the `float` type in detail. It is probably the most commonly used one in all of data science, even across programming languages."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `float` Type"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As we have seen before, some assumptions need to be made as to how the $0$s and $1$s in a computer's memory are to be translated into numbers. This process becomes a lot more involved when we go beyond integers and model [real numbers ](https://en.wikipedia.org/wiki/Real_number) (i.e., the set $\\mathbb{R}$) with possibly infinitely many digits to the right of the period like $1.23$.\n",
+ "\n",
+ "The **[Institute of Electrical and Electronics Engineers ](https://en.wikipedia.org/wiki/Institute_of_Electrical_and_Electronics_Engineers)** (IEEE, pronounced \"eye-triple-E\") is one of the important professional associations when it comes to standardizing all kinds of aspects regarding the implementation of soft- and hardware.\n",
+ "\n",
+ "The **[IEEE 754 ](https://en.wikipedia.org/wiki/IEEE_754)** standard defines the so-called **floating-point arithmetic** that is commonly used today by all major programming languages. The standard not only defines how the $0$s and $1$s are organized in memory but also, for example, how values are to be rounded, what happens in exceptional cases like divisions by zero, or what is a zero value in the first place.\n",
+ "\n",
+ "In Python, the simplest way to create a `float` object is to use a literal notation with a dot `.` in it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "b = 42.0"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "139923238853936"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(b)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "float"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(b)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42.0"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As with `int` literals, we may use underscores `_` to make longer `float` objects easier to read."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.123456789"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0.123_456_789"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In cases where the dot `.` is unnecessary from a mathematical point of view, we either need to end the number with it nevertheless or use the [float() ](https://docs.python.org/3/library/functions.html#float) built-in to cast the number explicitly. [float() ](https://docs.python.org/3/library/functions.html#float) can process any numeric object or a properly formatted `str` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42.0"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42.0"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42.0"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"42\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Leading and trailing whitespace is ignored ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42.87"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\" 42.87 \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "... but not whitespace in between."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "could not convert string to float: '42. 87'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[10], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43mfloat\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m42. 87\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mValueError\u001b[0m: could not convert string to float: '42. 87'"
+ ]
+ }
+ ],
+ "source": [
+ "float(\"42. 87\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`float` objects are implicitly created as the result of dividing an `int` object by another with the division operator `/`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.3333333333333333"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 / 3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In general, if we combine `float` and `int` objects in arithmetic operations, we always end up with a `float` type: Python uses the \"broader\" representation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42.0"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "40.0 + 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42.0"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "21 * 2.0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Scientific Notation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`float` objects may also be created with the **scientific literal notation**: We use the symbol `e` to indicate powers of $10$, so $1.23 * 10^0$ translates into `1.23e0`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1.23"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1.23e0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Syntactically, `e` needs a `float` or `int` object in its literal notation on its left and an `int` object on its right, both without a space. Otherwise, we get a `SyntaxError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "invalid syntax (1434619204.py, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m Cell \u001b[0;32mIn[15], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m 1.23 e0\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
+ ]
+ }
+ ],
+ "source": [
+ "1.23 e0"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "invalid decimal literal (3971374856.py, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m Cell \u001b[0;32mIn[16], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m 1.23e 0\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid decimal literal\n"
+ ]
+ }
+ ],
+ "source": [
+ "1.23e 0"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "invalid syntax (2795275998.py, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m Cell \u001b[0;32mIn[17], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m 1.23e0.0\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
+ ]
+ }
+ ],
+ "source": [
+ "1.23e0.0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If we leave out the number to the left, Python raises a `NameError` as it unsuccessfully tries to look up a variable named `e0`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "name 'e0' is not defined",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[18], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43me0\u001b[49m\n",
+ "\u001b[0;31mNameError\u001b[0m: name 'e0' is not defined"
+ ]
+ }
+ ],
+ "source": [
+ "e0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "So, to write $10^0$ in Python, we need to think of it as $1*10^0$ and write `1e0`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1.0"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1e0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To express thousands of something (i.e., $10^3$), we write `1e3`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1000.0"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1e3 # = thousands"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Similarly, to express, for example, milliseconds (i.e., $10^{-3} s$), we write `1e-3`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.001"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1e-3 # = milli"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Special Values"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "There are also three special values representing \"**not a number,**\" called `nan`, and positive or negative **infinity**, called `inf` or `-inf`, that are created by passing in the corresponding abbreviation as a `str` object to the [float() ](https://docs.python.org/3/library/functions.html#float) built-in. These values could be used, for example, as the result of a mathematically undefined operation like division by zero or to model the value of a mathematical function as it goes to infinity."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "nan"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"nan\") # also float(\"NaN\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "inf"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"+inf\") # also float(\"+infinity\") or float(\"infinity\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "inf"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"inf\") # also float(\"+inf\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-inf"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"-inf\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`nan` objects *never* compare equal to *anything*, not even to themselves. This happens in accordance with the [IEEE 754 ](https://en.wikipedia.org/wiki/IEEE_754) standard."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"nan\") == float(\"nan\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Another caveat is that any arithmetic involving a `nan` object results in `nan`. In other words, the addition below **fails silently** as no error is raised. As this also happens in accordance with the [IEEE 754 ](https://en.wikipedia.org/wiki/IEEE_754) standard, we *need* to be aware of that and check any data we work with for any `nan` occurrences *before* doing any calculations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "nan"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 + float(\"nan\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "On the contrary, as two values go to infinity, there is no such concept as difference and *everything* compares equal."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"inf\") == float(\"inf\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Adding `42` to `inf` makes no difference."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "inf"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"inf\") + 42"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"inf\") + 42 == float(\"inf\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We observe the same for multiplication ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "inf"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 * float(\"inf\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "42 * float(\"inf\") == float(\"inf\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "... and even exponentiation!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "inf"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"inf\") ** 42"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"inf\") ** 42 == float(\"inf\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Although absolute differences become unmeaningful as we approach infinity, signs are still respected."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "inf"
+ ]
+ },
+ "execution_count": 35,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "-42 * float(\"-inf\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "-42 * float(\"-inf\") == float(\"inf\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As a caveat, adding infinities of different signs is an *undefined operation* in math and results in a `nan` object. So, if we (accidentally or unknowingly) do this on a real dataset, we do *not* see any error messages, and our program may continue to run with non-meaningful results! This is another example of a piece of code **failing silently**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "nan"
+ ]
+ },
+ "execution_count": 37,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"inf\") + float(\"-inf\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "nan"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "float(\"inf\") - float(\"inf\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Imprecision"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`float` objects are *inherently* imprecise, and there is *nothing* we can do about it! In particular, arithmetic operations with two `float` objects may result in \"weird\" rounding \"errors\" that are strictly deterministic and occur in accordance with the [IEEE 754 ](https://en.wikipedia.org/wiki/IEEE_754) standard.\n",
+ "\n",
+ "For example, let's add `1` to `1e15` and `1e16`, respectively. In the latter case, the `1` somehow gets \"lost.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1000000000000001.0"
+ ]
+ },
+ "execution_count": 39,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1e15 + 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1e+16"
+ ]
+ },
+ "execution_count": 40,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1e16 + 1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Interactions between sufficiently large and small `float` objects are not the only source of imprecision."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "from math import sqrt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2.0000000000000004"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sqrt(2) ** 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.30000000000000004"
+ ]
+ },
+ "execution_count": 43,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0.1 + 0.2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This may become a problem if we rely on equality checks in our programs."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 44,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sqrt(2) ** 2 == 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 45,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0.1 + 0.2 == 0.3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A popular workaround is to benchmark the absolute value of the difference between the two numbers to be checked for equality against a pre-defined `threshold` *sufficiently* close to `0`, for example, `1e-15`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "threshold = 1e-15"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 47,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "abs((sqrt(2) ** 2) - 2) < threshold"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 48,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "abs((0.1 + 0.2) - 0.3) < threshold"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The built-in [format() ](https://docs.python.org/3/library/functions.html#format) function allows us to show the **significant digits** of a `float` number as they exist in memory to arbitrary precision. To exemplify it, let's view a couple of `float` objects with `50` digits. This analysis reveals that almost no `float` number is precise! After 14 or 15 digits \"weird\" things happen. As we see further below, the \"random\" digits ending the `float` numbers do *not* \"physically\" exist in memory! Rather, they are \"calculated\" by the [format() ](https://docs.python.org/3/library/functions.html#format) function that is forced to show `50` digits.\n",
+ "\n",
+ "The [format() ](https://docs.python.org/3/library/functions.html#format) function is different from the [format() ](https://docs.python.org/3/library/stdtypes.html#str.format) method on `str` objects introduced in the next chapter (cf., [Chapter 6 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/00_content.ipynb#format%28%29-Method)): Yet, both work with the so-called [format specification mini-language ](https://docs.python.org/3/library/string.html#format-specification-mini-language): `\".50f\"` is the instruction to show `50` digits of a `float` number."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0.10000000000000000555111512312578270211815834045410'"
+ ]
+ },
+ "execution_count": 49,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "format(0.1, \".50f\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0.20000000000000001110223024625156540423631668090820'"
+ ]
+ },
+ "execution_count": 50,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "format(0.2, \".50f\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0.29999999999999998889776975374843459576368331909180'"
+ ]
+ },
+ "execution_count": 51,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "format(0.3, \".50f\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0.33333333333333331482961625624739099293947219848633'"
+ ]
+ },
+ "execution_count": 52,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "format(1 / 3, \".50f\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [format() ](https://docs.python.org/3/library/functions.html#format) function does *not* round a `float` object in the mathematical sense! It just allows us to show an arbitrary number of the digits as stored in memory, and it also does *not* change these.\n",
+ "\n",
+ "On the contrary, the built-in [round() ](https://docs.python.org/3/library/functions.html#round) function creates a *new* numeric object that is a rounded version of the one passed in as the argument. It adheres to the common rules of math.\n",
+ "\n",
+ "For example, let's round `1 / 3` to five decimals. The obtained value for `roughly_a_third` is also *imprecise* but different from the \"exact\" representation of `1 / 3` above."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "roughly_a_third = round(1 / 3, 5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.33333"
+ ]
+ },
+ "execution_count": 54,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "roughly_a_third"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0.33333000000000001517008740847813896834850311279297'"
+ ]
+ },
+ "execution_count": 55,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "format(roughly_a_third, \".50f\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Surprisingly, `0.125` and `0.25` appear to be *precise*, and equality comparison works without the `threshold` workaround: Both are powers of $2$ in disguise."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0.12500000000000000000000000000000000000000000000000'"
+ ]
+ },
+ "execution_count": 56,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "format(0.125, \".50f\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0.25000000000000000000000000000000000000000000000000'"
+ ]
+ },
+ "execution_count": 57,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "format(0.25, \".50f\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 58,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0.125 + 0.125 == 0.25"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Binary Representations"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To understand these subtleties, we need to look at the **[binary representation of floats ](https://en.wikipedia.org/wiki/Double-precision_floating-point_format)** and review the basics of the **[IEEE 754 ](https://en.wikipedia.org/wiki/IEEE_754)** standard. On modern machines, floats are modeled in so-called double precision with $64$ bits that are grouped as in the figure below. The first bit determines the sign ($0$ for plus, $1$ for minus), the next $11$ bits represent an $exponent$ term, and the last $52$ bits resemble the actual significant digits, the so-called $fraction$ part. The three groups are put together like so:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "$$float = (-1)^{sign} * 1.fraction * 2^{exponent-1023}$$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A $1.$ is implicitly prepended as the first digit, and both, $fraction$ and $exponent$, are stored in base $2$ representation (i.e., they both are interpreted like integers above). As $exponent$ is consequently non-negative, between $0_{10}$ and $2047_{10}$ to be precise, the $-1023$, called the exponent bias, centers the entire $2^{exponent-1023}$ term around $1$ and allows the period within the $1.fraction$ part be shifted into either direction by the same amount. Floating-point numbers received their name as the period, formally called the **[radix point ](https://en.wikipedia.org/wiki/Radix_point)**, \"floats\" along the significant digits. As an aside, an $exponent$ of all $0$s or all $1$s is used to model the special values `nan` or `inf`.\n",
+ "\n",
+ "As the standard defines the exponent part to come as a power of $2$, we now see why `0.125` is a *precise* float: It can be represented as a power of $2$, i.e., $0.125 = (-1)^0 * 1.0 * 2^{1020-1023} = 2^{-3} = \\frac{1}{8}$. In other words, the floating-point representation of $0.125_{10}$ is $0_2$, $1111111100_2 = 1020_{10}$, and $0_2$ for the three groups, respectively."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "-"
+ }
+ },
+ "source": [
+ "![](\"static/floating_point.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The crucial fact for the data science practitioner to understand is that mapping the *infinite* set of the real numbers $\\mathbb{R}$ to a *finite* set of bits leads to the imprecisions shown above!\n",
+ "\n",
+ "So, floats are usually good approximations of real numbers only with their first $14$ or $15$ digits. If more precision is required, we need to revert to other data types such as a `Decimal` or a `Fraction`, as shown in the next two sections.\n",
+ "\n",
+ "This [blog post](http://fabiensanglard.net/floating_point_visually_explained/) gives another neat and *visual* way as to how to think of floats. It also explains why floats become worse approximations of the reals as their absolute values increase.\n",
+ "\n",
+ "The Python [documentation ](https://docs.python.org/3/tutorial/floatingpoint.html) provides another good discussion of floats and the goodness of their approximations.\n",
+ "\n",
+ "If we are interested in the exact bits behind a `float` object, we use the [.hex() ](https://docs.python.org/3/library/stdtypes.html#float.hex) method that returns a `str` object beginning with `\"0x1.\"` followed by the $fraction$ in hexadecimal notation and the $exponent$ as an integer after subtraction of $1023$ and separated by a `\"p\"`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "one_eighth = 1 / 8"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0x1.0000000000000p-3'"
+ ]
+ },
+ "execution_count": 60,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "one_eighth.hex()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Also, the [.as_integer_ratio() ](https://docs.python.org/3/library/stdtypes.html#float.as_integer_ratio) method returns the two smallest integers whose ratio best approximates a `float` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(1, 8)"
+ ]
+ },
+ "execution_count": 61,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "one_eighth.as_integer_ratio()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0x1.555475a31a4bep-2'"
+ ]
+ },
+ "execution_count": 62,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "roughly_a_third.hex()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(3002369727582815, 9007199254740992)"
+ ]
+ },
+ "execution_count": 63,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "roughly_a_third.as_integer_ratio()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`0.0` is also a power of $2$ and thus a *precise* `float` number."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "zero = 0.0"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0x0.0p+0'"
+ ]
+ },
+ "execution_count": 65,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "zero.hex()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(0, 1)"
+ ]
+ },
+ "execution_count": 66,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "zero.as_integer_ratio()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As seen in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#%28Data%29-Type-%2F-%22Behavior%22), the [.is_integer() ](https://docs.python.org/3/library/stdtypes.html#float.is_integer) method tells us if a `float` can be casted as an `int` object without any loss in precision."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 67,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 67,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "roughly_a_third.is_integer()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 68,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "one = roughly_a_third / roughly_a_third\n",
+ "\n",
+ "one.is_integer()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As the exact implementation of floats may vary and be dependent on a particular Python installation, we look up the [.float_info ](https://docs.python.org/3/library/sys.html#sys.float_info) attribute in the [sys ](https://docs.python.org/3/library/sys.html) module in the [standard library ](https://docs.python.org/3/library/index.html) to check the details. Usually, this is not necessary."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 69,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import sys"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 70,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)"
+ ]
+ },
+ "execution_count": 70,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sys.float_info"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/05_numbers/02_content.ipynb b/05_numbers/02_content.ipynb
new file mode 100644
index 0000000..701a414
--- /dev/null
+++ b/05_numbers/02_content.ipynb
@@ -0,0 +1,1519 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/05_numbers/02_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 5: Numbers & Bits (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In the third part of this chapter, we first look at the lesser known `complex` type. Then, we introduce a more abstract classification scheme for the numeric types."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `complex` Type"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "**What is the solution to $x^2 = -1$ ?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Some mathematical equations cannot be solved if the solution has to be in the set of the real numbers $\\mathbb{R}$. For example, $x^2 = -1$ can be rearranged into $x = \\sqrt{-1}$, but the square root is not defined for negative numbers. To mitigate this, mathematicians introduced the concept of an [imaginary number ](https://en.wikipedia.org/wiki/Imaginary_number) $\\textbf{i}$ that is *defined* as $\\textbf{i} = \\sqrt{-1}$ or often as the solution to the equation $\\textbf{i}^2 = -1$. So, the solution to $x = \\sqrt{-1}$ then becomes $x = \\textbf{i}$.\n",
+ "\n",
+ "If we generalize the example equation into $(mx-n)^2 = -1 \\implies x = \\frac{1}{m}(\\sqrt{-1} + n)$ where $m$ and $n$ are constants chosen from the reals $\\mathbb{R}$, then the solution to the equation comes in the form $x = a + b\\textbf{i}$, the sum of a real number and an imaginary number, with $a=\\frac{n}{m}$ and $b = \\frac{1}{m}$.\n",
+ "\n",
+ "Such \"compound\" numbers are called **[complex numbers ](https://en.wikipedia.org/wiki/Complex_number)**, and the set of all such numbers is commonly denoted by $\\mathbb{C}$. The reals $\\mathbb{R}$ are a strict subset of $\\mathbb{C}$ with $b=0$. Further, $a$ is referred to as the **real part** and $b$ as the **imaginary part** of the complex number.\n",
+ "\n",
+ "Complex numbers are often visualized in a plane like below, where the real part is depicted on the x-axis and the imaginary part on the y-axis."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "-"
+ }
+ },
+ "source": [
+ "![](\"static/complex_numbers.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`complex` numbers are part of core Python. The simplest way to create one is to write an arithmetic expression with the literal `j` notation for $\\textbf{i}$. The `j` is commonly used in many engineering disciplines instead of the symbol $\\textbf{i}$ from math as $I$ in engineering more often than not means [electric current ](https://en.wikipedia.org/wiki/Electric_current).\n",
+ "\n",
+ "For example, the answer to $x^2 = -1$ can be written in Python as `1j` like below. This creates a `complex` object with value `1j`. The same syntactic rules apply as with the above `e` notation: No spaces are allowed between the number and the `j`. The number may be any `int` or `float` literal; however, it is stored as a `float` internally. So, `complex` numbers suffer from the same imprecision as `float` numbers."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "x = 1j"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140084727448400"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(x)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "complex"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(x)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1j"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To verify that it solves the equation, let's raise it to the power of $2$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x ** 2 == -1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Often, we write an expression of the form $a + b\\textbf{i}$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(2+0.5j)"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "2 + 0.5j"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Alternatively, we may use the [complex() ](https://docs.python.org/3/library/functions.html#complex) built-in: This takes two parameters where the second is optional and defaults to `0`. We may either call it with one or two arguments of any numeric type or a `str` object in the format of the previous code cell without any spaces."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(2+0.5j)"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "complex(2, 0.5)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "By omitting the second argument, we set the imaginary part to $0$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(2+0j)"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "complex(2) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The arguments to [complex() ](https://docs.python.org/3/library/functions.html#complex) may be any numeric type or properly formated `str` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(2+0.5j)"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "complex(\"2+0.5j\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Arithmetic expressions work with `complex` numbers. They may be mixed with the other numeric types, and the result is always a `complex` number."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "c1 = 1 + 2j\n",
+ "c2 = 3 + 4j"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(4+6j)"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "c1 + c2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(-2-2j)"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "c1 - c2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(2+2j)"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "c1 + 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(0.5-4j)"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "3.5 - c2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(5+10j)"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "5 * c1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(0.5+0.6666666666666666j)"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "c2 / 6"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(-5+10j)"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "c1 * c2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(0.44+0.08j)"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "c1 / c2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A `complex` number comes with two **attributes** `.real` and `.imag` that return the two parts as `float` objects on their own."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.0"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x.real"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1.0"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x.imag"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Also, a `.conjugate()` method is bound to every `complex` object. The [complex conjugate ](https://en.wikipedia.org/wiki/Complex_conjugate) is defined to be the complex number with identical real part but an imaginary part reversed in sign."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-1j"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x.conjugate()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [cmath ](https://docs.python.org/3/library/cmath.html) module in the [standard library ](https://docs.python.org/3/library/index.html) implements many of the functions from the [math ](https://docs.python.org/3/library/math.html) module such that they work with complex numbers."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The Numerical Tower"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Analogous to the discussion of *containers* and *iterables* in [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/02_content.ipynb#Containers-vs.-Iterables), we contrast the *concrete* numeric data types in this chapter with the *abstract* ideas behind [numbers in mathematics ](https://en.wikipedia.org/wiki/Number).\n",
+ "\n",
+ "The figure below summarizes five *major* sets of [numbers in mathematics ](https://en.wikipedia.org/wiki/Number) as we know them from high school:\n",
+ "\n",
+ "- $\\mathbb{N}$: [Natural numbers ](https://en.wikipedia.org/wiki/Natural_number) are all non-negative count numbers, e.g., $0, 1, 2, ...$\n",
+ "- $\\mathbb{Z}$: [Integers ](https://en.wikipedia.org/wiki/Integer) are all numbers *without* a fractional component, e.g., $-1, 0, 1, ...$\n",
+ "- $\\mathbb{Q}$: [Rational numbers ](https://en.wikipedia.org/wiki/Rational_number) are all numbers that can be expressed as a quotient of two integers, e.g., $-\\frac{1}{2}, 0, \\frac{1}{2}, ...$\n",
+ "- $\\mathbb{R}$: [Real numbers ](https://en.wikipedia.org/wiki/Real_number) are all numbers that can be represented as a distance along a line, and negative means \"reversed,\" e.g., $\\sqrt{2}, \\pi, \\text{e}, ...$\n",
+ "- $\\mathbb{C}$: [Complex numbers ](https://en.wikipedia.org/wiki/Complex_number) are all numbers of the form $a + b\\textbf{i}$ where $a$ and $b$ are real numbers and $\\textbf{i}$ is the [imaginary number ](https://en.wikipedia.org/wiki/Imaginary_number), e.g., $0, \\textbf{i}, 1 + \\textbf{i}, ...$\n",
+ "\n",
+ "In the listed order, the five sets are perfect subsets of the respective following sets, and $\\mathbb{C}$ is the largest set. To be precise, all sets are infinite, but they still have a different number of elements."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "![](\"static/numbers.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The data types introduced in this chapter and its appendix are all *(im)perfect* models of *abstract* mathematical ideas.\n",
+ "\n",
+ "The `int` and `Fraction` types are the models \"closest\" to the idea they implement: Whereas $\\mathbb{Z}$ and $\\mathbb{Q}$ are, by definition, infinite, every computer runs out of bits when representing sufficiently large integers or fractions with a sufficiently large number of decimals. However, within a system-dependent range, we can model an integer or fraction without any loss in precision.\n",
+ "\n",
+ "For the other types, in particular, the `float` type, the implications of their imprecision are discussed in detail above.\n",
+ "\n",
+ "The abstract concepts behind the four outer-most mathematical sets are formalized in Python since [PEP 3141 ](https://www.python.org/dev/peps/pep-3141/) in 2007. The [numbers ](https://docs.python.org/3/library/numbers.html) module in the [standard library ](https://docs.python.org/3/library/index.html) defines what programmers call the **[numerical tower ](https://en.wikipedia.org/wiki/Numerical_tower)**, a collection of five **[abstract data types ](https://en.wikipedia.org/wiki/Abstract_data_type)**, or **abstract base classes** (ABCs) as they are called in Python jargon:\n",
+ "\n",
+ "- `Number`: \"any number\" (cf., [documentation ](https://docs.python.org/3/library/numbers.html#numbers.Number))\n",
+ "- `Complex`: \"all complex numbers\" (cf., [documentation ](https://docs.python.org/3/library/numbers.html#numbers.Complex))\n",
+ "- `Real`: \"all real numbers\" (cf., [documentation ](https://docs.python.org/3/library/numbers.html#numbers.Real))\n",
+ "- `Rational`: \"all rational numbers\" (cf., [documentation ](https://docs.python.org/3/library/numbers.html#numbers.Rational))\n",
+ "- `Integral`: \"all integers\" (cf., [documentation ](https://docs.python.org/3/library/numbers.html#numbers.Integral))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import numbers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['ABCMeta',\n",
+ " 'Complex',\n",
+ " 'Integral',\n",
+ " 'Number',\n",
+ " 'Rational',\n",
+ " 'Real',\n",
+ " '__all__',\n",
+ " '__builtins__',\n",
+ " '__cached__',\n",
+ " '__doc__',\n",
+ " '__file__',\n",
+ " '__loader__',\n",
+ " '__name__',\n",
+ " '__package__',\n",
+ " '__spec__',\n",
+ " 'abstractmethod']"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "dir(numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Duck Typing (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The primary purpose of ABCs is to classify the *concrete* data types and standardize how they behave. This guides us as the programmers in what kind of behavior we should expect from objects of a given data type. In this context, ABCs are not reflected in code but only in our heads.\n",
+ "\n",
+ "For, example, as all numeric data types are `Complex` numbers in the abstract sense, they all work with the built-in [abs() ](https://docs.python.org/3/library/functions.html#abs) function (cf., [documentation ](https://docs.python.org/3/library/numbers.html#numbers.Complex)). While it is intuitively clear what the [absolute value ](https://en.wikipedia.org/wiki/Absolute_value) (i.e., \"distance\" from $0$) of an integer, a fraction, or any real number is, [abs() ](https://docs.python.org/3/library/functions.html#abs) calculates the equivalent of that for complex numbers. That concept is called the [magnitude ](https://en.wikipedia.org/wiki/Magnitude_%28mathematics%29) of a number, and is really a *generalization* of the absolute value.\n",
+ "\n",
+ "Relating back to the concept of **duck typing** mentioned in [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/00_content.ipynb#Duck-Typing), `int`, `float`, and `complex` objects \"walk\" and \"quack\" alike in context of the [abs() ](https://docs.python.org/3/library/functions.html#abs) function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "abs(-1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42.87"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "abs(-42.87)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The absolute value of a `complex` number $x$ is defined with the Pythagorean Theorem where $\\lVert x \\rVert = \\sqrt{a^2 + b^2}$ and $a$ and $b$ are the real and imaginary parts."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "5.0"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "abs(3 + 4j)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "On the contrary, only `Real` numbers in the abstract sense may be rounded with the built-in [round() ](https://docs.python.org/3/library/functions.html#round) function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "100"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "round(123, -2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "round(42.1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`Complex` numbers are two-dimensional. So, rounding makes no sense here and leads to a `TypeError`. So, in the context of the [round() ](https://docs.python.org/3/library/functions.html#round) function, `int` and `float` objects \"walk\" and \"quack\" alike whereas `complex` objects do not."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "type complex doesn't define __round__ method",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[29], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43mround\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43mj\u001b[49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mTypeError\u001b[0m: type complex doesn't define __round__ method"
+ ]
+ }
+ ],
+ "source": [
+ "round(1 + 2j)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Goose Typing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Another way to use ABCs is in place of a *concrete* data type.\n",
+ "\n",
+ "For example, we may pass them as arguments to the built-in [isinstance() ](https://docs.python.org/3/library/functions.html#isinstance) function and check in which of the five mathematical sets the object `1 / 10` is."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(1 / 10, float)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A `float` object is a generic `Number` in the abstract sense but may also be seen as a `Complex` or `Real` number."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(1 / 10, numbers.Number)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(1 / 10, numbers.Complex)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(1 / 10, numbers.Real)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Due to the `float` type's inherent imprecision, `1 / 10` is *not* a `Rational` number."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(1 / 10, numbers.Rational)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, if we model `1 / 10` as a `Fraction` object (cf., [Appendix ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/03_appendix.ipynb#The-Fraction-Type)), it is recognized as a `Rational` number."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "from fractions import Fraction"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(Fraction(\"1/10\"), numbers.Rational)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Replacing *concrete* data types with ABCs is particularly valuable in the context of \"type checking:\" The revised version of the `factorial()` function below allows its user to take advantage of *duck typing*: If a real but non-integer argument `n` is passed in, `factorial()` tries to cast `n` as an `int` object with the [int() ](https://docs.python.org/3/library/functions.html#int) built-in.\n",
+ "\n",
+ "Two popular and distinguished Pythonistas, [Luciano Ramalho ](https://github.com/ramalho) and [Alex Martelli ](https://en.wikipedia.org/wiki/Alex_Martelli), coin the term **goose typing** to specifically mean using the built-in [isinstance() ](https://docs.python.org/3/library/functions.html#isinstance) function with an ABC (cf., Chapter 11 in this [book](https://www.amazon.com/Fluent-Python-Concise-Effective-Programming/dp/1491946008) or this [summary](https://dgkim5360.github.io/blog/python/2017/07/duck-typing-vs-goose-typing-pythonic-interfaces/) thereof)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "### Example: [Factorial ](https://en.wikipedia.org/wiki/Factorial) (revisited)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def factorial(n, *, strict=True):\n",
+ " \"\"\"Calculate the factorial of a number.\n",
+ "\n",
+ " Args:\n",
+ " n (int): number to calculate the factorial for; must be positive\n",
+ " strict (bool): if n must not contain decimals; defaults to True;\n",
+ " if set to False, the decimals in n are ignored\n",
+ "\n",
+ " Returns:\n",
+ " factorial (int)\n",
+ "\n",
+ " Raises:\n",
+ " TypeError: if n is not an integer or cannot be cast as such\n",
+ " ValueError: if n is negative\n",
+ " \"\"\"\n",
+ " if not isinstance(n, numbers.Integral):\n",
+ " if isinstance(n, numbers.Real):\n",
+ " if n != int(n) and strict:\n",
+ " raise TypeError(\"n is not integer-like; it has non-zero decimals\")\n",
+ " n = int(n)\n",
+ " else:\n",
+ " raise TypeError(\"Factorial is only defined for integers\")\n",
+ "\n",
+ " if n < 0:\n",
+ " raise ValueError(\"Factorial is not defined for negative integers\")\n",
+ " elif n == 0:\n",
+ " return 1\n",
+ " return n * factorial(n - 1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`factorial()` works as before, but now also accepts, for example, `float` numbers."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 39,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 40,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3.0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With the keyword-only argument `strict`, we can control whether or not a passed in `float` object may come with decimals that are then truncated. By default, this is not allowed and results in a `TypeError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "n is not integer-like; it has non-zero decimals",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[41], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3.1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[37], line 19\u001b[0m, in \u001b[0;36mfactorial\u001b[0;34m(n, strict)\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(n, numbers\u001b[38;5;241m.\u001b[39mReal):\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mint\u001b[39m(n) \u001b[38;5;129;01mand\u001b[39;00m strict:\n\u001b[0;32m---> 19\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mn is not integer-like; it has non-zero decimals\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 20\u001b[0m n \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(n)\n\u001b[1;32m 21\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
+ "\u001b[0;31mTypeError\u001b[0m: n is not integer-like; it has non-zero decimals"
+ ]
+ }
+ ],
+ "source": [
+ "factorial(3.1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In non-strict mode, the passed in `3.1` is truncated into `3` resulting in a factorial of `6`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "factorial(3.1, strict=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For `complex` numbers, `factorial()` still raises a `TypeError` because they are neither an `Integral` nor a `Real` number."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "Factorial is only defined for integers",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[43], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfactorial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43mj\u001b[49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[37], line 22\u001b[0m, in \u001b[0;36mfactorial\u001b[0;34m(n, strict)\u001b[0m\n\u001b[1;32m 20\u001b[0m n \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(n)\n\u001b[1;32m 21\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 22\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFactorial is only defined for integers\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 24\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 25\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFactorial is not defined for negative integers\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+ "\u001b[0;31mTypeError\u001b[0m: Factorial is only defined for integers"
+ ]
+ }
+ ],
+ "source": [
+ "factorial(1 + 2j)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/05_numbers/03_appendix.ipynb b/05_numbers/03_appendix.ipynb
new file mode 100644
index 0000000..4ab003b
--- /dev/null
+++ b/05_numbers/03_appendix.ipynb
@@ -0,0 +1,1508 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/05_numbers/03_appendix.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 5: Numbers & Bits (Appendix)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In this appendix, we look at the `Decimal` and `Fraction` types that can be used as replacements for the built-in `float` type mitigating its imprecision. The content is put in an appendix as the data science practitioner can live without knowing about it for quite some time. Eventually, when working with financial data, for example, knowing how to not use the `float` type in a bad way pays off."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `Decimal` Type"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [decimal ](https://docs.python.org/3/library/decimal.html) module in the [standard library ](https://docs.python.org/3/library/index.html) provides a [Decimal ](https://docs.python.org/3/library/decimal.html#decimal.Decimal) type that may be used to represent any real number to a user-defined level of precision: \"User-defined\" does *not* mean an infinite or exact precision! The `Decimal` type merely allows us to work with a number of bits *different* from the $64$ as specified for the `float` type and also to customize the rounding rules and some other settings.\n",
+ "\n",
+ "We import the `Decimal` type and also the [getcontext() ](https://docs.python.org/3/library/decimal.html#decimal.getcontext) function from the [decimal ](https://docs.python.org/3/library/decimal.html) module."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "from decimal import Decimal, getcontext"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[getcontext() ](https://docs.python.org/3/library/decimal.html#decimal.getcontext) shows us how the [decimal ](https://docs.python.org/3/library/decimal.html) module is set up. By default, the precision is set to `28` significant digits, which is roughly twice as many as with `float` objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "getcontext()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The two simplest ways to create a `Decimal` object is to either **instantiate** it with an `int` or a `str` object consisting of all the significant digits. In the latter case, the scientific notation is also possible."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('42')"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('0.1')"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(\"0.1\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('0.001')"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(\"1e-3\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "It is *not* a good idea to create a `Decimal` from a `float` object. If we did so, we would create a `Decimal` object that internally used extra bits to store the \"random\" digits that are not stored in the `float` object in the first place."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('0.1000000000000000055511151231257827021181583404541015625')"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(0.1) # do not do this!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With the `Decimal` type, the imprecisions in the arithmetic and equality comparisons go away."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('0.3')"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(\"0.1\") + Decimal(\"0.2\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(\"0.1\") + Decimal(\"0.2\") == Decimal(\"0.3\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`Decimal` numbers *preserve* the **significant digits**, even in cases where this is not needed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('0.30000')"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(\"0.10000\") + Decimal(\"0.20000\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(\"0.10000\") + Decimal(\"0.20000\") == Decimal(\"0.3\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Arithmetic operations between `Decimal` and `int` objects work as the latter are inherently precise: The results are *new* `Decimal` objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('42')"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "21 + Decimal(21)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('42.0')"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "10 * Decimal(\"4.2\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('0.1')"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(1) / 10"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To verify the precision, we apply the built-in [format() ](https://docs.python.org/3/library/functions.html#format) function to the previous code cell and compare it with the same division resulting in a `float` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0.10000000000000000000000000000000000000000000000000'"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "format(Decimal(1) / 10, \".50f\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0.10000000000000000555111512312578270211815834045410'"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "format(1 / 10, \".50f\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, mixing `Decimal` and `float` objects raises a `TypeError`: So, Python prevents us from potentially introducing imprecisions via innocent-looking arithmetic by **failing loudly**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "unsupported operand type(s) for *: 'float' and 'decimal.Decimal'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[16], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;241;43m1.0\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mDecimal\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m42\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for *: 'float' and 'decimal.Decimal'"
+ ]
+ }
+ ],
+ "source": [
+ "1.0 * Decimal(42)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To preserve the precision for more advanced mathematical functions, `Decimal` objects come with many **methods bound** on them. For example, [ln() ](https://docs.python.org/3/library/decimal.html#decimal.Decimal.ln) and [log10() ](https://docs.python.org/3/library/decimal.html#decimal.Decimal.log10) take the logarithm while [sqrt() ](https://docs.python.org/3/library/decimal.html#decimal.Decimal.sqrt) calculates the square root. The methods always return a *new* `Decimal` object. We must never use the functions in the [math ](https://docs.python.org/3/library/math.html) module in the [standard library ](https://docs.python.org/3/library/index.html) with `Decimal` objects as they do *not* preserve precision."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('2')"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(100).log10()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('1.414213562373095048801688724')"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(2).sqrt()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The object returned by the [sqrt() ](https://docs.python.org/3/library/decimal.html#decimal.Decimal.sqrt) method is still limited in precision: This must be so as, for example, $\\sqrt{2}$ is an **[irrational number ](https://en.wikipedia.org/wiki/Irrational_number)** that *cannot* be expressed with absolute precision using *any* number of bits, even in theory.\n",
+ "\n",
+ "We see this as raising $\\sqrt{2}$ to the power of $2$ results in an imprecise value as before!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('1.999999999999999999999999999')"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "two = Decimal(2).sqrt() ** 2\n",
+ "\n",
+ "two"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, the [quantize() ](https://docs.python.org/3/library/decimal.html#decimal.Decimal.quantize) method allows us to [quantize](https://www.dictionary.com/browse/quantize) (i.e., \"round\") a `Decimal` number at any precision that is *smaller* than the set precision. It takes the number of decimals to the right of the period of the `Decimal` argument we pass in and rounds accordingly.\n",
+ "\n",
+ "For example, as the overall imprecise value of `two` still has an internal precision of `28` digits, we can correctly round it to *four* decimals (i.e., `Decimal(\"0.0000\")` has four decimals)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('2.0000')"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "two.quantize(Decimal(\"0.0000\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We can never round a `Decimal` number and obtain a greater precision than before: The `InvalidOperation` exception tells us that *loudly*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "InvalidOperation",
+ "evalue": "[]",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mInvalidOperation\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[21], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtwo\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mquantize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mDecimal\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m1e-28\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mInvalidOperation\u001b[0m: []"
+ ]
+ }
+ ],
+ "source": [
+ "two.quantize(Decimal(\"1e-28\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Consequently, with this little workaround $\\sqrt{2}^2 = 2$ works, even in Python."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "two.quantize(Decimal(\"0.0000\")) == 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The downside is that the entire expression is not as pretty as `sqrt(2) ** 2 == 2`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(Decimal(2).sqrt() ** 2).quantize(Decimal(\"0.0000\")) == 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`nan` and positive and negative `inf` exist as well, and the same remarks from the discussion of the `float` type apply."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('NaN')"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(\"nan\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`Decimal(\"nan\")`s never compare equal to anything, not even to themselves."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(\"nan\") == Decimal(\"nan\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Infinity is larger than any concrete number."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('Infinity')"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(\"inf\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('-Infinity')"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(\"-inf\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Decimal('Infinity')"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(\"inf\") + 42"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Decimal(\"inf\") + 42 == Decimal(\"inf\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As with `float` objects, we cannot add infinities of different signs: Now, get a module-specific `InvalidOperation` exception instead of a `nan` value. Here, **failing loudly** is a good thing as it prevents us from working with invalid results."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "InvalidOperation",
+ "evalue": "[]",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mInvalidOperation\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[30], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mDecimal\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43minf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mDecimal\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m-inf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mInvalidOperation\u001b[0m: []"
+ ]
+ }
+ ],
+ "source": [
+ "Decimal(\"inf\") + Decimal(\"-inf\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "InvalidOperation",
+ "evalue": "[]",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mInvalidOperation\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[31], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mDecimal\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43minf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mDecimal\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43minf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mInvalidOperation\u001b[0m: []"
+ ]
+ }
+ ],
+ "source": [
+ "Decimal(\"inf\") - Decimal(\"inf\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For more information on the `Decimal` type, see the tutorial at [PYMOTW](https://pymotw.com/3/decimal/index.html) or the official [documentation ](https://docs.python.org/3/library/decimal.html)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `Fraction` Type"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If the numbers in an application can be expressed as [rational numbers ](https://en.wikipedia.org/wiki/Rational_number) (i.e., the set $\\mathbb{Q}$), we may model them as a [Fraction ](https://docs.python.org/3/library/fractions.html#fractions.Fraction) type from the [fractions ](https://docs.python.org/3/library/fractions.html) module in the [standard library ](https://docs.python.org/3/library/index.html). As any fraction can always be formulated as the division of one integer by another, `Fraction` objects are inherently precise, just as `int` objects on their own. Further, we maintain the precision as long as we do not use them in a mathematical operation that could result in an irrational number (e.g., taking the square root).\n",
+ "\n",
+ "We import the `Fraction` type from the [fractions ](https://docs.python.org/3/library/fractions.html) module."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "from fractions import Fraction"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Among others, there are two simple ways to create a `Fraction` object: We either instantiate one with two `int` objects representing the numerator and denominator or with a `str` object. In the latter case, we have two options again and use either the format \"numerator/denominator\" (i.e., *without* any spaces) or the same format as for `float` and `Decimal` objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Fraction(1, 3)"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fraction(1, 3) # 1 / 3 with \"full\" precision"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Fraction(1, 3)"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fraction(\"1/3\") # 1 / 3 with \"full\" precision"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Fraction(3333333333, 10000000000)"
+ ]
+ },
+ "execution_count": 35,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fraction(\"0.3333333333\") # 1 / 3 with a precision of 10 significant digits"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Fraction(3333333333, 10000000000)"
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fraction(\"3333333333e-10\") # scientific notation is also allowed"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Only the lowest common denominator version is maintained after creation: For example, $\\frac{3}{2}$ and $\\frac{6}{4}$ are the same, and both become `Fraction(3, 2)`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Fraction(3, 2)"
+ ]
+ },
+ "execution_count": 37,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fraction(3, 2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Fraction(3, 2)"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fraction(6, 4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We could also cast a `Decimal` object as a `Fraction` object: This only makes sense as `Decimal` objects come with a pre-defined precision."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Fraction(1, 10)"
+ ]
+ },
+ "execution_count": 39,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fraction(Decimal(\"0.1\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`float` objects may *syntactically* be cast as `Fraction` objects as well. However, then we create a `Fraction` object that precisely remembers the `float` object's imprecision: A *bad* idea!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Fraction(3602879701896397, 36028797018963968)"
+ ]
+ },
+ "execution_count": 40,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fraction(0.1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`Fraction` objects follow the arithmetic rules from middle school and may be mixed with `int` objects *without* any loss of precision. The result is always a *new* `Fraction` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Fraction(7, 4)"
+ ]
+ },
+ "execution_count": 41,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fraction(3, 2) + Fraction(1, 4)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Fraction(1, 2)"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fraction(5, 2) - 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Fraction(1, 1)"
+ ]
+ },
+ "execution_count": 43,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "3 * Fraction(1, 3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Fraction(1, 1)"
+ ]
+ },
+ "execution_count": 44,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fraction(3, 2) * Fraction(2, 3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`Fraction` and `float` objects may also be mixed *syntactically*. However, then the results may exhibit imprecision again, even if we do not see them at first sight! This is another example of code **failing silently**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.1"
+ ]
+ },
+ "execution_count": 45,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "10.0 * Fraction(1, 100) # do not do this!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0.10000000000000000555111512312578270211815834045410'"
+ ]
+ },
+ "execution_count": 46,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "format(10.0 * Fraction(1, 100), \".50f\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For more examples and discussions, see the tutorial at [PYMOTW](https://pymotw.com/3/fractions/index.html) or the official [documentation ](https://docs.python.org/3/library/fractions.html)."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/05_numbers/04_summary.ipynb b/05_numbers/04_summary.ipynb
new file mode 100644
index 0000000..ad1ebde
--- /dev/null
+++ b/05_numbers/04_summary.ipynb
@@ -0,0 +1,85 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 5: Numbers & Bits (TL;DR)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "There exist three numeric types in core Python:\n",
+ "- `int`: a near-perfect model for whole numbers (i.e., $\\mathbb{Z}$); inherently precise\n",
+ "- `float`: the \"gold\" standard to approximate real numbers (i.e., $\\mathbb{R}$); inherently imprecise\n",
+ "- `complex`: layer on top of the `float` type to approximate complex numbers (i.e., $\\mathbb{C}$); inherently imprecise\n",
+ "\n",
+ "Furthermore, the [standard library ](https://docs.python.org/3/library/index.html) provides two more types that can be used as substitutes for the `float` type:\n",
+ "- `Decimal`: similar to `float` but allows customizing the precision; still inherently imprecise\n",
+ "- `Fraction`: a near-perfect model for rational numbers (i.e., $\\mathbb{Q}$); built on top of the `int` type and therefore inherently precise\n",
+ "\n",
+ "The *important* takeaways for the data science practitioner are:\n",
+ "\n",
+ "1. **Do not mix** precise and imprecise data types, and\n",
+ "2. actively expect `nan` results when working with `float` numbers as there are no **loud failures**.\n",
+ "\n",
+ "The **numerical tower** is Python's way of implementing various **abstract** ideas of what numbers are in mathematics."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/05_numbers/05_review.ipynb b/05_numbers/05_review.ipynb
new file mode 100644
index 0000000..9c0a424
--- /dev/null
+++ b/05_numbers/05_review.ipynb
@@ -0,0 +1,327 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 5: Numbers & Bits (Review Questions)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The questions below assume that you have read the [first ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/00_content.ipynb), [second ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/01_content.ipynb), and the [third ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/02_content.ipynb) part of Chapter 5. Some questions regard the [Appendix ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/03_appendix.ipynb); that is indicated with a **\\***.\n",
+ "\n",
+ "Be concise in your answers! Most questions can be answered in *one* sentence."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Essay Questions "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Answer the following questions briefly with *at most* 300 characters per question!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: In what way is the **binary representation** of `int` objects *similar* to the **decimal system** taught in elementary school?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: Why may objects of type `bool` be regarded a **numeric type** as well?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: Colors are commonly expressed in the **hexadecimal system** in websites (cf., the [HTML ](https://en.wikipedia.org/wiki/HTML) and [CSS ](https://en.wikipedia.org/wiki/Cascading_Style_Sheets) formats).\n",
+ "\n",
+ "For example, $#000000$, $#ff9900$, and $#ffffff$ turn out to be black, orange, and white. The six digits are read in *pairs of two* from left to right, and the *three pairs* correspond to the proportions of red, green, and blue mixed together. They reach from $0_{16} = 0_{10}$ for $0$% to $\\text{ff}_{16} = 255_{10}$ for $100$% (cf., this [article ](https://en.wikipedia.org/wiki/RGB_color_model) for an in-depth discussion).\n",
+ "\n",
+ "In percent, what are the proportions of red, green, and blue that make up orange? Calculate the three percentages separately! How many **bytes** are needed to encode a color? How many **bits** are that?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: What does it mean for a code fragment to **fail silently**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: Explain why the mathematical set of all real numbers $\\mathbb{R}$ can only be **approximated** by floating-point numbers on a computer!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: How do we deal with a `float` object's imprecision if we need to **check for equality**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7**: What data type, built-in or from the [standard library ](https://docs.python.org/3/library/index.html), is best suited to represent the [transcendental numbers ](https://en.wikipedia.org/wiki/Transcendental_number) $\\pi$ and $\\text{e}$?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q8**: How can **abstract base classes**, for example, as defined in the **numerical tower**, be helpful in enabling **duck typing**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## True / False Questions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Motivate your answer with *one short* sentence!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q9**: The precision of `int` objects depends on how we choose to represent them in memory. For example, using a **hexadecimal representation** gives us $16^8$ digits whereas with a **binary representation** an `int` object can have *at most* $2^8$ digits."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q10**: With the built-in [round() ](https://docs.python.org/3/library/functions.html#round) function, we obtain a *precise* representation for any `float` object if we can live with *less than* $15$ digits of precision."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q11**: As most currencies operate with $2$ or $3$ decimals (e.g., EUR $9.99$), the `float` type's limitation of *at most* $15$ digits is *not* a problem in practice."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q12**: The [IEEE 754 ](https://en.wikipedia.org/wiki/IEEE_754) standard's **special values** provide no benefit in practice as we could always use a **[sentinel ](https://en.wikipedia.org/wiki/Sentinel_value)** value (i.e., a \"dummy\"). For example, instead of `nan`, we can always use `0` to indicate a *missing* value."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q13**: The following code fragment raises an `InvalidOperation` exception. That is an example of code **failing loudly**.\n",
+ "```python\n",
+ "float(\"inf\") + float(\"-inf\")\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q14**: Python provides a `scientific` type (e.g., `1.23e4`) that is useful mainly to model problems in the domains of physics or astrophysics."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q15**: From a practitioner's point of view, the built-in [format() ](https://docs.python.org/3/library/functions.html#format) function does the *same* as the built-in [round() ](https://docs.python.org/3/library/functions.html#round) function."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q16\\***: The `Decimal` type from the [decimal ](https://docs.python.org/3/library/decimal.html) module in the [standard library ](https://docs.python.org/3/library/index.html) allows us to model the set of the real numbers $\\mathbb{R}$ *precisely*."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q17\\***: The `Fraction` type from the [fractions ](https://docs.python.org/3/library/fractions.html) module in the [standard library ](https://docs.python.org/3/library/index.html) allows us to model the set of the rational numbers $\\mathbb{Q}$ *precisely*."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/05_numbers/06_resources.ipynb b/05_numbers/06_resources.ipynb
new file mode 100644
index 0000000..76db27c
--- /dev/null
+++ b/05_numbers/06_resources.ipynb
@@ -0,0 +1,318 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/05_numbers/06_resources.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 5: Numbers & Bits (Further Resources)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Working with Bits"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The two videos below show how addition and multiplication works with numbers in their binary representations. Subtraction is a bit more involved as we need to understand how negative numbers are represented in binary with the concept of [Two's Complement ](https://en.wikipedia.org/wiki/Two%27s_complement) first. A video on that is shown further below. Division in binary is actually also quite simple."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from IPython.display import YouTubeVideo\n",
+ "YouTubeVideo(\"RgklPQ8rbkg\", width=\"60%\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "YouTubeVideo(\"xHWKYFhhtJQ\", width=\"60%\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The video below explains the idea behind [Two's Complement ](https://en.wikipedia.org/wiki/Two%27s_complement). This is how most modern programming languages implement negative integers. The video also shows how subtraction in binary works."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdASFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2MBERISGBUYLxoaL2NCOEJjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY//AABEIAWgB4AMBIgACEQEDEQH/xAAbAAEAAwEBAQEAAAAAAAAAAAAAAQIDBAYFB//EAD8QAAICAQICCAIHBgUEAwAAAAABAhEDBBIhMQUTFkFRU5LSImEUMnGBkaHRBhVCUrHBIzVD4fBygrLxJTNi/8QAGQEBAQEBAQEAAAAAAAAAAAAAAAECAwQF/8QAIREBAQEBAAICAgMBAAAAAAAAAAERAgMSIVExQQQTUiL/2gAMAwEAAhEDEQA/APz8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHo+xfSPnaX1S9o7F9I+dpfVL2gecB6PsX0l52l9cvaT2K6S87S+uXtA82D0fYrpLztL65e0nsV0l52l9cvaB5sHo+xXSXnaX1y9pPYrpLz9L65e0DzYPR9iukvO0vql7R2K6S87S+qXtA84D0nYrpLztL65e0diukvO0vrl7QPNg9J2K6S8/SeuXtHYrpLz9J65e0DzYPSdiekvP0nrl7R2J6S87SeuXtA82D0nYnpLz9J65e0diekvP0nrl7QPNg9J2J6S8/SeuXtJ7E9JefpPXL2geaB6XsT0l5+k9cvaR2J6S8/SeuXtA82D0vYnpLz9J65e0jsT0l5+k9cvaB5sHpOxPSXn6T1y9o7E9JefpPXL2gebB6TsV0l5+k9cvaOxXSXn6T1y9oHmwek7FdJefpPXL2jsV0l5+k9cvaB5sHo+xXSXn6X1y9o7FdJefpfXL2gecB6PsV0l5+l9cvaOxXSXn6X1y9oHnAej7FdJefpfXL2jsV0l5+l9cvaB5wHpOxXSXn6X1y9o7FdJefpPXL2gebB6TsV0l5+k9cvaOxXSXn6T1y9oHmwek7FdJefpPXL2jsT0l5+k9cvaB5sHpOxPSXn6T1y9o7E9JefpPXL2gebB6XsT0l5+k9cvaOxPSXn6T1y9oHmgel7E9JefpPXL2jsT0l5+k9cvaB5oH3Nf+yuu0GknqcuXTyhCrUZSvi68D5H0efigMga9RLxQ+jz8YgZA1+jy8Yj6PLxiBkDX6PPxiPo8vGIGQNfo8/FD6PPxiBkDX6PPxiPo8/GIH6zRNEgqIokAACaFEEAkUBAJAVFEgAACQAAAAAAAAAAAEEgCCCxAEAMAQCSAABAAAAAAAJIAEggAWBBIEgACQQSAIJAHyf2n/AMi1H/b/AOSPAnv/ANpv8i1H/b/5I8AAAAAAAAAAAFAAAB+pAAqBIAAEggrOShCUnySsrDJudSi4Sq6fgWnHfBxfCyixvepTluaTSpUGpmHX42m07r5c/s8SVlg3BJ/XVplfo+J41BxuKjt4+AeCD23uqPdudBf+WwIJDKsnUW0rpcjGMoYsPW7tza48eZ0FVCKuoxTfPhzCysnqJOlDHcraa3eCsrPNm2wqCjJy2tPj9h0JJKkqQlFSST7mn+AXZ9OebyYsjcI2pZFubV0qX6ErNmkt0cPBNppvjwOgA9p9MHly7nWN05bVw5fNjJHLkxQr4JKSb/E3APb6guQADIAABAAEAEAACAAIsiwJsiyBYE2LK2LAtYsrYsC9grZNgWRJSyQLiytk2BYEImwBJAA+Z+0v+Ran7F/5I/Pz9A/aT/I9T9i/qj8+YAAACSABIIsmwAIJAAAD9SABUSASQAAAAAVXdHfsv4quvkVy5ceFReSajukoq+9srPE3qceVOtsZRa8br9CmqwzySxzgoT2XcJ8nYHQ3St8hGUZRUotNPk0c/wBGl+73pt/xODju7uP9hpMU8bySlCGJSarHB2uXF/f/AGA2eXGsixucVNq1G+Jc4s+mzSyZNmzbkcXub4wa8OHHkdoAAiUVKLi7pqnToDJ6rFHL1UnKMm6VwaTf21Rsc08DTwRjulGOTdJyldfC/H50dIAAAAAAAIAEEOcVJRbpvkiHkik25JJOiokFXNKUV/NyJsAQw2Y5M23J1cY7pVfOh+Tcasgi+BWwqWyLIsiyC1kWVbIsC9k2Z2LA0slMzTJTA0smylk2BeybOXNq4YY22fH1P7ROE9uLGn8yaSa9HYs8/p+m+ta3OmfTw6yM1zGmO6ybMo5FJcy1lHB+0T/+D1X/AEr+qPz5nv8A9oHfQeq/6V/VH5+AAAEggASCCQBJAAAkgD9TAJKgSAQAAAAAVhPI1rsWPdwljm2vGnH9WZ63JKGTHeWWHDTcpxSfHhSdp8Of4G88ijnx43HjNSqXhVcP+eBnnzzhkx4sWNZJzTdOW1JKrf5oCY5Mr0ayOH+L1e7b865GWizvLJxWZZoqCbko1T48GdOHIsuGGRKt0U68CMWXrN/Cts3ECmoc1kwbbp5KlXhtf+xuc+fLOOfHhxKLlNOTcnwSVfqjTBlWbDDIlW5XQGhEm1FtLc0uXiSAOHL0h1GeMcsHBbN22rlz+T+X5o7jmzywS1EIywdblh8SqKey++3y5fkdJQABAAIAEXd/Ikyhi2TnLc3u8WVFckJuTqqbTtviqEsVxkrX1tytcBkU25qNq4quPfxK7cksDi/rO+b/AANazi0cdRxqUrcON+PAuZvF/j9apNPvXiWZmrBsy+HJJT4/DaQ2TWZzc7jVbaKY4vZtmvq8E75lE9fFpSVuL4WXswlCSw9XF3fe+5F2xcJv7WbKtlXIq5GWl9xG4zciNwGjkNxluG4DbcSpGO4rPNGC4sDp3UuJy6rXRxRdNHz9V0jXCJ82c55ZXJmb1jU51rqtVPUOk3RjDAnzRpCNG8Uc7ddpzjn6hLiuBti1MsL48jTaZzxk3FvL6ml16kuZ9HFnjNczytSxu4nbpda1wlzOk6crw+p0876E1X/R/dHgD2fSeoWTofUxvnD+54tm3NIIsASAABIACwQAJJIQA/VAAVEgAgAAAAArPJjhOeNydSg90ePyr+5TVY8Th1mWThs/jjJxaXgWyQlLNhkuUW7/AAGoxSyxioyUZRkpK1adeIE4HjeGHVf/AFpUvlREFjhlyKL+OVTkr+6/yGnxdTjcXLdJycm6ri3Y6p/Snlvg4KNfff8AcBnxYcsEs8ITin/GrSNIpRioxSSXBJdxnqcby4JQjSk6av5OzUAVy445YbZ3XybT/IuVlbi1F0+5tWBzPT3qseTfGsfBcPifDk3fLvOo4npskdZhyue9OTc0o0r2tWdoAAAQAAiDOWKDbbjxfenTNCtlMZqEWnUp0nX1mUax9Wp/G065yff95pGNKSb4Ntoq4R6rq3xVUXUxnLFheRQePmrs15KlyRVpWn3rkyGyWrIiajNVJWjDJHFCEpOFqJrKRhNQe64r4lTEqWEY4ZcoK1zTXFFbhj3uLlwXFW2VVQvi23zbM6jFyav4uduy6SN96aso5GW9JUirmRWrkV3mLmV6wiujeN5zPIl3nPm1VcmDHZl1KguDPm6jVSk6TMJ5Z5GWx4Wc+unXnhSMHJ2zaMKNYY6L7eBh0ZpJF4FOTLwfEjTXaNlkriaKIVzyxHPkwtcUfQ2lJwsI+bklN4J43ykqPlZcNH38mI4s2nvuNTpz65fFapg6s2BruOVpo6y642YEkElRLBBIAcgAABIH6kSAVEgAgAAAAArPJk2Txxq3OVfZwb/saFZY4zlCTXGDtfhX9ywGWmyPLhUpVdtOvk2v7GU9TOOTLJRj1OKSjN9/JNv7rX5nTFRS+FJJ8eBjPBp5Z05Rj1j+Kr513td4E6vJPFhTxuKlKSinPkrfNk6bK8sJbtrcJOLceT+wvk2dXLrNuyvi3cqJjFQioxSSXJJAWIbSTbdJc2SQByw1inq444ZMU8c4uUXGVvhX3M6jla009VFdZ/iQd9WpcLrw8eJ1AAABDIJZDYRDZRsSkYZsmyEpeCso1cirkcc9Zshc4006lT5cLIz6iUHUf5W/wouVNdUpmcpmLypqzKeYitpZDF5ouTipJtd1mMsyOTc/pDmmkuTV3/6EhXe5mTyHLPUKP1pVZV5QOlzKOZzPKR1hFbuZDmYPIUeSwsmtMmRnM05M0pyNIYzla688qY8dG8VRFURuSMumNbKzlSM3liu8xyZ1VJkEyycS+LJbONybZridFH0oS4GikccMvA1WQiujciTnUy6mBMomM4I3uykkBwZcKd8Dhy6bwPsyhZlPEiy4zedfBlp2inVyR9fJh+RzyxtPkbnTneHBta7gdnV2HpbRfZn0cRJtPTuJi1RrWbMAAVH6mAgESAAAACgAA58kZPX4JU9scc7fddx/3Ogznkcc2KFcJ3x8KRoBjpYSxYI45pJxbSp918Pyowlpsj1U5bY7ZTjNZL4xSSVL8H+LOjSzlk08JT4yqpP5rgxknKOpwwTW2alf2qq/uBOox9dp8uL+eDj+KLxvar51xMdXkljwrbLY5yUFL+W3zJ0uR5IzTlv2TcVP+b/nL7gNyHxRJWbkoNwipS7k3Vgc88eZZdPtXWRhblKUqd8l3eDZ0mG6X0vGpJpSxvgnaTTX6m4AAAQ2UZdlGBz58sce3c63Ojm1GSUU/htHXmi2vhjFv/8ARzTjlf8ADj9T/Q0zr4uXpHqoUsKSvu5HHPp6a/gZ9nPo5ZE/ggvsPj6vo7LG3GCYGX77nL+GSIfSeV8vzRyyw5Iv4oBQ+VHTnmVy67sdH7xyfxJFoayCSXLxZyuJRxNXxxmeSu2OaNzV2ny/QvFvYk3xo+a4i5RdpszeK3PJH0rZDbOBanJHm7NI6py4bTnebHSdSum2y8VxMY7p8kXUMi7zja9HMdUaRfcclyXeOtaMujqlIwySszeVsq5NkUfEo6REp0c2XK+5liWutNNmqSPmwzO+LOqGdVzGM66d1ErNXec0sya5mTnufMYuu9ahN8GdGKTkcGCK4HdjkkiNOmJYxWQvGVkFqKSibJBpBlzSgmYZMPyOxohxsNPmvHTNIRN8mMy+qwljPNiVHzdRDaz603cT5+pXM3y59RwEgHVxfqaJIRIQAAAABQAAZ5IweXFKUqlFvb8+BoZZsbm8TjVwmpcfCmn/AFNQKYnBxfV1Sk06Vcb4kSlj66EGl1lOUeHJcn/UjDjePrLr4puSomWK9Rjyp1tjKLXjdfoBecYyg1OKlF801dlcLhLDCWKurcU40q4FzLS4fo+mx4W93VxUb+wDYrKUYRcpSUYrm26SLENWqYGGTV4oT28WlFSlKKtRT72zc5smixzy705RjSUoRpKVO1f4s6QAAAgqyzKlFGjOcbTXiasq0EcjxSrFyuPP58CmTDuyJ/w1TR1yRSSGmPlajo9Stx7z5Wp0GWHFQf4Hp2jOSNTuxjriV4+WOUecWijR6zJhxz+tBM5M3R2GfJUdJ5HO+L6ecaKtH183RbX1Gzhy6TJB8jc6lYvFjk2Wzpw4kikYNS4o6YKjl5K7+KNYqkS2V3OuBV2zyvZBlJI0RLVoiuaTozeVIvmVHDlltZZEtaznZk+Jn1qJ6wuM6s+BG9lHJkWVF97febYWcxeEtrA+pilSNoyk3wODFlO3FJWYsbldeODfNnRFUjDHNGqyIy3reJajOHE2VBKptG00dFWwRz5VwOOfM7cpx5OYVTuZx6jkzr7jlzrma5c+nz3zIJnwkQdXB+pokgFRIAAAAKAADl1mXbLHj63qt9tz8EvC+/8A3L4smSejjkcf8R492351yI1GfDCcMWSLnKabUVBy4Lv/ADNVkg8XWKVwq7+QHNpNRLLNR6yGVOG5yiq2vwf/ADuKavLk6+UISnGSgurjFfXk74v5LgdGn1EM3LHPG38SU405LxIyarZknFYpzjjVzlGuH3d/DiBbVPKtPJ4frWuSt1fGl40U0mVzlkipSyY1W2co0742v+eJu5LY5riqvh3jFNZMUJrlJJ/iBYEkAfLyabNLpKWTZl3b47Mm+oRhwtV48+7vPqGay3qp4dv1YRlf2tr+xoAIJIAMqWKsDHco6iScl8SXASyRWNzd0g8Tc38S2tptVxHVpwcW7Tbf52a+GflR5E1BpcJOuPcSyJQhGCTdJO7vvLMlWM2UkjRmc5KMXJ8EgMcqeyW1064PwMML3J3Jtp0+No2yT5bGnb5mGSdyio8McuG5cKZYlq0jKUU+asvjbakpO3F1fiGRXNPBjf8ACjmyYYLkjqyyo5MsyWtRhP4eRjKbLyk5Mya4nOusSmaplIY2zeOOjDbnzQuJ83UQ5n25QTRy5sGOXOVGuWenwXwZeLs+hPRY2+DM/oii+B1cWMY2X6svs29xKoYaweNortkdLRRo16al7xSDcTeOoa5GNF4xH9Vqf3SOvFkyTfGVI+jgUVVys+TFOJdZJLvJfB01P5HL70ckUuZdZEz4cM8l3nXi1F95x68fUdZ5Oa+mpEN8Dnhls0crRjHSKZGc8jaRnJBWJy51zOuXM5c6Ly59PnZF8bKl8v1ip2jjX6kACspAAAABQAAc+bDKWVZYZur+Ha/hT4fI0hihHD1SVwqufMx1mOU5Ym8fW4o25Y13vudd9cScWHJDQvHF7MjUqr+G7pfcBfDp1ikpOc8kktqc2uC+4pl0uJucpSlFZGlOKlSn3fouBXSQkppxxTwwUakpyvc+Hzfz495rqYSmsWxXtyRk+PcBtXCu4phxxw4YYoXthFRV+CI1EJ5ME4Y5bZNUndGOkwyx5JS6qOGNJKEZXb8QOsEADKM8EtRJRlF5lGmk+NL/ANmpzyxZvpsckVj6pRrjd23x/ojoAgAACrLGcp7XFNc3RURx63v27SihJYpwtK26f2kNx6xxUskVdXdqykXilGTlGTpX8Tu0axnULDGOPa5KPG/hfItF41WOMo8FyTKt4+rnJYknHmmkabIp2opP5IUirRhmeNpwycb5qrOlmbRmNONvHUFFTezlUWVyJz/0Xa5NtcDraOfHGall3d87X2Ui6mMUskEkoRUe/wCL/Ys0TWR5pbqUO7gRGG1Vdq+AqxzZonFlR9OcbRyZsJityvmvmXhC2Xlipm2GFczlXWJhiLvGaxXAttMtudwObNhVHe4mOSFoFfD1EGrptHMutb+s/wAT6epwvifPnuxs7cWftx7l/SVhyPn/AFDxyiVWpyLvX4F1nlLmdpeHC8+SMpTa7iOsN9u7uKSwfI3n0xv2iDi2bwo5VFxZtDIka5ufljrnfw6aVDaUjkRrHIjtLK895sV2ExUovgmbRyRXcaRyRfgLNJbF8UpHVC64mOJxbOpJVwR4vLxI+j4fJbFGjKSN5GUjyvVrGRyZzrmjmzR4FjFfMy/WKGuZUzI7Rxr9TRJCJKyAAASQAqSAAOfPmyx1GLDihBuacm5OqSr9S0M6lpXm28ot1fgNTHA8W7UqOyPfI0xuEscXjacGvhrlQGGDJlllipzxzUob6gq28q7+P+xpPJKOpxQ4bZqV/aq/3JxRxQlOGKMYtcZKKrmM2XDh2yyyjHjUb/sBoY6bJKccin9aGSUfuvh+VGtqrtVzszwZcGXc8E4T75bWmBsQSQByynOGuh/iSeKdxcbTSlVpVV+J1HM5aday3ij13CKybVfFN1f3HSAAIAMo4puLf8LtFysk3Fpc2ior1cN++uJXq4KLiopJ81RaLqEdzVvhz7yHOKck+G1Wx8nwr1cFDZtW3wBaMlOO6LtMAUaKNGhVkVm0ZtGsjnwZY5YcJqUl9au4qEkZyRs0UkiKxaMMqtHTJGc42gPnZI8RBm+SBztUzl1HXmt4M0TOeEjVSMOkXZSSLJkhXHmx2j5eowOz7so2c+XEmWVK87LE4smMT6mbTeCOKenkuRuVjGmOUIpWXeaD5KzCGB3x4nXjwKuRZ1YXmVzSxqXJGMsD7j6Tx0FitnSeb7cb4fp8vqci5F4Y83fR9eOmT7jWOjh3mp5eGL4u3y4YZy7zrwaJvjJs+hj0+OPKJuopckTr+R/lef4/zvTDFpowXI1aSLNlHxPNerfy9M5k/CkzKSNmjORlphIyyRtG0ishCvk6iHE5j6WpjzPnzVM7c1w6j9QJANsAAAAAKAADDUxm5Ypwg8ihK3FNLuaT4ltNjljw1Kk23JpclbuiuryvFiTUlDdJR3PlG+8aOc54blLek6jOq3rxAthxzjmzzlVTknGvDal/WzPNhyvM8mKcE5Q2fEr28+K/H8kaYpSeozxb4RcaX3FNZOUMSpuMXJKc0rcV4gXnp4z0r09tRcNtlcOGay9ZlnGUlHbHbHaku/8Aoho76hcZuNva589vdZbTylLrd7+rkaX2dwGwAA58ukxZNRjzuMVlxu921W1TVX95ufP2xz9IzUpZHceSlODhVcHTp3bZ9AAQSAIKzW6LSdWuZYBHPHFNJcltkmld/aXljUpSbfCUdrRG6UsOTbbkm1w+0rtydfuV7Pt4V+ptn4WxxjFOKbbT4tlmVW2M5fEvifIs0ZrUVKTkoq340aGOaGLJSm48GnxYhVJyrJxkoxird/MpOSjlUEo1JW2WUorJNpqSdfVVkSW+W7qba5OVGmdZwWzJLHbaq1buiWhjhJSk5pW/4ruy3Bq07RmtRk0UaNmijRFc84Wjky4z6DRjkhaJZqy4+fxReLLZIcSiRysx2laqRazNF0zDSWykjRUQ1YHNJGTgn3HW4EbC6OVY0uSJ5HRtI2LwLo5uLfI0hBmu35BIgmMeBpFEI0iiaJSJAIIIbJKtgVZnI0ZSQVlJFHyNJFaKjj1K4M+Zk4SPr6iPA+Tm+sdeHLt+ngA6OQAABJBIUIJAFMsoY8cp5GlCKtt+BXDmjmi6jKLi6cZKmic2OObFLHK6kqdEYcKxOT3SnKf1pSfFgWjOMpyivrRq/vGXJHFinln9WEXJ14IrDG458mTdwmoqq5VZbLjWXDPHLlOLi/vAsnavxOfHrMeTM8cVNpS2b9vw7vC/uN4rbBRu6VWYR0ajkT62bgpuahwq3+feB0gADnWqxvVSwOUYyVJXLjJ1bSX2UbmC0+F6l5bud21u4J1V140dAEAkgCJOotnO3PdLdOVJpLYdLXCmZvDB3wdt3dmpYzZaxlKEYKV5JJ3wuvvL9Xj3qLTbavi2y/U4/huP1eROxb9/fVDUkZY4wc57YRW10ml8jSi1EEakxUq4p8Wk39hcggyyRTg07r5HPpoSjCappt8G1V/cdjKtF34xM+dc+LHKCkpS3W7XAiGPZGrvi2btFWhq4yaKNGrRRoismikomzRRoDkyws5ZxaZ9GUbOfLjM2a1Ljliy6ZSSpiLOVjtK0ssiqLIy0kONlki1AZOJG02cSrQRltCiaUKIIjEulRBIAgkiwBVlmyjYEPgUkWZVoooypZogisc0bifI1MakfcyK4nyNZHidOK5dx+jgA7OIAABJBIUIJAHNrVklhShv2uXx9W/i2/L8i2k3vD8e7g3t3/Wce6zYAY4r+k57urjX4DWylDR5pY21KMG1XM2AAxcpLXqFvY8TdfO1+puAAAA5M2nxz12CfVR3RubybePDglf3/kdYAAgkAQAABDJIAgEkAQQyxAFSGixFAUaKtGlFWgM2ijRq0VaAyaKNGzRRoDFoznC0btFGgODNjOZ/Cz6eSFnDmxGOo3zURkXRhF06NoyTOddYupUWUytIijLTXmKKJl7AgUTwIIABDYRDI4kkNgGVJbIAmisi1lZBWbKlmiKANWj5mshzPqdxw6xcGb5Y6e7AB3ecAAUJIAEggkAAAAAAAAAAAAAAAAAQSAIILEAQCQBBBIAq0QWIAqQWZAFWirRchoDNoo0atFWgMmijRs0UaAxcTDJj3HU0UaA+Zlw0ZK48z6k4JnJlwmLy6TplGZfcYSTixGRysdJW9lkzKLLpkaXsWVslMCSCbBBBVlyrYFSSCQhRVolsq2FQ0VZZyKXxKJ7jj1atM7VyOXUrgyxmvbAA9DzAAAEkEgAAFAAAAAAAAAAAAAAAAAAAAAEAAAQSAIIJAEEEgCpBaiGBVoq0XZAGbRVo1aK0Bi0UaN2ijQGDiZyjaN2ijiBw5sRxzTiz604WjjzYTNjfNcikzSMjNwcWTE5WOkrdMtZkpIumZai9grZFkVeyrK2LCLEmdkqQVLMpWbWjOaCMtzslcRSHLkUW7jnzm9mOXkIV7QHgu2/SXkaT0S9w7b9JeRpPRL3HpeV70Hgu2/SXkaT0S9w7b9JeRpPRL3Ae9JPA9t+kvI0nol7h236S8jSeiXuCvfA8D236S8jSeiXuHbfpLyNJ6Je4D3wPA9t+kvI0nol7h236S8jSeiXuA98DwPbfpLyNJ6Je4dt+kvI0nol7gPfA8D236S8jSeiXuHbfpLyNJ6Je4D3wPA9t+kvI0nol7h236S8jSeiXuA96SeB7b9JeRpPRL3Dtv0l5Gk9EvcB74Hge2/SXkaT0S9w7b9JeRpPRL3Ae+B4Htv0l5Gk9EvcO2/SXkaT0S9wHvgeB7b9JeRpPRL3Dtv0l5Gk9EvcB74Hge2/SXkaT0S9w7b9JeRpPRL3Ae9B4Ltv0l5Gk9EvcO2/SXkaT0S9wHvSDwfbfpLyNJ6Je4dt+kvI0nol7gPeA8H226S8jSeiXuI7bdJeRpPRL3Ae8FHg+23SXkaT0S9w7bdJeRpPRL3Ae7og8L216S8jSeiXuI7a9JeRpfRL3Ae6oq0eH7adI+TpfRL3Dtp0j5Ol9MvcB7Zoq0eK7Z9I+TpfTL3EdsukPJ0vpl7gPZuJRo8d2w6Q8nS+mXuIf7X69/wCjpvTL3AevaMpxs8o/2s17/wBHTemX6kP9q9c/9LTemX6gehzYjknHaz48v2n1sueLT+mX6mMv2g1UueLB6X+pm861OsfdTLqR539+an+TF+D/AFH781P8mL8H+pj0rfvHpVImzzX791X8mH8H+o/f2q8vD+D/AFJ6Vr3j0rZWzzj6e1T/AIMP4P8AUfv3VfyYfwf6j0p7x6JiJ539+6r+TF+D/ULp7VL/AE8P4P8AUnpT+yPSoiXzZ5z9/wCr8vD+D/Uj9/ary8P4P9R6U949A0Qz4H7+1Xl4fwf6h9O6p/6eH8H+pfSp7x9+ymTij4X781P8mH8H+pH771L/ANPD+D/UelPePmgA7OIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/9k=\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "YouTubeVideo(\"4qH4unVtJkE\", width=\"60%\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## The Intuition behind Floating Point Numbers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This video by the YouTube channel [Computerphile](https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA) explains floating point numbers in an intuitive way with some numeric examples."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "YouTubeVideo(\"PZRI1IfStY0\", width=\"60%\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## An Introduction to Complex Numbers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Below is a short introduction to [complex numbers ](https://en.wikipedia.org/wiki/Complex_number) by [MIT](https://www.mit.edu) professor [Gilbert Strang ](https://en.wikipedia.org/wiki/Gilbert_Strang) aimed at high school students."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "YouTubeVideo(\"Jkv-55ndVYY\", width=\"60%\")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/05_numbers/static/complex_numbers.png b/05_numbers/static/complex_numbers.png
new file mode 100644
index 0000000..807eb46
Binary files /dev/null and b/05_numbers/static/complex_numbers.png differ
diff --git a/05_numbers/static/floating_point.png b/05_numbers/static/floating_point.png
new file mode 100644
index 0000000..345aaba
Binary files /dev/null and b/05_numbers/static/floating_point.png differ
diff --git a/05_numbers/static/numbers.png b/05_numbers/static/numbers.png
new file mode 100644
index 0000000..6d75726
Binary files /dev/null and b/05_numbers/static/numbers.png differ
diff --git a/06_text/00_content.ipynb b/06_text/00_content.ipynb
new file mode 100644
index 0000000..57c34fa
--- /dev/null
+++ b/06_text/00_content.ipynb
@@ -0,0 +1,3970 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/06_text/00_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 6: Text & Bytes"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In this chapter, we continue the study of the built-in data types. The next layer on top of numbers consists of **textual data** that are modeled primarily with the `str` type in Python. `str` objects are more complex than the numeric objects in [Chapter 5 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/00_content.ipynb) as they *consist* of an *arbitrary* and possibly large number of *individual* characters that may be chosen from *any* alphabet in the history of humankind. Luckily, Python abstracts away most of this complexity from us. However, after looking at the `str` type in great detail, we briefly introduce the `bytes` type at the end of this chapter to understand how characters are modeled in memory."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `str` Type"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To create a `str` object, we use the *literal* notation and type the text between enclosing **double quotes** `\"`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "text = \"Lorem ipsum dolor sit amet.\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Like everything in Python, `text` is an object with an *identity*, a *type*, and a *value*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140667764715968"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(text)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "str"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(text)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As seen before, a `str` object evaluates to itself in a literal notation with enclosing **single quotes** `'`.\n",
+ "\n",
+ "In [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#Value-/-(Semantic)-\"Meaning\"), we specify the double quotes `\"` convention this book follows. Yet, single quotes `'` and double quotes `\"` are *perfect* substitutes. We could use the reverse convention, as well. As [this discussion ](https://stackoverflow.com/questions/56011/single-quotes-vs-double-quotes-in-python) shows, many programmers have *strong* opinions about such conventions. Consequently, the discussion was \"closed as not constructive\" by the moderators."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem ipsum dolor sit amet.'"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As the single quote `'` is often used in the English language as a shortener, we could make an argument in favor of using the double quotes `\"`: There are possibly fewer situations like the two code cells below, where we must **escape** the kind of quote used as the `str` object's delimiter with a backslash `\"\\\"` inside the text (cf., also the \"*Unicode & (Special) Characters*\" section further below). However, double quotes `\"` are often used as well, for example, to indicate a quote like the one by [Albert Einstein](https://de.wikipedia.org/wiki/Albert_Einstein) below. So, such arguments are not convincing.\n",
+ "\n",
+ "Many proponents of the single quote `'` usage claim that double quotes `\"` cause more **visual noise** on the screen. However, this argument is also not convincing as, for example, one could claim that *two* single quotes `''` look so similar to *one* double quote `\"` that a reader may confuse an *empty* `str` object with a missing closing quote `\"`. With the double quotes `\"` convention we at least avoid such confusion (i.e., empty `str` objects are written as `\"\"`).\n",
+ "\n",
+ "This discussion is an excellent example of a [flame war ](https://en.wikipedia.org/wiki/Flaming_%28Internet%29#Flame_war) in the programming world: Everyone has an opinion and the discussion leads to *no* result."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Einstein said, \"If you can\\'t explain it, you don\\'t understand it.\"'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Einstein said, \\\"If you can't explain it, you don't understand it.\\\"\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Einstein said, \"If you can\\'t explain it, you don\\'t understand it.\"'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "'Einstein said, \"If you can\\'t explain it, you don\\'t understand it.\"'"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "An *important* fact to know is that enclosing quotes of either kind are *not* part of the `str` object's *value*! They are merely *syntax* indicating the literal notation.\n",
+ "\n",
+ "So, printing out the sentence with the built-in [print() ](https://docs.python.org/3/library/functions.html#print) function does the same in both cases."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Einstein said, \"If you can't explain it, you don't understand it.\"\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Einstein said, \\\"If you can't explain it, you don't understand it.\\\"\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Einstein said, \"If you can't explain it, you don't understand it.\"\n"
+ ]
+ }
+ ],
+ "source": [
+ "print('Einstein said, \"If you can\\'t explain it, you don\\'t understand it.\"')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As an alternative to the literal notation, we may use the built-in [str() ](https://docs.python.org/3/library/stdtypes.html#str) constructor to cast non-`str` objects as `str` ones. As [Chapter 11 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/00_content.ipynb) reveals, basically any object in Python has a **text representation**. Because of that we may also pass `list` objects, the boolean `True` and `False`, or `None` to [str() ](https://docs.python.org/3/library/stdtypes.html#str)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'42'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "str(42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'42.87'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "str(42.87)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'[1, 2, 3]'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "str([1, 2, 3])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'True'"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "str(True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'False'"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "str(False)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'None'"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "str(None)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### User Input"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As shown in the \"*Guessing a Coin Toss*\" example in [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/03_content.ipynb#Example:-Guessing-a-Coin-Toss), the built-in [input() ](https://docs.python.org/3/library/functions.html#input) function displays a prompt to the user and returns whatever is entered as a `str` object. [input() ](https://docs.python.org/3/library/functions.html#input) is in particular valuable when writing command-line tools."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdin",
+ "output_type": "stream",
+ "text": [
+ "Whatever you enter is put in a new string: 123\n"
+ ]
+ }
+ ],
+ "source": [
+ "user_input = input(\"Whatever you enter is put in a new string: \")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "str"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(user_input)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'123'"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "user_input"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Reading Files"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A more common situation where we obtain `str` objects is when reading the contents of a file with the [open() ](https://docs.python.org/3/library/functions.html#open) built-in. In its simplest usage form, to open a [text file ](https://en.wikipedia.org/wiki/Text_file) file, we pass in its path (i.e., \"filename\") as a `str` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "file = open(\"lorem_ipsum.txt\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[open() ](https://docs.python.org/3/library/functions.html#open) returns a **[proxy ](https://en.wikipedia.org/wiki/Proxy_pattern)** object of type `TextIOWrapper` that allows us to interact with the file on disk. `mode='r'` shows that we opened the file in read-only mode and `encoding='UTF-8'` is explained in detail in the [The `bytes` Type ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/01_content.ipynb#The-bytes-Type) section at the end of this chapter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "_io.TextIOWrapper"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(file)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<_io.TextIOWrapper name='lorem_ipsum.txt' mode='r' encoding='UTF-8'>"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`TextIOWrapper` objects come with plenty of type-specific methods and attributes."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.readable()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.writable()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'lorem_ipsum.txt'"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.name"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'UTF-8'"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.encoding"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "So far, we have not yet read anything from the file (i.e., from disk)! That is intentional as, for example, the file could contain more data than could fit into our computer's memory. Therefore, we have to explicitly instruct the `file` object to read some of or all the data in the file.\n",
+ "\n",
+ "One way to do that, is to simply loop over the `file` object with the `for` statement as shown next: In each iteration, `line` is assigned the next line in the file. Because we may loop over `TextIOWrapper` objects, they are *iterables*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Lorem Ipsum is simply dummy text of the printing and typesetting industry.\n",
+ "\n",
+ "Lorem Ipsum has been the industry's standard dummy text ever since the 1500s\n",
+ "\n",
+ "when an unknown printer took a galley of type and scrambled it to make a type\n",
+ "\n",
+ "specimen book. It has survived not only five centuries but also the leap into\n",
+ "\n",
+ "electronic typesetting, remaining essentially unchanged. It was popularised in\n",
+ "\n",
+ "the 1960s with the release of Letraset sheets.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "for line in file:\n",
+ " print(line)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Once we looped over the `file` object, it is **exhausted**: We can *not* loop over it a second time. So, the built-in [print() ](https://docs.python.org/3/library/functions.html#print) function is *never* called in the code cell below!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "for line in file:\n",
+ " print(line)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "After the `for`-loop, the `line` variable is still set and references the *last* line in the file. We verify that it is indeed a `str` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'the 1960s with the release of Letraset sheets.\\n'"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "line"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "str"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(line)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "An *important* observation is that the `file` object is still associated with an *open* **[file descriptor ](https://en.wikipedia.org/wiki/File_descriptor)**. Without going into any technical details, we note that an operating system can only handle a *limited* number of \"open files\" at the same time, and, therefore, we should always *close* the file once we are done processing it.\n",
+ "\n",
+ "`TextIOWrapper` objects have a `closed` attribute on them that indicates if the associated file descriptor is still open or has been closed. We can \"manually\" close any `TextIOWrapper` object with the [close() ](https://docs.python.org/3/library/io.html#io.IOBase.close) method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.closed"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "file.close()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.closed"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The more Pythonic way is to use [open() ](https://docs.python.org/3/library/functions.html#open) within the compound `with` statement (cf., [reference ](https://docs.python.org/3/reference/compound_stmts.html#the-with-statement)): In the example below, the indented code block is said to be executed within the **context** of the `file` object that now plays the role of a **[context manager ](https://docs.python.org/3/reference/datamodel.html#with-statement-context-managers)**. Many different kinds of context managers exist in Python with different applications and purposes. Context managers returned from [open() ](https://docs.python.org/3/library/functions.html#open) mainly ensure that file descriptors get automatically closed after the last line in the code block is executed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Lorem Ipsum is simply dummy text of the printing and typesetting industry.\n",
+ "\n",
+ "Lorem Ipsum has been the industry's standard dummy text ever since the 1500s\n",
+ "\n",
+ "when an unknown printer took a galley of type and scrambled it to make a type\n",
+ "\n",
+ "specimen book. It has survived not only five centuries but also the leap into\n",
+ "\n",
+ "electronic typesetting, remaining essentially unchanged. It was popularised in\n",
+ "\n",
+ "the 1960s with the release of Letraset sheets.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "with open(\"lorem_ipsum.txt\") as file:\n",
+ " for line in file:\n",
+ " print(line)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.closed"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Using syntax familiar from [Chapter 3 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/03_conditionals/00_content.ipynb#The-try-Statement) to explain what the `with open(...) as file:` does above, we provide an alternative formulation with a `try` statement below: The `finally`-branch is *always* executed, even if an exception is raised inside the `for`-loop. Therefore, `file` is sure to be closed too. However, this formulation is somewhat less expressive."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Lorem Ipsum is simply dummy text of the printing and typesetting industry.\n",
+ "\n",
+ "Lorem Ipsum has been the industry's standard dummy text ever since the 1500s\n",
+ "\n",
+ "when an unknown printer took a galley of type and scrambled it to make a type\n",
+ "\n",
+ "specimen book. It has survived not only five centuries but also the leap into\n",
+ "\n",
+ "electronic typesetting, remaining essentially unchanged. It was popularised in\n",
+ "\n",
+ "the 1960s with the release of Letraset sheets.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "try:\n",
+ " file = open(\"lorem_ipsum.txt\")\n",
+ " for line in file:\n",
+ " print(line)\n",
+ "finally:\n",
+ " file.close()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 35,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.closed"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As an alternative to reading the contents of a file by looping over a `TextIOWrapper` object, we may also call one of the methods they come with.\n",
+ "\n",
+ "For example, the [read() ](https://docs.python.org/3/library/io.html#io.TextIOBase.read) method takes a single `size` argument of type `int` and returns a `str` object with the specified number of characters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "file = open(\"lorem_ipsum.txt\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem Ipsum'"
+ ]
+ },
+ "execution_count": 37,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.read(11)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When we call [read() ](https://docs.python.org/3/library/io.html#io.TextIOBase.read) again, the returned `str` object begins where the previous one left off. This is because `TextIOWrapper` objects like `file` simply store a position at which the associated file on disk is being read. In other words, `file` is like a **cursor** pointing into a file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "' is simply '"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.read(11)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "On the contrary, the [readline() ](https://docs.python.org/3/library/io.html#io.TextIOBase.readline) method keeps reading until it hits a **newline character**. These are shown in `str` objects as `\"\\n\"`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'dummy text of the printing and typesetting industry.\\n'"
+ ]
+ },
+ "execution_count": 39,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.readline()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When we call [readline() ](https://docs.python.org/3/library/io.html#io.TextIOBase.readline) again, we obtain the next line."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"Lorem Ipsum has been the industry's standard dummy text ever since the 1500s\\n\""
+ ]
+ },
+ "execution_count": 40,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.readline()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Lastly, the [readlines() ](https://docs.python.org/3/library/io.html#io.IOBase.readlines) method returns a `list` object that holds *all* lines in the `file` from the current position to the end of the file. The latter position is often abbreviated as **EOF** in the documentation. Let's always remember that [readlines() ](https://docs.python.org/3/library/io.html#io.IOBase.readlines) has the potential to crash a computer with a `MemoryError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['when an unknown printer took a galley of type and scrambled it to make a type\\n',\n",
+ " 'specimen book. It has survived not only five centuries but also the leap into\\n',\n",
+ " 'electronic typesetting, remaining essentially unchanged. It was popularised in\\n',\n",
+ " 'the 1960s with the release of Letraset sheets.\\n']"
+ ]
+ },
+ "execution_count": 41,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.readlines()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Calling [readlines() ](https://docs.python.org/3/library/io.html#io.IOBase.readlines) a second time, is as pointless as looping over `file` a second time."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[]"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "file.readlines()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "file.close()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Because every `str` object created by reading the contents of a file in any of the ways shown in this section ends with a `\"\\n\"`, we see empty lines printed between each `line` in the `for`-loops above. To print the entire text without empty lines in between, we pass a `end=\"\"` argument to the [print() ](https://docs.python.org/3/library/functions.html#print) function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Lorem Ipsum is simply dummy text of the printing and typesetting industry.\n",
+ "Lorem Ipsum has been the industry's standard dummy text ever since the 1500s\n",
+ "when an unknown printer took a galley of type and scrambled it to make a type\n",
+ "specimen book. It has survived not only five centuries but also the leap into\n",
+ "electronic typesetting, remaining essentially unchanged. It was popularised in\n",
+ "the 1960s with the release of Letraset sheets.\n"
+ ]
+ }
+ ],
+ "source": [
+ "with open(\"lorem_ipsum.txt\") as file:\n",
+ " for line in file:\n",
+ " print(line, end=\"\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## A String of Characters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A **sequence** is yet another *abstract* concept (cf., the \"*Containers vs. Iterables*\" section in [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/02_content.ipynb#Containers-vs.-Iterables)).\n",
+ "\n",
+ "It unifies *four* [orthogonal ](https://en.wikipedia.org/wiki/Orthogonality) (i.e., \"independent\") concepts into one bigger idea: Any data type, such as `str`, is considered a sequence if it\n",
+ "\n",
+ "1. **contains**\n",
+ "2. a **finite** number of other objects that\n",
+ "3. can be **iterated** over\n",
+ "4. in a *predictable* **order**.\n",
+ "\n",
+ "[Chapter 7 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/00_content.ipynb#Collections-vs.-Sequences) formalizes these concepts in great detail. Here, we keep our focus on the `str` type that historically received its name as it models a **[string of characters ](https://en.wikipedia.org/wiki/String_%28computer_science%29)**. *String* is simply another term for *sequence* in the computer science literature.\n",
+ "\n",
+ "Another example of a sequence is the `list` type. Because of that, `str` objects may be treated like `list` objects in many situations.\n",
+ "\n",
+ "Below, the built-in [len() ](https://docs.python.org/3/library/functions.html#len) function tells us how many characters make up `text`. [len() ](https://docs.python.org/3/library/functions.html#len) would not work with an \"infinite\" object. As anything modeled in a program must fit into a computer's finite memory, there cannot exist truly infinite objects; however, [Chapter 8 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/08_mfr/00_content.ipynb#Iterators-vs.-Iterables) introduces specialized iterable data types that can be used to model an *infinite* series of \"things\" and that, consequently, have no concept of \"length.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem ipsum dolor sit amet.'"
+ ]
+ },
+ "execution_count": 45,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "27"
+ ]
+ },
+ "execution_count": 46,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(text)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Being iterable, we may loop over `text` and do something with the individual characters, for example, print them out with extra space in between them. If it were not for the appropriately chosen name of the `text` variable, we could not tell what *concrete* type of object the `for` statement is looping over."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "L o r e m i p s u m d o l o r s i t a m e t . "
+ ]
+ }
+ ],
+ "source": [
+ "for character in text:\n",
+ " print(character, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With the [reversed() ](https://docs.python.org/3/library/functions.html#reversed) built-in, we may loop over `text` in reversed order. Reversing `text` only works as it has a forward order to begin with."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ ". t e m a t i s r o l o d m u s p i m e r o L "
+ ]
+ }
+ ],
+ "source": [
+ "for character in reversed(text):\n",
+ " print(character, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Being a container, we may check if a given `str` object is contained in `text` with the `in` operator, which has *two* distinct usages: First, it checks if a *single* character is contained in a `str` object. Second, it may also check if a shorter `str` object, then called a **substring**, is contained in a longer one."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 49,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"L\" in text"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 50,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"ipsum\" in text"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 51,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"veni, vidi, vici\" in text"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Indexing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As `str` objects are *ordered* and *finite*, we may **index** into them to obtain individual characters with the **indexing operator** `[]`. This is analogous to how we obtained individual elements of a `list` object in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/03_content.ipynb#Who-am-I?-And-how-many?)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'L'"
+ ]
+ },
+ "execution_count": 52,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[0]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'o'"
+ ]
+ },
+ "execution_count": 53,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[1]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The index must be of type `int`; othewise, we get a `TypeError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "string indices must be integers, not 'float'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[54], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtext\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1.0\u001b[39;49m\u001b[43m]\u001b[49m\n",
+ "\u001b[0;31mTypeError\u001b[0m: string indices must be integers, not 'float'"
+ ]
+ }
+ ],
+ "source": [
+ "text[1.0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The last index is one less than the above \"length\" of the `str` object as we start counting at `0`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'.'"
+ ]
+ },
+ "execution_count": 55,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[26] # == text[len(text) - 1]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "An `IndexError` is raised whenever the index is out of range."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "IndexError",
+ "evalue": "string index out of range",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[56], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtext\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m27\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;66;03m# == text[len(text)]\u001b[39;00m\n",
+ "\u001b[0;31mIndexError\u001b[0m: string index out of range"
+ ]
+ }
+ ],
+ "source": [
+ "text[27] # == text[len(text)]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We may use *negative* indexes to start counting from the end of the `str` object, as shown in the figure below. Note how this only works because sequences are *finite*."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "| Index | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26|\n",
+ "|:---------:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|\n",
+ "|**Reverse**|-27|-26|-25|-24|-23|-22|-21|-20|-19|-18|-17|-16|-15|-14|-13|-12|-11|-10|-9 |-8 |-7 |-6 |-5 |-4 |-3 |-2 |-1 |\n",
+ "| **Character** |`L`|`o`|`r`|`e`|`m`|` `|`i`|`p`|`s`|`u`|`m`|` `|`d`|`o`|`l`|`o`|`r`|` `|`s`|`i`|`t`|` `|`a`|`m`|`e`|`t`|`.`|"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'.'"
+ ]
+ },
+ "execution_count": 57,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[-1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'L'"
+ ]
+ },
+ "execution_count": 58,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[-27] # == text[-len(text)]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "One reason why programmers like to start counting at `0` is that a positive index and its *corresponding* negative index always add up to the length of the sequence. Here, `6` and `21` add to `27`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'i'"
+ ]
+ },
+ "execution_count": 59,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[6]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'i'"
+ ]
+ },
+ "execution_count": 60,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[-21]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Slicing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A **slice** is a substring of a `str` object.\n",
+ "\n",
+ "The **slicing operator** is a generalization of the indexing operator: We put one, two, or three integers within the brackets `[]`, separated by colons `:`. The three integers are then referred to as the *start*, *stop*, and *step* values.\n",
+ "\n",
+ "Let's start with two integers, *start* and *stop*. Whereas the character at the *start* position is included in the returned `str` object, the one at the *stop* position is not. If both *start* and *stop* are positive, the difference \"*stop* minus *start*\" tells us how many characters the resulting slice has. So, below, `5 - 0 == 5` implies that `\"Lorem\"` consists of `5` characters. So, colloquially speaking, `text[0:5]` means \"taking the first `5 - 0 == 5` characters of `text`.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem'"
+ ]
+ },
+ "execution_count": 61,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[0:5]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'dolor sit amet.'"
+ ]
+ },
+ "execution_count": 62,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[12:len(text)]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If left out, *start* defaults to `0` and *stop* to the length of the `str` object (i.e., the end)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem'"
+ ]
+ },
+ "execution_count": 63,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[:5]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'dolor sit amet.'"
+ ]
+ },
+ "execution_count": 64,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[12:]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Not including the character at the *stop* position makes working with individual slices easier as they add up to the original `str` object again (cf., the \"*String Operations*\" section below regarding the overloaded `+` operator)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem ipsum dolor sit amet.'"
+ ]
+ },
+ "execution_count": 65,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[:5] + text[5:]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Slicing and indexing makes it easy to obtain shorter versions of the original `str` object. A common application would be to **parse** out meaningful substrings from raw text data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem ipsum sit amet.'"
+ ]
+ },
+ "execution_count": 66,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[:11] + text[-10:]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "By combining a positive *start* with a negative *stop* index, we specify both ends of the slice *relative* to the ends of the entire `str` object. So, colloquially speaking, `[6:-10]` below means \"drop the first six and last ten characters.\" The length of the resulting slice can then *not* be calculated from the indexes and depends only on the length of the original `str` object!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 67,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'ipsum dolor'"
+ ]
+ },
+ "execution_count": 67,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[6:-10]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "For convenience, the indexes do not need to lie within the range from `0` to `len(text)` when slicing. So, no `IndexError` is raised here."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem ipsum dolor sit amet.'"
+ ]
+ },
+ "execution_count": 68,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[-999:999]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "By leaving out both *start* and *stop*, we take a \"full\" slice that is essentially a *copy* of the original `str` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 69,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem ipsum dolor sit amet.'"
+ ]
+ },
+ "execution_count": 69,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[:]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A *step* value of `i` can be used to obtain only every `i`th character."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 70,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lrmismdlrstae.'"
+ ]
+ },
+ "execution_count": 70,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[::2]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A negative *step* size of `-1` reverses the order of the characters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 71,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'.tema tis rolod muspi meroL'"
+ ]
+ },
+ "execution_count": 71,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text[::-1]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Immutability"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Whereas elements of a `list` object *may* be *re-assigned*, as shortly hinted at in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/03_content.ipynb#Who-am-I?-And-how-many?), this is *not* allowed for the individual characters of `str` objects. Once created, they can *not* be changed. Formally, we say that `str` objects are **immutable**. In that regard, they are like the numeric types in [Chapter 5 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/00_content.ipynb).\n",
+ "\n",
+ "On the contrary, objects that may be changed after creation, are called **mutable**. We already saw in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/03_content.ipynb#Who-am-I?-And-how-many?) how mutable objects are more difficult to reason about for a beginner, in particular, if more than one variable references it. Yet, mutability does have its place in a programmer's toolbox, and we revisit this idea in the next chapters.\n",
+ "\n",
+ "The `TypeError` indicates that `str` objects are *immutable*: Assignment to an index or a slice are *not* supported."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 72,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "'str' object does not support item assignment",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[72], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtext\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mX\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
+ "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
+ ]
+ }
+ ],
+ "source": [
+ "text[0] = \"X\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "'str' object does not support item assignment",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[73], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtext\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrandom\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
+ "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
+ ]
+ }
+ ],
+ "source": [
+ "text[:5] = \"random\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## String Methods"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Objects of type `str` come with many **methods** bound on them (cf., the [documentation ](https://docs.python.org/3/library/stdtypes.html#string-methods) for a full list). As seen before, they work like *normal* functions and are accessed via the **dot operator** `.`. Calling a method is also referred to as **method invocation**.\n",
+ "\n",
+ "The [.find() ](https://docs.python.org/3/library/stdtypes.html#str.find) method returns the index of the first occurrence of a character or a substring. If no match is found, it returns `-1`. A mirrored version searching from the right called [.rfind() ](https://docs.python.org/3/library/stdtypes.html#str.rfind) exists as well. The [.index() ](https://docs.python.org/3/library/stdtypes.html#str.index) and [.rindex() ](https://docs.python.org/3/library/stdtypes.html#str.rindex) methods work in the same way but raise a `ValueError` if no match is found. So, we can control if a search fails *silently* or *loudly*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 74,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem ipsum dolor sit amet.'"
+ ]
+ },
+ "execution_count": 74,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 75,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "22"
+ ]
+ },
+ "execution_count": 75,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.find(\"a\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 76,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-1"
+ ]
+ },
+ "execution_count": 76,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.find(\"b\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 77,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "12"
+ ]
+ },
+ "execution_count": 77,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.find(\"dolor\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[.find() ](https://docs.python.org/3/library/stdtypes.html#str.find) takes optional *start* and *end* arguments that allow us to find occurrences other than the first one."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 78,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 78,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.find(\"o\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 79,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "13"
+ ]
+ },
+ "execution_count": 79,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.find(\"o\", 2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 80,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-1"
+ ]
+ },
+ "execution_count": 80,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.find(\"o\", 2, 12)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [.count() ](https://docs.python.org/3/library/stdtypes.html#str.count) method does what we expect."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 81,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem ipsum dolor sit amet.'"
+ ]
+ },
+ "execution_count": 81,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 82,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 82,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.count(\"l\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As [.count() ](https://docs.python.org/3/library/stdtypes.html#str.count) is *case-sensitive*, we must **chain** it with the [.lower() ](https://docs.python.org/3/library/stdtypes.html#str.lower) method to get the count of all `\"L\"`s and `\"l\"`s."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 83,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2"
+ ]
+ },
+ "execution_count": 83,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.lower().count(\"l\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Alternatively, we can use the [.upper() ](https://docs.python.org/3/library/stdtypes.html#str.upper) method and search for `\"L\"`s."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 84,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2"
+ ]
+ },
+ "execution_count": 84,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.upper().count(\"L\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Because `str` objects are *immutable*, [.upper() ](https://docs.python.org/3/library/stdtypes.html#str.upper) and [.lower() ](https://docs.python.org/3/library/stdtypes.html#str.lower) return *new* `str` objects, even if they do *not* change the value of the original `str` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 85,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "example = \"random\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 86,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140667840152112"
+ ]
+ },
+ "execution_count": 86,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(example)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 87,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "lower = example.lower()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 88,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140667764453680"
+ ]
+ },
+ "execution_count": 88,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(lower)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`example` and `lower` are *different* objects with the *same* value."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 89,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 89,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "example is lower"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 90,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 90,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "example == lower"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Besides [.upper() ](https://docs.python.org/3/library/stdtypes.html#str.upper) and [.lower() ](https://docs.python.org/3/library/stdtypes.html#str.lower) there exist also [.title() ](https://docs.python.org/3/library/stdtypes.html#str.title) and [.swapcase() ](https://docs.python.org/3/library/stdtypes.html#str.swapcase) methods."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 91,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'lorem ipsum dolor sit amet.'"
+ ]
+ },
+ "execution_count": 91,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.lower()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 92,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'LOREM IPSUM DOLOR SIT AMET.'"
+ ]
+ },
+ "execution_count": 92,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.upper()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 93,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem Ipsum Dolor Sit Amet.'"
+ ]
+ },
+ "execution_count": 93,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.title()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 94,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'lOREM IPSUM DOLOR SIT AMET.'"
+ ]
+ },
+ "execution_count": 94,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.swapcase()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Another popular string method is [.split() ](https://docs.python.org/3/library/stdtypes.html#str.split): It separates a longer `str` object into smaller ones collected in a `list` object. By default, groups of contiguous whitespace characters are used as the *separator*.\n",
+ "\n",
+ "As an example, we use [.split() ](https://docs.python.org/3/library/stdtypes.html#str.split) to print out the individual words in `text` with more whitespace in between them."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 95,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Lorem', 'ipsum', 'dolor', 'sit', 'amet.']"
+ ]
+ },
+ "execution_count": 95,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "text.split()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 96,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Lorem ipsum dolor sit amet. "
+ ]
+ }
+ ],
+ "source": [
+ "for word in text.split():\n",
+ " print(word, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The opposite of splitting is done with the [.join() ](https://docs.python.org/3/library/stdtypes.html#str.join) method. It is typically invoked on a `str` object that represents a separator (e.g., `\" \"` or `\", \"`) and connects the elements provided by an *iterable* argument (e.g., `words` below) into one *new* `str` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 97,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "words = [\"This\", \"will\", \"become\", \"a\", \"sentence.\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 98,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "sentence = \" \".join(words)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 99,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'This will become a sentence.'"
+ ]
+ },
+ "execution_count": 99,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sentence"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As the `str` object `\"abcde\"` below is an *iterable* itself, its characters (!) are joined together with a space `\" \"` in between."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 100,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'a b c d e'"
+ ]
+ },
+ "execution_count": 100,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\" \".join(\"abcde\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [.replace() ](https://docs.python.org/3/library/stdtypes.html#str.replace) method creates a *new* `str` object with parts of the original `str` object potentially replaced."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 101,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'This is a sentence.'"
+ ]
+ },
+ "execution_count": 101,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sentence.replace(\"will become\", \"is\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Note how `sentence` itself remains unchanged. Bound to an immutable object, [.replace() ](https://docs.python.org/3/library/stdtypes.html#str.replace) must create *new* objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 102,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'This will become a sentence.'"
+ ]
+ },
+ "execution_count": 102,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sentence"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As seen previously, the [.strip() ](https://docs.python.org/3/library/stdtypes.html#str.strip) method is often helpful in cleaning text data from unreliable sources like user input from unnecessary leading and trailing whitespace. The [.lstrip() ](https://docs.python.org/3/library/stdtypes.html#str.lstrip) and [.rstrip() ](https://docs.python.org/3/library/stdtypes.html#str.rstrip) methods are specialized versions of it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 103,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'text with whitespace'"
+ ]
+ },
+ "execution_count": 103,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\" text with whitespace \".strip()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 104,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'text with whitespace '"
+ ]
+ },
+ "execution_count": 104,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\" text with whitespace \".lstrip()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 105,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "' text with whitespace'"
+ ]
+ },
+ "execution_count": 105,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\" text with whitespace \".rstrip()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When justifying a `str` object for output, the [.ljust() ](https://docs.python.org/3/library/stdtypes.html#str.ljust) and [.rjust() ](https://docs.python.org/3/library/stdtypes.html#str.rjust) methods may be helpful."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 106,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'This will become a sentence. '"
+ ]
+ },
+ "execution_count": 106,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sentence.ljust(40)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 107,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "' This will become a sentence.'"
+ ]
+ },
+ "execution_count": 107,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sentence.rjust(40)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Similarly, the [.zfill() ](https://docs.python.org/3/library/stdtypes.html#str.zfill) method can be used to pad a `str` representation of a number with leading `0`s for justified output."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 108,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'0000042.87'"
+ ]
+ },
+ "execution_count": 108,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"42.87\".zfill(10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 109,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'-000042.87'"
+ ]
+ },
+ "execution_count": 109,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"-42.87\".zfill(10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## String Operations"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As mentioned in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#Operator-Overloading), the `+` and `*` operators are *overloaded* and used for **string concatenation**. They always create *new* `str` objects. That has nothing to do with the `str` type's immutability, but is the default behavior of operators."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 110,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Hello Lore'"
+ ]
+ },
+ "execution_count": 110,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Hello \" + text[:4]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 111,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum ...'"
+ ]
+ },
+ "execution_count": 111,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "5 * text[:12] + \"...\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### String Comparison"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The *relational* operators also work with `str` objects, another example of operator overloading. Comparison is done one character at a time in a pairwise fashion until the first pair differs or one operand ends. However, `str` objects are sorted in a \"weird\" way. For example, all upper case characters come before all lower case characters. The reason for that is given in the \"*Characters are Numbers with a Convention*\" sub-section in the [second part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/02_content.ipynb#Characters-are-Numbers-with-a-Convention) of this chapter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 112,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 112,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Apple\" < \"Banana\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 113,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 113,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"apple\" < \"Banana\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 114,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 114,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"apple\" < \"Banana\".lower()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Below is an example with typical German last names that shows how characters other than the first decide the ordering."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 115,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 115,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Mai\" < \"Maier\" < \"Mayer\" < \"Meier\" < \"Meyer\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## String Interpolation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Often, we want to use `str` objects as drafts in the source code that are filled in with concrete text only at runtime. This approach is called **string interpolation**. There are three ways to do that in Python."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### f-strings"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**[Formatted string literals ](https://docs.python.org/3/reference/lexical_analysis.html#formatted-string-literals)**, of **f-strings** for short, are the least recently added (cf., [PEP 498 ](https://www.python.org/dev/peps/pep-0498/) in 2016) and most readable way: We simply prepend a `str` in its literal notation with an `f`, and put variables, or more generally, expressions, within curly braces `{}`. These are then filled in when the string literal is evaluated."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 116,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "name = \"Alexander\"\n",
+ "time_of_day = \"morning\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 117,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Hello Alexander! Good morning.'"
+ ]
+ },
+ "execution_count": 117,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "f\"Hello {name}! Good {time_of_day}.\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Separated by a colon `:`, various formatting options are available. In the beginning, the ability to round numbers for output may be particularly useful: This can be achieved by adding `:.2f` to the variable name inside the curly braces, which casts the number as a `float` and rounds it to two digits. The `:.2f` is a so-called format specifier, and there exists a whole **[format specification mini-language ](https://docs.python.org/3/library/string.html#formatspec)** to govern how specifiers work."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 118,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "pi = 3.141592653"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 119,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Pi is 3.14'"
+ ]
+ },
+ "execution_count": 119,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "f\"Pi is {pi:.2f}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### [format() ](https://docs.python.org/3/library/stdtypes.html#str.format) Method"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`str` objects also provide a [.format() ](https://docs.python.org/3/library/stdtypes.html#str.format) method that accepts an arbitrary number of *positional* arguments that are inserted into the `str` object in the same order replacing empty curly brackets `{}`. String interpolation with the [.format() ](https://docs.python.org/3/library/stdtypes.html#str.format) method is a more traditional and probably the most common way as of today. While f-strings are the recommended way going forward, usage of the [.format() ](https://docs.python.org/3/library/stdtypes.html#str.format) method is likely not declining any time soon."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 120,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Hello Alexander! Good morning.'"
+ ]
+ },
+ "execution_count": 120,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Hello {}! Good {}.\".format(name, time_of_day)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We may use index numbers inside the curly braces if the order is different in the `str` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 121,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Good morning, Alexander'"
+ ]
+ },
+ "execution_count": 121,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Good {1}, {0}\".format(name, time_of_day)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [.format() ](https://docs.python.org/3/library/stdtypes.html#str.format) method may alternatively be used with *keyword* arguments as well. Then, we must put the keywords' names within the curly brackets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 122,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Hello Alexander! Good morning.'"
+ ]
+ },
+ "execution_count": 122,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Hello {name}! Good {time}.\".format(name=name, time=time_of_day)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Format specifiers work as in the f-string case."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 123,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Pi is 3.14'"
+ ]
+ },
+ "execution_count": 123,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Pi is {:.2f}\".format(pi)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### `%` Operator"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `%` operator that we saw in the context of modulo division in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#%28Arithmetic%29-Operators) is overloaded with string interpolation when its first operand is a `str` object. The second operand consists of all expressions to be filled in. Format specifiers work with a `%` instead of curly braces and according to a different set of rules referred to as **[printf-style string formatting ](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting)**. So, `{:.2f}` becomes `%.2f`.\n",
+ "\n",
+ "This way of string interpolation is the oldest and originates from the [C language ](https://en.wikipedia.org/wiki/C_%28programming_language%29). It is still widely spread, but we should use one of the other two ways instead. We show it here mainly for completeness sake."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 124,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Pi is 3.14'"
+ ]
+ },
+ "execution_count": 124,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Pi is %.2f\" % pi"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To insert more than one expression, we must list them in order and between parenthesis `(` and `)`. As [Chapter 7 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/00_content.ipynb#The-tuple-Type) reveals, this literal syntax creates an object of type `tuple`. Also, to format an expression as text, we use the format specifier `%s`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 125,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Hello Alexander! Good morning.'"
+ ]
+ },
+ "execution_count": 125,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Hello %s! Good %s.\" % (name, time_of_day)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/06_text/01_exercises_palindromes.ipynb b/06_text/01_exercises_palindromes.ipynb
new file mode 100644
index 0000000..b8a8c33
--- /dev/null
+++ b/06_text/01_exercises_palindromes.ipynb
@@ -0,0 +1,995 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Run All*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *after* finishing the exercises to ensure that your solution runs top to bottom *without* any errors. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/06_text/01_exercises.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 6: Text & Bytes (Coding Exercises)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The exercises below assume that you have read the [first part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/00_content.ipynb) of Chapter 6.\n",
+ "\n",
+ "The `...`'s in the code cells indicate where you need to fill in code snippets. The number of `...`'s within a code cell give you a rough idea of how many lines of code are needed to solve the task. You should not need to create any additional code cells for your final solution. However, you may want to use temporary code cells to try out some ideas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Detecting Palindromes"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "[Palindromes ](https://en.wikipedia.org/wiki/Palindrome) are sequences of characters that read the same backward as forward. Examples are first names like \"Hannah\" or \"Otto,\" words like \"radar\" or \"level,\" or sentences like \"Was it a car or a cat I saw?\"\n",
+ "\n",
+ "In this exercise, you implement various functions that check if the given arguments are palindromes or not. We start with an iterative implementation and end with a recursive one.\n",
+ "\n",
+ "Conceptually, the first function, `unpythonic_palindrome()`, is similar to the \"*Is the square of a number in `[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]` greater than `100`?*\" example in [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/03_content.ipynb#Example:-Is-the-square-of-a-number-in-[7,-11,-8,-5,-3,-12,-2,-6,-9,-10,-1,-4]-greater-than-100?): It assumes that the `text` argument is a palindrome (i.e., it initializes `is_palindrom` to `True`) and then checks in a `for`-loop if a pair of corresponding characters, `forward` and `backward`, contradicts that.\n",
+ "\n",
+ "**Q1**: How many iterations are needed in the `for`-loop? Take into account that `text` may contain an even or odd number of characters! Inside `unpythonic_palindrome()` below, write an expression whose result is assigned to `chars_to_check`!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer > "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: `forward_index` is the index going from left to right. How can we calculate `backward_index`, the index going from right to left, for a given `forward_index`? Write an expression whose result is assigned to `backward_index`! Then, use the indexing operator `[]` to obtain the two characters, `forward` and `backward`, from `text`."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: Finish `unpythonic_palindrome()` below! Add code that adjusts `text` such that the function is case insensitive if the `ignore_case` argument is `True`! Make sure that the function returns once the first pair of corresponding characters does not match!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def unpythonic_palindrome(text, *, ignore_case=True):\n",
+ " \"\"\"Check if a text is a palindrome or not.\n",
+ "\n",
+ " Args:\n",
+ " text (str): Text to be checked; must be an individual word\n",
+ " ignore_case (bool): If the check is case insensitive; defaults to True\n",
+ "\n",
+ " Returns:\n",
+ " is_palindrome (bool)\n",
+ " \"\"\"\n",
+ " # answer to Q3\n",
+ " is_palindrome = ...\n",
+ " if ignore_case:\n",
+ " ...\n",
+ " # answer to Q1\n",
+ " chars_to_check = ...\n",
+ "\n",
+ " for forward_index in range(chars_to_check):\n",
+ " # answer to Q2\n",
+ " backward_index = ...\n",
+ " forward = ...\n",
+ " backward = ...\n",
+ "\n",
+ " print(forward, \"and\", backward) # added for didactical purposes\n",
+ "\n",
+ " # answer to Q3\n",
+ " if ...:\n",
+ " is_palindrome = ...\n",
+ " ...\n",
+ "\n",
+ " return is_palindrome"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: Ensure that `unpythonic_palindrome()` works for the provided test cases (i.e., the `assert` statements do *not* raise an `AssertionError`)! Also, for each of the test cases, provide a brief explanation of what makes them *unique*!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert unpythonic_palindrome(\"noon\") is True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your explanation 1 >"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert unpythonic_palindrome(\"Hannah\") is True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your explanation 2 >"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert unpythonic_palindrome(\"Hannah\", ignore_case=False) is False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your explanation 3 >"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert unpythonic_palindrome(\"radar\") is True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your explanation 4 >"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert unpythonic_palindrome(\"Hanna\") is False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your explanation 5 >"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert unpythonic_palindrome(\"Warsaw\") is False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your explanation 6 >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "`unpythonic_palindrome()` is considered *not* Pythonic as it uses index variables to implement the looping logic. Instead, we should simply loop over an *iterable* object to work with its elements one by one.\n",
+ "\n",
+ "**Q5**: Copy your solutions to the previous questions into `almost_pythonic_palindrome()` below!\n",
+ "\n",
+ "**Q6**: The [reversed() ](https://docs.python.org/3/library/functions.html#reversed) and [zip() ](https://docs.python.org/3/library/functions.html#zip) built-ins allow us to loop over the same `text` argument *in parallel* in both forward *and* backward order. Finish the `for` statement's header line to do just that!\n",
+ "\n",
+ "Hint: You may need to slice the `text` argument."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def almost_pythonic_palindrome(text, *, ignore_case=True):\n",
+ " \"\"\"Check if a text is a palindrome or not.\n",
+ "\n",
+ " Args:\n",
+ " text (str): Text to be checked; must be an individual word\n",
+ " ignore_case (bool): If the check is case insensitive; defaults to True\n",
+ "\n",
+ " Returns:\n",
+ " is_palindrome (bool)\n",
+ " \"\"\"\n",
+ " # answers from above\n",
+ " is_palindrome = ...\n",
+ " if ignore_case:\n",
+ " ...\n",
+ " chars_to_check = ...\n",
+ "\n",
+ " # answer to Q6\n",
+ " for ... in ...:\n",
+ "\n",
+ " print(forward, \"and\", backward) # added for didactical purposes\n",
+ "\n",
+ " # answers from above\n",
+ " if ...:\n",
+ " is_palindrome = ...\n",
+ " ...\n",
+ "\n",
+ " return is_palindrome"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7**: Verify that the test cases work as before!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert almost_pythonic_palindrome(\"noon\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert almost_pythonic_palindrome(\"Hannah\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert almost_pythonic_palindrome(\"Hannah\", ignore_case=False) is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert almost_pythonic_palindrome(\"radar\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert almost_pythonic_palindrome(\"Hanna\") is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert almost_pythonic_palindrome(\"Warsaw\") is False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q8**: `almost_pythonic_palindrome()` above may be made more Pythonic by removing the variable `is_palindrome` with the *early exit* pattern. Make the corresponding changes!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def pythonic_palindrome(text, *, ignore_case=True):\n",
+ " \"\"\"Check if a text is a palindrome or not.\n",
+ "\n",
+ " Args:\n",
+ " text (str): Text to be checked; must be an individual word\n",
+ " ignore_case (bool): If the check is case insensitive; defaults to True\n",
+ "\n",
+ " Returns:\n",
+ " is_palindrome (bool)\n",
+ " \"\"\"\n",
+ " # answers from above\n",
+ " if ignore_case:\n",
+ " ...\n",
+ " chars_to_check = ...\n",
+ "\n",
+ " for ... in ...:\n",
+ "\n",
+ " print(forward, \"and\", backward) # added for didactical purposes\n",
+ "\n",
+ " if ...:\n",
+ " # answer to Q8\n",
+ " ...\n",
+ "\n",
+ " # answer to Q8\n",
+ " return ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q9**: Verify that the test cases still work!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert pythonic_palindrome(\"noon\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "assert pythonic_palindrome(\"Hannah\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert pythonic_palindrome(\"Hannah\", ignore_case=False) is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert pythonic_palindrome(\"radar\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert pythonic_palindrome(\"Hanna\") is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert pythonic_palindrome(\"Warsaw\") is False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q10**: `pythonic_palindrome()` is *not* able to check numeric palindromes. In addition to the string method that implements the case insensitivity and that essentially causes the `AttributeError`, what *abstract behaviors* are numeric data types, such as the `int` type in the example below, missing that would also cause runtime errors? "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pythonic_palindrome(12321)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q11**: Copy your code from `pythonic_palindrome()` above into `palindrome_ducks()` below and make the latter conform to *duck typing*!\n",
+ "\n",
+ "Hints: You may want to use the [str() ](https://docs.python.org/3/library/functions.html#func-str) built-in. You only need to add *one* short line of code."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def palindrome_ducks(text, *, ignore_case=True):\n",
+ " \"\"\"Check if a text is a palindrome or not.\n",
+ "\n",
+ " Args:\n",
+ " text (str): Text to be checked; must be an individual word\n",
+ " ignore_case (bool): If the check is case insensitive; defaults to True\n",
+ "\n",
+ " Returns:\n",
+ " is_palindrome (bool)\n",
+ " \"\"\"\n",
+ " # answer to Q11\n",
+ " ...\n",
+ " # answers from above\n",
+ " if ignore_case:\n",
+ " text = ...\n",
+ " chars_to_check = ...\n",
+ "\n",
+ " for ... in ...:\n",
+ " if ...:\n",
+ " ...\n",
+ "\n",
+ " return ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q12**: Verify that the two new test cases work as well!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert palindrome_ducks(12321) is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert palindrome_ducks(12345) is False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "`palindrome_ducks()` can *not* process palindromes that consist of more than one word."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "palindrome_ducks(\"Never odd or even.\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "palindrome_ducks(\"Eva, can I stab bats in a cave?\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "palindrome_ducks(\"A man, a plan, a canal - Panama.\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "palindrome_ducks(\"A Santa lived as a devil at NASA!\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "palindrome_ducks(\"\"\"\n",
+ " Dennis, Nell, Edna, Leon, Nedra, Anita, Rolf, Nora, Alice, Carol, Leo, Jane,\n",
+ " Reed, Dena, Dale, Basil, Rae, Penny, Lana, Dave, Denny, Lena, Ida, Bernadette,\n",
+ " Ben, Ray, Lila, Nina, Jo, Ira, Mara, Sara, Mario, Jan, Ina, Lily, Arne, Bette,\n",
+ " Dan, Reba, Diane, Lynn, Ed, Eva, Dana, Lynne, Pearl, Isabel, Ada, Ned, Dee,\n",
+ " Rena, Joel, Lora, Cecil, Aaron, Flora, Tina, Arden, Noel, and Ellen sinned.\n",
+ "\"\"\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q13**: Implement the final iterative version `is_a_palindrome()` below. Copy your solution from `palindrome_ducks()` above and add code that removes the \"special\" characters (and symbols) from the longer example palindromes above so that they are effectively ignored! Note that this processing should only be done if the `ignore_symbols` argument is set to `True`.\n",
+ "\n",
+ "Hints: Use the [replace() ](https://docs.python.org/3/library/stdtypes.html#str.replace) method on the `str` type to achieve that. You may want to do so within another `for`-loop."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def is_a_palindrome(text, *, ignore_case=True, ignore_symbols=True):\n",
+ " \"\"\"Check if a text is a palindrome or not.\n",
+ "\n",
+ " Args:\n",
+ " text (str): Text to be checked; may be multiple words\n",
+ " ignore_case (bool): If the check is case insensitive; defaults to True\n",
+ " ignore_symbols (bool): If special characters like \".\" or \"?\" and others\n",
+ " are ignored; defaults to True\n",
+ "\n",
+ " Returns:\n",
+ " is_palindrome (bool)\n",
+ " \"\"\"\n",
+ " # answers from above\n",
+ " ...\n",
+ " if ignore_case:\n",
+ " ...\n",
+ " # answer to Q13\n",
+ " if ignore_symbols:\n",
+ " for ... in ...:\n",
+ " ...\n",
+ " # answers from above\n",
+ " chars_to_check = ...\n",
+ "\n",
+ " for ... in ...:\n",
+ " if ...:\n",
+ " ...\n",
+ "\n",
+ " return ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q14**: Verify that all test cases below work!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(\"noon\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(\"Hannah\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(\"Hannah\", ignore_case=False) is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(\"radar\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(\"Hanna\") is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(\"Warsaw\") is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(12321) is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(12345) is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(\"Never odd or even.\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(\"Never odd or even.\", ignore_symbols=False) is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(\"Eva, can I stab bats in a cave?\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(\"A man, a plan, a canal - Panama.\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(\"A Santa lived as a devil at NASA!\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert is_a_palindrome(\"\"\"\n",
+ " Dennis, Nell, Edna, Leon, Nedra, Anita, Rolf, Nora, Alice, Carol, Leo, Jane,\n",
+ " Reed, Dena, Dale, Basil, Rae, Penny, Lana, Dave, Denny, Lena, Ida, Bernadette,\n",
+ " Ben, Ray, Lila, Nina, Jo, Ira, Mara, Sara, Mario, Jan, Ina, Lily, Arne, Bette,\n",
+ " Dan, Reba, Diane, Lynn, Ed, Eva, Dana, Lynne, Pearl, Isabel, Ada, Ned, Dee,\n",
+ " Rena, Joel, Lora, Cecil, Aaron, Flora, Tina, Arden, Noel, and Ellen sinned.\n",
+ "\"\"\") is True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now, let's look at a *recursive* formulation in `recursive_palindrome()` below.\n",
+ "\n",
+ "**Q15**: Copy the code from `is_a_palindrome()` that implements the duck typing, the case insensitivity, and the removal of special characters!\n",
+ "\n",
+ "The recursion becomes apparent if we remove the *first* and the *last* character from a given `text`: `text` can only be a palindrome if the two removed characters are the same *and* the remaining substring is a palindrome itself! So, the word `\"noon\"` has only *one* recursive call while `\"radar\"` has *two*.\n",
+ "\n",
+ "Further, `recursive_palindrome()` has *two* base cases of which only *one* is reached for a given `text`: First, if `recursive_palindrome()` is called with either an empty `\"\"` or a `text` argument with `len(text) == 1`, and, second, if the two removed characters are *not* the same.\n",
+ "\n",
+ "**Q16**: Implement the two base cases in `recursive_palindrome()`! Use the *early exit* pattern!\n",
+ "\n",
+ "**Q17**: Add the recursive call to `recursive_palindrome()` with a substring of `text`! Pass in the `ignore_case` and `ignore_symbols` arguments as `False`! This avoids unnecessary computations in the recursive calls. Why is that the case?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def recursive_palindrome(text, *, ignore_case=True, ignore_symbols=True):\n",
+ " \"\"\"Check if a text is a palindrome or not.\n",
+ "\n",
+ " Args:\n",
+ " text (str): Text to be checked; may be multiple words\n",
+ " ignore_case (bool): If the check is case insensitive; defaults to True\n",
+ " ignore_symbols (bool): If special characters like \".\" or \"?\" and others\n",
+ " are ignored; defaults to True\n",
+ "\n",
+ " Returns:\n",
+ " is_palindrome (bool)\n",
+ " \"\"\"\n",
+ " # answers from above\n",
+ " ...\n",
+ " if ignore_case:\n",
+ " ...\n",
+ " if ignore_symbols:\n",
+ " for ... in ...:\n",
+ " ...\n",
+ "\n",
+ " # answer to Q16\n",
+ " if ...:\n",
+ " ...\n",
+ " elif ...:\n",
+ " ...\n",
+ "\n",
+ " # answer to Q17\n",
+ " return ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q18**: Lastly, verify that `recursive_palindrome()` passes all the test cases below!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(\"noon\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(\"Hannah\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(\"Hannah\", ignore_case=False) is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(\"radar\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(\"Hanna\") is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(\"Warsaw\") is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(12321) is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(12345) is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(\"Never odd or even.\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(\"Never odd or even.\", ignore_symbols=False) is False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(\"Eva, can I stab bats in a cave?\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(\"A man, a plan, a canal - Panama.\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(\"A Santa lived as a devil at NASA!\") is True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "assert recursive_palindrome(\"\"\"\n",
+ " Dennis, Nell, Edna, Leon, Nedra, Anita, Rolf, Nora, Alice, Carol, Leo, Jane,\n",
+ " Reed, Dena, Dale, Basil, Rae, Penny, Lana, Dave, Denny, Lena, Ida, Bernadette,\n",
+ " Ben, Ray, Lila, Nina, Jo, Ira, Mara, Sara, Mario, Jan, Ina, Lily, Arne, Bette,\n",
+ " Dan, Reba, Diane, Lynn, Ed, Eva, Dana, Lynne, Pearl, Isabel, Ada, Ned, Dee,\n",
+ " Rena, Joel, Lora, Cecil, Aaron, Flora, Tina, Arden, Noel, and Ellen sinned.\n",
+ "\"\"\") is True"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/06_text/02_content.ipynb b/06_text/02_content.ipynb
new file mode 100644
index 0000000..887deb5
--- /dev/null
+++ b/06_text/02_content.ipynb
@@ -0,0 +1,2110 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/06_text/01_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 6: Text & Bytes (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In this second part of the chapter, we look in more detail at how `str` objects work in memory, in particular how the $0$s and $1$s in the memory translate into characters."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Special Characters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As previously seen, some characters have a special meaning when following the **escape character** `\"\\\"`. Besides escaping the kind of quote used as the `str` object's delimiter, `'` or `\"`, most of these **escape sequences** (i.e., `\"\\\"` with the subsequent character), act as a **control character** that moves the \"cursor\" in the output *without* generating any pixel on the screen. Because of that, we only see the effect of such escape sequences when used with the [print() ](https://docs.python.org/3/library/functions.html#print) function. The [documentation ](https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals) lists all available escape sequences, of which we show the most important ones below.\n",
+ "\n",
+ "The most common escape sequence is `\"\\n\"` that \"prints\" a [newline character ](https://en.wikipedia.org/wiki/Newline) that is also called the line feed character or LF for short."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'This is a sentence\\nthat is printed\\non three lines.'"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"This is a sentence\\nthat is printed\\non three lines.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "This is a sentence\n",
+ "that is printed\n",
+ "on three lines.\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"This is a sentence\\nthat is printed\\non three lines.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`\"\\b\"` is the [backspace character ](https://en.wikipedia.org/wiki/Backspace), or BS for short, that moves the cursor back by one character."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ABX\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"ABC\\bX\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ABXY\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"ABC\\bXY\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Similarly, `\"\\r\"` is the [carriage return character ](https://en.wikipedia.org/wiki/Carriage_return), or CR for short, that moves the cursor back to the beginning of the line."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "XBC\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"ABC\\rX\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "XYC\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"ABC\\rXY\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While Linux and modern MacOS systems use solely `\"\\n\"` to express a new line, Windows systems default to using `\"\\r\\n\"`. This may lead to \"weird\" bugs on software projects where people using both kind of operating systems collaborate."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "This is a sentence\n",
+ "that is printed\n",
+ "on three lines.\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"This is a sentence\\r\\nthat is printed\\r\\non three lines.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`\"\\t\"` makes the cursor \"jump\" in equidistant tab stops. That may be useful for formatting a program with lengthy and tabular results."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Jump\tfrom\ttab\tstop\tto\ttab\tstop.\n",
+ "The\tsecond\tline\tdoes\tso\ttoo.\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Jump\\tfrom\\ttab\\tstop\\tto\\ttab\\tstop.\\nThe\\tsecond\\tline\\tdoes\\tso\\ttoo.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Raw Strings"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Sometimes we do *not* want the backslash `\"\\\"` and its subsequent character be interpreted as an escape sequence. For example, let's print a typical installation path on a Windows systems. Obviously, the newline character `\"\\n\"` does *not* makes sense here."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "C:\\Programs\n",
+ "ew_application\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "<>:1: SyntaxWarning: invalid escape sequence '\\P'\n",
+ "<>:1: SyntaxWarning: invalid escape sequence '\\P'\n",
+ "/tmp/ipykernel_159416/1102122489.py:1: SyntaxWarning: invalid escape sequence '\\P'\n",
+ " print(\"C:\\Programs\\new_application\")\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"C:\\Programs\\new_application\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Some `str` objects even produce a `SyntaxError` because the `\"\\U\"` can *not* be interpreted as a Unicode code point (cf., next section)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "(unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \\UXXXXXXXX escape (2296736867.py, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m Cell \u001b[0;32mIn[10], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m print(\"C:\\Users\\Administrator\\Desktop\\Project\")\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m (unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \\UXXXXXXXX escape\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"C:\\Users\\Administrator\\Desktop\\Project\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A simple solution would be to escape the escape character with a *second* backslash `\"\\\"`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "C:\\Programs\\new_application\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"C:\\\\Programs\\\\new_application\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "C:\\Users\\Administrator\\Desktop\\Project\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"C:\\\\Users\\\\Administrator\\\\Desktop\\\\Project\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, this is tedious to remember and type. For such use cases, Python allows to prefix any string literal with a `r`. The literal is then interpreted in a \"raw\" way."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "C:\\Programs\\new_application\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(r\"C:\\Programs\\new_application\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "C:\\Users\\Administrator\\Desktop\\Project\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(r\"C:\\Users\\Administrator\\Desktop\\Project\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Characters are Numbers with a Convention"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "So far, we used the term **character** without any further consideration. In this section, we briefly look into what characters are and how they are modeled in software.\n",
+ "\n",
+ "[Chapter 5 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/00_content.ipynb) gives us an idea on how individual **bits** are used to express all types of numbers, from \"simple\" `int` objects to \"complex\" `float` ones. To model characters, another **layer of abstraction** is put on top of whole numbers. So, just as bits are used to express integers, they themselves are used to express characters."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### ASCII"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Many conventions have been developed as to what integer is associated with which character. The most basic one that was also adopted around the world is the the so-called [American Standard Code for Information Interchange ](https://en.wikipedia.org/wiki/ASCII), or **ASCII** for short. It uses 7 bits of information to map the unprintable control characters as well as the printable letters of the alphabet, numbers, and common symbols to the numbers `0` through `127`.\n",
+ "\n",
+ "A mapping from characters to numbers is referred to by the technical term **encoding**. We may use the built-in [ord() ](https://docs.python.org/3/library/functions.html#ord) function to **encode** any single character. The inverse to that is the built-in [chr() ](https://docs.python.org/3/library/functions.html#chr) function, which **decodes** a number into a character."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "65"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "ord(\"A\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'A'"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "chr(65)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Of course, unprintable escape sequences like `\"\\n\"` count as only *one* character."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "10"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "ord(\"\\n\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'\\n'"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "chr(10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In ASCII, the numbers `0` through `31` (and `127`) are mapped to all kinds of unprintable control characters. The decimal digits are encoded with the numbers `48` through `57`, the upper case letters with `65` through `90`, and the lower case letters with `97` through `122`. While this seems random as first, there is of course a \"sophisticated\" system behind it. That can immediately be seen when looking at the encoded numbers in their *binary* representations.\n",
+ "\n",
+ "For example, the digit `5` is mapped to the number `53` in ASCII. The binary representation of `53` is `0b_11_0101` and the least significant four bits, `0101`, mean $5$. Similarly, the letter `\"E\"` is the fifth letter in the alphabet. It is encoded with the number `69` in ASCII, which is `0b_100_0101` in binary. And, the least significant bits, `0_0101`, mean $5$. Analogously, `\"e\"` is encoded with `101` in ASCII, which is `0b_110_0101` in binary. And, the least significant bits, `0_0101`, mean $5$ again. This encoding was chosen mainly because programmers \"in the old days\" needed to implement these encodings \"by hand.\" Python abstracts that logic away from its users.\n",
+ "\n",
+ "This encoding scheme is also the cause for the \"weird\" sorting in the \"*String Comparison*\" section in the [first part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/01_content.ipynb#String-Comparison) of this chapter, where `\"apple\"` comes *after* `\"Banana\"`. As `\"a\"` is encoded with `97` and `\"B\"` with `66`, `\"Banana\"` must of course be \"smaller\" than `\"apple\"` when comparison is done in a pairwise fashion of the individual characters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "48 0b110000 -> 0\n",
+ "49 0b110001 -> 1\n",
+ "50 0b110010 -> 2\n",
+ "51 0b110011 -> 3\n",
+ "52 0b110100 -> 4\n",
+ "53 0b110101 -> 5\n",
+ "54 0b110110 -> 6\n",
+ "55 0b110111 -> 7\n",
+ "56 0b111000 -> 8\n",
+ "57 0b111001 -> 9\n"
+ ]
+ }
+ ],
+ "source": [
+ "for number in range(48, 58):\n",
+ " print(number, bin(number), \"-> \", chr(number))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "65 0b1000001 -> A\t66 0b1000010 -> B\t67 0b1000011 -> C\n",
+ "68 0b1000100 -> D\t69 0b1000101 -> E\t70 0b1000110 -> F\n",
+ "71 0b1000111 -> G\t72 0b1001000 -> H\t73 0b1001001 -> I\n",
+ "74 0b1001010 -> J\t75 0b1001011 -> K\t76 0b1001100 -> L\n",
+ "77 0b1001101 -> M\t78 0b1001110 -> N\t79 0b1001111 -> O\n",
+ "80 0b1010000 -> P\t81 0b1010001 -> Q\t82 0b1010010 -> R\n",
+ "83 0b1010011 -> S\t84 0b1010100 -> T\t85 0b1010101 -> U\n",
+ "86 0b1010110 -> V\t87 0b1010111 -> W\t88 0b1011000 -> X\n",
+ "89 0b1011001 -> Y\t90 0b1011010 -> Z\t"
+ ]
+ }
+ ],
+ "source": [
+ "for i, number in enumerate(range(65, 91), start=1):\n",
+ " end = \"\\n\" if i % 3 == 0 else \"\\t\"\n",
+ " print(number, bin(number), \"-> \", chr(number), end=end)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " 97 0b1100001 -> a\t 98 0b1100010 -> b\t 99 0b1100011 -> c\n",
+ "100 0b1100100 -> d\t101 0b1100101 -> e\t102 0b1100110 -> f\n",
+ "103 0b1100111 -> g\t104 0b1101000 -> h\t105 0b1101001 -> i\n",
+ "106 0b1101010 -> j\t107 0b1101011 -> k\t108 0b1101100 -> l\n",
+ "109 0b1101101 -> m\t110 0b1101110 -> n\t111 0b1101111 -> o\n",
+ "112 0b1110000 -> p\t113 0b1110001 -> q\t114 0b1110010 -> r\n",
+ "115 0b1110011 -> s\t116 0b1110100 -> t\t117 0b1110101 -> u\n",
+ "118 0b1110110 -> v\t119 0b1110111 -> w\t120 0b1111000 -> x\n",
+ "121 0b1111001 -> y\t122 0b1111010 -> z\t"
+ ]
+ }
+ ],
+ "source": [
+ "for i, number in enumerate(range(97, 123), start=1):\n",
+ " end = \"\\n\" if i % 3 == 0 else \"\\t\"\n",
+ " print(str(number).rjust(3), bin(number), \"-> \", chr(number), end=end)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The remaining `symbols` encoded in ASCII are encoded with the numbers still unused, which is why they are scattered."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "symbols = (\n",
+ " list(range(32, 48))\n",
+ " + list(range(58, 65))\n",
+ " + list(range(91, 97))\n",
+ " + list(range(123, 127))\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " 32 0b100000 -> \t 33 0b100001 -> !\t 34 0b100010 -> \"\n",
+ " 35 0b100011 -> #\t 36 0b100100 -> $\t 37 0b100101 -> %\n",
+ " 38 0b100110 -> &\t 39 0b100111 -> '\t 40 0b101000 -> (\n",
+ " 41 0b101001 -> )\t 42 0b101010 -> *\t 43 0b101011 -> +\n",
+ " 44 0b101100 -> ,\t 45 0b101101 -> -\t 46 0b101110 -> .\n",
+ " 47 0b101111 -> /\t 58 0b111010 -> :\t 59 0b111011 -> ;\n",
+ " 60 0b111100 -> <\t 61 0b111101 -> =\t 62 0b111110 -> >\n",
+ " 63 0b111111 -> ?\t 64 0b1000000 -> @\t 91 0b1011011 -> [\n",
+ " 92 0b1011100 -> \\\t 93 0b1011101 -> ]\t 94 0b1011110 -> ^\n",
+ " 95 0b1011111 -> _\t 96 0b1100000 -> `\t123 0b1111011 -> {\n",
+ "124 0b1111100 -> |\t125 0b1111101 -> }\t126 0b1111110 -> ~\n"
+ ]
+ }
+ ],
+ "source": [
+ "for i, number in enumerate(symbols, start=1):\n",
+ " end = \"\\n\" if i % 3 == 0 else \"\\t\"\n",
+ " print(str(number).rjust(3), bin(number).rjust(10), \"-> \", chr(number), end=end)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As the ASCII character set does not work for many languages other than English, various encodings were developed. Popular examples are [ISO 8859-1 ](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) for western European letters or [Windows 1250 ](https://en.wikipedia.org/wiki/Windows-1250) for Latin ones. Many of these encodings use 8-bit numbers (i.e., `0` through `255`) to map the multitude of non-English letters (e.g., the German [umlauts ](https://en.wikipedia.org/wiki/Umlaut_%28linguistics%29) `\"ä\"`, `\"ö\"`, `\"ü\"`, or `\"ß\"`)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Unicode"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, none of these specialized encodings can map *all* characters of *all* languages around the world from *all* times in human history. To achieve that, a truly global standard called **[Unicode ](https://en.wikipedia.org/wiki/Unicode)** was developed and its first version released in 1991. Since then, Unicode has been amended with many other \"characters.\" The most popular among them being [emojis ](https://en.wikipedia.org/wiki/Emoji) or the [Klingon ](https://en.wikipedia.org/wiki/Klingon_scripts) language (from the science fiction series [Star Trek ](https://en.wikipedia.org/wiki/Star_Trek)). In Unicode, every character is given an identity referred to as the **code point**. Code points are hexadecimal numbers from `0x0000` through `0x10ffff`, written as U+0000 and U+10FFFF outside of Python. Consequently, there exist at most $1,114,112$ code points, of which only about 10% are currently in use, allowing lots of room for new characters to be invented. The first `127` code points are identical to the ASCII encoding for reasons explained in the \"*The `bytes` Type*\" section further below. There exist plenty of lists of all Unicode characters on the web (e.g., [Wikipedia ](https://en.wikipedia.org/wiki/List_of_Unicode_characters)).\n",
+ "\n",
+ "All we need to know to print a character is its code point. Python uses the escape sequence `\"\\U\"` that is followed by eight hexadecimal digits. Underscore separators are unfortunately *not* allowed here.\n",
+ "\n",
+ "So, to print a smiley, we just need to look up the corresponding number (e.g., [here ](https://en.wikipedia.org/wiki/Emoji#Unicode_blocks))."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'😄'"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"\\U0001f604\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Every Unicode character also has a descriptive name that we can use with the escape sequence `\"\\N\"` and within curly braces `{}`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'😂'"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"\\N{FACE WITH TEARS OF JOY}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Whenever the code point can be expressed with just four hexadecimal digits, we may use the escape sequence `\"\\u\"` for brevity."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'A'"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"\\U00000041\" # hex(65) == 0x41"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'A'"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"\\u0041\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Analogously, if the code point can be expressed with two hexadecimal digits, we may use the escape sequence `\"\\x\"` for even conciser code."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'A'"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"\\x41\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As the `str` type is based on Unicode, a `str` object's behavior is more in line with how humans view text and not how it is expressed in source code.\n",
+ "\n",
+ "For example, while it is obvious that `len(\"A\")` evaluates to `1`, ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(\"A\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "... what should `len(\"\\N{SNAKE}\")` evaluate to? As the idea of a snake is expressed as *one* \"character,\" [len() ](https://docs.python.org/3/library/functions.html#len) also returns `1` here."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'🐍'"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"\\N{SNAKE}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(\"\\N{SNAKE}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Many of the built-in `str` methods also consider Unicode. For example, in contrast to [lower() ](https://docs.python.org/3/library/stdtypes.html#str.lower), the [casefold() ](https://docs.python.org/3/library/stdtypes.html#str.casefold) method knows that the German `\"ß\"` is commonly converted to `\"ss\"`. So, when searching for exact matches, normalizing text with [casefold() ](https://docs.python.org/3/library/stdtypes.html#str.casefold) may yield better results than with [lower() ](https://docs.python.org/3/library/stdtypes.html#str.lower)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'straße'"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Straße\".lower()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'strasse'"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"Straße\".casefold()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Many other methods like [isdecimal() ](https://docs.python.org/3/library/stdtypes.html#str.isdecimal), [isdigit() ](https://docs.python.org/3/library/stdtypes.html#str.isdigit), [isnumeric() ](https://docs.python.org/3/library/stdtypes.html#str.isnumeric), [isprintable() ](https://docs.python.org/3/library/stdtypes.html#str.isprintable), [isidentifier() ](https://docs.python.org/3/library/stdtypes.html#str.isidentifier), and many more may be worthwhile to know for the data science practitioner, especially when it comes to data cleaning."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Multi-line Strings"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Sometimes, it is convenient to split text across multiple lines in source code. For example, to make lines fit into the 79 characters requirement of [PEP 8 ](https://www.python.org/dev/peps/pep-0008/) or because the text consists of many lines and typing out `\"\\n\"` is tedious. However, using single double quotes `\"` around multiple lines results in a `SyntaxError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "unterminated string literal (detected at line 1) (2682216481.py, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m Cell \u001b[0;32mIn[34], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m \"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m unterminated string literal (detected at line 1)\n"
+ ]
+ }
+ ],
+ "source": [
+ "\"\n",
+ "Do not break the lines like this\n",
+ "\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Instead, we may enclose a string literal with either **triple double** quotes `\"\"\"` or **triple single** quotes `'''`. Then, newline characters in the source code are converted into `\"\\n\"` characters in the resulting `str` object. Docstrings are precisely that, and, by convention, always written within triple double quotes `\"\"\"`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "multi_line = \"\"\"\n",
+ "I am a multi-line string\n",
+ "consisting of four lines.\n",
+ "\"\"\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A caveat is that `\"\\n\"` characters are often inserted at the beginning or end of the text when we try to format the source code nicely."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'\\nI am a multi-line string\\nconsisting of four lines.\\n'"
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "multi_line"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "I am a multi-line string\n",
+ "consisting of four lines.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(multi_line)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Using the [split() ](https://docs.python.org/3/library/stdtypes.html#str.split) method with the optional `sep` argument, we confirm that `multi_line` consists of *four* lines with the first and last line being empty."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1 \n",
+ "2 I am a multi-line string\n",
+ "3 consisting of four lines.\n",
+ "4 \n"
+ ]
+ }
+ ],
+ "source": [
+ "for i, line in enumerate(multi_line.split(\"\\n\"), start=1):\n",
+ " print(i, line)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To mitigate that, we often see the [strip() ](https://docs.python.org/3/library/stdtypes.html#bytes.strip) method in source code."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "multi_line = \"\"\"\n",
+ "I am a multi-line string\n",
+ "consisting of two lines.\n",
+ "\"\"\".strip()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1 I am a multi-line string\n",
+ "2 consisting of two lines.\n"
+ ]
+ }
+ ],
+ "source": [
+ "for i, line in enumerate(multi_line.split(\"\\n\"), start=1):\n",
+ " print(i, line)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `bytes` Type"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To end this chapter, we want to briefly look at the `bytes` data type, which conceptually is a sequence of bytes. That data format is probably one of the most generic ways of exchanging data between any two programs or computers (e.g., a web browser obtains its data from a web server in this format).\n",
+ "\n",
+ "Let's open a binary file in read-only mode (i.e., `mode=\"rb\"`) and read in all of its contents."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "with open(\"full_house.bin\", mode=\"rb\") as binary_file:\n",
+ " data = binary_file.read()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`data` is an object of type `bytes`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "139880714782512"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "bytes"
+ ]
+ },
+ "execution_count": 43,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(data)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "It's value is given out in the literal bytes notation with a `b` prefix (cf., the [reference ](https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals)). Every byte is expressed in hexadecimal representation with the escape sequence `\"\\x\"`. This representation is commonly chosen as we can *not* tell what kind of information is hidden in the `data` by just looking at the bytes. Instead, we must be told by some other source how to **decode** the raw bytes into information we can interpret."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "b'\\xf0\\x9f\\x82\\xa7\\xf0\\x9f\\x82\\xb7\\xf0\\x9f\\x83\\x97\\xf0\\x9f\\x83\\x8e\\xf0\\x9f\\x83\\x9e'"
+ ]
+ },
+ "execution_count": 44,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`bytes` objects work like `str` objects in many ways. In particular, they are *sequences* as well: The number of bytes is *finite* and we may *iterate* over them in *order*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "20"
+ ]
+ },
+ "execution_count": 45,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(data)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Consisting of 8 bits, a single byte can always be interpreted as a whole number between `0` through `255`. That is exactly what we see when we loop over the `data` ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "240 159 130 167 240 159 130 183 240 159 131 151 240 159 131 142 240 159 131 158 "
+ ]
+ }
+ ],
+ "source": [
+ "for byte in data:\n",
+ " print(byte, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "... or index into them."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "158"
+ ]
+ },
+ "execution_count": 47,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "data[-1]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Slicing returns another `bytes` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "b'\\xf0\\x82\\xf0\\x82\\xf0\\x83\\xf0\\x83\\xf0\\x83'"
+ ]
+ },
+ "execution_count": 48,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "data[::2]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Character Encodings"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Luckily, `data` consists of bytes encoded with the [UTF-8 ](https://en.wikipedia.org/wiki/UTF-8) encoding. That is the most common way of mapping a Unicode character's code point to a sequence of bytes.\n",
+ "\n",
+ "To obtain a `str` object out of a given `bytes` object, we decode it with the `bytes` type's [decode() ](https://docs.python.org/3/library/stdtypes.html#bytes.decode) method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "cards = data.decode()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "str"
+ ]
+ },
+ "execution_count": 50,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(cards)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "So, `data` consisted of a [full house ](https://en.wikipedia.org/wiki/List_of_poker_hands#Full_house) hand in a poker game."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'🂧🂷🃗🃎🃞'"
+ ]
+ },
+ "execution_count": 51,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "cards"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To go the opposite direction and encode a given `str` object, we use the `str` type's [encode() ](https://docs.python.org/3/library/stdtypes.html#str.encode) method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "place = \"Café Kastanientörtchen\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "b'Caf\\xc3\\xa9 Kastanient\\xc3\\xb6rtchen'"
+ ]
+ },
+ "execution_count": 53,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "place.encode()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "By default, [encode() ](https://docs.python.org/3/library/stdtypes.html#str.encode) and [decode() ](https://docs.python.org/3/library/stdtypes.html#bytes.decode) use an `encoding=\"utf-8\"` argument. We may use another encoding like, for example, `\"iso-8859-1\"`, which can deal with ASCII and western European letters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "b'Caf\\xe9 Kastanient\\xf6rtchen'"
+ ]
+ },
+ "execution_count": 54,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "place.encode(\"iso-8859-1\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, we must use the *same* encoding for the decoding step as for the encoding step. Otherwise, a `UnicodeDecodeError` is raised."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "UnicodeDecodeError",
+ "evalue": "'utf-8' codec can't decode byte 0xe9 in position 3: invalid continuation byte",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mUnicodeDecodeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[55], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mplace\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mencode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43miso-8859-1\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecode\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mUnicodeDecodeError\u001b[0m: 'utf-8' codec can't decode byte 0xe9 in position 3: invalid continuation byte"
+ ]
+ }
+ ],
+ "source": [
+ "place.encode(\"iso-8859-1\").decode()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Not all encodings map all Unicode code points. For example `\"iso-8859-1\"` does not know Czech letters. Below, [encode() ](https://docs.python.org/3/library/stdtypes.html#str.encode) raises a `UnicodeEncodeError` because of that."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "UnicodeEncodeError",
+ "evalue": "'latin-1' codec can't encode character '\\u0159' in position 12: ordinal not in range(256)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mUnicodeEncodeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[56], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mDobrý den, přátelé!\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mencode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43miso-8859-1\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mUnicodeEncodeError\u001b[0m: 'latin-1' codec can't encode character '\\u0159' in position 12: ordinal not in range(256)"
+ ]
+ }
+ ],
+ "source": [
+ "\"Dobrý den, přátelé!\".encode(\"iso-8859-1\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Reading Files (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [open() ](https://docs.python.org/3/library/functions.html#open) function takes an optional `encoding` argument as well."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "UnicodeDecodeError",
+ "evalue": "'utf-8' codec can't decode byte 0xe4 in position 9: invalid continuation byte",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mUnicodeDecodeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[57], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mopen\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mumlauts.txt\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m file:\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(\u001b[43mfile\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreadlines\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m))\n",
+ "File \u001b[0;32m:322\u001b[0m, in \u001b[0;36mdecode\u001b[0;34m(self, input, final)\u001b[0m\n",
+ "\u001b[0;31mUnicodeDecodeError\u001b[0m: 'utf-8' codec can't decode byte 0xe4 in position 9: invalid continuation byte"
+ ]
+ }
+ ],
+ "source": [
+ "with open(\"umlauts.txt\") as file:\n",
+ " print(\"\".join(file.readlines()))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Lerchen-Lärchen-Ähnlichkeiten\n",
+ "fehlen. Dieses abzustreiten\n",
+ "mag im Klang der Worte liegen.\n",
+ "Merke, eine Lerch' kann fliegen,\n",
+ "Lärchen nicht, was kaum verwundert,\n",
+ "denn nicht eine unter hundert\n",
+ "ist geflügelt. Auch im Singen\n",
+ "sind die Bäume zu bezwingen.\n",
+ "Die Bätrachtung sollte reichen,\n",
+ "Rächtschreibfählern auszuweichen.\n",
+ "Leicht gälingt's, zu unterscheiden,\n",
+ "wär ist wär nun von dän beiden.\n"
+ ]
+ }
+ ],
+ "source": [
+ "with open(\"umlauts.txt\", encoding=\"iso-8859-1\") as file:\n",
+ " print(\"\".join(file.readlines()))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Best Practice: Use UTF-8 explicitly"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A best practice is to *always* specify the `encoding`, especially on computers running on Windows (cf., the talk by Łukasz Langa in the [Further Resources ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/05_resources.ipynb#Unicode)) section at the end of this chapter.\n",
+ "\n",
+ "Below is the first example involving [open() ](https://docs.python.org/3/library/functions.html#open) one last time: It shows how *all* the contents of a text file should be read into one `str` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "with open(\"lorem_ipsum.txt\", encoding=\"utf-8\") as file:\n",
+ " content = \"\".join(file.readlines())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"Lorem Ipsum is simply dummy text of the printing and typesetting industry.\\nLorem Ipsum has been the industry's standard dummy text ever since the 1500s\\nwhen an unknown printer took a galley of type and scrambled it to make a type\\nspecimen book. It has survived not only five centuries but also the leap into\\nelectronic typesetting, remaining essentially unchanged. It was popularised in\\nthe 1960s with the release of Letraset sheets.\\n\""
+ ]
+ },
+ "execution_count": 60,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "content"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Lorem Ipsum is simply dummy text of the printing and typesetting industry.\n",
+ "Lorem Ipsum has been the industry's standard dummy text ever since the 1500s\n",
+ "when an unknown printer took a galley of type and scrambled it to make a type\n",
+ "specimen book. It has survived not only five centuries but also the leap into\n",
+ "electronic typesetting, remaining essentially unchanged. It was popularised in\n",
+ "the 1960s with the release of Letraset sheets.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(content)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/06_text/03_summary.ipynb b/06_text/03_summary.ipynb
new file mode 100644
index 0000000..f3ac4d7
--- /dev/null
+++ b/06_text/03_summary.ipynb
@@ -0,0 +1,75 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 6: Text & Bytes (TL;DR)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Textual data is modeled with the **immutable** `str` type.\n",
+ "\n",
+ "The `str` type supports *four* orthogonal **abstract concepts** that together constitute the idea of a **sequence**: Every `str` object is an *iterable container* of a *finite* number of *ordered* characters.\n",
+ "\n",
+ "A single **character** in a `str` object follows the idea of a **Unicode** character. It is mapped to a *unique* **code point** that is encoded into **bytes** with a dedicated character encoding, for example, **UTF-8**."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/06_text/04_review.ipynb b/06_text/04_review.ipynb
new file mode 100644
index 0000000..17dd0a5
--- /dev/null
+++ b/06_text/04_review.ipynb
@@ -0,0 +1,199 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 6: Text & Bytes (Review Questions)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The questions below assume that you have read the [first ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/00_content.ipynb) and [second ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/01_content.ipynb) part of Chapter 6.\n",
+ "\n",
+ "Be concise in your answers! Most questions can be answered in *one* sentence."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Essay Questions "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Answer the following questions *briefly*!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: In what sense is a **\"string\" of characters** a **sequence**? What is a **sequence** after all? A *concrete* **data type**, or something else?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: What is a direct consequence of the `str` type's property of being an **ordered** sequence? What operations could we *not* do with it if it were *unordered*?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: What does it mean for an object to be **immutable**? Discuss how we can verify the `str` type's immutability by comparing the two variables `example` and `full_slice` below. Are they pointing to the *same* object in memory?\n",
+ "```python\n",
+ "example = \"text\"\n",
+ "full_slice = example[:]\n",
+ "```\n",
+ "Hint: Find out what `[:]` does first!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: Describe in your own words what we mean by **string interpolation**!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## True / False Questions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Motivate your answer with *one short* sentence!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: **Triple-double** quotes `\"\"\"` and **triple-single** quotes `'''` create a *new* object of type `text` that models so-called **multi-line strings**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: A **substring** is a string that *subsumes* another string."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7**: Indexing into a `str` object with a *negative* index **fails silently**: It does *neither* raise an error *nor* do anything useful."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q8**: We *cannot* assign a *different* character to an index or slice of a `str` object because it is **immutable**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/06_text/05_resources.ipynb b/06_text/05_resources.ipynb
new file mode 100644
index 0000000..425c6cf
--- /dev/null
+++ b/06_text/05_resources.ipynb
@@ -0,0 +1,365 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/06_text/05_resources.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 6: Text & Bytes (Further Resources)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Unicode"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We refer to the official [Unicode HOWTO ](https://docs.python.org/3/howto/unicode.html) in the Python documentation. Furthermore, the [unicodedata ](https://docs.python.org/3/library/unicodedata.html) module in the [standard library ](https://docs.python.org/3/library/index.html) provides a lot of utility functions around the Unicode standard.\n",
+ "\n",
+ "Next is a brief summary video by the YouTube channel [Computerphile](https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA) titled \"*Characters, Symbols and the Unicode Miracle*\"."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from IPython.display import YouTubeVideo\n",
+ "YouTubeVideo(\"MijmeoH9LT4\", width=\"60%\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In his [PyCon Australia 2018](https://2018.pycon-au.org/) talk titled \"*Unicode and Python: The absolute minimum you need to know*\" [Raphaël Merx](https://www.linkedin.com/raphaelmerx/) explains some caveats and best practices regarding Unicode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "YouTubeVideo(\"oXVmZGN6plY\", width=\"60%\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In a similar talk at [PyCon 2017](https://us.pycon.org/2017/) titled \"*Unicode what is the big deal*\" [Łukasz Langa](https://www.linkedin.com/llanga/) provides further lessons learned regarding Unicode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "YouTubeVideo(\"7m5JA3XaZ4k\", width=\"60%\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In a \"classic\" talk from PyCon 2012 titled \"*Pragmatic Unicode, or, How do I stop the pain?*\" [Ned Batchelder](https://nedbatchelder.com/) explains among others the concept of a \"Unicode Sandwich.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "YouTubeVideo(\"sgHbC6udIqc\", width=\"60%\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Character Encodings"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Lastly, in his entertaining talk at [PyCon.DE 2019](https://de.pycon.org/) titled \"*Your Name is Invalid!*\" [Miroslav Šedivý](https://www.linkedin.com/%C5%A1ediv%C3%BD/) shows how hard it actually is to write software that can process any name a human can possibly have. Miroslav also gave a lightning talk where he shows how he uses only one keyboard for the 12 (!!!) languages he speaks."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAUDBAgICAgICAgICAgGBwgIBwcHBwgICAgICAgICAgICAgIChALCAgPCQgIDRUODhERExMTCAsWGBYSGBASExIBBQUFBwYHDwgIDh4VEhUfGh4bGhseHh0aHRsbGhseHR4bGR8eGRkeGh0dGBofHR0aFxoXGh0XGxgfHx0dFRcdFf/AABEIAWgB4AMBIgACEQEDEQH/xAAdAAEAAgMBAQEBAAAAAAAAAAAABwgEBQYDAQIJ/8QASxAAAQQBAgMDBwkFBwIDCQAAAQACAwQFERIGEyEHFBgiMUFRZqXlCBUyVFWSk9PUI0JhcYEWJDNSYpGhcvAJgrIXNDU2Q3S00eH/xAAbAQEAAgMBAQAAAAAAAAAAAAAAAgQBBQYDB//EADIRAQABAwMCBAQFAwUAAAAAAAABAgMREiFhBDEFE0FRInGRsQaB0eHwMqHxFCNCUsH/2gAMAwEAAhEDEQA/AKZIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIrS+CzN/aNP8ACP5ieCzN/aNP8I/mLOEdUKtIrS+CzN/aNP8ACP5ieCzN/aNP8I/mJg1Qq0itL4LM39o0/wAI/mJ4LM39o0/wj+YmDVCrSK0vgszf2jT/AAj+Yngszf2jT/CP5iYNUKtIrS+CzN/aNP8ACP5ieCzN/aNP8I/mJg1Qq0itL4LM39o0/wAI/mJ4LM39o0/wj+YmDVCrSK0vgszf2jT/AAj+Yngszf2jT/CP5iYNUKtIrS+CzN/aNP8ACP5ieCzN/aNP8I/mJg1Qq0itL4LM39o0/wAI/mJ4LM39o0/wj+YmDVCrSK0vgszf2jT/AAj+Yngszf2jT/CP5iYNUKtIrS+CzN/aNP8ACP5ieCzN/aNP8I/mJg1Qq0itL4LM39o0/wAI/mJ4LM39o0/wj+YmDVCrSK0vgszf2jT/AAj+Yngszf2jT/CP5iYNUKtIrS+CzN/aNP8ACP5ieCzN/aNP8I/mJg1Qq0itL4LM39o0/wAI/mJ4LM39o0/wj+YmDVCrSK0vgszf2jT/AAj+Yngszf2jT/CP5iYNUKtIrS+CzN/aNP8ACP5ieCzN/aNP8I/mJg1Qq0itL4LM39o0/wAI/mJ4LM39o0/wj+YmDVCrSK0vgszf2jT/AAj+Yh+RZm/tGn+GfzEwaoVaRXM8DHtT7g+JJ4GPan3B8SWElM0VzPAx7U+4PiSeBj2p9wfEkFM0VzPAx7U+4PiSeBj2p9wfEkFM0VzPAx7U+4PiSeBj2p9wfEkFM0VzPAx7U+4PiSeBj2p9wfEkFM0VzPAx7U+4PiSeBj2p9wfEkFM0VzPAx7U+4PiSeBj2p9wfEkFM0VzPAx7U+4PiSeBj2p9wfEkFM0VzPAx7U+4PiSeBj2p9wfEkFM0VzPAx7U+4PiSeBj2p9wfEkFM0VzPAx7U+4PiSeBj2p9wfEkFzEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBEXxrgeoII9YOoQfUREBERAREQEXxzgNNSBqdBqfOfUP4r6gIiICIiAiIgIiICIiAiIgItXkuI6FYWTPcrR/N8Elm2108e+vBEwSSSyx67mMawhxJHmI9YWPwPxbjs3TZfxVqO5Uke9jZo2vbo+M6PY5krWvY4dOjgDoQfMQg3iIvzNK1gLnua1o87nENaP5k9Ag/SL4xwIBBBBGoIOoIPmII84X5jla4atc1wB01aQRr6unpQftEWLVyVaV74orEMskP8AixxTMe+Prp5bGklvX1oMpERAREQEREBFznHHEbsa2vII2ysmlLJGlxa7QNLgWO6gHUekH+iyeHOJql8aQyaSAaugk8mVo9J266OHUdWkjqq0dXZ86bOr4vb9Fj/S3vKi9p+H3bpERWVcREQEREBERAREQEREBERAREQEREBQT8u//wCSr/8A95j/AP8ALjU7LhO3js8/tThJ8P3zuPeZq8veu7d628iVsu3k82PXXbpruGmvpQUq7DGQu4i4T/sb88CxyKP9snSDWi3Xl/OBHo5GzvWgl8ndyNnlKXq/yjMvjK/GVHPdz+e+GdjcRyYDCy2ZpxTZLyHPO+Jrpatjo7UxzO82nWzHAmC+a8VjMZzef8042lR5/L5XO7pWjr83l7ncvdy923c7TXTU+dVI7deDqPFHahQxdWPXkU6knE0rPoGOtune120BwlNR1Wvv3HQzRDQbDqGP2scT8R5yDgbA5W6MeeNpG2co6mw1YzWuWWV6dVzddZXCs/mGJ50dLYYD9BpElcB9gTuE89TtYPiR8NCblsv4fLvjkkvtc8xyBhg5Ubn7XN5Z5Zc17fO4OIUhdvPY1Q4sq1Y5ZpaFzFPc/G5Cq1pfXLw0OjdESBJCTHE7QOY4GJujm9QeO7L/AJNrcfl4c5nM7e4lyFANFB95sjWVyzdy3uM9ieSVzC5zmDc1rXO10JAICP7nbpxtlRxBmOH62KiwPCk0gfHdY59m1DDuc97vLBdJymGVzW8va14aC9w1OdxZ8ozNzs4Jnwtamx3GL3wWKN1pc024clFjnRMstcDFC6Xfo/QkNc06aghbrij5Kplt5F2J4lvYjFZ+US5PDxVzNFKeY6R0bXtsxtMWr3BrXsdtDiNXDouizPyc6jrHCD6N91OrwHNFLFWkqCzJfcy9BeldLYbNG2GWSWJ5c4RuGsxIaAA1BynCPahxM7NcQ8J8TR46SaDAXbkNnFse2Jv91ZK1jTIdZYHRT+dzQ4Oj0OuvSEuyDsYp5DgvI8VRZG/j8vhHZGatLBPHHW0oV2WA0hsYmZI4F7N7ZBoXg6HTQ2vyHYuZeKcjxL85hvzph5MWKHcdeTzKkVbn957yOZoY923lt+lpr01UW4n5H9uKAY+XjTIuxEkvNs4qtSkrV5natJdy3ZCSBsurGHc6J/0B06BBDna9xXY4gwXZ1byzLF2V9vN07gqt/vV6KvdxUP7ED6VuSEBmvpk1Pp0Vpvkk8O4qnRyM2LxGcwzbV2OKerxE0ssyGvCHsmhY4a8kiy5uvpLHepYfaj8nGDJVuHKuIyZwUXB3eXUiyj32R8tiWrPzy82YtswmrGQu8rc6Unpp17zsg4Ny+HZbbluIrHELrT4nQSWKYqmq2MSB7GgWJA8PLmn0abPT6Apn2v5zF8U8YWrVu9kY+HZzHhsTnjA4Y7E5JkUDuY3V4jnqvkjmlcC+J221zDoIwTeThvET0MJBRtXX5Gejje7y5CVhZJaMUJYJpGuked5aBqS9xJ1JJ1UB3PkiRyOmpN4jvw8Oy35MhFgoqzCYbToTCx4sySuY8taQ3cYtSwBvn8tTX2WcIXsRhY8ReyoyzqsTq9W8aRqSNq7AyGGZhsy850Y1aH6t1aGAjVpc4P5tcJNxBw0ggGXPGPztH8zjGhxh7rsra7uX+05+7venL8rXlejVW/xXazxFgeIOHcRxTJWbjs5gacklyWFsU9fI9ya2yyxYY4xySNvROa4NAGlqM+gayd8nDsn/ALH4uxje/wDzj3rJSXu8dz7pt5lerX5XL58u7Tu27duH09NOmpiL/wARFtSzSwGPZEZ83dyrm4tkenMED2NhssJIPkyTyUWhurdzmA6/syCHHcb9oub4p4E4uyl9kEOJbk8fWwsEcHLnLW5WtLKZpC4iTZE+tGHN6F3O/wAq0HFPZk3hXhPBcaYLMZGjk7UGJmtQvsRGGZ92u2Z0cDGRNL2CTUmKXmNcwOB8x1s1lexCKfgiHg6K22nsr0xNfZVM4dZhtRXbUwgMrCRLO2Q6F/kiQefTRcFgvklbn0487xTlM3jcXsFXEuZNWrxtjAa2FhkuTcmDY0MLYRGdvQOagxsp22cWZnP1MHwvUx1aaLCUMrkXZVrizdbo1Lz4y4P3RwNF2vDo1u8vLjqB1HH5HtU4q4i4c48r2mUKsnD0lWKzXawgw1JJMoy/AyZjnCaw11WBrX9Adrj6VL/an8nk5POx5/D521w9dfBHXuuowFxmjijZAx0L454jXdyGMjLfKaRHGdAWnc7L/k4V8PU4ooz5WfIVuMYWQPc6s2C1VZH30B5sOlkbZsf3wO3ljRui1LTu0ARHwF2p5zhTs2p5BzKdk5DIPpcPbhI8wxPmyE1ya+3VpkkEsE4YGu08uInUBwPQXO1nj/EZrhXEZ2HEsbxHkaUck9WPmPkr2btWCaBwDw2G1E2VwLmgtPNZpqWknqKfyXmHhy1w5dz1q5B31l3CzmqY/miVjbALWVzacyeJ/eZS9oMYcXuI0do4YeL+S7cGRwWUvcW3clZ4cu1LAbdpvlZJBTsw2IalcyXC6o39k8Fx5mpkB2jboQ5n/wARGKN9zgxk0U88MlrKNmr1BrZmjdLhQ+KuPTO5pLWj/MQuY+TtPUw3GGVkpjK4PFUcDYuy4DiAviyV8Q1ec8xVtux+wxPlBLi4NB01BdtsL8onsXl4smw1iHLnETcOy2poZW0O+OfLYdSfG9v95i5RjdTB/e13+jTrpOAfk6urZp2dz2ftcR3BUmqQixV7rGyKxWlqSte3vEpkZyJ5mhjdgBlc7qeqCF2/Km4ndEMy2Thx1Q3uV/ZhpsuyoqhxHOLw36O3yebu+kd3K29F2PFPbxxbPxRZwvDePq5COziqVzGV7EbYZYBcxdG86e1NJMxhaznyDa5zBq9g1Omjuhw3yZLlORlSrxjmavD8V11tmHqh9ew3eNHRDIRWAAD5yeVp1J27iXLuML2OCrxla4tbkNzbdCOk3Fmo7WJsdSpVDzddYJlP913dYx9PTU6akK/G7PX4648s2YYJbVbs8tT2a9mKOatJZiwmFkmimhBLJYDK1zS3XaWkjzFfvGds+Ww/B3DVzE0sVXkzGayNWajVotgrvbHM0METQ/8AZyuJ0L3F30v4BTVmewU2c9xNm/nXZ/a7h+3he6fN+7ufeqVSn3nnd5HeNvdd+zYzXfpuGmp56X5MJOEwWH+fAP7N5WzkRa+ade8mxK2UQ8nvv7HbtI3bna6+YIPPhLtU4tpcbUuGeJYcS6PO1JLVY4rm6VWcq3JFtlk8qUb6csTmvGupDg7QaO2fyreBKN99TL8Q5p9XhvAwvdPhYo3NkvXHiba6GcTDWy4GFjW8txAZLoQHuI63insj79xjieLPnDlfMlDufzb3Pfz/AP4h+071zxyv/f8Azct3+F5/K6c78oX5P8nF+QrXH52ejBRqMhhx4pd6gE4mmkktBr7LGNle18TD5GpFdupI0ACrgv5zE9mTI3SWalTiTibl1BJI5rjizSfLKIyPKiqzWYtSBoHiOU6bZdXd7W7PIuD+OsRw/jcjemx/F+Gmr5aGeSF0sjbEWQrmTZHE2MMY+NssZLSWlkgJcC4GZ5fk/PvYS7hs9xDfzQs2a1rH3ZohHNjJqzHsb3dkksrHMc2R7HN0bq17gNDo5vj2NfJyjweVjzWSzdzPX6UDq+OfajdEypE6N0PmksTPkc2J8jGjc1jRK7yddCAgHsb4VtUch2lYfBOsPs0MXdo45+9vfJGw3jFo18YYO8uia4AtDfKI006LleD4G4fIcFWsfh87icnDmIaWduZKOSGtfmsWYWGtUbJ1LTXdO17drNolYCHEhytxwh2CxU8rxTkLORNuDjVlyOalFUdUfVjuWHzER2xZeXyNa/aHhjOoDhp5loOCvk1S1cji7OS4lu5jHcNWpbeGxViryxBO+UTRvlsGw/m7ZGtcQGN3Fjfot1aQsOiIgIT/AMf9+hEQRLiPlFcJ2ZeUy/I3WSGFsslK0InzztDo4GlsZJm0Ohbp5LiGnRxAMsSPDQXOIAaNSSdAAPOST5gv5d9lvGkPCXE9iwa081OtasU5a+6uy2KzLbem+aF45obCA5reWXdW72a6i3L+1ePNmQS0bVSlFYlr1+XMXSP7u8xmzyXBsNiBzh5IGhGw+X12jE03qqZ8qnMxHbOEZu2bUxN6rTTM4zjOPySB2kZenfEdaCzFzK8hfvfubA8lpbsbPpsDuuup0b/qC1vZfVkhyrWSscx3dpiA4ecHZo5p8z2n1jUFcq+CARd5N2qKm7Z3jc7fv03cnum3n8/aCdu3TTru06rf9j3FMc+TbRrRyd3EE8pmtP1lc9uwaxQMcYqrDuOo1e46DVw8y5bp+i6zqus8+/b06Z39O3pifvGzp7/X9H0/R+RYua4qjb17+uY2/Kd01IuU4epy245ppLtxrvnDIxNbFLG1jWQX7METWtMZ6BkbR118y9auUfTkuw25nWIqNSG620Ym84QSusMe2dkDQ17mGs5wc1o1a7zatJPXTb7xDk6b8TETMYiXTIvwZG7d+4bQ3du1G3bpru182mnXVaO1ddZdjzXnmghvRyTb2RRiRzOUySPVtmJ2zo7XQgHqvC5Xop1Yz2/us0U66tOff+zfotNPVuwgyRWX2ywaur2o4GmQDztjlrxs5cnqLg4evTzjLjy0JrstbiIpWMc07XF3l6bW7GguL9TptA116KMXoziqMfNObU4zTOfkzkWBRy8Ez+W0vbJtLhHPBNXe5o0Bcxs7Gl7RqNSNdNQsFmeYLdiFwm2QthDNtO07y3GYSalkZ8jyGaO8x66E9VieotxidUb7EWLk5jHZvUWFfykMLgx/Mc9zdwZDXnnft1I3FsDHEDUHqfUV64+7FOzfE7c0OLXdHNc1w01Y9jgHMeNR0cAeoU4uUTVpid/ZCaKojVjZkIiKaIiIgIiICIiAiIgLEr4ytHK+eOvBHNLu5k8cMbZX7iHO3yNbudq5oJ1PUgLLRAREQEREBERAREQEREBYlnGVpZWTSV4JJodvKmkhjfLHtcXN2SObubo4kjQ9CVlog0nH+Zkx2JyeQhh7xLjMbctw1/K/bSVq8kzIjt8rRzmAdOvXoq2cOdoOeojg/MT8SMzrONLsMGQwEdOozukVppdJLT7sOc00z5EmvQuGjtNVa4jXofMfOFxfDHZRw3jLrsjj8NQqXHbttiCANMW8Fr+7t+hW1a5zTyw3o4jzHRBFXCXbRxBmKEl2HH4arXy2My1jBn56jN6CXH95aBdpyAPnB7tId1djg3RpcNN235i+MuKLfZpJlmWqnz3NXY6rdbNXiLoH2oI3ySmdsdeC9y3WGhg6aiLTVxAUtcN9mHD2Ntz36OIpVrdxr2TTRQgEslOsjGMOrImO9LWBoPpWThez7C06FnF1sbVix2Qklkt0Wx615nzMZHIXRuJA1bHGNBoBsGmmiCE+xztNzFQ5ypbx3E+dZjcjSjpNlgx02Yrw3KPenNyBgnbBoCGkaOc4c4A6aaDM7R+Js5LxDwjFVv5LC1eMqeYrT4qzUqCxQsU6jzFbfrv3T77UT9m7b/dmefcVNHA3BmLwdd1TE0oaNd8rpnxwB3lyuAaXve8lz3bWtHUnQNAHQL3zHDFC5bo3rNZktvDOmdj7Di8PrOstYycs2uA8prGA6g/RQR18k3iPI5PBTT5O5JeswZnIVe8ysjY50Vd7GRjbE0NHpP8AVRNge0/PZDiGxw6/JzY6vY48ztaPNPihJNHGcow4DHkxGNtp2/XfL1Aki2l5Ox0+YrsxoUshj7mO1owY1uSdJRgdNyrU+R5IdLNumLNreXI7QsJLnRkOYGua/KudmGBminhkxkDo7mWfmZhulDjlH/SvMkD98Ng9fKYW+coInt/KBvR5KQNxlQ4Srxc3hKWR99/zwbmpa65HVLNr6w0JDer3aeceUW/GdvmUilzLLuNo1HUMdmrmMqzSX2WbBxDZJABLJAKmRhfEwPLqspLA7Ut0BKlmXsv4edlG5p2JpuyjHtkF10WsnNZpsnLSdjrA0BEhG8EA66hY7eyLhoT27Iw1Ns2TisxW3tY5u9l1nLt7WB22F0rCWudGGlwJBPVBE+L7bOLLE1WszA4bn5nhiLiPGvOWsCJlTa10rbI5G507gRtY3aGmRgL3AOI87vyjMjYr0XYvF0RPJwpPxRkhk774YWVatiarNVpOYzWWwX15HNL9Bo5uvmdpOFXgXExSVpo6UTJMfi/miq9rpNYcboB3Rvl6cvQDz9eg6rT5Tsd4YtVqVSxhactfEtcyjG9ryYGPkMro2v3b3RGRznbHEt1J6II1ufKBvd4xc7cZWq4fJUcTaluZCW7puyfSSFt2tWfVqPieWtHejGJNzXAtDgu2+VXxJdxHCOWyGOsOq3KncORYY1jnM5uTpQSaNkaWnWKR7eo/eW+zXZZw7dsVrVnD0pJ6EUMNZ/J2NZDXLXV4XRRkRywsLW7WPDmt2jQBeWJ7NaIxVvD392TpZC/ZuSw2nSlgEt3vkMDd0rpOXG5sWmr+pYToAdoCAsL2y5zBuzrL8l7IywvwMGIxmcr1Yb8cuUEgktzvwsUjJKWoOjWGSQlsTQ1heSelf2+Z5laow8PxPydniVuDEDnX6Na6Ja7pYrFU5KvFPVHMa5jhNHqwDU9TtEqYvsd4XrVbdKDCUGVsoI23YTDvE4idviDnPJcNr/KboRo7Qjr1WViOy7h+pDTgq4qrBFi7wyNNkTXt5d4NDBac4O3SzbGtbueXdGgeYBBXTibjPKPyuar5Z07u58Rdn8LMfVylqvXx9rI4+y++2vLWc100HeATscS12xrvOGkddW7fcyJ4ZZcTjvmqTjl/CL52XbAumUv0jssgMRjaxsbXuOrzuOjQGDyzMeR7OcJYsWbU2OhksX7dG7amc6XdLaxrHsozO0fpuibI8DTQeV11X5PZtg+WIfm6HltzPz61m6XQZbQjv2u/XnaE/wAP4IOtREQEKLV8X2I4sdfll/woaFqSXXXTlsgkc/XTr9EHzIP5Y8UEZ3im86ExiPN5+3Ix4fHFEyCzdkk5rpX6RsjbE4vL3dAGlx9KsRxH2IZqKaHF2uK/nKtXFaaGq9sle5LBHI99aKrZnkcGtDwSIxMSNGljSQNI3+T92AZPibE5e/EY60bq4rYmS1Hqy5ajsxTzCN2u6FjRByjLoRrO4DXa/Tp+xbKzS4xlO5YL7WIlmpGrPIHWKsEUjuXA5jjvbG17pWtB6DTaOjQBb6O3Fy5plrvFL1Vmxrpj1j/Pz5ShkqU/zb3fkzd4+emM7vypDPv7lJ5PK03l/wDDTVSL2H9nl+jaGRuBkA5EkbKpO+c8zad0m07Yho3zak9eobotv8n23LNVsiaR8vdpmMgMh3ujYY9SxjndQzX0a6BSenV1zF2qGPDbdM9PRVH83cbwpjrEkM748hYgY7J5bSKKGk5rdMnbB0dNA5x1IJ6k+f1dF0OKxEVcS9ZJpLJBsT2HB8kxDdrQ7QBjWBuoDGNa0au0HU65teBkYLY2NY0ue8tY0NBfI4vkcQP3nPc5xPpLiUtCTY/lFgk2nlmRpcwO08kva0gluvqIVequapW7dmKKYzvMOLduERwRJ3GZtdh18o4h7XSmQnXXQQRyVN3n3tafSF0GRAFygANAG2gAB0AETdAB6AvuLxswsPt2nxPndEIImwMLY4YQ7e9oc8lz3vftLidB+zjAA0Jdm5DHQWNvOiZJyySzeNdpPQ6eroodTmunFPE/nmJ/8enSR5c5q5j8sTEfcymQirRmSV2noYwDWSR5+jHEwdXyE9AAtLVdPWr0aw5cc9uSQPe8F7IXObLZkY1oI5j/ADtA1A6E9dNDtqWHqwu3xV4mP005jWDfp6g/zgfwWRdqRTsMc0bZGEg7XtBGoOrSNfM4HqCOoVaq3cr+Kdp9PrGd+ce2y3Tcop+GN4/zjbjPvu5/JRyR2scJLLZS648sYYWMk0FWyHOaWH6GhAOoPVzeq2FIjv8AcHp7tSOn8N1sa/y1B/2WRVxFaIhzIWBzXB4edXP3Na5rTvcS46Ne8Dr03H1rU8UWqkdiu2euJXPABm128lj54oW73+bYXyF21xA0ifpqdAYUWK6Z1c57z7Y7/twlVeoqjTxjtHvnt+7LM889ixDHKyBlMxtP7ISSyOkjbLv8s7WRaO2joSS1/UaaLx4dJ73faZWzOaKoe9jAzy9kgIcASC8NDAT08wGnRYeRy+KsN54AsOiDA57WTRuZE543cyTaNrQ3fIGuPlBjiAfOtvg5ahMjKrGsdDtjlY2F0QAY+VgDdzQHsEjJxubqCWu6qUWa9cVT6TM9559O3r/MsTdo0TER3iPSOPXv6NoiIrSsIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIR/wAoiDkuz/s4w2AkvSYim2l87TMmtRRPkMO9m/aIYnOLYIxzH+QzRo3aAAABZ+P4MxFd1p0GMoROycr5bz2U4Q61JI4vkdO4N1lJeSfK16lb5EjbsTv3aXhjhmrjeeKjXRstSNkdEXl7GOa3b+z3eUGn1En+Gi3SIs1VTVOZRoopojTTGIERFhIREQEREBYdvFwTP5ksYkdtDSHkljmtLnMD49dkm1znEbgdCSRosxEGAMPW2lpiDgW7CZHOkc5ukrdHPeS5w2zzDqfNIVk16scZJY0NJa1pIHUtaXFo19QL3n/zFeyICIiAiIgIoe7/AMd/Uqv3qX6lO/8AHf1Kr96l+pU9HLz8ziUwooe7/wAd/Uqv3qX6lO/8d/Uqv3qX6lNHJ5nEphRQ93/jv6lV+9S/Up3/AI7+pVfvUv1KaOTzOJTCih7v/Hf1Kr96l+pTv/Hf1Kr96l+pTRyeZxKYUUPd/wCO/qVX71L9Snf+O/qVX71L9Smjk8ziUwooe7/x39Sq/epfqU7/AMd/Uqv3qX6lNHJ5nEphRQ93/jv6lV+9S/Up3/jv6lV+9S/Upo5PM4lMKKHu/wDHf1Kr96l+pTv/AB39Sq/epfqU0cnmcSmFFD3f+O/qVX71L9Snf+O/qVX71L9Smjk8ziUwooe7/wAd/Uqv3qX6lO/8d/Uqv3qX6lNHJ5nEphRQ93/jv6lV+9S/Up3/AI7+pVfvUv1KaOTzOJTCih7v/Hf1Kr96l+pTv/Hf1Kr96l+pTRyeZxKYUUPd/wCO/qVX71L9Snf+O/qVX71L9Smjk8ziUwooe7/x39Sq/epfqU7/AMd/Uqv3qX6lNHJ5nEphRQ93/jv6lV+9S/Up3/jv6lV+9S/Upo5PM4lMKKHu/wDHf1Kr96l+pTv/AB39Sq/epfqU0cnmcSmFFD3f+O/qVX71L9Snf+O/qVX71L9Smjk8ziUwooe7/wAd/Uqv3qX6lO/8d/Uqv3qX6lNHJ5nEphRQ93/jv6lV+9S/Ur47IceaHSlV106eVS/Upo5PM4lMSIig9BERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQERajijPw0IJJpA+V0cbpG14QHSyBo1O1pIA8x6kjzek9FCu5Tbp1VTiEqaKq500xu26Lk+EeLG5ahHdhHK1kfFYg3B7oZWn6JfoNdWljgdB0kavud1fVstJJ31p29SfTE8Khe8Soo/pjPqXaarczFUbw6tFB3B73NpwlrnNP7Q6tcQf8V/pC6ijxDbh80pkb/km8sH/zHyh/QrVW/wAT2tWLlEx8t/0VLXUxXTFUx3SSi0WC4kisEMeOVKegaTq15/0O9f8AA9f5reroOn6m11NGu1VmFiJid4ERF7siIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgxsneirRPmmcWRRAF7w1ztoJDdSGAnTUj0dF8iyELpZIGv3SQsY+UBri1jX6lm5+m0OIBO3XXTrpovmZriWvPEWczmwSM5eoG/cwgNBPQE6+crlX8Pzx46rEIjNIZ4J8nAZWB9nyP2sRke7Y8BwjGhOhbEBqqd+9et1/DTmMZ9fp9vT0nvstWbVqun4qsTnH7/f6x23dk2VpAIc0hx0aQRoT6h6/MhmZ/mb01B6j0DU/wCw6rh6mFtQywWGUw2IZCWz83wywt7u11Tu8bhq4Rbtxe5wadBuGmq+43huWaeN12sOU6TI2pmGRj2GaxLHHDG4Ndq8d3j182nmB69F4x1l6dvL3/PGNt845+ez1npLUbzcjH5ZzvtjPHy3ddPk4GTQ13SATWmvdCzR3liMav0cBtHT1nr10X6qZCGVrnseC2OZ8LnEFo5kbyx7RuA3aOBGo6HTpquc4gwk9i1NOxu11WpB83yFzdDZZNJM8aa6taQ2OM6gAh5WtrYGy0Uu8Um3I217BlrPlh2Q3LE7pnSyB7i142u26t3EddB5lirq+opuTGjb07+8RzzPbtjlmnprFVETr39Y29pnjiO/fPEO7M7B1Lm9NddXD0dD/sv0JGk6ajXTXTXrp69PUuDwnC8gbELVRsja+Nm2xSOika65ZsSTSMOriC4ARjcenUHXpqkfC08UdHkRCKzDjbTZ7QcwP7zJWbFDE94O57Wvc7QjVrRGNNOiR1nUTEVeV98+nHM/QnpLETMeb9sevPEfV3jJGnUAglp0cAQSD6j6isetkYZOYWPBEMzoJCQWgSs03MBcBuI1HUahc3wfhHwz841nVQyqINrn1t0zi5r3PkbWaQ/Qt6Pe8uO92oC1dvAWnV4t1QyTudfle0yVZI2y2pi9rJ4piGlhYGftIn726EAHVZq6u9FEVxb99t/eOOfb0YjpbM1zT5ntvt7Tzx7+rubl6OJ0TZHbTZl5UQ2uO6Ta5+nkg6Daxx1Og6L1E7P8zejd30h9H1/y/iucy+Psl9IxRaijUtO0bINveTWbBBG0yu3H6Umjj6upWuq8JBvcoxXawMxlmG7M3lh0k00MUQjkIO6QamUjzgbR5uinV1N+K5iKMxt78ccz9EaenszTEzXjv7c88R9XbcxvQajUjUDXzj1j+CxMjlIa8L55H/s42hzizyjoXBg0aOp8ogLjG4G9JSL5otbXLqVe7CZgcaVd0ZnibKHbWvmc17j1002j0L6OHpnSzOZRbVhsWMa3ksfDoytBIbFh5ax20HeGAtb6eo3dSvKrrb8x8Nud42784ztxHrnd609HZifiuRtPHHbfn2xs7Wtea/m6tfGIZjFulDWh5Aad0ZBOrNXaanTqCsWLO13PZGHOLpLU1Vg2O6y12udL10+iA13lebouUgwVnWu+xRbbY/vss1V8sGyK1ZsmRssge4skAhIbqNxHXQLY8KYaWHuAmhex1WG3K93Njcxs9qUaxuAcXveI9dHDpoT1JSjquorqiNGO3eJ944iO0z6+jFfTWKKZnXn5Y55me8R9XXIiLaNcIiICIhKDT8S5uOo1rdW8+fUQRk/S2/ScR6WjUfz1H9OBsTvkcXvcXPedXOPnP/6H8FhcV4nJX7clgwbQ/pVhkngjm5DCdmkL5A8OPVxBGurisHD3J+e2nNHJznPEbQWkSh58zZGnrppod3q6np1XHeJdTevXcVUzFPpt3/eXSdL0lFu3qpqiavXg4Hm+aMwap8nH8Q+RF/kgvNOsTfU0EuLQB5+ZGP3CpUkoSPY5u3Tc1zepA84IXrg8DFXDXOa2SYdTKRrsdoQRHr9EaEjXznU/yW4W36XwyfKiL0/T7NP1t+i/c1Ux+6LcTwdfr1oo3xse6NpDuVK09S5zum7TXzrGnhfG4te1zHDzte0tP+x9CltY1+jFOAJWNftOrSR1aR6j/wB6qj1X4Zt1RM2apiee38+rVx01NNMU0+jj+GMV/wDWfoDpq0u6CNn+c/6iPN/D+a6jH5Jj38vr0GjHO879PPr6itZmN7HcvTRnnH+v/U4+k6+j0LBa4ggg6EHUEegj0roPCvCaOksY9ZQm7onTDskXhRn5kbX+lw6j+I6H/le6szGNlqJzGRERYZEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAXKdrnEMmKwt67DoJ4o2R1y4ahs1iWOvG8t/eDXSh2n+ldWoy+UzDM/h6wIY+Y/vVMlm9rPJFlmpLndBp0P9F49RVNNqqae+JX/CrdF3rrVFz+maqc/LMZQHnMdjMhbw0eOtXbN7KPgiy9i6HmWO3NLAzmskkYC5zd0zjtLmgRs0Pn1nvsVzjM13u8+Npfjb9qnRmb1LqDxHLWEhP05WxP2bvOQ4nzuKq3Xxt8EObEyNzTq13egHNPrDo2kg/yU19jde/DhGxVw4Tz8T7ZxUnezWs7Gs/xZ+STAzfG3ytpA0b61z/S1zTcmqqnnEcdvzzu+ifiixbjw/aqapp2iZ7xmZzvtGMYiIxtELDoo8vWuIa8bqrTDZniwrrPeo4HF0lyOIwurs1Ajc90zmTNJA1DXN2ddVj2c/Zrwx9xlvzRvisvltZHF3rMxuRRVzBREDI4nRtkL5CXAFocxzQQeg3E9fTHemY+b5j5Uz2lJaKPanFeVbbY21RdHUM8pklhrTSviigxbrM0LgwEvf3kxNY9gIfpI0DcBrj/ADjffkpeQ/IHdlqojrvqyil81Pp1n2ZHySQhsT2vdORo8P3gN0PUJPX0YzET3weTLsONJDHTlnZGZX1m8xsYO0uGoDxrof3ST5v3VEVzPZWx0jZ3dh9DGhjtP4vlO7X/AKdF2vZ/bsy4ay66+w6x3d3NFoWQ4OMH+WxBGGndrqIy9vQeUudfG4BriCBICWE+ZwBLSR/UEf0XQeD36LtnXp79suc8at1xdimKpiMb4/V03Y4bDYrUVh5eecyZpdI6R37Rmx2rnfxib6fSV3y4bs0/xLHq5cf/AKnf/wBXcqv1u9+Z/nZf8MjHTUx8/uIiKqviIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgLne0rGm3ib0LRueYDJG30ufA5s7Gj+JdGB/VdEhUaqYqiYl62bs2blNynvExP0U8Ck35P+ebBbmpSO0bkGtdCSdBz4Q7yP5vjLvwmj0rm+0/hs4zISRtbpXsl01RwHTluPlRD+LHEt09Ww+lcbkcqykwWHPcwxuBiLDpIZGnczl+p4IB19GmvoXP01VdPczPo+u9RbteK9DMRPw1xtPt7fSe/wBFzEUX9knagL2OrTZgQ4+xYfy4JJJWshttOvJkaX6COR4B8k9Habm9HACT2nUajzHzLfW7lNyM0vk3VdJd6WuaLsY+0/KX1EXPce8VwYijNdmjlmZA6Njo67Q5wdK4MYXkkCNmpGrj6xpqSAZV100RmqXlZs13q4t24zM7RHMvXizKV4mtrzO2d+D4t/oiaWEc13+kPLB/U+orlrFWSGzXDqr7EVaJjA1sbnRzahz3uaQ0hw5kjiP+karjr2ZdkH97LxIJ2gxln0BH+61g9AGp6efXXXrqsnFWLbnMr15p2mVwYyOOaRrdT/Bp0A01JPqBWys06KcxO0r3Vfh+LlMTNWmqO/8AOEocJ44xc+V0bYjak1EDSDymN1LWHToHeUToPNqP5DerEw9JteCOFp15TdC4+d7j1e8/xLiT/VZapXKprqzLV0W6bcaaewiIoJCIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiINHb4vxkWTgw0tyFmUu13Wa1BziJpoG87dJGNNHACvOdNddInH0LVX+0jGMmnq1jYyVqhfp0chUxVaS3NRkvPeyKW01ugjrt5che/U7Qw+nQKKO3LgPOWuLIc/iqZmkwHDdWXGSGeKOOxk6+cMs+NdrIHgTYye4wkgN/ajygR04/Adj+erTWpJKMks2RzXA+Wu2efXInuQWLl/iGYay67YrFt7fMNwA2goLb6j1pvGmuo09eo0/3VXLvYpfdieJLMVKwcxk+IskRVdlHwC/w7Pl696bH1yybkUxZjga4uIa8kFriAdFif+yzKPpZUx4S7SxE/EWJv4nhRtrF2n14qlKeHIWJ6VqV9O7XmsSxvNMzRHWEOD27W7gsxY4kpx5GHFPlIv26k1yGDlSkOrQSMilk5oby26PkYNpcCd3QFbbePWP8AdVWd2a8TS4+lFBQ+brUHBWfxcQjueTBNYykM1GrvmuzvrvmpREbRM+OHmBocxrQ1uFw92KWL13Ixf2cl4fxeR7P5cTEy3er3mszLMlWtQzbY7D3MAmhbN+7uMJedrpCgtsXAecgaDXz+j1qOOzPtYp5zI3aEE2NeKbZJKz6mQmnkuwNsPi7zDFLUiYa7QI2ufG+QCVz2glrWvfofk98M5kuy2a4kqCtl8xHQoCq+aOZrKeNoxQl7XxOcI22Lb7MrmAnTVvn0UccO8AcWRR5HGY2jdw1F+Cy9eGvkMrj8jXp35Zf7lHgMpGBkI68sZeXCUNawyya6uDSgtYHD1j0/8edcjmO0OhBYt1I47t65jJcay7Ux1GexNA3KuIqznyQx8G1r3vcxztgYdRqQDXZvZTmnYnMw4/B2sXDZq4aGbCOydKqzMGnZjkyDY46ckgryvrtfEbD5wZmuGrAdSvar2Y5Uvzj6nD1jFU7+S4LmxuOmvVbD4q+LuSy39Nth7YGsDjJyw4gczQddWgLY7h6x/utVRzzJrtmkyC2O4sjMtuSrJFTdJIGuENexLoLUgY4FxiDmt10Lg7VqgiLsqyTuJzQmoxv4Si4kn4ujsSTRyNffnoNhGPFVx3RxtvSTy6aFhaSOmqwewbg6Y8SWKMzmz4fsvsZGtgXh75N1jNubZbHK9xIklqVHPhIOu10jNNNEFm0REBERAREQaHjnhiDK1XV5fJe07684GroZdCA4D95h8xb6R6iARVODs3ycmYlZm4OVXoO8lrSXV7bSdY21XkDmQHQF7iAf3SGkkNuUsHOYmC7C+CwzeyRrmktc5j27gWl0cjCHRv0PnaQVU6jpKb06vVvPCvG7vQ0zaneifrHMfoqTnHvzmXq4yudIXWG1YyzTTqf7zYA821kbHkf6Yun0lYnL2nV3sr1XOhhqQRwxxxnRrWMaAxob5tAwMC1HAHY/BhslJfhsvnjFZ8VSGeNokrvlID3mVmjZP2YLRo1uge7XXVbPJ4u0ZZHmCQ7nkjaA/pr5P0CfRouF/E1HW2emiLVNWqqrMzTnaI7bx2bzxXxPpetu0W7M/wC3RT67ZqnvtP8AM5YsuUsuGjp5NPUHlv8A6dF+8QYnmSrZaJKuQjdXsRv6tc2QFvX7xGv+rX0L8sxNk9BBL/Vhb/y7QLY0+FrD9OYWxN9Op3u/2adP+VyPh9jxi51VF+3RXVVTP/LOOYmZ2xMbTu1lyuxTRMZiPl+yDG0LOAzDsLKJZ69uUOxz2sc972zOPKexrBqTqCyQAdHMc4DTz2A4G4Y7o3nTAGzI3TToRC0/ug+l59J/oPSTv2Y+LfFK9jJJ68Too7L42GZrH7OaGyaatDzGwkDQHYPUstfbuli5ateXM7eke0e2VbxTxqrrqafhxOPin/tPvj0z6iIi9WjEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQaDtE4gdisXeyLIopn0K7pWxWLcVKF5BAAktTeRCzrqSdfNoASQFEd75QromV3DH1Hltd9i8z50nhkk2ZmfDPqYaCzQZLkcg2SEyOhe2IN5kTQ5+9rjPMsbXtcx7Q5rwWua4Atc0jQtcD0II9CxGYmqBC0Vq4FQ61miCMCA+uEbf2R/wCnRBBTe3iXHUso/ICtNPjquYu1DNaipuu904nymHhoRMEWhcyGtV8tu5xMzdRqdT6Tdt+Rpx3Raq4mWxFxLmsbCXZSanWrVMXFNaHfpTUkdFZfBE3l+SGyAukJja3QzhLh6jw0Oq13BnM2h1eIhvOOs23VvTeervX6dV+rOLqy7xJWgk5r2PkEkMb974xox79zfKc0DoT1CCHO0/tTuwDEd1nqYiPLcPz5rm5COnZkmliNDTGV3WMhVqcxkdx80jucdWQHZ61j43tuytgwCHDVZI5ruFxoms5KahM69msNWykEjqRpzd3qNfPtd+1keG6ENkIIU33aMM7Q2eGKZrXB7WzRska1zfouAeCA4etHUIC4vMMRc6RkpcYmFxljbtZITpqZGtAAd5wAgrnf+UJegtOsSVqDasOBFqzip8rHDObdXiLL4W981ymoX5Kd5oxcuJ3KGhbro52h23AXGluDJQUa+JZSqZTj3iWncyMMNCOtdFSPKlh2R2TbORJoV980sQDuU7yjq1TgcPU1a7utbdG4OY7u8WrHB75Q5p2+S4SSSO1Hpe4+clezaMAIIhiBZK+ZpEbAWyybg+UHTpI4Odq7zncfWgyEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERARUz8c/st7/8AhqeOf2W9/wDw1BcxFTPxz+y3v/4anjn9lvf/AMNQXMRUz8c/st7/APhqeOf2W9//AA1BcxFTPxz+y3v/AOGp45/Zb3/8NQXMRUz8c/st7/8AhqeOf2W9/wDw1BcxFTPxz+y3v/4anjn9lvf/AMNQXMRUz8c/st7/APhqeOf2W9//AA1BcxFTPxz+y3v/AOGp45/Zb3/8NQXMRUz8c/st7/8AhqeOf2W9/wDw1BcxFTPxz+y3v/4anjn9lvf/AMNQXMRUz8c/st7/APhqeOf2W9//AA1BcxFTPxz+y3v/AOGp45/Zb3/8NQXMRUz8c/st7/8AhqeOf2W9/wDw1BcxFTPxz+y3v/4anjn9lvf/AMNQXMRUz8c/st7/APhqeOf2W9//AA1BcxFTPxz+y3v/AOGp45/Zb3/8NQXMRUz8c/st7/8AhqeOf2W9/wDw1BcxFTPxz+y3v/4anjn9lvf/AMNQXMRUz8c/st7/APhqeOf2W9//AA1BcxFTPxz+y3v/AOGp45/Zb3/8NQXMRUz8c/st7/8AhqeOf2W9/wDw1BcxFTPxz+y3v/4anjn9lvf/AMNQXMRUz8c/st7/APhqeOf2W9//AA1BcxFTPxz+y3v/AOGp45/Zb3/8NQXMRUz8c/st7/8AhqeOf2W9/wDw1BcxFTPxz+y3v/4anjn9lvf/AMNQXMRUz8c/st7/APhqeOf2W9//AA1BcxFTPxz+y3v/AOGp45/Zb3/8NQXMRUz8c/st7/8AhqeOf2W9/wDw1BcxFTPxz+y3v/4anjn9lvf/AMNQUzREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERB//2Q==\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "YouTubeVideo(\"pBuS7EUPnQA\", width=\"60%\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "YouTubeVideo(\"-4QjII981sM\", width=\"60%\")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/06_text/full_house.bin b/06_text/full_house.bin
new file mode 100644
index 0000000..4ad5e35
--- /dev/null
+++ b/06_text/full_house.bin
@@ -0,0 +1 @@
+🂧🂷🃗🃎🃞
\ No newline at end of file
diff --git a/06_text/lorem_ipsum.txt b/06_text/lorem_ipsum.txt
new file mode 100644
index 0000000..c0e21ab
--- /dev/null
+++ b/06_text/lorem_ipsum.txt
@@ -0,0 +1,6 @@
+Lorem Ipsum is simply dummy text of the printing and typesetting industry.
+Lorem Ipsum has been the industry's standard dummy text ever since the 1500s
+when an unknown printer took a galley of type and scrambled it to make a type
+specimen book. It has survived not only five centuries but also the leap into
+electronic typesetting, remaining essentially unchanged. It was popularised in
+the 1960s with the release of Letraset sheets.
diff --git a/06_text/umlauts.txt b/06_text/umlauts.txt
new file mode 100644
index 0000000..9c0f911
--- /dev/null
+++ b/06_text/umlauts.txt
@@ -0,0 +1,12 @@
+Lerchen-Lrchen-hnlichkeiten
+fehlen. Dieses abzustreiten
+mag im Klang der Worte liegen.
+Merke, eine Lerch' kann fliegen,
+Lrchen nicht, was kaum verwundert,
+denn nicht eine unter hundert
+ist geflgelt. Auch im Singen
+sind die Bume zu bezwingen.
+Die Btrachtung sollte reichen,
+Rchtschreibfhlern auszuweichen.
+Leicht glingt's, zu unterscheiden,
+wr ist wr nun von dn beiden.
\ No newline at end of file
diff --git a/07_sequences/00_content.ipynb b/07_sequences/00_content.ipynb
new file mode 100644
index 0000000..8f8984f
--- /dev/null
+++ b/07_sequences/00_content.ipynb
@@ -0,0 +1,958 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/07_sequences/00_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 7: Sequential Data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We studied numbers (cf., [Chapter 5 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/00_content.ipynb)) and textual data (cf., [Chapter 6 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/00_content.ipynb)) first mainly because objects of the presented data types are \"simple.\" That is so for two reasons: First, they are *immutable*, and, as we saw in the \"*Who am I? And how many?*\" section in [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/03_content.ipynb#Who-am-I?-And-how-many?), mutable objects can quickly become hard to reason about. Second, they are \"flat\" in the sense that they are *not* composed of other objects.\n",
+ "\n",
+ "The `str` type is a bit of a corner case in this regard. While one could argue that a longer `str` object, for example, `\"text\"`, is composed of individual characters, this is *not* the case in memory as the literal `\"text\"` only creates *one* object (i.e., one \"bag\" of $0$s and $1$s modeling all characters).\n",
+ "\n",
+ "This chapter, [Chapter 8 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/08_mfr/00_content.ipynb), [Chapter 9 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/09_mappings/00_content.ipynb), and [Chapter 10 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/10_arrays/00_content.ipynb) introduce various \"complex\" data types. While some are mutable and others are not, they all share that they are primarily used to \"manage,\" or structure, the memory in a program (i.e., they provide references to other objects). Unsurprisingly, computer scientists refer to the ideas behind these data types as **[data structures ](https://en.wikipedia.org/wiki/Data_structure)**.\n",
+ "\n",
+ "In this chapter, we focus on data types that model all kinds of sequential data. Examples of such data are [spreadsheets ](https://en.wikipedia.org/wiki/Spreadsheet) or [matrices ](https://en.wikipedia.org/wiki/Matrix_%28mathematics%29) and [vectors ](https://en.wikipedia.org/wiki/Vector_%28mathematics_and_physics%29). These formats share the property that they are composed of smaller units that come in a sequence of, for example, rows/columns/cells or elements/entries."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Collections vs. Sequences"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[Chapter 6 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/00_content.ipynb#A-\"String\"-of-Characters) already describes the **sequence** properties of `str` objects. In this section, we take a step back and study these properties one by one.\n",
+ "\n",
+ "The [collections.abc ](https://docs.python.org/3/library/collections.abc.html) module in the [standard library ](https://docs.python.org/3/library/index.html) defines a variety of **abstract base classes** (ABCs). We saw ABCs already in [Chapter 5 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/02_content.ipynb#The-Numerical-Tower), where we use the ones from the [numbers ](https://docs.python.org/3/library/numbers.html) module in the [standard library ](https://docs.python.org/3/library/index.html) to classify Python's numeric data types according to mathematical ideas. Now, we take the ABCs from the [collections.abc ](https://docs.python.org/3/library/collections.abc.html) module to classify the data types in this chapter according to their behavior in various contexts.\n",
+ "\n",
+ "As an illustration, consider `numbers` and `text` below, two objects of *different* types."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "numbers = [7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]\n",
+ "text = \"Lorem ipsum dolor sit amet.\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Among others, one commonality between the two is that we may loop over them with the `for` statement. So, in the context of iteration, both exhibit the *same* behavior."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "7 11 8 5 3 12 2 6 9 10 1 4 "
+ ]
+ }
+ ],
+ "source": [
+ "for number in numbers:\n",
+ " print(number, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "L o r e m i p s u m d o l o r s i t a m e t . "
+ ]
+ }
+ ],
+ "source": [
+ "for character in text:\n",
+ " print(character, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/02_content.ipynb#Containers-vs.-Iterables), we referred to such types as *iterables*. That is *not* a proper [English](https://dictionary.cambridge.org/spellcheck/english-german/?q=iterable) word, even if it may sound like one at first sight. Yet, it is an official term in the Python world formalized with the `Iterable` ABC in the [collections.abc ](https://docs.python.org/3/library/collections.abc.html) module.\n",
+ "\n",
+ "For the data science practitioner, it is worthwhile to know such terms as, for example, the documentation on the [built-ins ](https://docs.python.org/3/library/functions.html) uses them extensively: In simple words, any built-in that takes an argument called \"*iterable*\" may be called with *any* object that supports being looped over. Already familiar [built-ins ](https://docs.python.org/3/library/functions.html) include [enumerate() ](https://docs.python.org/3/library/functions.html#enumerate), [sum() ](https://docs.python.org/3/library/functions.html#sum), or [zip() ](https://docs.python.org/3/library/functions.html#zip). So, they do *not* require the argument to be of a certain data type (e.g., `list`); instead, any *iterable* type works."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import collections.abc as abc"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "collections.abc.Iterable"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "abc.Iterable"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As seen in [Chapter 5 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/05_numbers/02_content.ipynb#Goose-Typing), we can use ABCs with the built-in [isinstance() ](https://docs.python.org/3/library/functions.html#isinstance) function to check if an object supports a behavior.\n",
+ "\n",
+ "So, let's \"ask\" Python if it can loop over `numbers` or `text`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(numbers, abc.Iterable)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(text, abc.Iterable)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Contrary to `list` or `str` objects, numeric objects are *not* iterable."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(999, abc.Iterable)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Instead of asking, we could try to loop over `999`, but this results in a `TypeError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "'int' object is not iterable",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[9], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mdigit\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;241;43m999\u001b[39;49m\u001b[43m:\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mprint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mdigit\u001b[49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
+ ]
+ }
+ ],
+ "source": [
+ "for digit in 999:\n",
+ " print(digit)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Most of the data types in this chapter and [Chapter 9 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/09_mappings/00_content.ipynb) and [Chapter 10 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/10_arrays/00_content.ipynb) exhibit three [orthogonal ](https://en.wikipedia.org/wiki/Orthogonality) (i.e., \"independent\") behaviors, formalized by ABCs in the [collections.abc ](https://docs.python.org/3/library/collections.abc.html) module as:\n",
+ "- `Iterable`: An object may be looped over.\n",
+ "- `Container`: An object \"contains\" references to other objects; a \"whole\" is composed of many \"parts.\"\n",
+ "- `Sized`: The number of references to other objects, the \"parts,\" is *finite*.\n",
+ "\n",
+ "The characteristical operation supported by `Container` types is the `in` operator for membership testing."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0 in numbers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\"l\" in text"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Alternatively, we could also check if `numbers` and `text` are `Container` types with [isinstance() ](https://docs.python.org/3/library/functions.html#isinstance)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(numbers, abc.Container)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(text, abc.Container)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Numeric objects do *not* \"contain\" references to other objects, and that is why they are considered \"flat\" data types. The `in` operator raises a `TypeError`. Conceptually speaking, Python views numeric types as \"wholes\" without any \"parts.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(999, abc.Container)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "argument of type 'int' is not iterable",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[15], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;241;43m9\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;241;43m999\u001b[39;49m\n",
+ "\u001b[0;31mTypeError\u001b[0m: argument of type 'int' is not iterable"
+ ]
+ }
+ ],
+ "source": [
+ "9 in 999"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Analogously, being `Sized` types, we can pass `numbers` and `text` as the argument to the built-in [len() ](https://docs.python.org/3/library/functions.html#len) function and obtain \"meaningful\" results. The exact meaning depends on the data type: For `numbers`, [len() ](https://docs.python.org/3/library/functions.html#len) tells us how many elements are in the `list` object; for `text`, it tells us how many [Unicode characters ](https://en.wikipedia.org/wiki/Unicode) make up the `str` object. *Abstractly* speaking, both data types exhibit the *same* behavior of *finiteness*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "12"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(numbers)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "27"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(text)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(numbers, abc.Sized)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(text, abc.Sized)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "On the contrary, even though `999` consists of three digits for humans, numeric objects in Python have no concept of a \"size\" or \"length,\" and the [len() ](https://docs.python.org/3/library/functions.html#len) function raises a `TypeError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(999, abc.Sized)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "object of type 'int' has no len()",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[21], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m999\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mTypeError\u001b[0m: object of type 'int' has no len()"
+ ]
+ }
+ ],
+ "source": [
+ "len(999)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "These three behaviors are so essential that whenever they coincide for a data type, it is called a **collection**, formalized with the `Collection` ABC. That is where the [collections.abc ](https://docs.python.org/3/library/collections.abc.html) module got its name from: It summarizes all ABCs related to collections; in particular, it defines a hierarchy of specialized kinds of collections.\n",
+ "\n",
+ "Without going into too much detail, one way to read the summary table at the beginning of the [collections.abc ](https://docs.python.org/3/library/collections.abc.html) module's documention is as follows: The first column, titled \"ABC\", lists all collection-related ABCs in Python. The second column, titled \"Inherits from,\" indicates if the idea behind the ABC is *original* (e.g., the first row with the `Container` ABC has an empty \"Inherits from\" column) or a *combination* (e.g., the row with the `Collection` ABC has `Sized`, `Iterable`, and `Container` in the \"Inherits from\" column). The third and fourth columns list the methods that come with a data type following an ABC. We keep ignoring the methods named in the dunder style for now.\n",
+ "\n",
+ "So, let's confirm that both `numbers` and `text` are collections."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(numbers, abc.Collection)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(text, abc.Collection)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "They share one more common behavior: When looping over them, we can *predict* the *order* of the elements or characters. The ABC in the [collections.abc ](https://docs.python.org/3/library/collections.abc.html) module corresponding to this behavior is `Reversible`. While sounding unintuitive at first, it is evident that if something is reversible, it must have a forward order, to begin with.\n",
+ "\n",
+ "The [reversed() ](https://docs.python.org/3/library/functions.html#reversed) built-in allows us to loop over the elements or characters in reverse order."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4 1 10 9 6 2 12 3 5 8 11 7 "
+ ]
+ }
+ ],
+ "source": [
+ "for number in reversed(numbers):\n",
+ " print(number, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ ". t e m a t i s r o l o d m u s p i m e r o L "
+ ]
+ }
+ ],
+ "source": [
+ "for character in reversed(text):\n",
+ " print(character, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(numbers, abc.Reversible)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(text, abc.Reversible)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Collections that exhibit this fourth behavior are referred to as **sequences**, formalized with the `Sequence` ABC in the [collections.abc ](https://docs.python.org/3/library/collections.abc.html) module."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(numbers, abc.Sequence)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(text, abc.Sequence)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The data types introduced in this chapter are sequences. Nevertheless, we also look at some data types that are neither collections nor sequences but are still useful to model sequential data in practice in [Chapter 8 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/08_mfr/00_content.ipynb).\n",
+ "\n",
+ "In Python-related documentations, the terms collection and sequence are heavily used, and the data science practitioner should always think of them in terms of the three or four behaviors they exhibit.\n",
+ "\n",
+ "Data types that are collections but not sequences are covered in [Chapter 9 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/09_mappings/00_content.ipynb)."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/07_sequences/01_content.ipynb b/07_sequences/01_content.ipynb
new file mode 100644
index 0000000..d267d48
--- /dev/null
+++ b/07_sequences/01_content.ipynb
@@ -0,0 +1,2999 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/07_sequences/01_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 7: Sequential Data (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In this second part of the chapter, we look closely at the built-in `list` type, which is probably the most commonly used sequence data type in practice."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `list` Type"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As already seen multiple times, to create a `list` object, we use the *literal notation* and list all elements within brackets `[` and `]`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "empty = []"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "simple = [40, 50]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The elements do *not* need to be of the *same* type, and `list` objects may also be **nested**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "nested = [empty, 10, 20.0, \"Thirty\", simple]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[PythonTutor ](http://pythontutor.com/visualize.html#code=empty%20%3D%20%5B%5D%0Asimple%20%3D%20%5B40,%2050%5D%0Anested%20%3D%20%5Bempty,%2010,%2020.0,%20%22Thirty%22,%20simple%5D&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) shows how `nested` holds references to the `empty` and `simple` objects. Technically, it holds three more references to the `10`, `20.0`, and `\"Thirty\"` objects as well. However, to simplify the visualization, these three objects are shown right inside the `nested` object. That may be done because they are immutable and \"flat\" data types. In general, the $0$s and $1$s inside a `list` object in memory always constitute references to other objects only."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[[], 10, 20.0, 'Thirty', [40, 50]]"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Let's not forget that `nested` is an object on its own with an *identity* and *data type*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "139688113982848"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(nested)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "list"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(nested)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Alternatively, we use the built-in [list() ](https://docs.python.org/3/library/functions.html#func-list) constructor to create a `list` object out of any (finite) *iterable* we pass to it as the argument.\n",
+ "\n",
+ "For example, we can wrap the [range() ](https://docs.python.org/3/library/functions.html#func-range) built-in with [list() ](https://docs.python.org/3/library/functions.html#func-list): As described in [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/02_content.ipynb#Containers-vs.-Iterables), `range` objects, like `range(1, 13)` below, are iterable and generate `int` objects \"on the fly\" (i.e., one by one). The [list() ](https://docs.python.org/3/library/functions.html#func-list) around it acts like a `for`-loop and **materializes** twelve `int` objects in memory that then become the elements of the newly created `list` object. [PythonTutor ](http://pythontutor.com/visualize.html#code=r%20%3D%20range%281,%2013%29%0Al%20%3D%20list%28range%281,%2013%29%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) shows this difference visually."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "list(range(1, 13))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Beware of passing a `range` object over a \"big\" horizon as the argument to [list() ](https://docs.python.org/3/library/functions.html#func-list) as that may lead to a `MemoryError` and the computer crashing."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "MemoryError",
+ "evalue": "",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mMemoryError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mrange\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m999_999_999_999\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mMemoryError\u001b[0m: "
+ ]
+ }
+ ],
+ "source": [
+ "list(range(999_999_999_999))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As another example, we create a `list` object from a `str` object, which is iterable, as well. Then, the individual characters become the elements of the new `list` object!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['i', 't', 'e', 'r', 'a', 'b', 'l', 'e']"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "list(\"iterable\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Sequence Behaviors"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`list` objects are *sequences*. To reiterate that, we briefly summarize the *four* behaviors of a sequence and provide some more `list`-specific details below:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "- `Container`:\n",
+ " - holds references to other objects in memory (with their own *identity* and *type*)\n",
+ " - implements membership testing via the `in` operator\n",
+ "- `Iterable`:\n",
+ " - supports being looped over\n",
+ " - works with the `for` or `while` statements\n",
+ "- `Reversible`:\n",
+ " - the elements come in a *predictable* order that we may loop over in a forward or backward fashion\n",
+ " - works with the [reversed() ](https://docs.python.org/3/library/functions.html#reversed) built-in\n",
+ "- `Sized`:\n",
+ " - the number of elements is finite *and* known in advance\n",
+ " - works with the built-in [len() ](https://docs.python.org/3/library/functions.html#len) function"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The \"length\" of `nested` is *five* because `empty` and `simple` count as *one* element each. In other words, `nested` holds five references to other objects, two of which are `list` objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "5"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(nested)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With a `for`-loop, we can iterate over all elements in a *predictable* order, forward or backward. As `list` objects hold *references* to other *objects*, these have an *indentity* and may even be of *different* types; however, the latter observation is rarely, if ever, useful in practice."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[] 139688113991744 \n",
+ "10 94291567220768 \n",
+ "20.0 139688114016656 \n",
+ "Thirty 139688114205808 \n",
+ "[40, 50] 139688113982208 \n"
+ ]
+ }
+ ],
+ "source": [
+ "for element in nested:\n",
+ " print(str(element).ljust(10), str(id(element)).ljust(18), type(element))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[40, 50] Thirty 20.0 10 [] "
+ ]
+ }
+ ],
+ "source": [
+ "for element in reversed(nested):\n",
+ " print(element, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `in` operator checks if a given object is \"contained\" in a `list` object. It uses the `==` operator behind the scenes (i.e., *not* the `is` operator) conducting a **[linear search ](https://en.wikipedia.org/wiki/Linear_search)**: So, Python implicitly loops over *all* elements and only stops prematurely if an element evaluates equal to the searched object. A linear search may, therefore, be relatively *slow* for big `list` objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "10 in nested"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`20` compares equal to the `20.0` in `nested`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "20 in nested"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "30 in nested"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Indexing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Because of the *predictable* order and the *finiteness*, each element in a sequence can be labeled with a unique *index*, an `int` object in the range $0 \\leq \\text{index} < \\lvert \\text{sequence} \\rvert$.\n",
+ "\n",
+ "Brackets, `[` and `]`, are the literal syntax for accessing individual elements of any sequence type. In this book, we also call them the *indexing operator* in this context."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[]"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested[0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The last index is one less than `len(nested)`, and Python raises an `IndexError` if we look up an index that is not in the range."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "IndexError",
+ "evalue": "list index out of range",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[17], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mnested\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m]\u001b[49m\n",
+ "\u001b[0;31mIndexError\u001b[0m: list index out of range"
+ ]
+ }
+ ],
+ "source": [
+ "nested[5]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Negative indices are used to count in reverse order from the end of a sequence, and brackets may be chained to access nested objects. So, to access the `50` inside `simple` via the `nested` object, we write `nested[-1][1]`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[40, 50]"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested[-1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "50"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested[-1][1]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Slicing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Slicing `list` objects works analogously to slicing `str` objects: We use the literal syntax with either one or two colons `:` inside the brackets `[]` to separate the *start*, *stop*, and *step* values. Slicing creates a *new* `list` object with the elements chosen from the original one.\n",
+ "\n",
+ "For example, to obtain the three elements in the \"middle\" of `nested`, we slice from `1` (including) to `4` (excluding)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[10, 20.0, 'Thirty']"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested[1:4]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To obtain \"every other\" element, we slice from beginning to end, defaulting to `0` and `len(nested)` when omitted, in steps of `2`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[[], 20.0, [40, 50]]"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested[::2]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The literal notation with the colons `:` is *syntactic sugar*. It saves us from using the [slice() ](https://docs.python.org/3/library/functions.html#slice) built-in to create `slice` objects. [slice() ](https://docs.python.org/3/library/functions.html#slice) takes *start*, *stop*, and *step* arguments in the same way as the familiar [range() ](https://docs.python.org/3/library/functions.html#func-range), and the `slice` objects it creates are used just as *indexes* above.\n",
+ "\n",
+ "In most cases, the literal notation is more convenient to use; however, with `slice` objects, we can give names to slices and reuse them across several sequences."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "middle = slice(1, 4)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "slice"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(middle)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[10, 20.0, 'Thirty']"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested[middle]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`slice` objects come with three read-only attributes `start`, `stop`, and `step` on them."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "middle.start"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "middle.stop"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If not passed to [slice() ](https://docs.python.org/3/library/functions.html#slice), these attributes default to `None`. That is why the cell below has no output."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "middle.step"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A good trick to know is taking a \"full\" slice: This copies *all* elements of a `list` object into a *new* `list` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "nested_copy = nested[:]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[[], 10, 20.0, 'Thirty', [40, 50]]"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested_copy"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "At first glance, `nested` and `nested_copy` seem to cause no pain. For `list` objects, the comparison operator `==` goes over the elements in both operands in a pairwise fashion and checks if they all evaluate equal (cf., the \"*List Comparison*\" section below for more details).\n",
+ "\n",
+ "We confirm that `nested` and `nested_copy` compare equal as could be expected but also that they are *different* objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested == nested_copy"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested is nested_copy"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, as [PythonTutor ](http://pythontutor.com/visualize.html#code=nested%20%3D%20%5B%5B%5D,%2010,%2020.0,%20%22Thirty%22,%20%5B40,%2050%5D%5D%0Anested_copy%20%3D%20nested%5B%3A%5D&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) reveals, only the *references* to the elements are copied, and not the objects in `nested` themselves! Because of that, `nested_copy` is a so-called **[shallow copy ](https://en.wikipedia.org/wiki/Object_copying#Shallow_copy)** of `nested`.\n",
+ "\n",
+ "We could also see this with the [id() ](https://docs.python.org/3/library/functions.html#id) function: The respective first elements in both `nested` and `nested_copy` are the *same* object, namely `empty`. So, we have three ways of accessing the *same* address in memory. Also, we say that `nested` and `nested_copy` partially share the *same* state."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested[0] is nested_copy[0]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "139688113991744"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(nested[0])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "139688113991744"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(nested_copy[0])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Knowing this becomes critical if the elements in a `list` object are mutable objects (i.e., we can change them *in place*), and this is the case with `nested` and `nested_copy`, as we see in the next section on \"*Mutability*\".\n",
+ "\n",
+ "As both the original `nested` object and its copy reference the *same* `list` objects in memory, any changes made to them are visible to both! Because of that, working with shallow copies can easily become confusing.\n",
+ "\n",
+ "Instead of a shallow copy, we could also create a so-called **[deep copy ](https://en.wikipedia.org/wiki/Object_copying#Deep_copy)** of `nested`: Then, the copying process recursively follows every reference in a nested data structure and creates copies of *every* object found.\n",
+ "\n",
+ "To explicitly create shallow or deep copies, the [copy ](https://docs.python.org/3/library/copy.html) module in the [standard library ](https://docs.python.org/3/library/index.html) provides two functions, [copy() ](https://docs.python.org/3/library/copy.html#copy.copy) and [deepcopy() ](https://docs.python.org/3/library/copy.html#copy.deepcopy). We must always remember that slicing creates *shallow* copies only."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import copy"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "nested_deep_copy = copy.deepcopy(nested)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 37,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested == nested_deep_copy"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Now, the first elements of `nested` and `nested_deep_copy` are *different* objects, and [PythonTutor ](http://pythontutor.com/visualize.html#code=import%20copy%0Anested%20%3D%20%5B%5B%5D,%2010,%2020.0,%20%22Thirty%22,%20%5B40,%2050%5D%5D%0Anested_deep_copy%20%3D%20copy.deepcopy%28nested%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) shows that there are *six* `list` objects in memory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested[0] is nested_deep_copy[0]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "139688113991744"
+ ]
+ },
+ "execution_count": 39,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(nested[0])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "139688113233152"
+ ]
+ },
+ "execution_count": 40,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(nested_deep_copy[0])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As this [StackOverflow question ](https://stackoverflow.com/questions/184710/what-is-the-difference-between-a-deep-copy-and-a-shallow-copy) shows, understanding shallow and deep copies is a common source of confusion, independent of the programming language."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Mutability"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In contrast to `str` objects, `list` objects are *mutable*: We may assign new elements to indices or slices and also remove elements. That changes the *references* in a `list` object. In general, if an object is *mutable*, we say that it may be changed *in place*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "nested[0] = 0"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[0, 10, 20.0, 'Thirty', [40, 50]]"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "When we re-assign a slice, we can even change the size of the `list` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "nested[:4] = [100, 100, 100]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[100, 100, 100, [40, 50]]"
+ ]
+ },
+ "execution_count": 44,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 45,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(nested)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `list` object's identity does *not* change. That is the main point behind mutable objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "139688113982848"
+ ]
+ },
+ "execution_count": 46,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(nested) # same memory location as before"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`nested_copy` is unchanged!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[[], 10, 20.0, 'Thirty', [40, 50]]"
+ ]
+ },
+ "execution_count": 47,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested_copy"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Let's change the nested `[40, 50]` via `nested_copy` into `[1, 2, 3]` by replacing all its elements."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "nested_copy[-1][:] = [1, 2, 3]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[[], 10, 20.0, 'Thirty', [1, 2, 3]]"
+ ]
+ },
+ "execution_count": 49,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested_copy"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "That has a surprising side effect on `nested`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[100, 100, 100, [1, 2, 3]]"
+ ]
+ },
+ "execution_count": 50,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "That is precisely the confusion we talked about above when we said that `nested_copy` is a *shallow* copy of `nested`. [PythonTutor ](http://pythontutor.com/visualize.html#code=nested%20%3D%20%5B%5B%5D,%2010,%2020.0,%20%22Thirty%22,%20%5B40,%2050%5D%5D%0Anested_copy%20%3D%20nested%5B%3A%5D%0Anested%5B%3A4%5D%20%3D%20%5B100,%20100,%20100%5D%0Anested_copy%5B-1%5D%5B%3A%5D%20%3D%20%5B1,%202,%203%5D&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) shows how both reference the *same* nested `list` object that is changed *in place* from `[40, 50]` into `[1, 2, 3]`.\n",
+ "\n",
+ "Lastly, we use the `del` statement to remove an element."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "del nested[-1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[100, 100, 100]"
+ ]
+ },
+ "execution_count": 52,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `del` statement also works for slices. Here, we remove all references `nested` holds."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "del nested[:]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[]"
+ ]
+ },
+ "execution_count": 54,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nested"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Mutability for sequences is formalized by the `MutableSequence` ABC in the [collections.abc ](https://docs.python.org/3/library/collections.abc.html) module."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## List Methods"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `list` type is an essential data structure in any real-world Python application, and many typical `list`-related algorithms from computer science theory are already built into it at the C level (cf., the [documentation ](https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types) or the [tutorial ](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists) for a full overview; unfortunately, not all methods have direct links). So, understanding and applying the built-in methods of the `list` type not only speeds up the development process but also makes programs significantly faster.\n",
+ "\n",
+ "In contrast to the `str` type's methods in [Chapter 6 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/00_content.ipynb#String-Methods) (e.g., [.upper() ](https://docs.python.org/3/library/stdtypes.html#str.upper) or [.lower() ](https://docs.python.org/3/library/stdtypes.html#str.lower)), the `list` type's methods that mutate an object do so *in place*. That means they *never* create *new* `list` objects and return `None` to indicate that. So, we must *never* assign the return value of `list` methods to the variable holding the list!\n",
+ "\n",
+ "Let's look at the following `names` example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "names = [\"Carl\", \"Peter\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To add an object to the end of `names`, we use the `.append()` method. The code cell shows no output indicating that `None` must be the return value."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "names.append(\"Eckardt\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Carl', 'Peter', 'Eckardt']"
+ ]
+ },
+ "execution_count": 57,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With the `.extend()` method, we may also append multiple elements provided by an iterable. Here, the iterable is a `list` object itself holding two `str` objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "names.extend([\"Karl\", \"Oliver\"])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Carl', 'Peter', 'Eckardt', 'Karl', 'Oliver']"
+ ]
+ },
+ "execution_count": 59,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Similar to `.append()`, we may add a new element at an arbitrary position with the `.insert()` method. `.insert()` takes two arguments, an *index* and the element to be inserted."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "names.insert(1, \"Berthold\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Carl', 'Berthold', 'Peter', 'Eckardt', 'Karl', 'Oliver']"
+ ]
+ },
+ "execution_count": 61,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`list` objects may be sorted *in place* with the [.sort() ](https://docs.python.org/3/library/stdtypes.html#list.sort) method. That is different from the built-in [sorted() ](https://docs.python.org/3/library/functions.html#sorted) function that takes any *finite* and *iterable* object and returns a *new* `list` object with the iterable's elements sorted!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Berthold', 'Carl', 'Eckardt', 'Karl', 'Oliver', 'Peter']"
+ ]
+ },
+ "execution_count": 62,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sorted(names)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As the previous code cell created a *new* `list` object, `names` is still unsorted."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Carl', 'Berthold', 'Peter', 'Eckardt', 'Karl', 'Oliver']"
+ ]
+ },
+ "execution_count": 63,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Let's sort the elements in `names` instead."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "names.sort()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Berthold', 'Carl', 'Eckardt', 'Karl', 'Oliver', 'Peter']"
+ ]
+ },
+ "execution_count": 65,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To sort in reverse order, we pass a keyword-only `reverse=True` argument to either the [.sort() ](https://docs.python.org/3/library/stdtypes.html#list.sort) method or the [sorted() ](https://docs.python.org/3/library/functions.html#sorted) function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "names.sort(reverse=True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 67,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Peter', 'Oliver', 'Karl', 'Eckardt', 'Carl', 'Berthold']"
+ ]
+ },
+ "execution_count": 67,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The [.sort() ](https://docs.python.org/3/library/stdtypes.html#list.sort) method and the [sorted() ](https://docs.python.org/3/library/functions.html#sorted) function sort the elements in `names` in alphabetical order, forward or backward. However, that does *not* hold in general.\n",
+ "\n",
+ "We mention above that `list` objects may contain objects of *any* type and even of *mixed* types. Because of that, the sorting is **[delegated ](https://en.wikipedia.org/wiki/Delegation_(object-oriented_programming))** to the elements in a `list` object. In a way, Python \"asks\" the elements in a `list` object to sort themselves. As `names` contains only `str` objects, they are sorted according the the comparison rules explained in [Chapter 6 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/06_text/00_content.ipynb#String-Comparison).\n",
+ "\n",
+ "To customize the sorting, we pass a keyword-only `key` argument to [.sort() ](https://docs.python.org/3/library/stdtypes.html#list.sort) or [sorted() ](https://docs.python.org/3/library/functions.html#sorted), which must be a `function` object accepting *one* positional argument. Then, the elements in the `list` object are passed to that one by one, and the return values are used as the **sort keys**. The `key` argument is also a popular use case for `lambda` expressions.\n",
+ "\n",
+ "For example, to sort `names` not by alphabet but by the names' lengths, we pass in a reference to the built-in [len() ](https://docs.python.org/3/library/functions.html#len) function as `key=len`. Note that there are *no* parentheses after `len`!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "names.sort(key=len)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If two names have the same length, their relative order is kept as is. That is why `\"Karl\"` comes before `\"Carl\" ` below. A [sorting algorithm ](https://en.wikipedia.org/wiki/Sorting_algorithm) with that property is called **[stable ](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability)**.\n",
+ "\n",
+ "Sorting is an important topic in programming, and we refer to the official [HOWTO ](https://docs.python.org/3/howto/sorting.html) for a more comprehensive introduction."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 69,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Karl', 'Carl', 'Peter', 'Oliver', 'Eckardt', 'Berthold']"
+ ]
+ },
+ "execution_count": 69,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`.sort(reverse=True)` is different from the `.reverse()` method. Whereas the former applies some sorting rule in reverse order, the latter simply reverses the elements in a `list` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 70,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "names.reverse()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 71,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Berthold', 'Eckardt', 'Oliver', 'Peter', 'Carl', 'Karl']"
+ ]
+ },
+ "execution_count": 71,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `.pop()` method removes the *last* element from a `list` object *and* returns it. Below we **capture** the `removed` element to show that the return value is not `None` as with all the methods introduced so far."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 72,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "removed = names.pop()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Karl'"
+ ]
+ },
+ "execution_count": 73,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "removed"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 74,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Berthold', 'Eckardt', 'Oliver', 'Peter', 'Carl']"
+ ]
+ },
+ "execution_count": 74,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`.pop()` takes an optional *index* argument and removes that instead.\n",
+ "\n",
+ "So, to remove the second element, `\"Eckhardt\"`, from `names`, we write this."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 75,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "removed = names.pop(1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 76,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Eckardt'"
+ ]
+ },
+ "execution_count": 76,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "removed"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 77,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Berthold', 'Oliver', 'Peter', 'Carl']"
+ ]
+ },
+ "execution_count": 77,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Instead of removing an element by its index, we can also remove it by its value with the `.remove()` method. Behind the scenes, Python then compares the object to be removed, `\"Peter\"` in the example, sequentially to each element with the `==` operator and removes the *first* one that evaluates equal to it. `.remove()` does *not* return the removed element."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 78,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "names.remove(\"Peter\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 79,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Berthold', 'Oliver', 'Carl']"
+ ]
+ },
+ "execution_count": 79,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Also, `.remove()` raises a `ValueError` if the value is not found."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 80,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "list.remove(x): x not in list",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[80], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mnames\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mremove\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mPeter\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mValueError\u001b[0m: list.remove(x): x not in list"
+ ]
+ }
+ ],
+ "source": [
+ "names.remove(\"Peter\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`list` objects implement an `.index()` method that returns the position of the first element that compares equal to its argument. It fails *loudly* with a `ValueError` if no element compares equal."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 81,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Berthold', 'Oliver', 'Carl']"
+ ]
+ },
+ "execution_count": 81,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 82,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 82,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names.index(\"Oliver\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 83,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "'Karl' is not in list",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[83], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mnames\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mKarl\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mValueError\u001b[0m: 'Karl' is not in list"
+ ]
+ }
+ ],
+ "source": [
+ "names.index(\"Karl\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `.count()` method returns the number of elements that compare equal to its argument."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 84,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 84,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names.count(\"Carl\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 85,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 85,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names.count(\"Karl\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Two more methods, `.copy()` and `.clear()`, are *syntactic sugar* and replace working with slices.\n",
+ "\n",
+ "`.copy()` creates a *shallow* copy. So, `names.copy()` below does the same as taking a full slice with `names[:]`, and the caveats from above apply, too."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 86,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "names_copy = names.copy()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 87,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Berthold', 'Oliver', 'Carl']"
+ ]
+ },
+ "execution_count": 87,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names_copy"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`.clear()` removes all references from a `list` object. So, `names_copy.clear()` is the same as `del names_copy[:]`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 88,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "names_copy.clear()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 89,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[]"
+ ]
+ },
+ "execution_count": 89,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names_copy"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Many methods introduced in this section are mentioned in the [collections.abc ](https://docs.python.org/3/library/collections.abc.html) module's documentation as well: While the `.index()` and `.count()` methods come with any data type that is a `Sequence`, the `.append()`, `.extend()`, `.insert()`, `.reverse()`, `.pop()`, and `.remove()` methods are part of any `MutableSequence` type. The `.sort()`, `.copy()`, and `.clear()` methods are `list`-specific.\n",
+ "\n",
+ "So, being a sequence does not only imply the four *behaviors* specified above, but also means that a data type comes with certain standardized methods."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## List Operations"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As with `str` objects, the `+` and `*` operators are overloaded for concatenation and always return a *new* `list` object. The references in this newly created `list` object reference the *same* objects as the two original `list` objects. So, the same caveat as with *shallow* copies from above applies!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 90,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Berthold', 'Oliver', 'Carl']"
+ ]
+ },
+ "execution_count": 90,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 91,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Berthold', 'Oliver', 'Carl', 'Diedrich', 'Yves']"
+ ]
+ },
+ "execution_count": 91,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names + [\"Diedrich\", \"Yves\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 92,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Berthold', 'Oliver', 'Carl', 'Berthold', 'Oliver', 'Carl']"
+ ]
+ },
+ "execution_count": 92,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "2 * names"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Unpacking"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Besides being an operator, the `*` symbol has a second syntactical use, as explained in [PEP 3132 ](https://www.python.org/dev/peps/pep-3132/) and [PEP 448 ](https://www.python.org/dev/peps/pep-0448/): It implements what is called **iterable unpacking**. It is *not* an operator syntactically but a notation that Python reads as a literal.\n",
+ "\n",
+ "In the example, Python interprets the expression as if the elements of the iterable `names` were placed between `\"Achim\"` and `\"Xavier\"` one by one. So, we do not obtain a nested but a *flat* list."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 93,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Achim', 'Berthold', 'Oliver', 'Carl', 'Xavier']"
+ ]
+ },
+ "execution_count": 93,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "[\"Achim\", *names, \"Xavier\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Effectively, Python reads that as if we wrote the following."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 94,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Achim', 'Berthold', 'Oliver', 'Carl', 'Xavier']"
+ ]
+ },
+ "execution_count": 94,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "[\"Achim\", names[0], names[1], names[2], \"Xavier\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### List Comparison"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The relational operators also work with `list` objects; yet another example of operator overloading.\n",
+ "\n",
+ "Comparison is made in a pairwise fashion until the first pair of elements does not evaluate equal or one of the `list` objects ends. The exact comparison rules depend on the elements and not the `list` objects. As with [.sort() ](https://docs.python.org/3/library/stdtypes.html#list.sort) or [sorted() ](https://docs.python.org/3/library/functions.html#sorted) above, comparison is *delegated* to the objects to be compared, and Python \"asks\" the elements in the two `list` objects to compare themselves. Usually, all elements are of the *same* type, and comparison is straightforward."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 95,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['Berthold', 'Oliver', 'Carl']"
+ ]
+ },
+ "execution_count": 95,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 96,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 96,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names == [\"Berthold\", \"Oliver\", \"Carl\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 97,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 97,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names != [\"Berthold\", \"Oliver\", \"Karl\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 98,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 98,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "names < [\"Berthold\", \"Oliver\", \"Karl\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If two `list` objects have a different number of elements and all overlapping elements compare equal, the shorter `list` object is considered \"smaller.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 99,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 99,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "[\"Berthold\", \"Oliver\"] < names < [\"Berthold\", \"Oliver\", \"Carl\", \"Xavier\"]"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/07_sequences/02_exercises_lists.ipynb b/07_sequences/02_exercises_lists.ipynb
new file mode 100644
index 0000000..7d5fab5
--- /dev/null
+++ b/07_sequences/02_exercises_lists.ipynb
@@ -0,0 +1,257 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Run All*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *after* finishing the exercises to ensure that your solution runs top to bottom *without* any errors. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/07_sequences/02_exercises.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 7: Sequential Data (Coding Exercises)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The exercises below assume that you have read the [second part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/01_content.ipynb) of Chapter 7.\n",
+ "\n",
+ "The `...`'s in the code cells indicate where you need to fill in code snippets. The number of `...`'s within a code cell give you a rough idea of how many lines of code are needed to solve the task. You should not need to create any additional code cells for your final solution. However, you may want to use temporary code cells to try out some ideas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Working with Lists"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: Write a function `nested_sum()` that takes a `list` object as its argument, which contains other `list` objects with numbers, and adds up the numbers! Use `nested_numbers` below to test your function!\n",
+ "\n",
+ "Hint: You need at least one `for`-loop."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "nested_numbers = [[1, 2, 3], [4], [5], [6, 7], [8], [9]]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def nested_sum(list_of_lists):\n",
+ " \"\"\"Add up numbers in nested lists.\n",
+ " \n",
+ " Args:\n",
+ " list_of_lists (list): A list containing the lists with the numbers\n",
+ " \n",
+ " Returns:\n",
+ " sum (int or float)\n",
+ " \"\"\"\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " return ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "nested_sum(nested_numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: Generalize `nested_sum()` into a function `mixed_sum()` that can process a \"mixed\" `list` object, which contains numbers and other `list` objects with numbers! Use `mixed_numbers` below for testing!\n",
+ "\n",
+ "Hints: Use the built-in [isinstance() ](https://docs.python.org/3/library/functions.html#isinstance) function to check how an element is to be processed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mixed_numbers = [[1, 2, 3], 4, 5, [6, 7], 8, [9]]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import collections.abc as abc"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def mixed_sum(list_of_lists_or_numbers):\n",
+ " \"\"\"Add up numbers in nested lists.\n",
+ " \n",
+ " Args:\n",
+ " list_of_lists_or_numbers (list): A list containing both numbers and\n",
+ " lists with numbers\n",
+ " \n",
+ " Returns:\n",
+ " sum (int or float)\n",
+ " \"\"\"\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " return ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mixed_sum(mixed_numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3.1**: Write a function `cum_sum()` that takes a `list` object with numbers as its argument and returns a *new* `list` object with the **cumulative sums** of these numbers! So, `sum_up` below, `[1, 2, 3, 4, 5]`, should return `[1, 3, 6, 10, 15]`.\n",
+ "\n",
+ "Hint: The idea behind is similar to the [cumulative distribution function ](https://en.wikipedia.org/wiki/Cumulative_distribution_function) from statistics."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sum_up = [1, 2, 3, 4, 5]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def cum_sum(numbers):\n",
+ " \"\"\"Create the cumulative sums for some numbers.\n",
+ "\n",
+ " Args:\n",
+ " numbers (list): A list with numbers for that the cumulative sums\n",
+ " are calculated\n",
+ " \n",
+ " Returns:\n",
+ " cum_sums (list): A list with all the cumulative sums\n",
+ " \"\"\"\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " return ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cum_sum(sum_up)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3.2**: We should always make sure that our functions also work in corner cases. What happens if your implementation of `cum_sum()` is called with an empty list `[]`? Make sure it handles that case *without* crashing! What would be a good return value in this corner case?\n",
+ "\n",
+ "Hint: It is possible to write this without any extra input validation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cum_sum([])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/07_sequences/03_content.ipynb b/07_sequences/03_content.ipynb
new file mode 100644
index 0000000..bf7e929
--- /dev/null
+++ b/07_sequences/03_content.ipynb
@@ -0,0 +1,2494 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/07_sequences/03_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 7: Sequential Data (continued)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In this third part of the chapter, we first look at a major implication of the `list` type's mutability. Then, we see how its close relative, the `tuple` type, can mitigate this. Lastly, we see how Python's syntax assumes sequential data at various places: for example, when unpacking iterables during a `for`-loop or an assignment, or when working with `function` objects."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Modifiers vs. Pure Functions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As `list` objects are mutable, the caller of a function can see the changes made to a `list` object passed to the function as an argument. That is often a surprising *side effect* and should be avoided.\n",
+ "\n",
+ "As an example, consider the `add_xyz()` function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "letters = [\"a\", \"b\", \"c\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def add_xyz(arg):\n",
+ " \"\"\"Append letters to a list.\"\"\"\n",
+ " arg.extend([\"x\", \"y\", \"z\"])\n",
+ " return arg"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While this function is being executed, two variables, namely `letters` in the global scope and `arg` inside the function's local scope, reference the *same* `list` object in memory. Furthermore, the passed in `arg` is also the return value.\n",
+ "\n",
+ "So, after the function call, `letters_with_xyz` and `letters` are **aliases** as well, referencing the *same* object. We can also visualize that with [PythonTutor ](http://pythontutor.com/visualize.html#code=letters%20%3D%20%5B%22a%22,%20%22b%22,%20%22c%22%5D%0A%0Adef%20add_xyz%28arg%29%3A%0A%20%20%20%20arg.extend%28%5B%22x%22,%20%22y%22,%20%22z%22%5D%29%0A%20%20%20%20return%20arg%0A%0Aletters_with_xyz%20%3D%20add_xyz%28letters%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "letters_with_xyz = add_xyz(letters)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['a', 'b', 'c', 'x', 'y', 'z']"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "letters_with_xyz"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['a', 'b', 'c', 'x', 'y', 'z']"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "letters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A better practice is to first create a copy of `arg` within the function that is then modified and returned. If we are sure that `arg` contains immutable elements only, we get away with a shallow copy. The downside of this approach is the higher amount of memory necessary.\n",
+ "\n",
+ "The revised `add_xyz()` function below is more natural to reason about as it does *not* modify the passed in `arg` internally. [PythonTutor ](http://pythontutor.com/visualize.html#code=letters%20%3D%20%5B%22a%22,%20%22b%22,%20%22c%22%5D%0A%0Adef%20add_xyz%28arg%29%3A%0A%20%20%20%20new_arg%20%3D%20arg%5B%3A%5D%0A%20%20%20%20new_arg.extend%28%5B%22x%22,%20%22y%22,%20%22z%22%5D%29%0A%20%20%20%20return%20new_arg%0A%0Aletters_with_xyz%20%3D%20add_xyz%28letters%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) shows that as well. This approach is following the **[functional programming ](https://en.wikipedia.org/wiki/Functional_programming)** paradigm that is going through a \"renaissance\" currently. Two essential characteristics of functional programming are that a function *never* changes its inputs and *always* returns the same output given the same inputs.\n",
+ "\n",
+ "For a beginner, it is probably better to stick to this idea and not change any arguments as the original `add_xyz()` above. However, functions that modify and return the argument passed in are an important aspect of object-oriented programming, as explained in [Chapter 11 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/00_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "letters = [\"a\", \"b\", \"c\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def add_xyz(arg):\n",
+ " \"\"\"Create a new list from an existing one.\"\"\"\n",
+ " new_arg = arg[:]\n",
+ " new_arg.extend([\"x\", \"y\", \"z\"])\n",
+ " return new_arg"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "letters_with_xyz = add_xyz(letters)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['a', 'b', 'c', 'x', 'y', 'z']"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "letters_with_xyz"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['a', 'b', 'c']"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "letters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If we want to modify the argument passed in, it is best to return `None` and not `arg`, as does the final version of `add_xyz()` below. Then, the user of our function cannot accidentally create two aliases to the same object. That is also why the list methods above all return `None`. [PythonTutor ](http://pythontutor.com/visualize.html#code=letters%20%3D%20%5B%22a%22,%20%22b%22,%20%22c%22%5D%0A%0Adef%20add_xyz%28arg%29%3A%0A%20%20%20%20arg.extend%28%5B%22x%22,%20%22y%22,%20%22z%22%5D%29%0A%20%20%20%20return%0A%0Aadd_xyz%28letters%29&cumulative=false&curstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) shows how there is only *one* reference to `letters` after the function call."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "letters = [\"a\", \"b\", \"c\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def add_xyz(arg):\n",
+ " \"\"\"Append letters to a list.\"\"\"\n",
+ " arg.extend([\"x\", \"y\", \"z\"])\n",
+ " return # None"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "add_xyz(letters)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['a', 'b', 'c', 'x', 'y', 'z']"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "letters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "If we call `add_xyz()` with `letters` as the argument again, we end up with an even longer `list` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "add_xyz(letters)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['a', 'b', 'c', 'x', 'y', 'z', 'x', 'y', 'z']"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "letters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Functions that only work on the argument passed in are called **modifiers**. Their primary purpose is to change the **state** of the argument. On the contrary, functions that have *no* side effects on the arguments are said to be **pure**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `tuple` Type"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To create a `tuple` object, we can use the same literal notation as for `list` objects *without* the brackets and list all elements."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "numbers = 7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4)"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, to be clearer, many Pythonistas write out the optional parentheses `(` and `)`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "numbers = (7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4)"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As before, `numbers` is an object on its own."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140248673535456"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(numbers)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tuple"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While we could use empty parentheses `()` to create an empty `tuple` object ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "empty_tuple = ()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "()"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "empty_tuple"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tuple"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(empty_tuple)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "... we must use a *trailing comma* to create a `tuple` object holding one element. If we forget the comma, the parentheses are interpreted as the grouping operator and effectively useless!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "one_tuple = (1,) # we could ommit the parentheses but not the comma"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(1,)"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "one_tuple"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tuple"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(one_tuple)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "no_tuple = (1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "no_tuple"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "int"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(no_tuple)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Alternatively, we may use the [tuple() ](https://docs.python.org/3/library/functions.html#func-tuple) built-in that takes any iterable as its argument and creates a new `tuple` from its elements."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(1,)"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "tuple([1])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "('i', 't', 'e', 'r', 'a', 'b', 'l', 'e')"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "tuple(\"iterable\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Tuples are like \"Immutable Lists\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Most operations involving `tuple` objects work in the same way as with `list` objects. The main difference is that `tuple` objects are *immutable*. So, if our program does not depend on mutability, we may and should use `tuple` and not `list` objects to model sequential data. That way, we avoid the pitfalls seen above.\n",
+ "\n",
+ "`tuple` objects are *sequences* exhibiting the familiar *four* behaviors. So, `numbers` holds a *finite* number of elements ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "12"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "... that we can obtain individually by looping over it in a predictable *forward* or *reverse* order."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "7 11 8 5 3 12 2 6 9 10 1 4 "
+ ]
+ }
+ ],
+ "source": [
+ "for number in numbers:\n",
+ " print(number, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4 1 10 9 6 2 12 3 5 8 11 7 "
+ ]
+ }
+ ],
+ "source": [
+ "for number in reversed(numbers):\n",
+ " print(number, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "To check if a given object is *contained* in `numbers`, we use the `in` operator and conduct a linear search."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 37,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0 in numbers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 in numbers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 39,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1.0 in numbers # in relies on == behind the scenes"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We may index and slice with the `[]` operator. The latter returns *new* `tuple` objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7"
+ ]
+ },
+ "execution_count": 40,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers[0]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 41,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers[-1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(2, 6, 9, 10, 1, 4)"
+ ]
+ },
+ "execution_count": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers[6:]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Index assignment does *not* work as tuples are *immutable* and results in a `TypeError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "'tuple' object does not support item assignment",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[43], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mnumbers\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m99\u001b[39m\n",
+ "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
+ ]
+ }
+ ],
+ "source": [
+ "numbers[-1] = 99"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `+` and `*` operators work with `tuple` objects as well: They always create *new* `tuple` objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4, 99)"
+ ]
+ },
+ "execution_count": 44,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers + (99,)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4, 7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4)"
+ ]
+ },
+ "execution_count": 45,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "2 * numbers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Being immutable, `tuple` objects only provide the `.count()` and `.index()` methods of `Sequence` types. The `.append()`, `.extend()`, `.insert()`, `.reverse()`, `.pop()`, and `.remove()` methods of `MutableSequence` types are *not* available. The same holds for the `list`-specific `.sort()`, `.copy()`, and `.clear()` methods."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 46,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers.count(0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "10"
+ ]
+ },
+ "execution_count": 47,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers.index(1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The relational operators work in the *same* way as for `list` objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4)"
+ ]
+ },
+ "execution_count": 48,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 49,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers == (7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 50,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers != (99, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 51,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numbers < (99, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "While `tuple` objects are immutable, this only relates to the references they hold. If a `tuple` object contains references to mutable objects, the entire nested structure is *not* immutable as a whole!\n",
+ "\n",
+ "Consider the following stylized example `not_immutable`: It contains *three* elements, `1`, `[2, ..., 11]`, and `12`, and the elements of the nested `list` object may be changed. While it is not practical to mix data types in a `tuple` object that is used as an \"immutable list,\" we want to make the point that the mere usage of the `tuple` type does *not* guarantee a nested object to be immutable as a whole."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "not_immutable = (1, [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 12)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(1, [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 12)"
+ ]
+ },
+ "execution_count": 53,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "not_immutable"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "not_immutable[1][:] = [99, 99, 99]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(1, [99, 99, 99], 12)"
+ ]
+ },
+ "execution_count": 55,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "not_immutable"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Packing & Unpacking"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In the \"*List Operations*\" section in the [second part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/01_content.ipynb#List-Operations) of this chapter, the `*` symbol **unpacks** the elements of a `list` object into another one. This idea of *iterable unpacking* is built into Python at various places, even *without* the `*` symbol.\n",
+ "\n",
+ "For example, we may write variables on the left-hand side of a `=` statement in a literal `tuple` style. Then, any *finite* iterable on the right-hand side is unpacked. So, `numbers` is unpacked into *twelve* variables below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12 = numbers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7"
+ ]
+ },
+ "execution_count": 57,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "n1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "11"
+ ]
+ },
+ "execution_count": 58,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "n2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "8"
+ ]
+ },
+ "execution_count": 59,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "n3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Having to type twelve variables on the left is already tedious. Furthermore, if the iterable on the right yields a number of elements *different* from the number of variables, we get a `ValueError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "too many values to unpack (expected 11)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[60], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11 \u001b[38;5;241m=\u001b[39m numbers\n",
+ "\u001b[0;31mValueError\u001b[0m: too many values to unpack (expected 11)"
+ ]
+ }
+ ],
+ "source": [
+ "n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11 = numbers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "not enough values to unpack (expected 13, got 12)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[61], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, n13 \u001b[38;5;241m=\u001b[39m numbers\n",
+ "\u001b[0;31mValueError\u001b[0m: not enough values to unpack (expected 13, got 12)"
+ ]
+ }
+ ],
+ "source": [
+ "n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, n13 = numbers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "So, to make iterable unpacking useful, we prepend the `*` symbol to *one* of the variables on the left: That variable then becomes a `list` object holding the elements not captured by the other variables. We say that the excess elements from the iterable are **packed** into this variable.\n",
+ "\n",
+ "For example, let's get the `first` and `last` element of `numbers` and collect the rest in `middle`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "first, *middle, last = numbers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7"
+ ]
+ },
+ "execution_count": 63,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "first"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[11, 8, 5, 3, 12, 2, 6, 9, 10, 1]"
+ ]
+ },
+ "execution_count": 64,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "middle # always a list!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 65,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "last"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We already used unpacking before this section without knowing it. Whenever we write a `for`-loop over the [zip() ](https://docs.python.org/3/library/functions.html#zip) built-in, that generates a new `tuple` object in each iteration that we unpack by listing several loop variables.\n",
+ "\n",
+ "So, the `name, position` below acts like a left-hand side of an `=` statement and unpacks the `tuple` objects generated from \"zipping\" the `names` list and the `positions` tuple together."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "names = [\"Berthold\", \"Oliver\", \"Carl\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 67,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "positions = (\"goalkeeper\", \"defender\", \"midfielder\", \"striker\", \"coach\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Berthold is a goalkeeper\n",
+ "Oliver is a defender\n",
+ "Carl is a midfielder\n"
+ ]
+ }
+ ],
+ "source": [
+ "for name, position in zip(names, positions):\n",
+ " print(name, \"is a\", position)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Without unpacking, [zip() ](https://docs.python.org/3/library/functions.html#zip) generates a series of `tuple` objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 69,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " ('Berthold', 'goalkeeper')\n",
+ " ('Oliver', 'defender')\n",
+ " ('Carl', 'midfielder')\n"
+ ]
+ }
+ ],
+ "source": [
+ "for pair in zip(names, positions):\n",
+ " print(type(pair), pair, sep=\" \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Unpacking also works for nested objects. Below, we wrap [zip() ](https://docs.python.org/3/library/functions.html#zip) with the [enumerate() ](https://docs.python.org/3/library/functions.html#enumerate) built-in to have an index variable `number` inside the `for`-loop. In each iteration, a `tuple` object consisting of `number` and another `tuple` object is created. The inner one then holds the `name` and `position`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 70,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Berthold (jersey #1) is a goalkeeper\n",
+ "Oliver (jersey #2) is a defender\n",
+ "Carl (jersey #3) is a midfielder\n"
+ ]
+ }
+ ],
+ "source": [
+ "for number, (name, position) in enumerate(zip(names, positions), start=1):\n",
+ " print(f\"{name} (jersey #{number}) is a {position}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Swapping Variables"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A popular use case of unpacking is **swapping** two variables.\n",
+ "\n",
+ "Consider `a` and `b` below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 71,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "a = 0\n",
+ "b = 1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Without unpacking, we must use a temporary variable `temp` to swap `a` and `b`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 72,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "temp = a\n",
+ "a = b\n",
+ "b = temp\n",
+ "\n",
+ "del temp"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 73,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 74,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 74,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With unpacking, the solution is more elegant. *All* expressions on the right-hand side are evaluated *before* any assignment takes place."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 75,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "a, b = 0, 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 76,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "a, b = b, a"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 77,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(1, 0)"
+ ]
+ },
+ "execution_count": 77,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a, b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "#### Example: [Fibonacci Numbers ](https://en.wikipedia.org/wiki/Fibonacci_number) (revisited)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Unpacking allows us to rewrite the iterative `fibonacci()` function from [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/02_content.ipynb#\"Hard-at-first-Glance\"-Example:-Fibonacci-Numbers-%28revisited%29) in a concise way."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 78,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def fibonacci(i):\n",
+ " \"\"\"Calculate the ith Fibonacci number.\n",
+ "\n",
+ " Args:\n",
+ " i (int): index of the Fibonacci number to calculate\n",
+ "\n",
+ " Returns:\n",
+ " ith_fibonacci (int)\n",
+ " \"\"\"\n",
+ " a, b = 0, 1\n",
+ "\n",
+ " for _ in range(i - 1):\n",
+ " a, b = b, a + b\n",
+ "\n",
+ " return b"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 79,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "144"
+ ]
+ },
+ "execution_count": 79,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "fibonacci(12)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Function Definitions & Calls"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The concepts of packing and unpacking are also helpful when writing and using functions.\n",
+ "\n",
+ "For example, let's look at the `product()` function below. Its implementation suggests that `args` must be a sequence type. Otherwise, it would not make sense to index into it with `[0]` or take a slice with `[1:]`. In line with the function's name, the `for`-loop multiplies all elements of the `args` sequence. So, what does the `*` do in the header line, and what is the exact data type of `args`?\n",
+ "\n",
+ "The `*` is again *not* an operator in this context but a special syntax that makes Python *pack* all *positional* arguments passed to `product()` into a single `tuple` object called `args`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 80,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def product(*args):\n",
+ " \"\"\"Multiply all arguments.\"\"\"\n",
+ " result = args[0]\n",
+ "\n",
+ " for arg in args[1:]:\n",
+ " result *= arg\n",
+ "\n",
+ " return result"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "So, we can pass an *arbitrary* (i.e., also none) number of *positional* arguments to `product()`.\n",
+ "\n",
+ "The product of just one number is the number itself."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 81,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42"
+ ]
+ },
+ "execution_count": 81,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "product(42)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Passing in several numbers works as expected."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 82,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "100"
+ ]
+ },
+ "execution_count": 82,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "product(2, 5, 10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "However, this implementation of `product()` needs *at least* one argument passed in due to the expression `args[0]` used internally. Otherwise, we see a *runtime* error, namely an `IndexError`. We emphasize that this error is *not* caused in the header line."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 83,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "IndexError",
+ "evalue": "tuple index out of range",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[83], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mproduct\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[0;32mIn[80], line 3\u001b[0m, in \u001b[0;36mproduct\u001b[0;34m(*args)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mproduct\u001b[39m(\u001b[38;5;241m*\u001b[39margs):\n\u001b[1;32m 2\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Multiply all arguments.\"\"\"\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43margs\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m arg \u001b[38;5;129;01min\u001b[39;00m args[\u001b[38;5;241m1\u001b[39m:]:\n\u001b[1;32m 6\u001b[0m result \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m=\u001b[39m arg\n",
+ "\u001b[0;31mIndexError\u001b[0m: tuple index out of range"
+ ]
+ }
+ ],
+ "source": [
+ "product()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Another downside of this implementation is that we can easily generate *semantic* errors: For example, if we pass in an iterable object like the `one_hundred` list, *no* exception is raised. However, the return value is also not a numeric object as we expect. The reason for this is that during the function call, `args` becomes a `tuple` object holding *one* element, which is `one_hundred`, a `list` object. So, we created a nested structure by accident."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 84,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "one_hundred = [2, 5, 10]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 85,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[2, 5, 10]"
+ ]
+ },
+ "execution_count": 85,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "product(one_hundred) # a semantic error!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "This error does not occur if we unpack `one_hundred` upon passing it as the argument."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 86,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "100"
+ ]
+ },
+ "execution_count": 86,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "product(*one_hundred)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "That is the equivalent of writing out the following tedious expression. Yet, that does *not* scale for iterables with many elements in them."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 87,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "100"
+ ]
+ },
+ "execution_count": 87,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "product(one_hundred[0], one_hundred[1], one_hundred[2])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In the \"*Packing & Unpacking with Functions*\" [exercise ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/04_exercises.ipynb), we look at `product()` in more detail.\n",
+ "\n",
+ "While we needed to unpack `one_hundred` above to avoid the semantic error, unpacking an argument in a function call may also be a convenience in general. For example, to print the elements of `one_hundred` in one line, we need to use a `for` statement, until now. With unpacking, we get away *without* a loop."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 88,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[2, 5, 10]\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(one_hundred) # prints the tuple; we do not want that"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 89,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2 5 10 "
+ ]
+ }
+ ],
+ "source": [
+ "for number in one_hundred:\n",
+ " print(number, end=\" \")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 90,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2 5 10\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(*one_hundred) # replaces the for-loop"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/07_sequences/04_exercises_un-packing.ipynb b/07_sequences/04_exercises_un-packing.ipynb
new file mode 100644
index 0000000..3f783a2
--- /dev/null
+++ b/07_sequences/04_exercises_un-packing.ipynb
@@ -0,0 +1,663 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Run All*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *after* finishing the exercises to ensure that your solution runs top to bottom *without* any errors. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/07_sequences/04_exercises.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 7: Sequential Data (Coding Exercises)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The exercises below assume that you have read the [third part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/03_content.ipynb) of Chapter 7.\n",
+ "\n",
+ "The `...`'s in the code cells indicate where you need to fill in code snippets. The number of `...`'s within a code cell give you a rough idea of how many lines of code are needed to solve the task. You should not need to create any additional code cells for your final solution. However, you may want to use temporary code cells to try out some ideas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Packing & Unpacking with Functions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In the \"*Function Definitions & Calls*\" section in [Chapter 7 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/03_content.ipynb#Function-Definitions-&-Calls), we define the following function `product()`. In this exercise, you will improve it by making it more \"user-friendly.\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def product(*args):\n",
+ " \"\"\"Multiply all arguments.\"\"\"\n",
+ " result = args[0]\n",
+ "\n",
+ " for arg in args[1:]:\n",
+ " result *= arg\n",
+ "\n",
+ " return result"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The `*` in the function's header line *packs* all *positional* arguments passed to `product()` into one *iterable* called `args`.\n",
+ "\n",
+ "**Q1**: What is the data type of `args` within the function's body?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Because of the packing, we may call `product()` with an abitrary number of *positional* arguments: The product of just `42` remains `42`, while `2`, `5`, and `10` multiplied together result in `100`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(2, 5, 10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "However, \"abitrary\" does not mean that we can pass *no* argument. If we do so, we get an `IndexError`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: What line in the body of `product()` causes this exception? What is the exact problem?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In [Chapter 7 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/00_content.ipynb#Function-Definitions-&-Calls), we also pass a `list` object, like `one_hundred`, to `product()`, and *no* exception is raised."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "one_hundred = [2, 5, 10]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(one_hundred)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: What is wrong with that? What *kind* of error (cf., [Chapter 1 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/01_elements/00_content.ipynb#Formal-vs.-Natural-Languages)) is that conceptually? Describe precisely what happens to the passed in `one_hundred` in every line within `product()`!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Of course, one solution is to *unpack* `one_hundred` with the `*` symbol. We look at another solution further below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(*one_hundred)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's continue with the issue when calling `product()` *without* any argument.\n",
+ "\n",
+ "This revised version of `product()` avoids the `IndexError` from before."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def product(*args):\n",
+ " \"\"\"Multiply all arguments.\"\"\"\n",
+ " result = None\n",
+ "\n",
+ " for arg in args:\n",
+ " result *= arg\n",
+ "\n",
+ " return result"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: Describe why no error occurs by going over every line in `product()`!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Unfortunately, the new version cannot process any arguments we pass in any more."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(2, 5, 10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: What line causes troubles now? What is the exact problem?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: Replace the `None` in `product()` above with something reasonable that does *not* cause exceptions! Ensure that `product(42)` and `product(2, 5, 10)` return a correct result.\n",
+ "\n",
+ "Hints: It is ok if `product()` returns a result *different* from the `None` above. Look at the documentation of the built-in [sum() ](https://docs.python.org/3/library/functions.html#sum) function for some inspiration."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def product(*args):\n",
+ " \"\"\"Multiply all arguments.\"\"\"\n",
+ " result = ...\n",
+ "\n",
+ " for arg in args:\n",
+ " result *= arg\n",
+ "\n",
+ " return result"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(2, 5, 10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now, calling `product()` without any arguments returns what we would best describe as a *default* or *start* value. To be \"philosophical,\" what is the product of *no* numbers? We know that the product of *one* number is just the number itself, but what could be a reasonable result when multiplying *no* numbers? The answer is what you use as the initial value of `result` above, and there is only *one* way to make `product(42)` and `product(2, 5, 10)` work."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7**: Rewrite `product()` so that it takes a *keyword-only* argument `start`, defaulting to the above *default* or *start* value, and use `start` internally instead of `result`!\n",
+ "\n",
+ "Hint: Remember that a *keyword-only* argument is any parameter specified in a function's header line after the first and only `*` (cf., [Chapter 2 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/02_functions/00_content.ipynb#Keyword-only-Arguments))."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def product(*args, ...):\n",
+ " \"\"\"Multiply all arguments.\"\"\"\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " return ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now, we can call `product()` with a truly arbitrary number of *positional* arguments."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(2, 5, 10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Without any *positional* arguments but only the *keyword* argument `start`, for example, `start=0`, we can adjust the answer to the \"philosophical\" problem of multiplying *no* numbers. Because of the *keyword-only* syntax, there is *no* way to pass in a `start` number *without* naming it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(start=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We could use `start` to inject a multiplier, for example, to double the outcomes."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(42, start=2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(2, 5, 10, start=2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "There is still one issue left: Because of the function's name, a user of `product()` may assume that it is ok to pass a *collection* of numbers, like `one_hundred`, which are then multiplied."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(one_hundred)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q8**: What is a **collection**? How is that different from a **sequence**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q9**: Rewrite the latest version of `product()` to check if the *only* positional argument is a *collection* type! If so, its elements are multiplied together. Otherwise, the logic remains the same.\n",
+ "\n",
+ "Hints: Use the built-in [len() ](https://docs.python.org/3/library/functions.html#len) and [isinstance() ](https://docs.python.org/3/library/functions.html#isinstance) functions to check if there is only *one* positional argument and if it is a *collection* type. Use the *abstract base class* `Collection` from the [collections.abc ](https://docs.python.org/3/library/collections.abc.html) module in the [standard library ](https://docs.python.org/3/library/index.html). You may want to *re-assign* `args` inside the body."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import collections.abc as abc"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def product(*args, ...):\n",
+ " \"\"\"Multiply all arguments.\"\"\"\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " return ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "All *five* code cells below now return correct results. We may unpack `one_hundred` or not."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(2, 5, 10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(one_hundred)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product(*one_hundred)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Side Note**: Above, we make `product()` work with a single *collection* type argument instead of a *sequence* type to keep it more generic: For example, we can pass in a `set` object, like `{2, 5, 10}` below, and `product()` continues to work correctly. The `set` type is introducted in [Chapter 9 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/09_mappings/00_content.ipynb#The-set-Type), and one essential difference to the `list` type is that objects of type `set` have *no* order regarding their elements. So, even though `[2, 5, 10]` and `{2, 5, 10}` look almost the same, the order implied in the literal notation gets lost in memory!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product([2, 5, 10]) # the argument is a collection that is also a sequence"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product({2, 5, 10}) # the argument is a collection that is NOT a sequence"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "isinstance({2, 5, 10}, abc.Sequence) # sets are NO sequences"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's continue to improve `product()` and make it more Pythonic. It is always a good idea to mimic the behavior of built-ins when writing our own functions. And, [sum() ](https://docs.python.org/3/library/functions.html#sum), for example, raises a `TypeError` if called *without* any arguments. It does *not* return the \"philosophical\" answer to adding *no* numbers, which would be `0`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sum()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q10**: Adapt the latest version of `product()` to also raise a `TypeError` if called *without* any *positional* arguments!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def product(*args, ...):\n",
+ " \"\"\"Multiply all arguments.\"\"\"\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " ...\n",
+ " ...\n",
+ "\n",
+ " return ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product()"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/07_sequences/05_appendix.ipynb b/07_sequences/05_appendix.ipynb
new file mode 100644
index 0000000..f34771d
--- /dev/null
+++ b/07_sequences/05_appendix.ipynb
@@ -0,0 +1,609 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/07_sequences/05_appendix.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 7: Sequential Data (Appendix)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In the [third part ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/03_content.ipynb#Tuples-are-like-\"Immutable-Lists\") of the chapter, we proposed the idea that `tuple` objects are like \"immutable lists.\" Often, however, we use `tuple` objects to represent a **record** of related **fields**. Then, each element has a *semantic* meaning (i.e., a descriptive name).\n",
+ "\n",
+ "As an example, think of a spreadsheet with information on students in a course. Each row represents a record and holds all the data associated with an individual student. The columns (e.g., matriculation number, first name, last name) are the fields that may come as *different* data types (e.g., `int` for the matriculation number, `str` for the names).\n",
+ "\n",
+ "A simple way of modeling a single student is as a `tuple` object, for example, `(123456, \"John\", \"Doe\")`. A disadvantage of this approach is that we must remember the order and meaning of the elements/fields in the `tuple` object.\n",
+ "\n",
+ "An example from a different domain is the representation of $(x, y)$-points in the $x$-$y$-plane. Again, we could use a `tuple` object like `current_position` below to model the point $(4, 2)$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "current_position = (4, 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We implicitly assume that the first element represents the $x$ and the second the $y$ coordinate. While that follows intuitively from convention in math, we should at least add comments somewhere in the code to document this assumption."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The `namedtuple` Type"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "A better way is to create a *custom* data type. While that is covered in depth in [Chapter 11 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/11_classes/00_content.ipynb), the [collections ](https://docs.python.org/3/library/collections.html) module in the [standard library ](https://docs.python.org/3/library/index.html) provides a [namedtuple() ](https://docs.python.org/3/library/collections.html#collections.namedtuple) **factory function** that creates \"simple\" custom data types on top of the standard `tuple` type."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "from collections import namedtuple"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "[namedtuple() ](https://docs.python.org/3/library/collections.html#collections.namedtuple) takes two arguments. The first argument is the name of the data type. That could be different from the variable `Point` we use to refer to the new type, but in most cases it is best to keep them in sync. The second argument is a sequence with the field names as `str` objects. The names' order corresponds to the one assumed in `current_position`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "Point = namedtuple(\"Point\", [\"x\", \"y\"])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The `Point` object is a so-called **class**. That is what it means if an object is of type `type`. It can be used as a **factory** to create *new* `tuple`-like objects of type `Point`. In a way, [namedtuple() ](https://docs.python.org/3/library/collections.html#collections.namedtuple) gives us a way to create our own custom **constructors**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "94457911453856"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(Point)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "type"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(Point)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "The value of `Point` is just itself in a *literal notation*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "__main__.Point"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Point"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We write `Point(4, 2)` to create a *new* object of type `Point`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "current_position = Point(4, 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "Now, `current_position` has a somewhat nicer representation. In particular, the coordinates are named `x` and `y`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Point(x=4, y=2)"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "current_position"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "It is *not* a `tuple` any more but an object of type `Point`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140376178109184"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "id(current_position)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "__main__.Point"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "type(current_position)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We use the dot operator `.` to access the defined attributes."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "current_position.x"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "current_position.y"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As before, we get an `AttributeError` if we try to access an undefined attribute."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "AttributeError",
+ "evalue": "'Point' object has no attribute 'z'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[13], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mcurrent_position\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mz\u001b[49m\n",
+ "\u001b[0;31mAttributeError\u001b[0m: 'Point' object has no attribute 'z'"
+ ]
+ }
+ ],
+ "source": [
+ "current_position.z"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "`current_position` continues to work like a `tuple` object! That is why we can use `namedtuple` as a replacement for `tuple`. The underlying implementations exhibit the *same* computational efficiencies and memory usages.\n",
+ "\n",
+ "For example, we can index into or loop over `current_position` as it is still a sequence with the familiar four properties."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "current_position[0]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "current_position[1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4\n",
+ "2\n"
+ ]
+ }
+ ],
+ "source": [
+ "for number in current_position:\n",
+ " print(number)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2\n",
+ "4\n"
+ ]
+ }
+ ],
+ "source": [
+ "for number in reversed(current_position):\n",
+ " print(number)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(current_position)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/07_sequences/06_summary.ipynb b/07_sequences/06_summary.ipynb
new file mode 100644
index 0000000..043ed03
--- /dev/null
+++ b/07_sequences/06_summary.ipynb
@@ -0,0 +1,85 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 7: Sequential Data (TL;DR)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Sequences** are an *abstract* concept that summarizes *four* behaviors an object may or may not exhibit. Sequences are\n",
+ "- **finite** and\n",
+ "- **ordered**\n",
+ "- **containers** that we may\n",
+ "- **loop over**.\n",
+ "\n",
+ "Examples are the `list`, `tuple`, but also the `str` types.\n",
+ "\n",
+ "Objects that exhibit all behaviors *except* being ordered are referred to as **collections**.\n",
+ "\n",
+ "The objects inside a sequence are called its **elements** and may be labeled with a unique **index**, an `int` object in the range $0 \\leq \\text{index} < \\lvert \\text{sequence} \\rvert$.\n",
+ "\n",
+ "`list` objects are **mutable**. That means we can change the references to the other objects it contains, and, in particular, re-assign them.\n",
+ "\n",
+ "On the contrary, `tuple` objects are like **immutable** lists: We can use them in place of any `list` object as long as we do *not* need to mutate it. Often, `tuple` objects are also used to model **records** of related **fields**."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "livereveal": {
+ "auto_select": "code",
+ "auto_select_fragment": true,
+ "scroll": true,
+ "theme": "serif"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "384px"
+ },
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/07_sequences/07_review.ipynb b/07_sequences/07_review.ipynb
new file mode 100644
index 0000000..57927bd
--- /dev/null
+++ b/07_sequences/07_review.ipynb
@@ -0,0 +1,252 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapter 7: Sequential Data (Review Questions)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The questions below assume that you have read the [first ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/00_content.ipynb), [second ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/01_content.ipynb), and the [third ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/03_content.ipynb) part of Chapter 7. Some questions regard the [Appendix ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/05_appendix.ipynb); that is indicated with a **\\***.\n",
+ "\n",
+ "Be concise in your answers! Most questions can be answered in *one* sentence."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Essay Questions "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Answer the following questions *briefly*!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q1**: We have seen **containers** and **iterables** before in [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/02_content.ipynb#Containers-vs.-Iterables). How do they relate to **sequences**? "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q2**: What are **abstract base classes**? How can we make use of the ones from the [collections.abc ](https://docs.python.org/3/library/collections.abc.html) module in the [standard library ](https://docs.python.org/3/library/index.html)?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q3**: How are the *abstract behaviors* of **reversibility** and **finiteness** essential for *indexing* and *slicing* sequences?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q4**: Explain the difference between **mutable** and **immutable** objects in Python with the examples of the `list` and `tuple` types!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q5**: What is the difference between a **shallow** and a **deep** copy of an object? How can one of them become a \"problem?\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q6**: Many **list methods** change `list` objects \"**in place**.\" What do we mean by that?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7.1**: `tuple` objects have *two* primary usages. First, they can be used in place of `list` objects where **mutability** is *not* required. Second, we use them to model data **records**.\n",
+ "\n",
+ "Describe why `tuple` objects are a suitable replacement for `list` objects in general!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q7.2\\***: What do we mean by a **record**? How are `tuple` objects suitable to model records? How can we integrate a **semantic meaning** when working with records into our code?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q8**: How is (iterable) **packing** and **unpacking** useful in the context of **function definitions** and **calls**?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## True / False Questions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Motivate your answer with *one short* sentence!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q9**: `sequence` objects are *not* part of core Python but may be imported from the [standard library ](https://docs.python.org/3/library/index.html)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q10**: The built-in [.sort() ](https://docs.python.org/3/library/stdtypes.html#list.sort) function takes a *finite* **iterable** as its argument an returns a *new* `list` object. On the contrary, the [sorted() ](https://docs.python.org/3/library/functions.html#sorted) method on `list` objects *mutates* them *in place*."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Q11**: Passing **mutable** objects as arguments to functions is not problematic because functions operate in a **local** scope without affecting the **global** scope."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " < your answer >"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": false,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/08_mfr/00_content.ipynb b/08_mfr/00_content.ipynb
new file mode 100644
index 0000000..4a1ae86
--- /dev/null
+++ b/08_mfr/00_content.ipynb
@@ -0,0 +1,1381 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Note**: Click on \"*Kernel*\" > \"*Restart Kernel and Clear All Outputs*\" in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) *before* reading this notebook to reset its output. If you cannot run this file on your machine, you may want to open it [in the cloud ](https://mybinder.org/v2/gh/webartifex/intro-to-python/main?urlpath=lab/tree/08_mfr/00_content.ipynb)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Chapter 8: Map, Filter, & Reduce"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "In this chapter, we continue the study of sequential data by looking at memory efficient ways to process the elements in a sequence. That is an important topic for the data science practitioner who must be able to work with data that does *not* fit into a single computer's memory.\n",
+ "\n",
+ "As shown in [Chapter 4 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/04_iteration/02_content.ipynb#Containers-vs.-Iterables), both the `list` objects `[0, 1, 2, 3, 4]` and `[1, 3, 5, 7, 9]` on the one side and the `range` objects `range(5)` and `range(1, 10, 2)` on the other side allow us to loop over the same numbers. However, the latter two only create *one* `int` object in every iteration while the former two create *all* `int` objects before the loop even starts. In this aspect, we consider `range` objects to be \"rules\" in memory that know how to calculate the numbers *without* calculating them.\n",
+ "\n",
+ "In [Chapter 7 ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/main/07_sequences/01_content.ipynb#The-list-Type), we see how the built-in [list() ](https://docs.python.org/3/library/functions.html#func-list) constructor **materializes** the `range(1, 13)` object into the `list` object `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]`. In other words, we make `range(1, 13)` calculate *all* numbers at once and store them in a `list` object for further processing.\n",
+ "\n",
+ "In many cases, however, it is not necessary to do that, and, in this chapter, we look at other types of \"rules\" in memory and how we can compose different \"rules\" together to implement bigger computations.\n",
+ "\n",
+ "Next, we take a step back and continue with a simple example involving the familiar `numbers` list. Then, we iteratively exchange `list` objects with \"rule\"-like objects *without* changing the overall computation at all. As computations involving sequential data are commonly classified into three categories **map**, **filter**, or **reduce**, we do so too for our `numbers` example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "numbers = [7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Mapping"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "**Mapping** refers to the idea of applying a transformation to every element in a sequence.\n",
+ "\n",
+ "For example, let's square each element in `numbers` and add `1` to the squares. In essence, we apply the transformation $y := x^2 + 1$ as expressed with the `transform()` function below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def transform(element):\n",
+ " \"\"\"Map elements to their squares plus 1.\"\"\"\n",
+ " return (element ** 2) + 1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "With the syntax we know so far, we revert to a `for`-loop that iteratively appends the transformed elements to an initially empty `transformed_numbers` list."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "transformed_numbers = []\n",
+ "\n",
+ "for old in numbers:\n",
+ " new = transform(old)\n",
+ " transformed_numbers.append(new)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[50, 122, 65, 26, 10, 145, 5, 37, 82, 101, 2, 17]"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "transformed_numbers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "As this kind of data processing is so common, Python provides the [map() ](https://docs.python.org/3/library/functions.html#map) built-in. In its simplest usage form, it takes two arguments: A transformation `function` that takes exactly *one* positional argument and an `iterable` that provides the objects to be mapped.\n",
+ "\n",
+ "We call [map() ](https://docs.python.org/3/library/functions.html#map) with a reference to the `transform()` function and the `numbers` list as the arguments and store the result in the variable `transformer` to inspect it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "transformer = map(transform, numbers)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "source": [
+ "We might expect to get back a materialized sequence (i.e., all elements exist in memory), and a `list` object would feel the most natural because of the type of the `numbers` argument. However, `transformer` is an object of type `map`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "