pint_introducao.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O pacote pint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O pacote [pint](https://pint.readthedocs.io/en/stable/) permite trabalhar com quantidades físicas: produto de um valor numérico e uma unidade de medida. Possui uma [ampla lista](https://github.com/hgrecco/pint/blob/master/pint/default_en.txt) de unidades, prefixos e constantes que pode ainda ser extendida pelo usuário. É compatível com diversas operações do amplamente utilizado pacote [numpy](https://numpy.org/doc/stable/user/absolute_beginners.html).\n",
    "\n",
    "Caso tenha ficado curioso sobre o símbolo no [site do projeto](https://pint.readthedocs.io/en/stable/) ser um copo de cerveja, leia [esse artigo da Wikipedia](https://en.wikipedia.org/wiki/Pint_glass). O nome nada mais é do que uma referência a um tradicional copo de cerveja muito comum em países Europeus e nos Estados Unidos. E, claro, cada país tem sua própria medida de volume para 1 pint conforme mostra [essa tabela](https://en.wikipedia.org/wiki/Pint_glass#Other_countries). Ótimo nome para um pacote de conversão de unidades, certo?\n",
    "\n",
    "O `pint` requer Python 3.6+ e não possui nenhuma outra dependência.\n",
    "\n",
    "A instalação é bem simples, conforme mostra [a documentação](https://pint.readthedocs.io/en/stable/getting.html), podendo ser feita via conda ou via pip:\n",
    "\n",
    "```bash\n",
    "pip install pint\n",
    "```\n",
    "\n",
    "Veja [esse artigo](https://cienciaprogramada.com.br/2020/08/ambiente-virtual-projeto-python/) caso queira instalar em ambientes virtuais.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O `pint` trabalha com o conceito de *registro de unidades*. Após importar o pacote, cria-se um registro que irá armazenar e avaliar as unidades de todo o código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:48.887814Z",
     "start_time": "2020-09-03T11:39:48.566115Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:13.040319Z",
     "iopub.status.busy": "2020-09-03T11:20:13.040097Z",
     "iopub.status.idle": "2020-09-03T11:20:13.499540Z",
     "shell.execute_reply": "2020-09-03T11:20:13.498897Z",
     "shell.execute_reply.started": "2020-09-03T11:20:13.040270Z"
    }
   },
   "outputs": [],
   "source": [
    "import pint\n",
    "\n",
    "ureg = pint.UnitRegistry()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviamente que tal registro, que se trata de uma variável, pode ter qualquer nome, mas costuma-se seguir a convenção da documentação de chamá-lo `ureg`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos agora verificar que o pacote irá tratar de operações envolvendo unidades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:48.896421Z",
     "start_time": "2020-09-03T11:39:48.889048Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:13.500512Z",
     "iopub.status.busy": "2020-09-03T11:20:13.500364Z",
     "iopub.status.idle": "2020-09-03T11:20:13.508791Z",
     "shell.execute_reply": "2020-09-03T11:20:13.508185Z",
     "shell.execute_reply.started": "2020-09-03T11:20:13.500497Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "2.0 meter"
      ],
      "text/latex": [
       "$2.0\\ \\mathrm{meter}$"
      ],
      "text/plain": [
       "2.0 <Unit('meter')>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 * ureg.meter + 100 * ureg.cm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perceba que na soma acima, o pacote reconheceu que 100 cm equivale a 1 m e retornou o resultado como 2 m. Vejamos com calma a utilização do pacote para entender esse comportamento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Criando quantidades"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos considerar uma situação simples, onde se quer calcular uma velocidade média, dada uma variação de distância em um dado intervalo de tempo. Podemos criar uma variável com magnitude e unidade de duas formas. A primeira é pelo conceito de que uma quantidade é um valor numérico multiplicado por uma unidade:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:49.129743Z",
     "start_time": "2020-09-03T11:39:48.897802Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:13.510045Z",
     "iopub.status.busy": "2020-09-03T11:20:13.509886Z",
     "iopub.status.idle": "2020-09-03T11:20:13.965695Z",
     "shell.execute_reply": "2020-09-03T11:20:13.963319Z",
     "shell.execute_reply.started": "2020-09-03T11:20:13.510028Z"
    }
   },
   "outputs": [],
   "source": [
    "distancia = 50 * ureg.meter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:49.315452Z",
     "start_time": "2020-09-03T11:39:49.131134Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:13.969564Z",
     "iopub.status.busy": "2020-09-03T11:20:13.968984Z",
     "iopub.status.idle": "2020-09-03T11:20:14.200609Z",
     "shell.execute_reply": "2020-09-03T11:20:14.197839Z",
     "shell.execute_reply.started": "2020-09-03T11:20:13.969495Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "50 meter"
      ],
      "text/latex": [
       "$50\\ \\mathrm{meter}$"
      ],
      "text/plain": [
       "50 <Unit('meter')>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distancia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A segunda é via um construtor de quantidades. Novamente, o construtor pode ter qualquer nome, mas a convenção criada pela documentação do pacote é chamá-lo de `Q_`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:49.593088Z",
     "start_time": "2020-09-03T11:39:49.316634Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:14.205198Z",
     "iopub.status.busy": "2020-09-03T11:20:14.204331Z",
     "iopub.status.idle": "2020-09-03T11:20:14.431624Z",
     "shell.execute_reply": "2020-09-03T11:20:14.430883Z",
     "shell.execute_reply.started": "2020-09-03T11:20:14.205120Z"
    }
   },
   "outputs": [],
   "source": [
    "Q_ = ureg.Quantity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:49.778680Z",
     "start_time": "2020-09-03T11:39:49.597696Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:14.432641Z",
     "iopub.status.busy": "2020-09-03T11:20:14.432455Z",
     "iopub.status.idle": "2020-09-03T11:20:14.665044Z",
     "shell.execute_reply": "2020-09-03T11:20:14.663029Z",
     "shell.execute_reply.started": "2020-09-03T11:20:14.432618Z"
    }
   },
   "outputs": [],
   "source": [
    "tempo = Q_(10, ureg.second)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:49.984184Z",
     "start_time": "2020-09-03T11:39:49.782945Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:14.668360Z",
     "iopub.status.busy": "2020-09-03T11:20:14.667733Z",
     "iopub.status.idle": "2020-09-03T11:20:14.919580Z",
     "shell.execute_reply": "2020-09-03T11:20:14.917500Z",
     "shell.execute_reply.started": "2020-09-03T11:20:14.668285Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "10 second"
      ],
      "text/latex": [
       "$10\\ \\mathrm{second}$"
      ],
      "text/plain": [
       "10 <Unit('second')>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tempo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para calcular a velocidade média, basta seguir a definição física:\n",
    "\n",
    "\\\\[\\overline{v} = \\frac{\\Delta x}{\\Delta t} \\\\]\n",
    "\n",
    "onde $\\overline{v}$ é a velocidade média, $x$ é a distância, $t$ é o tempo e o símbolo $\\Delta$ indica variação."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:50.179690Z",
     "start_time": "2020-09-03T11:39:49.986219Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:14.922898Z",
     "iopub.status.busy": "2020-09-03T11:20:14.922321Z",
     "iopub.status.idle": "2020-09-03T11:20:15.168215Z",
     "shell.execute_reply": "2020-09-03T11:20:15.166058Z",
     "shell.execute_reply.started": "2020-09-03T11:20:14.922827Z"
    }
   },
   "outputs": [],
   "source": [
    "velocidade_media = distancia / tempo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:50.381412Z",
     "start_time": "2020-09-03T11:39:50.181592Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:15.173787Z",
     "iopub.status.busy": "2020-09-03T11:20:15.173622Z",
     "iopub.status.idle": "2020-09-03T11:20:15.405516Z",
     "shell.execute_reply": "2020-09-03T11:20:15.404954Z",
     "shell.execute_reply.started": "2020-09-03T11:20:15.173770Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "5.0 meter/second"
      ],
      "text/latex": [
       "$5.0\\ \\frac{\\mathrm{meter}}{\\mathrm{second}}$"
      ],
      "text/plain": [
       "5.0 <Unit('meter / second')>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare que a unidade da velocidade está correta considerando as unidades passadas para as variáveis relacionadas a distância e ao tempo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos verificar que, independentemente da forma como as variáveis foram definidas, todas são do tipo `Quantity`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:50.572709Z",
     "start_time": "2020-09-03T11:39:50.385787Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:15.406663Z",
     "iopub.status.busy": "2020-09-03T11:20:15.406514Z",
     "iopub.status.idle": "2020-09-03T11:20:15.642569Z",
     "shell.execute_reply": "2020-09-03T11:20:15.639891Z",
     "shell.execute_reply.started": "2020-09-03T11:20:15.406646Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pint.quantity.build_quantity_class.<locals>.Quantity'>\n",
      "<class 'pint.quantity.build_quantity_class.<locals>.Quantity'>\n",
      "<class 'pint.quantity.build_quantity_class.<locals>.Quantity'>\n"
     ]
    }
   ],
   "source": [
    "print(type(distancia))\n",
    "print(type(tempo))\n",
    "print(type(velocidade_media))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso pode também verificado verificando a [`repr`](https://docs.python.org/3/library/functions.html#repr) de cada um desses objetos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:50.746224Z",
     "start_time": "2020-09-03T11:39:50.574028Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:15.645988Z",
     "iopub.status.busy": "2020-09-03T11:20:15.645409Z",
     "iopub.status.idle": "2020-09-03T11:20:15.882496Z",
     "shell.execute_reply": "2020-09-03T11:20:15.879839Z",
     "shell.execute_reply.started": "2020-09-03T11:20:15.645916Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Quantity(50, 'meter')>\n",
      "<Quantity(10, 'second')>\n",
      "<Quantity(5.0, 'meter / second')>\n"
     ]
    }
   ],
   "source": [
    "print(repr(distancia))\n",
    "print(repr(tempo))\n",
    "print(repr(velocidade_media))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-08-31T19:30:38.155388Z",
     "iopub.status.busy": "2020-08-31T19:30:38.155194Z",
     "iopub.status.idle": "2020-08-31T19:30:38.158310Z",
     "shell.execute_reply": "2020-08-31T19:30:38.157816Z",
     "shell.execute_reply.started": "2020-08-31T19:30:38.155370Z"
    }
   },
   "source": [
    "Uma coisa interessante que pode ser percebida pela análise do `repr` é que a unidade também pode ser passada como uma `string`. E aqui temos um grande poder do `pint`. Veja como poderíamos declarar a distância de diversos formas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:50.943164Z",
     "start_time": "2020-09-03T11:39:50.747741Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:15.886073Z",
     "iopub.status.busy": "2020-09-03T11:20:15.885403Z",
     "iopub.status.idle": "2020-09-03T11:20:16.135111Z",
     "shell.execute_reply": "2020-09-03T11:20:16.132807Z",
     "shell.execute_reply.started": "2020-09-03T11:20:15.885998Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "10 meter"
      ],
      "text/latex": [
       "$10\\ \\mathrm{meter}$"
      ],
      "text/plain": [
       "10 <Unit('meter')>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 * ureg.meter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:51.513377Z",
     "start_time": "2020-09-03T11:39:50.945011Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:16.138863Z",
     "iopub.status.busy": "2020-09-03T11:20:16.138144Z",
     "iopub.status.idle": "2020-09-03T11:20:16.389909Z",
     "shell.execute_reply": "2020-09-03T11:20:16.389459Z",
     "shell.execute_reply.started": "2020-09-03T11:20:16.138788Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "10 meter"
      ],
      "text/latex": [
       "$10\\ \\mathrm{meter}$"
      ],
      "text/plain": [
       "10 <Unit('meter')>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 * ureg.m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:52.069908Z",
     "start_time": "2020-09-03T11:39:51.518297Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:16.390815Z",
     "iopub.status.busy": "2020-09-03T11:20:16.390644Z",
     "iopub.status.idle": "2020-09-03T11:20:16.619480Z",
     "shell.execute_reply": "2020-09-03T11:20:16.618964Z",
     "shell.execute_reply.started": "2020-09-03T11:20:16.390794Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "10 meter"
      ],
      "text/latex": [
       "$10\\ \\mathrm{meter}$"
      ],
      "text/plain": [
       "10 <Unit('meter')>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 * ureg('meter')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:53.176992Z",
     "start_time": "2020-09-03T11:39:52.071329Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:16.620343Z",
     "iopub.status.busy": "2020-09-03T11:20:16.620201Z",
     "iopub.status.idle": "2020-09-03T11:20:16.849293Z",
     "shell.execute_reply": "2020-09-03T11:20:16.848671Z",
     "shell.execute_reply.started": "2020-09-03T11:20:16.620326Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "10 meter"
      ],
      "text/latex": [
       "$10\\ \\mathrm{meter}$"
      ],
      "text/plain": [
       "10 <Unit('meter')>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 * ureg('m')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:53.950395Z",
     "start_time": "2020-09-03T11:39:53.179876Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:16.850199Z",
     "iopub.status.busy": "2020-09-03T11:20:16.849943Z",
     "iopub.status.idle": "2020-09-03T11:20:17.078607Z",
     "shell.execute_reply": "2020-09-03T11:20:17.078078Z",
     "shell.execute_reply.started": "2020-09-03T11:20:16.850169Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "10 meter"
      ],
      "text/latex": [
       "$10\\ \\mathrm{meter}$"
      ],
      "text/plain": [
       "10 <Unit('meter')>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q_(10, ureg.meter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:54.601690Z",
     "start_time": "2020-09-03T11:39:53.957209Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:17.079503Z",
     "iopub.status.busy": "2020-09-03T11:20:17.079352Z",
     "iopub.status.idle": "2020-09-03T11:20:17.318970Z",
     "shell.execute_reply": "2020-09-03T11:20:17.318461Z",
     "shell.execute_reply.started": "2020-09-03T11:20:17.079486Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "10 meter"
      ],
      "text/latex": [
       "$10\\ \\mathrm{meter}$"
      ],
      "text/plain": [
       "10 <Unit('meter')>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q_('10 m')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare que a última forma é a maneira pela qual descrevemos uma quantidade usualmente, de forma manuscrita e em trabalhos redigidos. Isso é uma grande vantagem do `pint`, o pacote permite o *parse* (transformação) de strings de forma que considero essa a forma mais fácil. Por exemplo, a constante universal dos gases, com as unidades SI e arredondada para 3 casas decimais, poderia ser declarada como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:54.802266Z",
     "start_time": "2020-09-03T11:39:54.608085Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:17.320356Z",
     "iopub.status.busy": "2020-09-03T11:20:17.320085Z",
     "iopub.status.idle": "2020-09-03T11:20:17.617510Z",
     "shell.execute_reply": "2020-09-03T11:20:17.617088Z",
     "shell.execute_reply.started": "2020-09-03T11:20:17.320325Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "8.314 joule/(kelvin mole)"
      ],
      "text/latex": [
       "$8.314\\ \\frac{\\mathrm{joule}}{\\left(\\mathrm{kelvin} \\cdot \\mathrm{mole}\\right)}$"
      ],
      "text/plain": [
       "8.314 <Unit('joule / kelvin / mole')>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q_('8.314 J/(mol*K)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perceba o cuidado na utilização de parênteses. Unidades também seguem regras de precedência conforme o comportamento usual."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convertendo unidades"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma forma de converter é utilizando o método `to`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:55.003580Z",
     "start_time": "2020-09-03T11:39:54.804228Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:17.618239Z",
     "iopub.status.busy": "2020-09-03T11:20:17.618086Z",
     "iopub.status.idle": "2020-09-03T11:20:18.119053Z",
     "shell.execute_reply": "2020-09-03T11:20:18.118365Z",
     "shell.execute_reply.started": "2020-09-03T11:20:17.618219Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "18.0 kilometer/hour"
      ],
      "text/latex": [
       "$18.0\\ \\frac{\\mathrm{kilometer}}{\\mathrm{hour}}$"
      ],
      "text/plain": [
       "18.0 <Unit('kilometer / hour')>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media.to(ureg.km / ureg.hour)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como já verificamos que o pacote aceita strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:55.207609Z",
     "start_time": "2020-09-03T11:39:55.008053Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:18.120066Z",
     "iopub.status.busy": "2020-09-03T11:20:18.119889Z",
     "iopub.status.idle": "2020-09-03T11:20:18.553269Z",
     "shell.execute_reply": "2020-09-03T11:20:18.552745Z",
     "shell.execute_reply.started": "2020-09-03T11:20:18.120046Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "18.0 kilometer/hour"
      ],
      "text/latex": [
       "$18.0\\ \\frac{\\mathrm{kilometer}}{\\mathrm{hour}}$"
      ],
      "text/plain": [
       "18.0 <Unit('kilometer / hour')>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media.to('km/hour')  # quilômetros por hora"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:55.391562Z",
     "start_time": "2020-09-03T11:39:55.210803Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:18.554309Z",
     "iopub.status.busy": "2020-09-03T11:20:18.554162Z",
     "iopub.status.idle": "2020-09-03T11:20:18.789974Z",
     "shell.execute_reply": "2020-09-03T11:20:18.787026Z",
     "shell.execute_reply.started": "2020-09-03T11:20:18.554291Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "16.404199475065617 foot/second"
      ],
      "text/latex": [
       "$16.404199475065617\\ \\frac{\\mathrm{foot}}{\\mathrm{second}}$"
      ],
      "text/plain": [
       "16.404199475065617 <Unit('foot / second')>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media.to('ft/s')  # pés por segundo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizando o `to`, a quantidade ligada à variável permanece com as unidades de origem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:55.586374Z",
     "start_time": "2020-09-03T11:39:55.393240Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:18.795136Z",
     "iopub.status.busy": "2020-09-03T11:20:18.794175Z",
     "iopub.status.idle": "2020-09-03T11:20:19.024903Z",
     "shell.execute_reply": "2020-09-03T11:20:19.023391Z",
     "shell.execute_reply.started": "2020-09-03T11:20:18.795020Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "5.0 meter/second"
      ],
      "text/latex": [
       "$5.0\\ \\frac{\\mathrm{meter}}{\\mathrm{second}}$"
      ],
      "text/plain": [
       "5.0 <Unit('meter / second')>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para que a conversão seja feita de forma definitiva, devemos utilizar o método `ito` (o *i* pode ser entendido como [*inplace*](https://en.wikipedia.org/wiki/In-place_algorithm)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:55.781739Z",
     "start_time": "2020-09-03T11:39:55.589783Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:19.027608Z",
     "iopub.status.busy": "2020-09-03T11:20:19.027121Z",
     "iopub.status.idle": "2020-09-03T11:20:19.262794Z",
     "shell.execute_reply": "2020-09-03T11:20:19.261446Z",
     "shell.execute_reply.started": "2020-09-03T11:20:19.027554Z"
    }
   },
   "outputs": [],
   "source": [
    "velocidade_media.ito('km/hour')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:55.979087Z",
     "start_time": "2020-09-03T11:39:55.783954Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:19.264691Z",
     "iopub.status.busy": "2020-09-03T11:20:19.264303Z",
     "iopub.status.idle": "2020-09-03T11:20:19.509680Z",
     "shell.execute_reply": "2020-09-03T11:20:19.507240Z",
     "shell.execute_reply.started": "2020-09-03T11:20:19.264646Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "18.0 kilometer/hour"
      ],
      "text/latex": [
       "$18.0\\ \\frac{\\mathrm{kilometer}}{\\mathrm{hour}}$"
      ],
      "text/plain": [
       "18.0 <Unit('kilometer / hour')>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O `pint` possui o método `to_base_units` (e o análogo `ito_base_units`) para que uma determinada quantidade seja convertida para as unidades do sistema de unidades definido no registro de unidades. Por padrão, o registro de unidades considera o Sistema Internacional de Unidades (SI). Podemos verificar todos os sistemas disponíveis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:56.163436Z",
     "start_time": "2020-09-03T11:39:55.980655Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:19.513600Z",
     "iopub.status.busy": "2020-09-03T11:20:19.512797Z",
     "iopub.status.idle": "2020-09-03T11:20:19.895117Z",
     "shell.execute_reply": "2020-09-03T11:20:19.892670Z",
     "shell.execute_reply.started": "2020-09-03T11:20:19.513482Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Planck', 'SI', 'US', 'atomic', 'cgs', 'imperial', 'mks']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(ureg.sys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como o sistema padrão é o SI, podemos então pegar a velocidade média, no momento armazenada em quilômetros por hora, e solicitar a conversão para as unidades do SI:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:56.339319Z",
     "start_time": "2020-09-03T11:39:56.164586Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:19.898325Z",
     "iopub.status.busy": "2020-09-03T11:20:19.897732Z",
     "iopub.status.idle": "2020-09-03T11:20:20.303822Z",
     "shell.execute_reply": "2020-09-03T11:20:20.303233Z",
     "shell.execute_reply.started": "2020-09-03T11:20:19.898228Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "5.0 meter/second"
      ],
      "text/latex": [
       "$5.0\\ \\frac{\\mathrm{meter}}{\\mathrm{second}}$"
      ],
      "text/plain": [
       "5.0 <Unit('meter / second')>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media.to_base_units()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Considerando um contexto, por exemplo, de estar no Sistema Imperial, podemos definir tal sistema:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:56.601773Z",
     "start_time": "2020-09-03T11:39:56.341501Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:20.310619Z",
     "iopub.status.busy": "2020-09-03T11:20:20.310326Z",
     "iopub.status.idle": "2020-09-03T11:20:21.065654Z",
     "shell.execute_reply": "2020-09-03T11:20:21.063286Z",
     "shell.execute_reply.started": "2020-09-03T11:20:20.310584Z"
    }
   },
   "outputs": [],
   "source": [
    "ureg.default_system = 'imperial'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora, a velocidade média pode ser convertida para as unidades do sistema imperial (jardas/segundo):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:56.799576Z",
     "start_time": "2020-09-03T11:39:56.603050Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:21.070629Z",
     "iopub.status.busy": "2020-09-03T11:20:21.069908Z",
     "iopub.status.idle": "2020-09-03T11:20:21.493304Z",
     "shell.execute_reply": "2020-09-03T11:20:21.490921Z",
     "shell.execute_reply.started": "2020-09-03T11:20:21.070520Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "5.46806649168854 yard/second"
      ],
      "text/latex": [
       "$5.46806649168854\\ \\frac{\\mathrm{yard}}{\\mathrm{second}}$"
      ],
      "text/plain": [
       "5.46806649168854 <Unit('yard / second')>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media.to_base_units()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos voltar ao SI:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:57.075709Z",
     "start_time": "2020-09-03T11:39:56.800815Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:21.495462Z",
     "iopub.status.busy": "2020-09-03T11:20:21.495185Z",
     "iopub.status.idle": "2020-09-03T11:20:22.015655Z",
     "shell.execute_reply": "2020-09-03T11:20:22.013285Z",
     "shell.execute_reply.started": "2020-09-03T11:20:21.495433Z"
    }
   },
   "outputs": [],
   "source": [
    "ureg.default_system = 'SI'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:57.273266Z",
     "start_time": "2020-09-03T11:39:57.080408Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:22.018456Z",
     "iopub.status.busy": "2020-09-03T11:20:22.017919Z",
     "iopub.status.idle": "2020-09-03T11:20:22.478127Z",
     "shell.execute_reply": "2020-09-03T11:20:22.477243Z",
     "shell.execute_reply.started": "2020-09-03T11:20:22.018388Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "5.0 meter/second"
      ],
      "text/latex": [
       "$5.0\\ \\frac{\\mathrm{meter}}{\\mathrm{second}}$"
      ],
      "text/plain": [
       "5.0 <Unit('meter / second')>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media.to_base_units()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos converter definitivamente de volta para as unidades SI:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:57.454701Z",
     "start_time": "2020-09-03T11:39:57.275661Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:22.479277Z",
     "iopub.status.busy": "2020-09-03T11:20:22.479007Z",
     "iopub.status.idle": "2020-09-03T11:20:22.948335Z",
     "shell.execute_reply": "2020-09-03T11:20:22.947499Z",
     "shell.execute_reply.started": "2020-09-03T11:20:22.479256Z"
    }
   },
   "outputs": [],
   "source": [
    "velocidade_media.ito_base_units()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:57.771233Z",
     "start_time": "2020-09-03T11:39:57.455881Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:22.949711Z",
     "iopub.status.busy": "2020-09-03T11:20:22.949476Z",
     "iopub.status.idle": "2020-09-03T11:20:23.376561Z",
     "shell.execute_reply": "2020-09-03T11:20:23.374788Z",
     "shell.execute_reply.started": "2020-09-03T11:20:22.949681Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "5.0 meter/second"
      ],
      "text/latex": [
       "$5.0\\ \\frac{\\mathrm{meter}}{\\mathrm{second}}$"
      ],
      "text/plain": [
       "5.0 <Unit('meter / second')>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conhecendo cada parte da quantidade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conforme já descrevemos, uma quantidade física é definida por um valor, magnitude, e sua respectiva unidade. Podemos verificar cada uma dessas entidades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:58.183857Z",
     "start_time": "2020-09-03T11:39:57.776681Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:23.380004Z",
     "iopub.status.busy": "2020-09-03T11:20:23.379272Z",
     "iopub.status.idle": "2020-09-03T11:20:24.006995Z",
     "shell.execute_reply": "2020-09-03T11:20:24.004506Z",
     "shell.execute_reply.started": "2020-09-03T11:20:23.379914Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media.magnitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:58.580776Z",
     "start_time": "2020-09-03T11:39:58.188635Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:24.009284Z",
     "iopub.status.busy": "2020-09-03T11:20:24.009046Z",
     "iopub.status.idle": "2020-09-03T11:20:24.474799Z",
     "shell.execute_reply": "2020-09-03T11:20:24.472063Z",
     "shell.execute_reply.started": "2020-09-03T11:20:24.009258Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "meter/second"
      ],
      "text/latex": [
       "$\\frac{\\mathrm{meter}}{\\mathrm{second}}$"
      ],
      "text/plain": [
       "<Unit('meter / second')>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media.units"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também verificar as dimensões, para fazer uma análise dimensional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:58.771567Z",
     "start_time": "2020-09-03T11:39:58.585169Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:24.476540Z",
     "iopub.status.busy": "2020-09-03T11:20:24.476328Z",
     "iopub.status.idle": "2020-09-03T11:20:24.884472Z",
     "shell.execute_reply": "2020-09-03T11:20:24.881893Z",
     "shell.execute_reply.started": "2020-09-03T11:20:24.476514Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<UnitsContainer({'[length]': 1, '[time]': -1})>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "velocidade_media.dimensionality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aplicando em um caso real"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em [um dos últimos artigos](https://cienciaprogramada.com.br/2020/08/erro-conversao-unidade-derruba-aviao/) do site, vimos o caso de um avião que ficou sem combustível durante o voo. Tal situação ocorreu por um erro de conversão de unidades, conforme descrito no post.\n",
    "\n",
    "Vou aproveitar o caso para mostrar como trabalhar com unidades na definição de funções.\n",
    "\n",
    "É óbvio, mas não custa ressaltar, que o caso é complexo e algumas simplificações serão feitas para manter o foco na explicação dos conceitos envolvidos. Aqueles que quiserem mais detalhes sobre medição de densidade de combustível e sobre consumo de combustível em aviação podem ler [aqui](http://www.avioesemusicas.com/como-o-boeing-777-sabe-quanto-tem-de-combustivel-nos-seus-tanques.html) e [aqui](http://www.avioesemusicas.com/quantos-quilometros-um-boeing-777-faz-com-um-litro-de-combustivel-pergunta.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vimos no artigo, a densidade que deveriam ter utilizado nas contas deveria estar em kg/l. Em uma situação real, é consultada uma tabela de densidades para verificar qual o valor a ser utilizado a depender da temperatura (ou se usa algum equipamento de medição de densidade). Aqui, simplificaremos considerando que a densidade é constante e no valor de 0,803 kg/l, valor que deveria ter sido utilizado no caso em questão:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:59.195525Z",
     "start_time": "2020-09-03T11:39:58.772748Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:24.888881Z",
     "iopub.status.busy": "2020-09-03T11:20:24.888012Z",
     "iopub.status.idle": "2020-09-03T11:20:25.122744Z",
     "shell.execute_reply": "2020-09-03T11:20:25.120841Z",
     "shell.execute_reply.started": "2020-09-03T11:20:24.888766Z"
    }
   },
   "outputs": [],
   "source": [
    "densidade_combustivel = Q_('0.803 kg/l')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:59.537349Z",
     "start_time": "2020-09-03T11:39:59.200408Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:25.125986Z",
     "iopub.status.busy": "2020-09-03T11:20:25.125470Z",
     "iopub.status.idle": "2020-09-03T11:20:25.366159Z",
     "shell.execute_reply": "2020-09-03T11:20:25.363571Z",
     "shell.execute_reply.started": "2020-09-03T11:20:25.125920Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "0.803 kilogram/liter"
      ],
      "text/latex": [
       "$0.803\\ \\frac{\\mathrm{kilogram}}{\\mathrm{liter}}$"
      ],
      "text/plain": [
       "0.803 <Unit('kilogram / liter')>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "densidade_combustivel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Relembrando das contas do artigo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![contas_aviao](https://cienciaprogramada.com.br/wp-content/uploads/2020/08/aviao09-1024x182.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim, podemos pensar, em um primeiro momento, em definir um função que irá receber os valores de volume de combustível presente no tanque e a massa total de combustível necessária para a viagem. Associar, então, tais valores a unidades e retornar o valor do volume de combustível necessário para abastecer o avião. Vamos definir tal função:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:39:59.722696Z",
     "start_time": "2020-09-03T11:39:59.540407Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:25.371162Z",
     "iopub.status.busy": "2020-09-03T11:20:25.370206Z",
     "iopub.status.idle": "2020-09-03T11:20:25.616408Z",
     "shell.execute_reply": "2020-09-03T11:20:25.613677Z",
     "shell.execute_reply.started": "2020-09-03T11:20:25.371042Z"
    }
   },
   "outputs": [],
   "source": [
    "def volume_abastecer_implementacao1(volume_presente, massa_total, densidade_combustivel=Q_('0.803 kg/l')):\n",
    "    '''Retorna o volume de combustível que deve abastercer o avião.\n",
    "    \n",
    "    Parâmetros\n",
    "    ----------\n",
    "    volume_presente: float, espera-se valor em litro\n",
    "    massa_total: float, espera-se valor em quilograma\n",
    "    densidade_combustivel: pint.Quantity, valor em kg/l, padrão de 0.803 kg/l\n",
    "    \n",
    "    Retorno\n",
    "    -------\n",
    "    volume a reabastecer: float, valor em litros\n",
    "    \n",
    "    OBS.: Primeira implementação, não é a ideal. Verificar a implementação mais adequada adiante no artigo.\n",
    "    '''\n",
    "    \n",
    "    volume_presente = Q_(volume_presente, 'l')\n",
    "    massa_total = Q_(massa_total, 'kg')    \n",
    "    massa_presente = volume_presente * densidade_combustivel\n",
    "    massa_abastecer = massa_total - massa_presente\n",
    "    \n",
    "    return massa_abastecer / densidade_combustivel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:00.005566Z",
     "start_time": "2020-09-03T11:39:59.726810Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:25.621106Z",
     "iopub.status.busy": "2020-09-03T11:20:25.620189Z",
     "iopub.status.idle": "2020-09-03T11:20:25.946513Z",
     "shell.execute_reply": "2020-09-03T11:20:25.945858Z",
     "shell.execute_reply.started": "2020-09-03T11:20:25.620992Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "20088.85927770859 liter"
      ],
      "text/latex": [
       "$20088.85927770859\\ \\mathrm{liter}$"
      ],
      "text/plain": [
       "20088.85927770859 <Unit('liter')>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volume_abastecer_implementacao1(7682, 22300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare que a resposta retornada está correta. No entanto, a implementação da função ainda não é a ideal pois a função recebe apenas valores numéricos. Por mais que a documentação (DOCUMENTE seu código!) diga que os valores de volume e de massa devam estar em litro e quilograma, respectivamente, nada impede que valores em outras unidades sejam passados por engano. Alguém poderia, por exemplo, passar inadvertidamente um volume em metros cúbicos e nada no código iria alertar que se trata de um erro.\n",
    "\n",
    "Vamos reimplementar a função:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:00.506013Z",
     "start_time": "2020-09-03T11:40:00.009851Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:25.947402Z",
     "iopub.status.busy": "2020-09-03T11:20:25.947255Z",
     "iopub.status.idle": "2020-09-03T11:20:26.162136Z",
     "shell.execute_reply": "2020-09-03T11:20:26.160181Z",
     "shell.execute_reply.started": "2020-09-03T11:20:25.947384Z"
    }
   },
   "outputs": [],
   "source": [
    "def volume_abastecer_implementacao2(volume_presente, massa_total, densidade_combustivel=Q_('0.803 kg/l')):\n",
    "    '''Retorna o volume de combustível que deve abastercer o avião.\n",
    "    \n",
    "    Parâmetros\n",
    "    ----------\n",
    "    volume_presente: pint.Quantity, espera-se valor em litro\n",
    "    massa_total: pint.Quantity, espera-se valor em quilograma\n",
    "    densidade_combustível: pint.Quantity, por padrão '0.803 kg/l`\n",
    "    \n",
    "    \n",
    "    Retorno\n",
    "    -------\n",
    "    volume a reabastecer: pint.Quantity, valor em litros\n",
    "    \n",
    "    OBS.: Implementação não ideal. Verificar a implementação mais adequada adiante no artigo.\n",
    "    '''\n",
    "    \n",
    "    if isinstance(volume_presente, pint.Quantity) and isinstance(massa_total, pint.Quantity):            \n",
    "        massa_presente = volume_presente * densidade_combustivel\n",
    "        massa_abastecer = massa_total - massa_presente\n",
    "        return massa_abastecer / densidade_combustivel\n",
    "    else:\n",
    "        raise ValueError('Forneça os valores como quantidades físicas do Pint (pint.Quantity)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nessa implementação, começo verificando se os parâmetros são do tipo correto. [Não é uma coisa muito usual em Python](https://stackoverflow.com/questions/11360858/what-is-the-eafp-principle-in-python), mas serve pro que queremos no momento. Se não for do tipo correto, um erro é mostrado ao usuário."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos verificar agora como a função se comporta passando valores sem unidades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:00.924166Z",
     "start_time": "2020-09-03T11:40:00.510207Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:20:26.166791Z",
     "iopub.status.busy": "2020-09-03T11:20:26.165976Z",
     "iopub.status.idle": "2020-09-03T11:20:26.476230Z",
     "shell.execute_reply": "2020-09-03T11:20:26.475314Z",
     "shell.execute_reply.started": "2020-09-03T11:20:26.166672Z"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Forneça os valores como quantidades físicas do Pint (pint.Quantity)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-41-d3388580cae6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvolume_abastecer_implementacao2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m7682\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m22300\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-40-e5d679f70da5>\u001b[0m in \u001b[0;36mvolume_abastecer_implementacao2\u001b[0;34m(volume_presente, massa_total, densidade_combustivel)\u001b[0m\n\u001b[1;32m     21\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mmassa_abastecer\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mdensidade_combustivel\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Forneça os valores como quantidades físicas do Pint (pint.Quantity)'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: Forneça os valores como quantidades físicas do Pint (pint.Quantity)"
     ]
    }
   ],
   "source": [
    "volume_abastecer_implementacao2(7682, 22300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ótimo! Vamos agora criar então quantidades para serem passadas para a função."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:41.155236Z",
     "start_time": "2020-09-03T11:40:41.152654Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:27.345419Z",
     "iopub.status.busy": "2020-09-03T11:30:27.345101Z",
     "iopub.status.idle": "2020-09-03T11:30:27.349394Z",
     "shell.execute_reply": "2020-09-03T11:30:27.348644Z",
     "shell.execute_reply.started": "2020-09-03T11:30:27.345391Z"
    }
   },
   "outputs": [],
   "source": [
    "vol_presente = Q_('7682 l')\n",
    "m_total = Q_('22300 kg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:41.479479Z",
     "start_time": "2020-09-03T11:40:41.157163Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:27.351056Z",
     "iopub.status.busy": "2020-09-03T11:30:27.350772Z",
     "iopub.status.idle": "2020-09-03T11:30:27.642259Z",
     "shell.execute_reply": "2020-09-03T11:30:27.639814Z",
     "shell.execute_reply.started": "2020-09-03T11:30:27.351003Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "20088.85927770859 liter"
      ],
      "text/latex": [
       "$20088.85927770859\\ \\mathrm{liter}$"
      ],
      "text/plain": [
       "20088.85927770859 <Unit('liter')>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volume_abastecer_implementacao2(vol_presente, m_total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ótimo! Resposta correta. \n",
    "\n",
    "Há ainda um \"efeito colateral\" da implementação da forma como foi feita. Se passarmos os valores em outras unidades, o `pint` não se encarregará de convertê-las automaticamente para as unidades do sistema de medidas utilizado. Ou seja, se, por exemplo, passarmos a massa em libras, teremos uma resposta um pouco estranha:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:41.660232Z",
     "start_time": "2020-09-03T11:40:41.484733Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:27.646681Z",
     "iopub.status.busy": "2020-09-03T11:30:27.646122Z",
     "iopub.status.idle": "2020-09-03T11:30:28.099430Z",
     "shell.execute_reply": "2020-09-03T11:30:28.097182Z",
     "shell.execute_reply.started": "2020-09-03T11:30:27.646611Z"
    }
   },
   "outputs": [],
   "source": [
    "m_total.ito('lb')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:41.845934Z",
     "start_time": "2020-09-03T11:40:41.662592Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:28.103025Z",
     "iopub.status.busy": "2020-09-03T11:30:28.102501Z",
     "iopub.status.idle": "2020-09-03T11:30:28.355397Z",
     "shell.execute_reply": "2020-09-03T11:30:28.353227Z",
     "shell.execute_reply.started": "2020-09-03T11:30:28.102961Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "49163.084467227694 pound"
      ],
      "text/latex": [
       "$49163.084467227694\\ \\mathrm{pound}$"
      ],
      "text/plain": [
       "49163.084467227694 <Unit('pound')>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m_total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:42.034413Z",
     "start_time": "2020-09-03T11:40:41.847324Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:28.358663Z",
     "iopub.status.busy": "2020-09-03T11:30:28.358109Z",
     "iopub.status.idle": "2020-09-03T11:30:28.611303Z",
     "shell.execute_reply": "2020-09-03T11:30:28.610726Z",
     "shell.execute_reply.started": "2020-09-03T11:30:28.358596Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "44288.35361077301 liter pound/kilogram"
      ],
      "text/latex": [
       "$44288.35361077301\\ \\frac{\\mathrm{liter} \\cdot \\mathrm{pound}}{\\mathrm{kilogram}}$"
      ],
      "text/plain": [
       "44288.35361077301 <Unit('liter * pound / kilogram')>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volume_abastecer_implementacao2(vol_presente, m_total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare que não foram unificadas as unidades libra e quilograma, mesmo sendo de uma mesma dimensão. Para resolver situações como essa, o `pint` possui o método `to_reduced_units` que combina unidades que são de uma mesma dimensionalidade. De acordo [com a documentação](https://pint.readthedocs.io/en/stable/tutorial.html), essa funcionalidade pode ser ativada no escopo global mas, por padrão, é desativida por questões de performance. Vamos então redefinir nossa função para resolver esse pequeno problema:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:42.218452Z",
     "start_time": "2020-09-03T11:40:42.037791Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:28.612194Z",
     "iopub.status.busy": "2020-09-03T11:30:28.612003Z",
     "iopub.status.idle": "2020-09-03T11:30:29.107489Z",
     "shell.execute_reply": "2020-09-03T11:30:29.106952Z",
     "shell.execute_reply.started": "2020-09-03T11:30:28.612177Z"
    }
   },
   "outputs": [],
   "source": [
    "def volume_abastecer_implementacao3(volume_presente, massa_total, densidade_combustivel=Q_('0.803 kg/l')):\n",
    "    '''Retorna o volume de combustível que deve abastercer o avião.\n",
    "    \n",
    "    Parâmetros\n",
    "    ----------\n",
    "    volume_presente: pint.Quantity, espera-se valor em litro\n",
    "    massa_total: pint.Quantity, espera-se valor em quilograma\n",
    "    densidade_combustível: pint.Quantity, por padrão '0.803 kg/l`\n",
    "    \n",
    "    Retorno\n",
    "    -------\n",
    "    volume a reabastecer: pint.Quantity, valor em litros\n",
    "    \n",
    "    OBS.: Implementação não ideal. Verificar a implementação mais adequada adiante no artigo.\n",
    "    '''\n",
    "    \n",
    "    if isinstance(volume_presente, pint.Quantity) and isinstance(massa_total, pint.Quantity):            \n",
    "        massa_presente = volume_presente * densidade_combustivel\n",
    "        massa_abastecer = massa_total - massa_presente\n",
    "        return (massa_abastecer / densidade_combustivel).to_reduced_units()\n",
    "    else:\n",
    "        raise ValueError('Forneça os valores como quantidades físicas do Pint (pint.Quantity)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verificando as unidades dos parâmetros a serem passados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:42.389242Z",
     "start_time": "2020-09-03T11:40:42.222724Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:29.108277Z",
     "iopub.status.busy": "2020-09-03T11:30:29.108146Z",
     "iopub.status.idle": "2020-09-03T11:30:29.501018Z",
     "shell.execute_reply": "2020-09-03T11:30:29.499543Z",
     "shell.execute_reply.started": "2020-09-03T11:30:29.108261Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7682 liter\n",
      "49163.084467227694 pound\n"
     ]
    }
   ],
   "source": [
    "print(vol_presente)\n",
    "print(m_total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verificando resultado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:42.589553Z",
     "start_time": "2020-09-03T11:40:42.390480Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:29.502935Z",
     "iopub.status.busy": "2020-09-03T11:30:29.502765Z",
     "iopub.status.idle": "2020-09-03T11:30:29.919236Z",
     "shell.execute_reply": "2020-09-03T11:30:29.918736Z",
     "shell.execute_reply.started": "2020-09-03T11:30:29.502916Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "20088.85927770859 liter"
      ],
      "text/latex": [
       "$20088.85927770859\\ \\mathrm{liter}$"
      ],
      "text/plain": [
       "20088.85927770859 <Unit('liter')>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volume_abastecer_implementacao3(vol_presente, m_total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ótimo! Resposta correta. Agora o usuário pode passar os parâmetros em qualquer sistema de unidade que o `pint` cuidará internamente de converter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas ainda não estamos numa implementação ideal... \n",
    "\n",
    "Imagine um programa real. Em um código real, essa seria apenas mais uma das dezenas de funções presentes no programa. Haveria ainda classes, outros módulos. Enfim, todo um universo de código a ser mantido. Muito provavelmente outras partes desse código também lidariam com quantidades físicas. Imagine em cada função ou método ficar verificando se o tipo correto foi passado para a função/método? Seria muita repetição de código com uma mesma funcionalidade, algo que é [interessante evitar](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself).\n",
    "\n",
    "Sendo um pacote desenvolvido para lidar com unidades e que tem uma comunidade bem ativa no desenvolvimento, certamente que alguém já pensou em resolver esse tipo de problema. Para isso, existe o `wraps`.\n",
    "\n",
    "O `wraps` é um [*decorator*](https://docs.python.org/3/glossary.html#term-decorator). O conceito de decorator provê uma maneira simples de modificar o comportamento de uma função sem necessariamente alterá-la. Nada mais é que um método para envolver (*wrap* em inglês) uma função, modificando seu comportamento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No caso, o `wraps` recebe dois parâmetros em forma de tupla. O primeiro se refere às unidades do retorno da função envolvida e o segundo às unidades dos parâmetros da dita função. Assim, nossa nova implementação passa a ser:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:42.781576Z",
     "start_time": "2020-09-03T11:40:42.595374Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:29.920521Z",
     "iopub.status.busy": "2020-09-03T11:30:29.920334Z",
     "iopub.status.idle": "2020-09-03T11:30:30.389957Z",
     "shell.execute_reply": "2020-09-03T11:30:30.387949Z",
     "shell.execute_reply.started": "2020-09-03T11:30:29.920503Z"
    }
   },
   "outputs": [],
   "source": [
    "@ureg.wraps(('l'), ('l', 'kg', 'kg/l'))\n",
    "def volume_abastecer(volume_presente, massa_total, densidade_combustivel=Q_('0.803 kg/l')):\n",
    "    '''Retorna o volume de combustível que deve abastercer o avião.\n",
    "    \n",
    "    Parâmetros\n",
    "    ----------\n",
    "    volume_presente: pint.Quantity, espera-se valor em litro\n",
    "    massa_total: pint.Quantity, espera-se valor em quilograma\n",
    "    densidade_combustível: pint.Quantity, por padrão '0.803 kg/l`    \n",
    "    \n",
    "    Retorno\n",
    "    -------\n",
    "    volume a reabastecer: pint.Quantity, valor em litros\n",
    "    '''\n",
    "    \n",
    "    massa_presente = volume_presente * densidade_combustivel\n",
    "    massa_abastecer = massa_total - massa_presente\n",
    "    \n",
    "    return massa_abastecer / densidade_combustivel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare nas modificações feitas: retirada da verificação `isinstance` e retirada do `to_reduced_units`. A primeira modificação se deve ao fato de que agora o `wraps` cuida da verificação. A segunda, se deve ao fato de que apenas valores (magnitudes) são passadas para dentro da função. As unidades são verificadas anteriormente, retiradas, as contas são feitas e as unidades são aplicadas ao retorno. [Isso melhora a perfomance](https://pint.readthedocs.io/en/stable/performance.html) do programa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos verificar o comportamento quando são passados valores sem unidades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:40:42.958579Z",
     "start_time": "2020-09-03T11:40:42.783048Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:30.392957Z",
     "iopub.status.busy": "2020-09-03T11:30:30.392350Z",
     "iopub.status.idle": "2020-09-03T11:30:31.259605Z",
     "shell.execute_reply": "2020-09-03T11:30:31.258695Z",
     "shell.execute_reply.started": "2020-09-03T11:30:30.392885Z"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "A wrapped function using strict=True requires quantity or a string for all arguments with not None units. (error found for l, 7682)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-52-98280d6f7137>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvolume_abastecer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m7682\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m22300\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/Dropbox/work/cienciaprogramada/code/pint/.venv/lib/python3.8/site-packages/pint/registry_helpers.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*values, **kw)\u001b[0m\n\u001b[1;32m    263\u001b[0m             \u001b[0;31m# In principle, the values are used as is\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    264\u001b[0m             \u001b[0;31m# When then extract the magnitudes when needed.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 265\u001b[0;31m             \u001b[0mnew_values\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalues_by_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconverter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mureg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstrict\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    266\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    267\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mnew_values\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Dropbox/work/cienciaprogramada/code/pint/.venv/lib/python3.8/site-packages/pint/registry_helpers.py\u001b[0m in \u001b[0;36m_converter\u001b[0;34m(ureg, values, strict)\u001b[0m\n\u001b[1;32m    147\u001b[0m                         )\n\u001b[1;32m    148\u001b[0m                     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 149\u001b[0;31m                         raise ValueError(\n\u001b[0m\u001b[1;32m    150\u001b[0m                             \u001b[0;34m\"A wrapped function using strict=True requires \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    151\u001b[0m                             \u001b[0;34m\"quantity or a string for all arguments with not None units. \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: A wrapped function using strict=True requires quantity or a string for all arguments with not None units. (error found for l, 7682)"
     ]
    }
   ],
   "source": [
    "volume_abastecer(7682, 22300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ótimo, apresentou erro, comportamento que desejamos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos verificar o comportamento passando quantidades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:02.250543Z",
     "start_time": "2020-09-03T11:41:02.247137Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:42.085490Z",
     "iopub.status.busy": "2020-09-03T11:30:42.085311Z",
     "iopub.status.idle": "2020-09-03T11:30:42.088848Z",
     "shell.execute_reply": "2020-09-03T11:30:42.088012Z",
     "shell.execute_reply.started": "2020-09-03T11:30:42.085453Z"
    }
   },
   "outputs": [],
   "source": [
    "vol_presente = Q_('7682 l')\n",
    "m_total = Q_('22300 kg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:02.402084Z",
     "start_time": "2020-09-03T11:41:02.252426Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:42.089875Z",
     "iopub.status.busy": "2020-09-03T11:30:42.089740Z",
     "iopub.status.idle": "2020-09-03T11:30:42.500664Z",
     "shell.execute_reply": "2020-09-03T11:30:42.498347Z",
     "shell.execute_reply.started": "2020-09-03T11:30:42.089859Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "20088.85927770858 liter"
      ],
      "text/latex": [
       "$20088.85927770858\\ \\mathrm{liter}$"
      ],
      "text/plain": [
       "20088.85927770858 <Unit('liter')>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volume_abastecer(vol_presente, m_total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show, resultado esperado novamente. Por fim, vamos verificar o que ocorre com essa nova versão quando se passa um parâmetro em outro sistema de unidade."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:02.565532Z",
     "start_time": "2020-09-03T11:41:02.404432Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:42.505276Z",
     "iopub.status.busy": "2020-09-03T11:30:42.504679Z",
     "iopub.status.idle": "2020-09-03T11:30:42.746341Z",
     "shell.execute_reply": "2020-09-03T11:30:42.745647Z",
     "shell.execute_reply.started": "2020-09-03T11:30:42.505207Z"
    }
   },
   "outputs": [],
   "source": [
    "m_total.ito('lb')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:02.738459Z",
     "start_time": "2020-09-03T11:41:02.570000Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:42.748054Z",
     "iopub.status.busy": "2020-09-03T11:30:42.747778Z",
     "iopub.status.idle": "2020-09-03T11:30:43.005792Z",
     "shell.execute_reply": "2020-09-03T11:30:43.003366Z",
     "shell.execute_reply.started": "2020-09-03T11:30:42.748013Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "49163.084467227694 pound"
      ],
      "text/latex": [
       "$49163.084467227694\\ \\mathrm{pound}$"
      ],
      "text/plain": [
       "49163.084467227694 <Unit('pound')>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m_total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:02.916870Z",
     "start_time": "2020-09-03T11:41:02.740529Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:43.008907Z",
     "iopub.status.busy": "2020-09-03T11:30:43.008341Z",
     "iopub.status.idle": "2020-09-03T11:30:43.261821Z",
     "shell.execute_reply": "2020-09-03T11:30:43.261192Z",
     "shell.execute_reply.started": "2020-09-03T11:30:43.008834Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "20088.85927770858 liter"
      ],
      "text/latex": [
       "$20088.85927770858\\ \\mathrm{liter}$"
      ],
      "text/plain": [
       "20088.85927770858 <Unit('liter')>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volume_abastecer(vol_presente, m_total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ótimo!! Agora temos nossa função implementada com as melhores práticas e mais segura de ser utilizada."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Melhorando a aparência do resultado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último, mas não menos importante, vejamos como melhorar o aspecto de nossa resposta. No contexto em que estamos, abastecimento de um avião com milhares de litros de combustível, certamente qualquer casa decimal pode ser desconsiderada. Afinal, como vimos no [artigo](https://cienciaprogramada.com.br/2020/08/erro-conversao-unidade-derruba-aviao/), usualmente os valores são arredondados. Primeiro, vamos armazenar o resultado em uma variável:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:03.076893Z",
     "start_time": "2020-09-03T11:41:02.921339Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:43.262759Z",
     "iopub.status.busy": "2020-09-03T11:30:43.262590Z",
     "iopub.status.idle": "2020-09-03T11:30:43.699570Z",
     "shell.execute_reply": "2020-09-03T11:30:43.698976Z",
     "shell.execute_reply.started": "2020-09-03T11:30:43.262741Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "20088.85927770858 liter"
      ],
      "text/latex": [
       "$20088.85927770858\\ \\mathrm{liter}$"
      ],
      "text/plain": [
       "20088.85927770858 <Unit('liter')>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volume = volume_abastecer(vol_presente, m_total)\n",
    "volume"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As formatações disponíveis para f-strings funcionam com o `pint`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:03.214642Z",
     "start_time": "2020-09-03T11:41:03.081408Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:43.700508Z",
     "iopub.status.busy": "2020-09-03T11:30:43.700306Z",
     "iopub.status.idle": "2020-09-03T11:30:44.153741Z",
     "shell.execute_reply": "2020-09-03T11:30:44.151825Z",
     "shell.execute_reply.started": "2020-09-03T11:30:43.700480Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20088.86 liter\n"
     ]
    }
   ],
   "source": [
    "print(f'{volume:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:03.378555Z",
     "start_time": "2020-09-03T11:41:03.216219Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:44.160173Z",
     "iopub.status.busy": "2020-09-03T11:30:44.159566Z",
     "iopub.status.idle": "2020-09-03T11:30:44.656429Z",
     "shell.execute_reply": "2020-09-03T11:30:44.655847Z",
     "shell.execute_reply.started": "2020-09-03T11:30:44.160103Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20089 liter\n"
     ]
    }
   ],
   "source": [
    "print(f'{volume:.0f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:03.585895Z",
     "start_time": "2020-09-03T11:41:03.379741Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:44.657389Z",
     "iopub.status.busy": "2020-09-03T11:30:44.657209Z",
     "iopub.status.idle": "2020-09-03T11:30:44.924513Z",
     "shell.execute_reply": "2020-09-03T11:30:44.922145Z",
     "shell.execute_reply.started": "2020-09-03T11:30:44.657371Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2e+04 liter\n"
     ]
    }
   ],
   "source": [
    "print(f'{volume:.0e}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:03.749478Z",
     "start_time": "2020-09-03T11:41:03.588043Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:44.928057Z",
     "iopub.status.busy": "2020-09-03T11:30:44.927275Z",
     "iopub.status.idle": "2020-09-03T11:30:45.456619Z",
     "shell.execute_reply": "2020-09-03T11:30:45.454907Z",
     "shell.execute_reply.started": "2020-09-03T11:30:44.927977Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.01e+04 liter\n"
     ]
    }
   ],
   "source": [
    "print(f'{volume:.2e}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma formatação mais visual, com os símbolos das unidades e potências de 10 (quando existentes), pode ser obtida com `~P`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:03.969108Z",
     "start_time": "2020-09-03T11:41:03.751792Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:45.457528Z",
     "iopub.status.busy": "2020-09-03T11:30:45.457331Z",
     "iopub.status.idle": "2020-09-03T11:30:45.805278Z",
     "shell.execute_reply": "2020-09-03T11:30:45.804652Z",
     "shell.execute_reply.started": "2020-09-03T11:30:45.457495Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.01×10⁴ l\n"
     ]
    }
   ],
   "source": [
    "print(f'{volume:.2e~P}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em algumas situações, podemos querer exportar o resultado para utilizar em algum documento. E, em ciências e engenharias, usamos muito [LaTeX](https://en.wikipedia.org/wiki/LaTeX). Assim, podemos expressar o resultado em código LaTeX:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:04.129100Z",
     "start_time": "2020-09-03T11:41:03.973766Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:45.806230Z",
     "iopub.status.busy": "2020-09-03T11:30:45.806034Z",
     "iopub.status.idle": "2020-09-03T11:30:46.012559Z",
     "shell.execute_reply": "2020-09-03T11:30:46.012013Z",
     "shell.execute_reply.started": "2020-09-03T11:30:45.806204Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.01\\times 10^{4}\\ \\mathrm{l}\n"
     ]
    }
   ],
   "source": [
    "print(f'{volume:.2e~L}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usuários do pacote `siunitx` do LaTeX ficarão felizes sabendo que é possível exportar com a sintaxe do pacote:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:04.335543Z",
     "start_time": "2020-09-03T11:41:04.130259Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:46.013620Z",
     "iopub.status.busy": "2020-09-03T11:30:46.013439Z",
     "iopub.status.idle": "2020-09-03T11:30:46.230468Z",
     "shell.execute_reply": "2020-09-03T11:30:46.229871Z",
     "shell.execute_reply.started": "2020-09-03T11:30:46.013596Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\SI[]{2.01e+04}{\\liter}\n"
     ]
    }
   ],
   "source": [
    "print(f'{volume:.2e~Lx}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Caso você tenha o pacote [`babel`](http://babel.pocoo.org/en/latest/) instalado, pode ter até tradução das unidades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:04.525036Z",
     "start_time": "2020-09-03T11:41:04.336740Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:46.231131Z",
     "iopub.status.busy": "2020-09-03T11:30:46.231003Z",
     "iopub.status.idle": "2020-09-03T11:30:46.510874Z",
     "shell.execute_reply": "2020-09-03T11:30:46.510333Z",
     "shell.execute_reply.started": "2020-09-03T11:30:46.231115Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'20088.85927770858 litros'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volume.format_babel(locale='pt_BR')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-03T11:41:04.667023Z",
     "start_time": "2020-09-03T11:41:04.526319Z"
    },
    "execution": {
     "iopub.execute_input": "2020-09-03T11:30:46.511704Z",
     "iopub.status.busy": "2020-09-03T11:30:46.511528Z",
     "iopub.status.idle": "2020-09-03T11:30:46.763958Z",
     "shell.execute_reply": "2020-09-03T11:30:46.761665Z",
     "shell.execute_reply.started": "2020-09-03T11:30:46.511687Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5.0 metros por segundos'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reutilizando a velocidade_media definida lá no início do artigo\n",
    "velocidade_media.format_babel(locale='pt_BR')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Versões dos pacotes utilizados nesse documento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esse artigo foi escrito em um [Jupyter Notebook](https://jupyter.org/). O Jupyter Notebook é uma interfarce gráfica que permite a edição de notebooks em um navegador web, tais como Google Chrome ou Firefox. Notebooks são documentos virtuais que permitem a execução de códigos juntamente com ferramentas para edição de textos; ou seja, além das rotinas usuais de programação, o usuário pode documentar todo o processo de produção do código. Exatamente como foi feito aqui, texto explicando cada trecho de código. Dessa forma, o notebook permite uma maneira interativa de programar. Também permite uma programação mais dinâmica, oferecendo ao usuário o output imediato do código; não havendo, assim, a necessidade de compilar ou executar todo o documento.\n",
    "\n",
    "Já escrevi [aqui no site sobre o Projeto Anaconda](https://cienciaprogramada.com.br/2020/08/instalando-o-anaconda-em-linux/). Ao se instalar o Anaconda, os programas Jupyter Notebook e JupyterLab são instalados. Ambos permitem interagir com Notebooks.\n",
    "\n",
    "É sempre importante sabermos as versões de cada pacote que utilizamos, pois algumas funcionalidades podem mudar com o tempo, durante o avanço do desenvolvimento de cada projeto. O [pacote version_information](https://github.com/jrjohansson/version_information) ajuda essa verificação em Jupyter Notebooks mas infelizmente não é compatível no momento com o Python 3.8. Listo a seguir as informações de versões relevantes utilizadas ao escrever esse notebook:\n",
    "\n",
    "- Python 3.8.5\n",
    "- IPython 7.18.1\n",
    "- pint 0.15\n",
    "- babel 2.8.0\n",
    "- notebook gerado em um Linux Mint 20 com kernel Linux 5.4.0 45 generic x86_64 with glibc2.29\n",
    "\n",
    "O Notebook está [neste meu repositório do GitHub](https://github.com/Ciencia-Programada/pint-examples). No mesmo repositório também estão os arquivos Pipfile que permitem que você crie um ambiente virtual exatamente igual ao que criei para escrever esse artigo e os códigos exibidos. Caso queira saber mais sobre ambientes virtuais, como criá-los do zero e a partir de arquivos como os Pipfile, [leia esse artigo](https://cienciaprogramada.com.br/2020/08/ambiente-virtual-projeto-python/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusão"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É aí, curtiu? É um pacote bem poderoso e ainda nem vimos metade de suas funcionalidades! Mas espero que tenha percebido que não há mais desculpas para fazer códigos que envolvam quantidades físicas sem considerar suas unidades.\n",
    "\n",
    "No próximo artigo do site irei explorar mais aspectos da utilização do `pint`. Afinal, como utilizá-lo com listas de valores? Arrays? Combinado com o pacote mais utilizado em ciências, o `numpy`? E como utilizar quando há incertezas associadas aos valores? E em gráficos? Se quiser saber, nos acompanhe nas redes sociais, sempre aviso quando há novos artigos no site.\n",
    "\n",
    "Até a próxima!"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "pint",
   "language": "python",
   "name": "pint"
  },
  "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "toc-showtags": false,
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}