02 - Variáveis + Entrada e Saída.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5950f75a",
   "metadata": {},
   "source": [
    "# Introdução à Programação para Ciência de Dados\n",
    "\n",
    "### Aula 2:  Variáveis + Entrada e Saída\n",
    "\n",
    "**Professor:** Igor Malheiros"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee3252da",
   "metadata": {},
   "source": [
    "## Elementos de um Sistema\n",
    "\n",
    "O modelo mais simples para o desenvolvimento de sistemas é o IPO Model, input-process-output. Como o nome já sugere, nesse modelo de criação de software existem três componentes fundamentais utilizadas, a **entrada** de dados, o **processamento** de dados e a **saída** de dados. Nós utilizaremos o modelo IPO para facilitar um primeiro entendimento do funcionamento dos programas em Python.\n",
    "\n",
    " ### Entrada de dados\n",
    " \n",
    "São os dados requeridos pelo sistema. O usuário deve entrar com esses dados para obter algum resultado. Por exemplo, quando escolhemos um *destino de viagem* no Uber, um *pedido* no Ifood, quais *palavras* desejamos buscar no Google, um *arquivo* para anexar ao e-mail ou uma *foto*/*vídeo* no Instagram.\n",
    "     \n",
    "### Processamento de dados\n",
    "\n",
    "É o conjunto de operações, modificações, cálculos e análises que são realizados sobre o conjunto de dados (geralmente vindos do processo de entrada). Por exemplo, o *cálculo* de custo de viagem no Uber, a *checagem* de disponibilidade do pedido do Ifood, a *busca* do que e em qual ordem os resultados do Google são apresentados ou a *verificação* se o sua foto/vídeo não é impróprio para o Instagram.\n",
    "\n",
    "### Saída de dados\n",
    "\n",
    "É a apresentação de dados do sistema para o usuário. Por exemplo, a *notificação* da chegada do motorista no Uber, o *aviso* de confirmação do pedido no Ifood, a *apresentação* da lista de endereços no Google ou a *exibição* fotos/vídeos de outros usuários no Instagram.\n",
    " \n",
    "## Comandos\n",
    "\n",
    "As etapas de um programa é feita por meio do uso de **comandos** que o programador específica o que deseja que o computador execute. Em outras palavras, um programa é feito por um conjunto ordenado de comandos descritos pelo desenvolvedor.\n",
    "\n",
    "Um comando é composto por elementos de programação, dentre os elementos podemos citar:\n",
    "\n",
    "- Variáveis: elementos que podem mudar seu valor/estado durante a execução do programa;\n",
    "\n",
    "- Constantes: elementos que não mudam seu valor/estado durante a execução do programa;\n",
    "\n",
    "- Operadores: elementos que realizam operações aritméticas ou lógicas nas variáveis e/ou constantes;\n",
    "\n",
    "- Condições: elementos que controlam se/quando certas partes do programa vão ser executadas;\n",
    "\n",
    "- Repetições: elementos que repetem partes do programa.\n",
    "\n",
    "\n",
    "## Variáveis\n",
    "\n",
    "As variáveis são locais de memórias que reservamos durante a execução de um programa para inserir informações do nosso interesse e usá-las em algum outro momento. Essa variável é identificada por um **nome** que é escolhido pelo programador. Para utilizarmos a informação armazenada nesse espaço reservado de memória, precisamos apenas digitar o nome dessa variável e pegarmos a informação armazenada. \n",
    "\n",
    "```Python\n",
    "x = 10\n",
    "\n",
    "# x é uma variável\n",
    "# = é um operador\n",
    "# 10 é uma constante\n",
    "\n",
    "\"\"\"\n",
    "Representação da memória do computador:\n",
    "\n",
    " ================\n",
    " |  |  |  |  |  |\n",
    " ================\n",
    " |  |  |10|  |  |\n",
    " ================\n",
    "        ^(x)\n",
    "\"\"\"\n",
    "```\n",
    "\n",
    "É importante destacar que em Python atribuir um valor em uma variável é feita pelo operador `=`. O operador `=` significa **atribuição** do valor na memória, não é o mesmo que igualdade lógica. Para igualdade nós vamos utilizar outro operador (próxima aula)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "19e1a5cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "# Atribuindo um valor numérico em uma variável\n",
    "x = 100\n",
    "y = 20\n",
    "x = y\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6dba6f80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oi'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Atribuindo um valor de texto em uma variável\n",
    "y = \"oi\"\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d0406394",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Re-atribuindo um valor numérico em uma variável\n",
    "x = 2\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b63a4e03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hi'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Re-atribuindo um valor de texto em uma variável que tinha valor numérico\n",
    "y = \"hi\"\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "229e25d1",
   "metadata": {},
   "source": [
    "```Python\n",
    "\"\"\"\n",
    "Representação da memória do computador:\n",
    "\n",
    " =====================         =====================\n",
    " |    |    |    |    |         |    |    |    |    |\n",
    " =====================    =>   =====================\n",
    " |    | 10 |    |\"oi\"|         |    | 50 |    |\"hi\"|\n",
    " =====================         =====================\n",
    "        ^(x)       ^(y)               ^(x)       ^(y)\n",
    "\"\"\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "869a26d8",
   "metadata": {},
   "source": [
    "O programador pode escolher quase qualquer nome para suas variáveis, as regras básicas são:\n",
    "\n",
    "- O nome de uma variável deve começar com letras ou *underscore* `_`;\n",
    "\n",
    "- O nome da variável pode conter dígitos, desde que não seja no começo do nome;\n",
    "\n",
    "- Variáveis são *case-sensitive*, ou seja, se temos as variáveis `nota`, `NOTA`, `Nota`, `NoTa` e `noTA`, cada uma representa uma posição de memória diferente;\n",
    "\n",
    "- Cada linguagem de programação possui um conjunto de palavras reservadas que possuem uma função própria. Essas palavras não podem ser utilizadas como nome de variáveis. Em Python temos:\n",
    "\n",
    "```Python\n",
    "\n",
    "and       as        assert     break\n",
    "class     continue  def        del\n",
    "elif      else      except     False\n",
    "finally   for       from       global\n",
    "if        import    in         is\n",
    "lambda    None      nonlocal   not\n",
    "or        pass      raise      return\n",
    "True      try       while      with\n",
    "yield\t\t\t\n",
    "```\n",
    "\n",
    "Dentre os desenvolvedores, existem algumas convenções e guias para a escolha de nomes de variáveis. Além disso, a comunidade de Python tem algumas regras próprias também.\n",
    "\n",
    "```Python\n",
    "\n",
    "# nomes das variáveis sempre com letras minúsculas\n",
    "Nota = 10 # não recomendado\n",
    "nota = 10 # recomendado\n",
    "\n",
    "Idade = 30 # não recomendado\n",
    "idade = 30 # recomendado\n",
    "\n",
    "# em caso de palavras compostas, conectar com o uso de underscore\n",
    "notafinal = 10  # não recomendado\n",
    "notaFinal = 10  # não recomendado\n",
    "nota_final = 10 # recomendado\n",
    "\n",
    "# palavras em inglês são mais recomendadas do que em português\n",
    "media = 7   # não recomendado\n",
    "average = 7 # recomendado\n",
    "\n",
    "nome = \"Carlos\" # não recomendado\n",
    "name = \"Carlos\" # recomendado\n",
    "\n",
    "# Os nomes de variáveis devem ser o mais significativo possível!!!\n",
    "\n",
    "x3112cmane = 10 # péssimo nome\n",
    "a = 10          # nome pouco significativo\n",
    "cost = 10       # nome significativo!\n",
    "\n",
    "b = \"Carlos\"     # nome pouco significativo\n",
    "names = \"Carlos\" # é significativo, mas não faz sentido ser no plural\n",
    "name = \"Carlos\"  # recomendado!\n",
    "```\n",
    "\n",
    "## Entrada de dados com `input()`\n",
    "\n",
    "Existem diversas formas para o programa ler dados de entrada. Por enquanto vamos nos restringir aos dados de entrada que serão lidos pelo o que será digitado por um usuário. Em breve estudaremos como ler arquivos de texto e arquivos `.csv`.\n",
    "\n",
    "Python é uma linguagem que já nos fornece uma função própria para a leitura de dados. A função `input()` vai ler tudo que o usuário digita até apertar *enter* e atribuir o texto em uma variável."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a8c10d1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "joao\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'joao'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# exemplo básico\n",
    "name = input()\n",
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b4f829d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite o seu nomeblabla\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'blabla'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# exemplo com uma mensagem intuitiva\n",
    "name = input(\"Digite o seu nome\")\n",
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b7caabf0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite sua idade25\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'25'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# exemplo com um número\n",
    "idade = input(\"Digite sua idade\")\n",
    "idade"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "241b0dde",
   "metadata": {},
   "source": [
    "## Saída de dados com `print()`\n",
    "\n",
    "Para a saída de dados também existem diversas formas. Mas por enquanto vamos nos restringir em apresentar os dados em texto. Em breve estudaremos como mostrar tabelas e figuras.\n",
    "\n",
    "Python é uma linguagem que já nos fornece uma função própria para a imprimir os dados. A função `print()` vai imprimir textos ou valores digitados pelo programador."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "da094fe4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "# imprimindo um número\n",
    "print(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "faca8990",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá\n"
     ]
    }
   ],
   "source": [
    "# imprimindo texto\n",
    "print(\"Olá\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "cfe5ec1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "# imprimindo uma variável numérica\n",
    "idade = 18\n",
    "print(idade)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "a4f3c45f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Carlos\n"
     ]
    }
   ],
   "source": [
    "# imprimindo uma variável de texto\n",
    "name = \"Carlos\"\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "bbfe1e4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sua idade eh:  18\n"
     ]
    }
   ],
   "source": [
    "# imprimindo número e texto\n",
    "print(\"Sua idade eh: \", 18)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "f31d6221",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18 70\n"
     ]
    }
   ],
   "source": [
    "# imprimindo variáveis numéricas\n",
    "idade = 18\n",
    "peso = 70\n",
    "print(idade, peso)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "5193c80a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Carlos 18\n"
     ]
    }
   ],
   "source": [
    "# imprimindo variáveis numéricas e variáveis de texto\n",
    "print(name, idade)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "926b93d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seu nome eh Carlos e a sua idade eh 18.5\n"
     ]
    }
   ],
   "source": [
    "# imprimindo texto, variáveis numéricas e variáveis de texto\n",
    "print(\"Seu nome eh\", name, \"e a sua idade eh\", (idade + 0.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7694e5ba",
   "metadata": {},
   "source": [
    "## Tratamento de erros\n",
    "\n",
    "Assim como a infinita capacidade de coisas que podemos fazer, a quantidade de erros que podem surgir também são infinitas. Porém, alguns erros são indicados pelo interpretador. Vejamos alguns exemplos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "34ff33e0",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (1621003048.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/tmp/ipykernel_31049/1621003048.py\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    3x = 10\u001b[0m\n\u001b[0m     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Variável com nome proibido\n",
    "3x = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "d81bdef4",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'altura' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_31049/1822455717.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# imprimir variável que não existe\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maltura\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'altura' is not defined"
     ]
    }
   ],
   "source": [
    "# imprimir variável que não existe\n",
    "print(altura)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "62654d64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python eh legal\n"
     ]
    }
   ],
   "source": [
    "# esquecer de fechar aspas\n",
    "print(\"Python eh legal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6d219a9",
   "metadata": {},
   "source": [
    "## Exercício\n",
    "\n",
    "Faça um programa que:\n",
    "- Pergunta e recebe o login de um usuário e guarda em uma variável\n",
    "- Pergunta e recebe o email de um usuário e guarda em uma variável\n",
    "- Pergunta e recebe a idade um usuário e guarda em uma variável\n",
    "- Imprime: `\"O usuário Fulano com e-mail meuemail@mail.com tem 18 anos\"`, onde `\"Fulano\"` estava na primeira variável, `\"meuemail@mail.com\"` na segunda variável e `18` na terceira variável."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "ffe43222",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite o seu login:Fulano\n",
      "Digite o seu email:meuemail@mail.com\n",
      "Digite a sua idade:18\n",
      "O usuário Fulano com e-mail meuemail@mail.com tem 18 anos\n"
     ]
    }
   ],
   "source": [
    "login = input(\"Digite o seu login:\")\n",
    "email = input(\"Digite o seu email:\")\n",
    "idade = input(\"Digite a sua idade:\")\n",
    "\n",
    "print(\"O usuário\", login, \"com e-mail\", email, \"tem\", idade, \"anos\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc90ff20",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}