Aula0_intro_var_oper.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "eb0c7b62",
   "metadata": {},
   "source": [
    "<img src=\"imgs/mesttra.png\" alt=\"mesttra_logo\" style=\"width: 200px;\"/>\n",
    "\n",
    "\n",
    "# Introdução\n",
    "___\n",
    "\n",
    "Python é uma linguagem interpretada de propósito geral criada em 1991. Ela foi criada por Guido Van Rossum, como um projeto de férias e o nome foi uma dedicatória ao show Monty Python.Ela é uma linguagem que valoriza a legibilidade do código por meio do uso de espaçamentos. Foi a segunda linguagem de programação mais usada em 2020 e mantem seu status em 2021 também é a principal linguagem utilizada pelos cientistas de dados.\n",
    "\n",
    "<img src=\"imgs/top_languages.png\" alt=\"linguagens_mais_usadas\" style=\"width: 600px;\"/>\n",
    "\n",
    "As principais ferramentas de análise de dados e machine learning possuem APIs em python, consequentemente, entender python, sua sintaxe e usabilidade é extremamente necessários para um cientista de dados. Algumas fas ferramentas mais utilizadas por cientistas de dados e que estão em python:\n",
    "\n",
    "* [Scikit-Learn](https://scikit-learn.org/stable/index.html) - Machine learning, algoritmos de pré-processamento de dados, extração de características, redução de dimensionalidade, algoritmos supervisionados e não supervisionados, métricas e funções para construção de pipelines.\n",
    "\n",
    "```python\n",
    "## exemplo de uma support vector machine para previsão de valores contínuos\n",
    "from sklearn import svm\n",
    "\n",
    "X = [[0, 0], [2, 2]]\n",
    "y = [0.5, 2.5]\n",
    "regr = svm.SVR()\n",
    "regr.fit(X, y)\n",
    "regr.predict([[1, 1]])\n",
    "\n",
    "```\n",
    "\n",
    "* [Pandas](https://pandas.pydata.org/) - Análise de dados, conjunto de funções para abertura de arquivos de diversas extensões (.csv,.json,.stata,.xlsx etc), funções para construção, junção, reformatação de dataframes e séries de dados. Habitualmente compara a ferramentas de trabalho com tabelas como o MS Excel.\n",
    "\n",
    "```python\n",
    "## exemplo de comando para leitura de um arquivo  com extensão .csv\n",
    "import pandas as pd\n",
    "\n",
    "alunos = \"arquivo.csv\"\n",
    "\n",
    "pd.read_csv(StringIO(data))\n",
    "\n",
    "  col1 col2  col3\n",
    "0    a    b     1\n",
    "1    a    b     2\n",
    "2    c    d     3\n",
    "\n",
    "```\n",
    "\n",
    "* [Numpy](https://numpy.org/) - Arrays e Matrizes, conjunto de funções para construção, manipulação e operações com arrays e matrizes, álgebra linear, operações estatísticas básicas, simulações de valores aleatórios, operações lógicas e matemáticas básicas.\n",
    "\n",
    "```python\n",
    "## exemplo da criação de um array\n",
    "\n",
    "import numpy as np\n",
    "a = np.arange(15).reshape(3, 5)\n",
    "a\n",
    "array([[ 0,  1,  2,  3,  4],\n",
    "       [ 5,  6,  7,  8,  9],\n",
    "       [10, 11, 12, 13, 14]])\n",
    "\n",
    "```\n",
    "* [Matplotlib](https://matplotlib.org/stable/index.html) - Gráficos, conjunto de funções para construção de gráficos dos mais variados tipos, funções para definição de estilo, texto, títulos, legendas e outros componentes acessários a um gráfico.\n",
    "\n",
    "```python\n",
    "## exemplo da criação de um gráfico de linha.\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "fig, ax = plt.subplots()  \n",
    "ax.plot([1, 2, 3, 4], [1, 4, 2, 3]) \n",
    "```\n",
    "![grafico](https://matplotlib.org/stable/_images/sphx_glr_usage_001.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "694e9f1a",
   "metadata": {},
   "source": [
    "# Lógica de Programação\n",
    "___\n",
    "\n",
    "A lógica de programação é a técnica de encadear pensamentos para atingir determinado objetivo. Ela é necessária para o desenvolvimento de sistemas, visto que, sistemas nada mais são do que ferramentas (escritas em numa linguagem de computador) que recebem instruções e executam tarefas. O encadeamento correto e lógico dessas tarefas irá gerar o resultado esperado de forma previsível e coesa. Por exemplo, para cozinhar uma batata é necessário uma série de instruções e atividades que fazemos de forma automática, porém em desenvolvimento devemos claramente descrever cada etapada do processo, isso é uma sequência lógica de instruções.\n",
    "\n",
    "1. Pegar 1 batata\n",
    "2. Pegar 1 panela\n",
    "3. Descascar a batata\n",
    "4. Colocar a batata na panela\n",
    "5. Encher a panela com água\n",
    "6. Colocar a panela no fogão\n",
    "7. Ligar o fogão em fogo alto\n",
    "8. Esperar 15 minutos\n",
    "9. Desligar o fogo\n",
    "10. Retirar a água da penela\n",
    "11. Retirar a batata cozida da panela\n",
    "\n",
    "Essa sequência finita de instruções é um **algoritmo**. Algoritmos não suportam redundâncias ou subjetividades, as tarefas devem ser claramente escritas e precisas naquilo que fazem. Em nossa alfabetização aprendemos uma sequência de tarefas que devem ser feitas para chegar em um resultado específico, por exemplo uma soma.\n",
    "\n",
    "#### Some dois números quaisquer\n",
    "\n",
    "* Escreva o primeiro número no retângulo A\n",
    "* Escreva o segundo número no retângulo B\n",
    "* Some o número do retângulo A com o número do retângulo B e coloque o resultado no retângulo C.\n",
    "\n",
    "![retangulos](imgs/retangulos.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f32018b",
   "metadata": {},
   "source": [
    "# Algoritmos\n",
    "\n",
    "Algoritmos resolvem problemas, entender logicamente esses problemas e planejar o algoritmo em três fases são o primeiro passo. Essas três fases são **ENTRADA**->**PROCESSAMENTO**->**SAÍDA**, por exemplo, um algoritmo que recebe(entrada) qualquer valor numérico (inteiro ou contínuo), cálcula o cubo desta entrada (processamento) e printa o resultado (saída)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "272a8426",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cubo(valor_numerico):\n",
    "    \n",
    "    resultado = valor_numerico ** 3\n",
    "    \n",
    "    print(resultado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "98a9e541",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n"
     ]
    }
   ],
   "source": [
    "cubo(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e37bd6d",
   "metadata": {},
   "source": [
    "A \"entrada\" são os dados de entrada do algoritmo, esses dados de entrada podem valores inteiro, contínuos (flutuantes), listas ou objetos mais complexos. Um carro autônomo pro exemplo tem um algoritmo que toma decisão de mudança de direção, a entrada desse algoritmo são imagens e dados dos diversos sensores.\n",
    "\n",
    "![carro_autonomo](https://static01.nyt.com/images/2017/05/26/business/26wheels-top/26wheels-top-articleLarge-v2.gif?quality=75&auto=webp&disable=upscale)\n",
    "\n",
    "Representação dos dados de LIDAR de um carro autônomo.\n",
    "\n",
    "O \"processamento\" são os procedimentos utilizados para chegar até o resultado final. Aqui temos todas as operações e passos lógicos para chegarmos no resultado esperado. No processamento utilizamos técnicas matemáticas, estatísticas e computacionais para transformar a entrada na saída.\n",
    "\n",
    "<img src=\"https://i.pinimg.com/originals/04/8a/51/048a51831e45b04321af593612a04a16.gif\" alt=\"neural\" style=\"width: 600px;\"/>\n",
    "\n",
    "Uma rede neural efetuando o processamento de uma imagem para predição.\n",
    "\n",
    "A \"saída\" são os dados processados no formato do resultado esperado. Saídas podem ser textuais, numéricas, objetos e até mesmo imagens. No exemplo acima da rede neural a entrada é uma imagem, o processamento é feito através de técnicas de convolução e multiplicação de matrizes e a saída é uma classe (cachorro), que pode ser representada por um número ou por texto."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75bb1639",
   "metadata": {},
   "source": [
    "Podemos representar visualmente algoritmos através de uma notação padronizada. Ela nos ajudará a entender e planejar alguns algorimtos mais simples. É extremamente recomendável que, antes de qualquer trabalho, seja feita uma etapa de planejamento do algoritmo, suas entradas, saídas e etapas de processamento. Pergunte-se: o que espero como saída? quais são as entradas necessárias? quais etapas de processamento serão necessárias para chegar no resultado que espero? um algoritmo é suficiente? \n",
    "\n",
    "![notacao](imgs/notacao.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62a44895",
   "metadata": {},
   "source": [
    "Um algoritmo de cálcula a média de 4 notas de um determinada matéria, pode funcionar da seguinte forma.\n",
    "\n",
    "![](imgs/algoritmo.png)\n",
    "\n",
    "E em python esse algoritmo pode ser:\n",
    "\n",
    "```python\n",
    "\n",
    "def media_notas(n1,n2,n3,n4):\n",
    "    media = (n1+n2+n3+n4)/4\n",
    "    print(media)\n",
    "    \n",
    ">> media_notas(10,10,4,3)\n",
    ">> 6.75\n",
    "```\n",
    "\n",
    "Mas esse algoritmo também pode ser descrito em outras linguagens, javascript, por exemplo.\n",
    "\n",
    "```javascript\n",
    "function myFunction(n1, n2, n3, n4) {\n",
    "  return (n1+n2+n3+n4)/4; \n",
    "}\n",
    "\n",
    "console.log(myFunction(10,10,4,3))\n",
    "\n",
    "6.75\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "076fab98",
   "metadata": {},
   "source": [
    "O caminho mais comumente utilizado é a transformação da necessidade em linguagem natural (um texto), depois em diagrama (como o demonstrado acima), esse diagrama é então reescrito em uma linguagem de programação (human-readable) e assim na sua execução enviada para a unidade lógica em lingaguem de máquina (comandos binários). Python é uma linguagem interpretada, ou seja, os comandos são enviados a um interpretador que transforma a linguagem de programação padronizada em comandos que possam ser executados por unidades de processamento, isso torna o aprendizado de python bem fácil visto que sua sintaxe de escrita é simples e de fácil leitura."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce231d8c",
   "metadata": {},
   "source": [
    "# Python\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6de6e6bc",
   "metadata": {},
   "source": [
    "## Variáveis\n",
    "\n",
    "\n",
    "Variáveis são espaços na memória do computador que possuem valores acessáveis. Utilizamos um símbolo de igual ```=```, também chamado de símbolo de atribuição para criar variáveis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d67ce316",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5047966b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ab3fa50d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "17b34f04",
   "metadata": {},
   "outputs": [],
   "source": [
    "nome = 'João'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "26c84f9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "João\n"
     ]
    }
   ],
   "source": [
    "print(nome)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4eca55ec",
   "metadata": {},
   "source": [
    "É importante entender que o identificador é único e recebe somente um valor por vez, para criarmos conjuntos de valores foram criadas estruturas de dados (dicionários, arrays, listas, tuplas). Se usarmos um identificador mais de um vez ele terá seu valor sobreescrito pelo valor mais recente. Exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "cb695f39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "João\n"
     ]
    }
   ],
   "source": [
    "print(nome)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "bdec8cb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "nome = 'Nasser'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5a5cd299",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nasser\n"
     ]
    }
   ],
   "source": [
    "print('Nasser')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8608c8b9",
   "metadata": {},
   "source": [
    "Acima percebemos que a variável ```nome``` já existia com o valor ```João```, ao atribuirmos um novo valor a essa mesma variável, perdemos ```João``` e guardado na variável agora existe o valor ```Nasser```. É importante notar que o python executa as células de código numa ordenação de cima para baixo linha a linha."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d62e01c",
   "metadata": {},
   "source": [
    "```python\n",
    "idade = 30\n",
    "idade = 115\n",
    "idade = 10\n",
    "```\n",
    "\n",
    "Usando os conceitos vistos até então, qual seria o valor final na variável ```idade``` ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10e9c555",
   "metadata": {},
   "source": [
    "Variáveis são necessárias e ajudam a construir algoritmos mais dinâmicos e capazes de receberem valores diferentes e mesmo assim darem o mesmo resultado. A função ```cubo``` demonstrada nos exemplos da sessão anterior está preparada para receber qualquer valor e executar a operação de potência ao cubo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f9aa621a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n"
     ]
    }
   ],
   "source": [
    "cubo(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "52edc4a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8000\n"
     ]
    }
   ],
   "source": [
    "cubo(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dda1f929",
   "metadata": {},
   "source": [
    "Vale a pena notar que ao criar variáveis, seus identificadores (ou nomes) devem seguir algumas regras. As variáveis podem ter números e letras, porém não podemos iniciar o nome de variáveis com números e nem utilizar algumas palavras reservadas pelo sistema. A criação de identificadores também é sensível a caixa alta, sendo considerado diferentes identificadores escritos de formas diferentes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "bcc4815e",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid decimal literal (<ipython-input-25-c6798dc40ac0>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-25-c6798dc40ac0>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    12_idade_joao = 15\u001b[0m\n\u001b[0m      ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid decimal literal\n"
     ]
    }
   ],
   "source": [
    "12_idade_joao = 15"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85c7b730",
   "metadata": {},
   "source": [
    "Acima o erro de sintaxe demonstra que não podemos criar uma variável iniciando com o número 12."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e960313b",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-26-43275c85c0df>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-26-43275c85c0df>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    return = 15\u001b[0m\n\u001b[0m           ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "return = 15"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a986244",
   "metadata": {},
   "source": [
    "A palavra reservada ```return``` já descreve um comando nativo do python que não pode ser substituído e por isso não podemos utilizar esse identificador para criar uma variável. Segue uma lista de palavras reservadas em python.\n",
    "\n",
    "![palavras_reservadas](https://www.computersciencemaster.com.br/wp-content/uploads/2021/04/Palavras_reservadas.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01253955",
   "metadata": {},
   "source": [
    "## Tipos de dados\n",
    "\n",
    "As variáveis podem receber dados e objetos. Pode-se dividir os dados em 4 tipos diferentes, cada tipo de dado tem sua particularidade e pode ser utilizado em situações específicas. Todo código em python vai ter, em seu processamento, que lidar com esses tipos de dados, são eles:\n",
    "\n",
    "* string (str) - valores textuais, representados por aspas (simples ou duplas) ou criados através da função ```str()```\n",
    "* integer (int) - valores númericos inteiros, criados através da função ```int()```\n",
    "* float (float) - valores numéricos fracionários, também chamados de valores flutuantes, criados através da função ```float()```\n",
    "* boolean (bool) - valores booleanos, só assumem dois valores possíveis ```True``` e ```False```. Computacionalmente ```True``` pode ser representado pelo valor 1 e ```False``` por 0.\n",
    "\n",
    "\n",
    "É possível descrobrir o tipo de um dado usando a função ```type()```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0a328599",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## uma string\n",
    "\n",
    "x = 'Nasser'\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c729c471",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## um integer\n",
    "\n",
    "x = 150\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "abdac53f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## um float\n",
    "\n",
    "x = 3.75\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "0648e634",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## um boolean\n",
    "\n",
    "x = True\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2243ab2",
   "metadata": {},
   "source": [
    "É interessante notar que o simples fato de atribuirmos um valor a uma variável o tipo do dado já é reconhecido, ou seja, não há necessidade de declarar a variável ou o tipo de dados que será guardado."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d5093b5",
   "metadata": {},
   "source": [
    "## Operadores Aritiméticos\n",
    "\n",
    "Operações aritiméticas são necessárias para qualquer trabalho de processamento, utilizando variáveis podemos executar operações matemáticas de forma dinâmica. Esses são os operadores matemáticos utilizados em python.\n",
    "\n",
    "| Operador |            Ação            |\n",
    "|:--------:|:--------------------------:|\n",
    "|     -    |          subtração         |\n",
    "|     +    |           adição           |\n",
    "|     *    |        multiplicação       |\n",
    "|     %    |  módulo da divisão (resto) |\n",
    "|    **    |         potenciação        |\n",
    "|    +=    |      incremento (soma)     |\n",
    "|    *=    | incremento (multiplicação) |\n",
    "|    -=    |   decremento (subtração)   |\n",
    "\n",
    "Para utilizar qualquer uma das operações demonstradas acima, basta escrever o operador associado com as variáveis, bem similar a uma fórmula matemática comum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "cc7a750c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "56"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## subtração\n",
    "\n",
    "28 - 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "4026a632",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "56"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## adição\n",
    "\n",
    "28 + 28"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "7bcba454",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## multiplicação\n",
    "\n",
    "28 * 1.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "d0e81c43",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## módulo\n",
    "\n",
    "55 % 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "aa107c7a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## potências\n",
    "\n",
    "10**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "ab3ddb16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "## incremento\n",
    "\n",
    "x = 10\n",
    "x += 5\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "e7c011f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22.0\n"
     ]
    }
   ],
   "source": [
    "## incremento (multiplicação)\n",
    "\n",
    "x = 10\n",
    "x *= 2.2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "4a05ff4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.5\n"
     ]
    }
   ],
   "source": [
    "## decremento\n",
    "\n",
    "x = 10\n",
    "x -= 2.5\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b13638fa",
   "metadata": {},
   "source": [
    "### Exercício\n",
    "\n",
    "Usando as operações acima. Como podemos calcular o IMC de uma pessoa?\n",
    "\n",
    "[referência IMC](https://www.tuasaude.com/calculadora/imc/)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfe56d2f",
   "metadata": {},
   "source": [
    "### Exercício\n",
    "\n",
    "Tente executar operações com alguns tipos de dados diferentes em cada variável. Quais são possíveis e quais não são possíveis?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13d5ec59",
   "metadata": {},
   "source": [
    "## Entrada e Saída\n",
    "\n",
    "Em python podemos trabalhar com a entrada manual de dados através da função ```input()```. Ela recebe uma entrada do usuário (podendo ser texto ou valores numéricos) e retorna sempre uma string. Podemos guardar essa string resultante da entrada do usuário em uma variável.\n",
    "\n",
    "Além disso pode-se usar a função ```print()``` para imprimir o valor de uma variável no seu terminal de execução. Vale a pena notar que o resultado de um print é um tipo nulo e nunca pode ser guardado dentro de uma variável."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "af701cf6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Escreva seu nome: nasser\n"
     ]
    }
   ],
   "source": [
    "nome_do_cliente = input('Escreva seu nome:')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3fb08627",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nasser'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nome_do_cliente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "282642d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Escreva sua idade: 30\n"
     ]
    }
   ],
   "source": [
    "idade_do_cliente = input('Escreva sua idade:')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b05afcdc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(idade_do_cliente)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ad64808",
   "metadata": {},
   "source": [
    "Pelo fato da variável ```idade_do_cliente``` ter sido populada com o resultado da função ```input()``` o valor digitado pelo usuário foi transformado em string. Podemos forçar que o valor resultante seja um inteiro utilizando ```int()```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a0a5600b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Escreva sua idade: 30\n"
     ]
    }
   ],
   "source": [
    "idade_do_cliente = int(input('Escreva sua idade:'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3c0146de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(idade_do_cliente)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f498e36e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "print(idade_do_cliente)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7e7e8618",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "valor_print = print(idade_do_cliente)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9d7f1e4c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(valor_print)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a06118c6",
   "metadata": {},
   "source": [
    "Perceba que no exemplo acima, ao tentar guardar a saída da função ```print()``` em uma variável ela acaba vazia. A dica é utilizar a função ```print()``` para ter mensagens que possma ser lidas e marquem partes da execução importante do seu algoritmo ou que deem algum tipo de informação para quem está o rodando.\n",
    "\n",
    "Existe um recurso em python chamado de f-string, sua principal função é adicionar variáveis junto a texto de uma forma fácil. Esse recurso funciona muito bem com a função ```print()```, mas também pode ser utilizado em strings puras e até docstrings (strings de documentação).Para utiliza-la basta colocar a letra ```f``` antes de abrir as aspas de uma string e colocar a variável desejada entre ```{}``` (chaves)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e2624b27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A idade digitada foi 30 anos!\n"
     ]
    }
   ],
   "source": [
    "print(f'A idade digitada foi {idade_do_cliente} anos!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f42222a2",
   "metadata": {},
   "source": [
    "# Referências\n",
    "\n",
    "http://ftp.unicamp.br/pub/apoio/treinamentos/logica/logica.pdf"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}