.ipynb_checkpoints/numbers-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Оригинал © Семён Лукашевский](https://pyprog.pro/python/py/nums/nums.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Числа в Python\n",
    "\n",
    "Числа в языке Python представлены тремя встроенными типами: целые (`int`), вещественные (`float`) и комплексные (`comlex`), а так же двумя типами чисел, которые предоставляет его стандартная библиотека: десятичные дроби неограниченной точности (`Decimal`) и обыкновенные дроби (`Float`).\n",
    "\n",
    "Начнем с того, что числовые литералы не содержат знаки \"`+`\" и \"`-`\", т.е. с точки зрения Python число `−3.14` не является единым отрицательным числом, а является командой, которая состоит из унарного оператора (`-`) и числа `3.14`. Это говорит о том, что знаки \"`+`\" и \"`-`\" хоть и способны обозначать положительные и отрицательные числа, но на самом деле эти знаки являются операторами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-+-+--++1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Помимо этого, числа встроенных типов (`int`, `float` и `complex`) относятся к неизменяемым объектам, т.е. объектам, чья структура не может быть изменена напрямую. Нельзя изменить какую-нибудь цифру существующего числа, нельзя расставить его цифры в обратном порядке. То, что кажется изменением числа, на самом деле таковым не является. Например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1\n",
    "x = x - 1\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вроде бы мы создали объект-число со значением `1`, а затем изменили его значение на `0`. Но если это так, то `id` объекта (его адрес в памяти) не должен меняться, а он меняется:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "94004608652320"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1\n",
    "id(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = x - 1\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "94004608652288"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видим, изменения объекта не произошло, старый объект исчез и появился новый. \n",
    "\n",
    "Результат для встроенных числовых типов всегда преобразуется к более общему типу, если это необходимо. Например, если частное двух целых чисел (`int`) не является целым числом, то оно будет преобразовано к вещественному типу (`float`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.04"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 / 25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А если результат не может быть выражен типами `int` и `float`, то он будет преобразован к типу `complex`. Так что если вдруг будете вычислять корни четной степени из отрицательных чисел, не ждите ошибки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0605752387249068e-16+1.7320508075688772j)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(-3) ** 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0850398284807605e-16+1.772004514666935j)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(-3.14) ** 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Целые числа (int)\n",
    "\n",
    "В самом общем смысле, целые числа - это самые обыкновенные целые числа со знаком или без, например: \n",
    "$−11$, $126$, $0$ или $401734511064747568885490523085290650630550748445698208825344$. \n",
    "Последнее число в примере - это $2^{198}$, в чем очень легко убедиться:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "401734511064747568885490523085290650630550748445698208825344"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** 198"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Например, вы можете легко убедиться в том что 561 - [число Кармайкла](https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D0%9A%D0%B0%D1%80%D0%BC%D0%B0%D0%B9%D0%BA%D0%BB%D0%B0), действительно, проходит [тест Ферма](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D1%81%D1%82_%D0%A4%D0%B5%D1%80%D0%BC%D0%B0):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** (561 - 1) % 561 == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Однако, если вы попытаетесь проверить это для числа $9746347772161$, \n",
    "то результата придется ждать очень долго (если вообще дождемся). \n",
    "\n",
    "Но, если воспользоваться встроенной функцией `pow()`, то результат будет получен моментально:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pow(2, 9746347772160, 9746347772161) == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Все дело в том, что данная функция для трех аргументов реализована, как [алгоритм быстрого возведения в степень по модулю](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B_%D0%B1%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B3%D0%BE_%D0%B2%D0%BE%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B2_%D1%81%D1%82%D0%B5%D0%BF%D0%B5%D0%BD%D1%8C_%D0%BF%D0%BE_%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8E), что на порядки быстрее, чем эквивалентная команда:\n",
    "```\n",
    "2 ** 9746347772160 % 9746347772161\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Вещественные числа (float)\n",
    "\n",
    "Наверное, было бы правильнее называть эти числа [числами с плавающей точкой](https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D0%B7%D0%B0%D0%BF%D1%8F%D1%82%D0%BE%D0%B9) нежели [вещественными](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D1%89%D0%B5%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%BE), но в принципе, с определенной натяжкой, можно сказать, что это, как бы одно и тоже. Давайте разберемся почему.\n",
    "\n",
    "В качестве примера возьмем число $\\sqrt2$, которое является вещественным, потому что мы никогда не сможем выразить его с помощью обыкновенной дроби. А если мы все-таки извлечем корень из двойки, то обнаружим, что это бесконечная десятичная дробь. \n",
    "\n",
    "Но вычислив этот корень на Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** (1 / 2)    #  равносильно 2**0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы увидим, что никакой бесконечной дробью и не пахнет. Python вернул только начало этой дроби, а все остальное отбросил, т.е. он вернул число с плавающей точкой, которое как бы и соответствует вещественному числу, но с определенной погрешностью.\n",
    "\n",
    "На самом деле, работая с числами с плавающей точкой, мы очень часто подразумеваем числа вещественные, например вот такое число $\\sqrt[77]7$, его мы увидим в виде конечной десятичной дроби:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0255935932948266"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 ** (1 / 77)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А число $7^{-77}$ $-$ в виде мантисы $8.461569363277291$ (опять же конечной десятичной дроби) и порядка $−66$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.461569363277291e-66"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 ** (-77)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Кстати, можно было бы подумать, что `8.461569363277291*10**(-66)` вернет результат идентичный предыдущему, но:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.461569363277292e-66"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8.461569363277291*10**(-66)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Отличие настолько незначительное, что для нас оно становится абсолютно неважным. Возможно, поэтому числа типа `float` в Python все чаще называют вещественными, а не числами с плавающей точкой."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def far_to_cels_v1(far):\n",
    "     return (far - 32) * 5/9\n",
    "    \n",
    "def far_to_cels_v2(far):\n",
    "     return 5/9 * (far - 32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "235.55555555555554"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "far_to_cels_v1(456)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "235.55555555555557"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "far_to_cels_v2(456)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Десятичные дроби (Decimal)\n",
    "\n",
    "[Подробнее](https://pyprog.pro/python/st_lib/decimal.html)\n",
    "\n",
    "Числа данного типа позволяют производить вычисления над десятичными дробями с заданной точностью. Возможно, вы сразу задались вопросом: \"А разве типом `float` мы обойтись не можем? Ведь это как бы и десятичные дроби, а погрешности при вычислениях с ними, настолько ничтожны, что мы можем вообще не обращать на них внимания.\" Чтож, вполне обоснованное замечание, но давайте посмотрим вот на такой пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.39999999999999997"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.11 + 0.29"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Должно получиться ровно $0.4$, а получилось $0.39999999999999997$. \n",
    "Конечно, как вы сказали: на такую погрешность можно вообще не обращать внимания, но как минимум, такой результат сложения кажется странным сам по себе. Ну в самом деле, разве это так трудно правильно сложить? Дело в том, что компьютер использует двоичную арифметику, над числами в двоичном представлении, а конечная десятичная дробь, в двоичном представлении может оказаться бесконечной, бесконечный \"хвост\" которой и отбрасывается при вычислениях, что в свою очередь и приводит к таким \"ничтожным\" погрешностям.\n",
    "\n",
    "Но, как говорится \"Дьявол кроется в мелочах\". Очень неприятным последствием таких \"ничтожно-маленьких\" погрешностей является то, что вы не можете точно проверить истинность равенства:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.7 + 0.2 - 0.9 == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Потому что с точки зрения компьютера:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.1102230246251565e-16"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.7 + 0.2 - 0.9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А в финансовой и бухгалтерской среде подобные логические проверки выполняются постоянно.\n",
    "\n",
    "Вторым неприятным последствием становится то, что погрешности имеют свойство накопления. Расмотрим простой пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 0\n",
    "for i in range(100000000):\n",
    "    s += 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9999999.98112945"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы $100000000$ раз сложили число $0.1$ с самим собой, но вместо \n",
    "$10000000$ мы получили $9999999.98112945$, которое отличается от правильного результата на целых $0.018870549276471138$. В принципе не так уж и сильно отличается. Да и пример \"притянут за уши\". Но что-то подобное происходит при решении дифференциальных уравнений. Если с помощью таких уравнений строится траектория космического аппарата, то из-за такой мизерной погрешности он, конечно, полетит в сторону нужной планеты, но пролетит мимо. А если вы рассчитываете параметры химической реакции, то на компьютере все может выглядеть более чем безобидно, но в действительности, из-за этой мизерной погрешности вполне может произойти взрыв."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Потребность в повышенной точности, возникает очень редко, но возникает неспроста. Именно эту потребность и призваны удовлетворить числа типа `Decimal`. Этот тип не является встроенным, а предоставляется модулем `Decimal` из стандартной библиотеки Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from decimal import *    #  импортируем модуль\n",
    "getcontext().prec = 10    #  устанавливаем точность"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('0.7647058824')"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  Вычислим частное 13/17\n",
    "Decimal(13) / Decimal(17)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Причем точность может быть настолько большой, насколько позволяет мощность компьютера. Допустим, мы хотим видеть результат с точностью \n",
    "$80$ знаков после запятой (хотя можем увидеть и $1000$), вот они:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "getcontext().prec = 80    #  меняем точность"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('0.76470588235294117647058823529411764705882352941176470588235294117647058823529412')"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Decimal(13) / Decimal(17)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Хотелось бы думать, что такая точность доступна абсолютно для всех математических операций и функций, например таких как всякие синусы, косинусы и прочая экзотика. Но нет, слишком хорошо – тоже не хорошо. К тому же все эти и другие функции могут быть получены с помощью базовых математических операций, которые модулем Decimal прекрасно поддерживаются, например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('1.7320508075688772935274463415058723669428052538103806280558069794519330169088000')"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Decimal(3).sqrt()    #  квадратный корень из 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('1.1699308127586868762703324263880195497962096309602270476311059210484631095336891')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Decimal(3)**Decimal(1/7)    #  корень 7-й степени"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('1.0986122886681096913952452369225257046474905578227494517346943336374942932186090')"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Decimal(3).ln()    #  натуральный логарифм"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from decimal import *    #  импортируем модуль\n",
    "\n",
    "def far_to_cels_v1(far):\n",
    "     return (Decimal(far) - Decimal(32)) * Decimal(5/9)\n",
    "    \n",
    "def far_to_cels_v2(far):\n",
    "     return Decimal(5/9) * (Decimal(far) - Decimal(32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('235.5555555555555660163236098')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "far_to_cels_v1(456)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('235.5555555555555660163236098')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "far_to_cels_v2(456)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Обыкновенные дроби (Fraction)\n",
    "\n",
    "[Подробнее](https://pyprog.pro/python/st_lib/fractions.html)\n",
    "\n",
    "Рациональные числа, они же - обыкновенные дроби предоставляются модулем `fractions`. Обыкновенная дробь в данном модуле представляется в виде пары двух чисел `numerator` – числитель и `denominator` – знаменатель:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(3, 7)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from fractions import Fraction\n",
    "a = Fraction(21, 49)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Честно говоря без чисел типа `Fraction` можно легко обойтись, но из примера видно, что данный модуль выполнил сокращение числителя и знаменателя автоматически, что довольно любопытно и наводит на вопрос \"А где бы мне это могло пригодиться?\". \n",
    "\n",
    "Самый очевидный ответ – числовые ряды и пределы. Для примера рассмотрим [ряд Лейбница](https://ru.wikipedia.org/wiki/%D0%A0%D1%8F%D0%B4_%D0%9B%D0%B5%D0%B9%D0%B1%D0%BD%D0%B8%D1%86%D0%B0), который сходится к $\\pi/4$ (правда медленно... ооочень медленно сходится):\n",
    "\n",
    "$1 - \\frac{1}{3} + \\frac{1}{5} - \\frac{1}{7} + \\frac{1}{9} - \\frac{1}{11} + \\frac{1}{13} - \\frac{1}{15} + \\frac{1}{17} - \\frac{1}{19} + \\frac{1}{21} - \\cdots = \\sum_{n=0}^\\infty \\, \\frac{(-1)^n}{2n+1}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1, -1/3, 1/5, -1/7, 1/9, -1/11, 1/13, -1/15, 1/17, -1/19, 1/21, -1/23, 1/25, -1/27, 1/29, -1/31, 1/33, -1/35, 1/37, -1/39, "
     ]
    }
   ],
   "source": [
    "for n in range(20):\n",
    "    print(Fraction((-1)**n, 2*n + 1), end=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Или посмотреть на поведение вот такого предела:\n",
    "\n",
    "$\\pi=\\lim \\limits_{m\\rightarrow \\infty }{\\frac { (m!)^{4}\\,{2}^{4m}}{\\left[ (2m )! \\right] ^{2}\\,m}}$\n",
    "\n",
    "который тоже можно выразить с помощью чисел типа fractions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 = 4.0\n",
      "32/9 = 3.5555555555555554\n",
      "256/75 = 3.4133333333333336\n",
      "4096/1225 = 3.3436734693877552\n",
      "65536/19845 = 3.3023935500125976\n",
      "524288/160083 = 3.2751010413348074\n",
      "4194304/1288287 = 3.255721745232235\n",
      "134217728/41409225 = 3.2412518708089806\n",
      "4294967296/1329696225 = 3.2300364664117174\n",
      "34359738368/10667118605 = 3.221088996975674\n",
      "274877906944/85530896451 = 3.2137849402931895\n",
      "4398046511104/1371086188563 = 3.2077097324665482\n",
      "70368744177664/21972535073125 = 3.202577396894602\n",
      "562949953421312/176021737014375 = 3.198184286610796\n",
      "4503599627370496/1409850293610375 = 3.1943814515494275\n",
      "288230376151711744/90324408810638025 = 3.1910574333896466\n",
      "18446744073709551616/5786075364399106425 = 3.18812716944714\n",
      "147573952589676412928/46326420401234675625 = 3.1855246166557545\n",
      "1180591620717411303424/370882277949065911875 = 3.1831977177392785\n"
     ]
    }
   ],
   "source": [
    "from math import factorial\n",
    "\n",
    "for m in range(1, 20):\n",
    "    pi = Fraction(factorial(m)**4*2**(4*m), factorial(2*m)**2*m)\n",
    "    print(pi, '=', pi.numerator / pi.denominator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fractions import Fraction\n",
    "\n",
    "def far_to_cels_v1(far):\n",
    "     return (far - 32) * Fraction(5/9)\n",
    "    \n",
    "def far_to_cels_v2(far):\n",
    "     return Fraction(5/9) * (far - 32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(532925955905508717, 4503599627370496)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "far_to_cels_v1(245)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(532925955905508717, 4503599627370496)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "far_to_cels_v2(245)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "118.33333333333334"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(Fraction(532925955905508717, 4503599627370496))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}