{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "##
Introdução à Lógica de Programação
\n", "###
Um curso prático para estudantes das Ciências da Vida
\n", "---\n", "##
Aula 1. Primeiros Passos
\n", "#####
Instrutor: Pedro C. de Siracusa
" ] }, { "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", "" ] }, { "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 \n", "42.5 \n", "Palavra \n", "C \n", "True \n", "False \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": [ "Cuidado! 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" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": false, "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 } }, "nbformat": 4, "nbformat_minor": 2 }