notebooks/03/Numbers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numbers\n",
    "\n",
    "Computers are designed to perform numerical calculations, but there are some\n",
    "important details about working with numbers that every programmer working\n",
    "with quantitative data should know. Python (and most other programming\n",
    "languages) distinguishes between two different types of numbers:\n",
    "\n",
    "* Integers are called `int` values in the Python language. They can only\n",
    "  represent whole numbers (negative, zero, or positive) that don't have a\n",
    "  fractional component\n",
    "* Real numbers are called `float` values (or *floating point values*) in the\n",
    "  Python language. They can represent whole or fractional numbers but have\n",
    "  some limitations.\n",
    "\n",
    "The type of a number is evident from the way it is displayed: `int` values\n",
    "have no decimal point and `float` values always have a decimal point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Some int values\n",
    "2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1234567890000000000"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-1234567890000000000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Some float values\n",
    "1.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.5 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 / 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.23456789e+19"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-12345678900000000000.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a `float` value is combined with an `int` value using some arithmetic\n",
    "operator, then the result is always a `float` value. In most cases, two\n",
    "integers combine to form another integer, but any number (`int` or `float`)\n",
    "divided by another will be a `float` value. Very large or very small `float`\n",
    "values are displayed using scientific notation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Float Values\n",
    "\n",
    "Float values are very flexible, but they do have limits.\n",
    "\n",
    "1. A `float` can represent extremely large and extremely small numbers. There\n",
    "   are limits, but you will rarely encounter them.\n",
    "2. A `float` only represents 15 or 16 significant digits for any number; the\n",
    "   remaining precision is lost. This limited precision is enough for the vast\n",
    "   majority of applications.\n",
    "3. After combining `float` values with arithmetic, the last few digits may be\n",
    "   incorrect. Small rounding errors are often confusing when first\n",
    "   encountered.\n",
    "\n",
    "The first limit can be observed in two ways. If the result of a computation is\n",
    "a very large number, then it is represented as infinite. If the result is a\n",
    "very small number, then it is represented as zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2e+307"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2e306 * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inf"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2e306 * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2e-323"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2e-322 / 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2e-322 / 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second limit can be observed by an expression that involves numbers with\n",
    "more than 15 significant digits. These extra digits are discarded before any\n",
    "arithmetic is carried out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.6666666666666666 - 0.6666666666666666123456789"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The third limit can be observed when taking the difference between two\n",
    "expressions that should be equivalent. For example, the expression `2 ** 0.5`\n",
    "computes the square root of 2, but squaring this value does not exactly\n",
    "recover 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0000000000000004"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(2) * math.sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.440892098500626e-16"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(2) * math.sqrt(2) - 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final result above is `0.0000000000000004440892098500626`, a number that\n",
    "is very close to zero. The correct answer to this arithmetic expression is 0,\n",
    "but a small error in the final significant digit appears very different in\n",
    "scientific notation. This behavior appears in almost all programming languages\n",
    "because it is the result of the standard way that arithmetic is carried out on\n",
    "computers.\n",
    "\n",
    "Although `float` values are not always exact, they are predictable and work\n",
    "in the same way across all different kinds of computers and programming\n",
    "languages.\n",
    "\n",
    "{% data8page Numbers %}"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}