0. Introduction to Jupyter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Welcome\n",
    "\n",
    "I hope you're ready to learn how Bitcoin works! I know I am ...\n",
    "\n",
    "This is a Jupyter Notebook. It's an interactive programming environment that is very well-suited for teaching.\n",
    "\n",
    "A notebook is a sequence of \"cells\". Cells contain either Markdown text (like this one) or python code (like the next one).\n",
    "\n",
    "Hit `Shift+Enter` twice to execute the first two cells"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Don't trust, verify\n"
     ]
    }
   ],
   "source": [
    "print(\"Don't trust, verify\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Executing the cell above executed the Python code -- a `print` statement -- contained within it.\n",
    "\n",
    "Every cell builds upon the previous one. Execute four more cells to see how."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cef473af3fa4bc65e3214ce74cdb807dfd7cdeb0879fe801e996d65e97866d63'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sha256(b\"this fails because we haven't imported the sha256 function yet\").hexdigest()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from hashlib import sha256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4a39d7e6e3428b65398bd74d6489e5f1c701547278869bf8780120459fd992a5'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sha256(b\"this work, because the previous cell imported sha256\").hexdigest()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we tried to call the `sha256` function, but since we hadn't imported it yet the notebook threw an exception. The next cell imported `sha256` and the following cell successfully called it.\n",
    "\n",
    "This gives you a taste for how the course will work. With every cell we will assemble the pieces needed to assemble our python-intial-block-downloader, the objective of the first part of the course.\n",
    "\n",
    "To ensure you're on the right track, I will frequently include \"unittests\" after every exercise. To see what I mean, let's do our first exercise.\n",
    "\n",
    "Fill out this `is_even_int(n)` function below. It should:\n",
    "* return `True` if `n` is an even integer\n",
    "* return `False` otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_even_int(n):\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "unittest.case.FunctionTestCase (test_is_even_0) ... ERROR\n",
      "unittest.case.FunctionTestCase (test_is_even_1) ... ERROR\n",
      "unittest.case.FunctionTestCase (test_is_even_2) ... ERROR\n",
      "\n",
      "======================================================================\n",
      "ERROR: unittest.case.FunctionTestCase (test_is_even_0)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-24-0511ddf53fa3>\", line 6, in test_is_even_0\n",
      "    assert is_even_int(21) is False\n",
      "  File \"<ipython-input-23-621ee8e0ec44>\", line 2, in is_even_int\n",
      "    raise NotImplementedError()\n",
      "NotImplementedError\n",
      "\n",
      "======================================================================\n",
      "ERROR: unittest.case.FunctionTestCase (test_is_even_1)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-24-0511ddf53fa3>\", line 9, in test_is_even_1\n",
      "    assert is_even_int(21000000) is True\n",
      "  File \"<ipython-input-23-621ee8e0ec44>\", line 2, in is_even_int\n",
      "    raise NotImplementedError()\n",
      "NotImplementedError\n",
      "\n",
      "======================================================================\n",
      "ERROR: unittest.case.FunctionTestCase (test_is_even_2)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-24-0511ddf53fa3>\", line 12, in test_is_even_2\n",
      "    assert is_even_int('btc') is False\n",
      "  File \"<ipython-input-23-621ee8e0ec44>\", line 2, in is_even_int\n",
      "    raise NotImplementedError()\n",
      "NotImplementedError\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 3 tests in 0.002s\n",
      "\n",
      "FAILED (errors=3)\n"
     ]
    }
   ],
   "source": [
    "import ipytest, pytest\n",
    "\n",
    "ipytest.clean_tests(\"test_is_even*\")\n",
    "\n",
    "def test_is_even_0():\n",
    "    assert is_even_int(21) is False\n",
    "    \n",
    "def test_is_even_1():\n",
    "    assert is_even_int(21000000) is True\n",
    "    \n",
    "def test_is_even_2():\n",
    "    assert is_even_int('btc') is False\n",
    "    \n",
    "ipytest.run_tests(doctest=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell below contains an implementation that will make all 3 tests pass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_even_int(n):\n",
    "    try:\n",
    "        return n % 2 == 0\n",
    "    except TypeError:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`n % 2` means \"n modulo 2\". Here's a [YouTube refresher on \"modular arithmetic\"](https://www.youtube.com/watch?v=Eg6CTCu8iio), in case you've forgotten.\n",
    "\n",
    "If this is equal to `0`, it means that \"2 evenly evenly divides `n`, leaving no remainder\", which is the definition of \"even\".\n",
    "\n",
    "But we must consider all possible inputs. If `n` is a string then `n % 2` will raise an error, because that `\"foo\" % 2` no longer means \"modular division\", but when applied to a string it is a string formatting operator! Python raises a `TypeError` exception because `\"foo\" % 2` is an invalid string formatting expression. This would be a valid formatting expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'two == 2'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"two == %s\" % 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you may ask, how does python know to treat integers and strings so differently when applying the `%` operator? Here's how:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'two == 2'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"two == %s\".__mod__(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 21000000\n",
    "n.__mod__(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The integer `int` class and string `str` class have different `__mod__` methods, which define how instances of these classes should handle the `%` operator.\n",
    "\n",
    "In case your wondering, this is what happens when the `__mod__` method isn't defined:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Foo:\n",
    "    pass\n",
    "\n",
    "foo = Foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Does 'foo.__mod__' exist?  False\n"
     ]
    }
   ],
   "source": [
    "print(\"Does 'foo.__mod__' exist? \", hasattr(foo, '__mod__'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for %: 'Foo' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-31-661eba179656>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfoo\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for %: 'Foo' and 'int'"
     ]
    }
   ],
   "source": [
    "foo % 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion\n",
    "\n",
    "Hopefully all that made some sense to you. The class will mostly happen in Jupyter, so an understanding of how Jupyter works is the only important takeaway from this lesson.\n",
    "\n",
    "If you want to learn more about Jupyter, head over to Youtube!"
   ]
  }
 ],
 "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.7.0b5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}