aulas/aula1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center>Introdução à Lógica de Programação</center>\n",
    "###  <center>Um curso prático para estudantes das Ciências da Vida</center>\n",
    "---\n",
    "## <center>Aula 1. Primeiros Passos</center>\n",
    "##### <center>Instrutor: <a href=\"https://pedrosiracusa.github.io\" target=\"_blank\">Pedro C. de Siracusa</a></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O que é programar?\n",
    "\n",
    "Programar é como brincar com *LEGO*. Seguindo esta analogia, o trabalho do **programador** é construir estruturas complexas (como um castelo) encaixando blocos. \n",
    "Ele projeta as funcionalidades que deseja criar e planeja um passo-a-passo para chegar ate elas, partindo do pressuposto de que um conjunto de blocos fundamentais já estarão disponíveis para ele. \n",
    "O conjunto de blocos fundamentais disponíveis para o programador é o que constituiria uma **linguagem de programação**. Em termos gerais ela reúne conjuntos de regras e estruturas que permitem que o programador expresse suas ideias na forma de **código**. Escrever código seria como encaixar blocos. Sendo assim, o programador não precisa se preocupar em construir os blocos do zero antes de começar a trabalhar.\n",
    "\n",
    "<img src=\"img/lego_programming.png\" >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste curso você trabalhará com a linguagem [*Python*](https://www.python.org/), uma linguagem de **propósito geral** que oferece **alto nível** de abstração. Isso faz de *Python* uma excelente primeira linguagem a ser aprendida, pois *(i)* você poderá aplicar seus novos conhecimentos em programação a vários projetos e contextos diferentes; e *(ii)* você trabalhará projetando suas ideias, sem ter que se preocupar com os mínimos detalhes sobre como seu código funciona.\n",
    "\n",
    "Um componente fundamental da linguagem *Python* que nos permite **executar** o código que escrevemos é o **interpretador**.\n",
    "No fundo, o interpretador é um programa que executa programas! Ele lê as instruções que escrevemos na forma de código e as executa logo em seguida, sem antes precisar traduzi-lo para código de máquina. Quer ver um exemplo?\n",
    "\n",
    "Vamos começar construindo o [programa \"Hello World\"](https://www.wikiwand.com/en/%22Hello,_World!%22_program), uma tradição bem conhecida entre os programadores quando estão aprendendo uma linguagem nova.\n",
    "Este pequeno programa é encarado como um primeiro teste, e simplesmente imprime uma mensagem com o texto *\"Hello World\"* no console.\n",
    "Escrever o programa \"Hello World em *Python* é realmente muito simples. Veja na célula abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O que fizemos foi simplesmente executar uma **função**, que já faz todo o \"trabalho sujo\" para nós. Esta função, que se chama `print`, recebe um texto como **argumento**, entre parênteses, e o imprime no console. No caso, o texto que passamos é `\"Hello World\"`. As aspas envolvendo o texto servem para dizer ao interpretador que estamos construindo uma *string* (o tipo de dado que usamos para representar texto)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por enquanto vamos focar no uso mais básico do interpretador *Python*, operando valores numéricos apenas.\n",
    "Nesta aula vamos aprender a usar o interpretador como uma calculadora um pouco mais elaborada. \n",
    "No fim você codificará um modelo de crescimento exponencial para estimar o tamanho populacional em uma cultura bacteriana."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objetivos. \n",
    "Após esta aula você deverá ser capaz de: \n",
    "\n",
    "* Reconhecer os principais **operadores numéricos**;\n",
    "* Construir e computar **expressões** matemáticas;\n",
    "* Armazenar e consultar resultados de computações em **variáveis**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Tipos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tipos** são abstrações fundamentais nas linguagens de programação que nos permitem representar elementos de informação. Cada linguagem possui um conjunto de *tipos primitivos* (ou fundamentais), a partir dos quais o programador pode construir *tipos compostos*.\n",
    "Por enquanto vamos conhecer alguns dos tipos primitivos, que já vêm definidos na linguagem *Python*:\n",
    "\n",
    "* Tipos **numéricos**:\n",
    " * **Integer** (inteiros): Permite representar números inteiros, por exemplo `4`.\n",
    " * **Float** (ponto flutuante): Permite representar números com parte fracionária, por exemplo `42.5`.\n",
    "\n",
    "* **String**: Permite representar informação na forma de texto, por exemplo `\"Palavra\"` ou `\"C\"`. Usamos aspas (duplas ou simples) para representar informação textual. Em muitas outras linguagens de programação existe também o tipo caractere (ou char). Porém, em *Python* um caractere é uma string de comprimento 1.\n",
    "\n",
    "* **Boolean**: Representa informação em lógica binária, `True` ou `False`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42 <class 'int'>\n",
      "42.5 <class 'float'>\n",
      "Palavra <class 'str'>\n",
      "C <class 'str'>\n",
      "True <class 'bool'>\n",
      "False <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(42, type(42))\n",
    "print(42.5, type(42.5))\n",
    "print(\"Palavra\", type(\"Palavra\"))\n",
    "print('C', type('C'))\n",
    "print(True, type(True))\n",
    "print(False, type(False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja os [tipos nativos](https://docs.python.org/3/library/stdtypes.html#built-in-types) da linguagem *Python*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Operadores e expressões"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Operadores** são os símbolos que especificam as computações mais fundamentais, como por exemplo soma, subtração, multiplicação e divisão. Sempre que aplicamos um operador sobre dois operandos, esperamos obter algum resultado imediatamente. Podemos combinar vários operadores e operandos, construindo assim **expressões**. Veja na tabela abaixo os principais operadores numéricos da linguagem *Python*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Operação| Operador| Exemplo | Resultado\n",
    "|:-|---|-:|--|\n",
    "| Soma      | `+` | `9 + 7` | `16` |\n",
    "| Subtração | `-` | `9 - 7` | `2` |\n",
    "| Multiplicação | `*` | `9 * 7` | `63` |\n",
    "| Divisão | `/` | `5 / 2`| `2.5` | \n",
    "| Exponenciação | `**` | `9**2` | `81` |\n",
    "| Módulo | `%` | `9 % 2` | `1` |\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Experimente operar alguns números na célula abaixo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 + 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 - 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "256"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 % 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 % 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você também pode criar expressões combinando valores e operadores!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48.7"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 + 7 - 3/10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3*2 - 4%2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b style=\"color:red\">Cuidado!</b> A ordem de avaliação dos elementos em uma expressão segue a mesma convenção de precedência utilizada na matemática. Elementos entre parênteses têm prioridade durante a avaliação."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na célula abaixo, represente a seguinte expressão em código e obtenha seu resultado: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\frac{3+(3\\times5)}{2\\times(2+3)} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.8"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(3+(3*5))/(2*(2+3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Comentários**: Está vendo este `#` na primeira linha da célula acima? Linhas de código precedidas por este símbolo são comentários, que funcionam como mensagens a quem está lendo seu código, normalmente outros programadores. \n",
    "Qualquer coisa escrita na mesma linha **à direita** do símbolo é simplesmente ignorada pelo interpretador, ou seja, **não é executada**. \n",
    "É comum utilizar comentários para documentar partes de um código, ou marcar regiões que devem ser trabalhadas futuramente. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Variáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando estamos programando, frequentemente precisamos armazenar valores obtidos em etapas anteriores em memória.\n",
    "Assim, podemos re-utilizar estes valores sem precisar repetir todo o código.\n",
    "Linguagens de programação oferecem uma maneira bastante intuitiva para isso, por meio de **variáveis**.\n",
    "O símbolo que usamos para **atribuir** valores a variáveis é o sinal de igual (`=`). Na linguagem *Python*, uma variável é criada assim que atribuimos algum valor a ela.\n",
    "\n",
    "**obs:** O nome da variável sempre deve ser escrito à esquerda do símbolo `=`, e o valor a ser atribuído à variável, à direita."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por exemplo, podemos criar uma variável chamada `idade`, para armazenar sua idade. Assim, sempre que quisermos saber o valor atribuído a esta variável, basta escrever seu nome em uma célula e executá-la!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "idade = 29"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Declare uma variável chamada `semestre` que armazene o valor numérico do semestre que está cursando atualmente.\n",
    "Em seguida, escreva o nome da variável para obter seu valor. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "semestre = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "semestre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando lidamos com expressões grandes e complexas pode ser interessante quebrá-las em várias sub-expressões. Veja o seguinte exemplo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ 2 \\bigg[ \\frac{3\\times(2+5)-20}{3} \\bigg]^2 + \\sqrt 2 + 1  $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para facilitar a codificação desta expressão, vamos escrevê-la nas seguintes etapas:\n",
    "\n",
    "1. Atribua o resultado de $\\frac{3\\times(2+5)-20}{3}$ a uma variável de nome `a`.\n",
    "2. Atribua o resultado de $\\sqrt{2}+1$ a uma variável de nome `b`. Lembrando que $\\sqrt{2} = 2^{\\frac{1}{2}}$\n",
    "3. Agora, compute o resultado da expressão inteira usando as variáveis que você acabou de criar. $2a^2 + b$ e atribua o resultado a uma variável de nome `c`.\n",
    "4. Por fim, imprima no console o valor da variável `c`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.6364357845953172"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = (3*(2+5)-20)/3\n",
    "b = 2**(1/2) + 1\n",
    "c = 2*a**2 + b\n",
    "\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercícios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 1.** Associe o resultado da expressão $2(10+1) + \\frac{8}{3+1}$ a uma variável de nome `a`. \n",
    "Em seguida, associe à mesma variável o valor $5$ e imprima seu valor no console, usando a função `print`.\n",
    "Qual valor será mostrado? E se você quisesse imprimir o resultado do primeiro valor que a variável recebeu? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Primeiro valor de a: 24.0\n",
      "Segundo valor de a: 5\n"
     ]
    }
   ],
   "source": [
    "a = 2*(10+1) + (8/(3+1))\n",
    "print(\"Primeiro valor de a:\",a)\n",
    "a = 5\n",
    "print(\"Segundo valor de a:\",a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 2.** Veja na célula abaixo a codificação da expressão $\\sqrt{\\frac{3(3+5)}{5+1}}$. Execute a célula e observe o resultado. O valor está correto? Caso não esteja, como corrigir a expressão?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "( 3*(3+5) / (5+1) )**(1/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 3.** Para valores de $x$ em $\\{ 1,5,8, 9\\}$, compute o valor da função $\\quad{}f(x) = \\beta_0 + \\beta_1 x \\quad{}$, com parâmetros $\\beta_0 = -1.3$ e $\\beta_1=3.5$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1 -> f(x) = 2.2\n",
      "x = 5 -> f(x) = 16.2\n",
      "x = 8 -> f(x) = 26.7\n",
      "x = 9 -> f(x) = 30.2\n"
     ]
    }
   ],
   "source": [
    "# Crie as variáveis b0 e b1\n",
    "b0=-1.3\n",
    "b1=3.5\n",
    "\n",
    "# Para cada print, armazene os valores de x e f(x) nas variáveis x e f_x \n",
    "x = 1\n",
    "f_x = b0+b1*x\n",
    "print(\"x = 1 -> f(x) =\", f_x ) # res. esperado: 2.2\n",
    "\n",
    "x = 5\n",
    "f_x = b0+b1*x\n",
    "print(\"x = 5 -> f(x) =\", f_x ) # res. esperado: 16.2\n",
    "\n",
    "x = 8\n",
    "f_x = b0+b1*x\n",
    "print(\"x = 8 -> f(x) =\", f_x ) # res. esperado: 26.7\n",
    "\n",
    "x = 9\n",
    "f_x = b0+b1*x\n",
    "print(\"x = 9 -> f(x) =\", f_x ) # res. esperado: 30.2"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}