Aula_05.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Aula 05 - Sintaxe da Linguagem Python**\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O Zen do Python\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como dito em aulas anteriores, o Python foi construído para ser uma linguagem fácil e rápida de ser escrita.\n",
    "\n",
    "Como ocorre com vários produtos, sobretudo da área da tecnologia, o Python tem o que na Indústria é chamado de ***Easter Egg*** (Ovo de Páscoa, em inglês), que nada mais é do que um segredo escondido que apenas alguns conseguem encontrar. Esse _Easter Egg_, ao ser encontrado, revela toda a filosofia por trás do funcionamento do Python, que é chamado de **Zen do Python**. Para encontrá-lo, basta executar o código `import this`, que se encontra logo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A saída desse código é nada mais do que um poema com os mandamentos do Python. Segue abaixo a tradução desse poema:\n",
    "\n",
    "**O Zen do Python, de Tim Peters**\n",
    "\n",
    "_Bonito é melhor que feio. <br />\n",
    "Explícito é melhor que implícito. <br />\n",
    "Simples é melhor que complexo. <br />\n",
    "Complexo é melhor que complicado. <br />\n",
    "Plano é melhor que aninhado. <br />\n",
    "Esparso é melhor que denso. <br />\n",
    "A legibilidade conta. <br />\n",
    "Casos especiais não são especiais o suficiente para quebrar as regras. <br />\n",
    "Embora a praticidade supere a pureza. <br />\n",
    "Os erros nunca devem passar silenciosamente. <br />\n",
    "A menos que seja explicitamente silenciado. <br />\n",
    "Diante da ambiguidade, recuse a tentação de adivinhar. <br />\n",
    "Deveria haver uma - e de preferência apenas uma - maneira óbvia de fazer isso. <br />\n",
    "Embora essa forma possa não ser óbvia à primeira vista, a menos que você seja holandês. <br />\n",
    "Agora é melhor do que nunca. <br />\n",
    "Embora nunca seja melhor do que *agora*. <br />\n",
    "Se a implementação for difícil de explicar, é uma má ideia. <br />\n",
    "Se a implementação for fácil de explicar, pode ser uma boa ideia. <br />\n",
    "Namespaces são uma ótima ideia - vamos fazer mais deles!_ <br />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saída de dados do Python\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na aula anterior, vimos o comando `print('Olá, mundo!')`, que é utilizado para mostrar uma saída de dados da linguagem no console, que nesse caso foi a mensagem **Olá, mundo!**.\n",
    "\n",
    "Nas versões anteriores do Python, esse comando podia ser executado sem os parênteses, simplesmente executando `print 'Olá, mundo!'`, mas isso deixou de funcionar a partir do Python 3.x. O texto a ser exibido pode ser colocado entre aspas simples (') ou duplas (\"). Ou seja, o comando pode ser executado tanto com `print('Olá, mundo!')` como com `print(\"Olá, mundo!\")`. Em ambos os casos, irá funcionar perfeitamente. Repare que os comandos em Python nunca são finalizados com ponto e vírgula (;).\n",
    "\n",
    "O código com aspas simples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, mundo!\n"
     ]
    }
   ],
   "source": [
    "print('Olá, mundo!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O mesmo código com aspas duplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, mundo!\n"
     ]
    }
   ],
   "source": [
    "print(\"Olá, mundo!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comentários\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os comentários são pedaços de código que não são executados. Sua função é basicamente conter alguma informação sobre uma parte do código-fonte, auxiliando o programador a se lembrar daquela funcionalidade, ou ajudando um possível substituto a entender seu código e ajudá-lo a continuar o algoritmo. Em Python, o comentário de uma linha é feito usando o símbolo de serquilha/hashtag/jogo da velha/sustenido/sharp (#). Já os comentários de múltiplas linhas é iniciado com três aspas simples ou duplas (''') ou (\"\"\"), e finalizado também com 3 aspas (simples se tiver iniciado com simpels, ou duplas se tiver iniciado com duplas).\n",
    "\n",
    "### Exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Este é um exemplo de um comentário de uma linha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Este é um exemplo\n",
    "de um comentário\n",
    "de múltiplas linhas\n",
    "com aspas simples\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Este é um exemplo\n",
    "de um comentário\n",
    "de múltiplas linhas\n",
    "com aspas duplas\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Anchor/TODO Comments\n",
    "\n",
    "Alguns editores/IDEs podem identificar comentários específicos, que funcionam como âncoras ou marcadores no seu código-fonte. Esses comentários têm como objetivo indicar alguma observação mais específica em determinado trecho de código, como uma funcionalidade a ser acrescentada ou corrigida, por exemplo. São sempre escritos em caixa alta. Segue os exemplos mais usados abaixo:\n",
    "\n",
    "#### TODO\n",
    "\n",
    "Serve para marcar um trecho a fazer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: fazer esse trecho de código"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### FIXME\n",
    "\n",
    "Serve para marcar um trecho de código defeituoso, que está causando um _bug_ ou impede a execução do código, e que deve ser corrigido:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax. Perhaps you forgot a comma? (1914352591.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[9], line 2\u001b[1;36m\u001b[0m\n\u001b[1;33m    printar(texto para ser exibido);\u001b[0m\n\u001b[1;37m            ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax. Perhaps you forgot a comma?\n"
     ]
    }
   ],
   "source": [
    "# FIXME: corrija esse trecho de código\n",
    "printar(texto para ser exibido);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### REVIEW\n",
    "\n",
    "Serve para marcar um trecho para ser revisado. Normalmente o código aparentemente funciona, mas pode ser que esteja causando um _bug_ em outra parte do código, ou pode ser um algoritmo que pode ser melhorado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exibir\n",
      "este texto\n"
     ]
    }
   ],
   "source": [
    "# REVIEW: revise esse código\n",
    "texto1 = 'Exibir'\n",
    "texto2 = 'este texto'\n",
    "\n",
    "print(texto1)\n",
    "print(texto2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NOTE\n",
    "\n",
    "Serve para informar algum aviso importante sobre um trecho do código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Código rodado!\n"
     ]
    }
   ],
   "source": [
    "# NOTE: você pode executar esse código clicando no botão Executar do lado dessa célula, em formato de triângulo\n",
    "print('Código rodado!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variáveis\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Álgebra, aprendemos o conceito de **variável**, que nada mais é do que um valor, que como o próprio nome já diz, varia, e não podemos ter certeza de qual valor ele vai assumir. Geralmente são os valores dessas variáveis que queremos descobrir em uma equação matemática.\n",
    "\n",
    "Na programação usamos esse mesmo conceito para guardar um valor que iremos utilizar em algum momento dentro do nosso algorítmo, sendo que não sabemos com certeza que valor é esse, e que pode ser modificado no decorrer do nosso programa a qualquer momento.\n",
    "\n",
    "### Mas como esse valor é guardado?\n",
    "\n",
    "Imagine a seguinte situação: você quer fazer um jantar super romântico para a sua namorada para comemorar o aniversário de namoro, e para isso deseja levá-la naquele restaurante chiquérrimo, mas fora o valor a ser desembolsado, precisa garantir que, ao chegar lá, vai ter mesa disponível. Então o que você faz? Horas antes, liga para o restaurante e faz uma reserva de uma mesa para dois. Assim, quando você chegar com sua companhia no restaurante na hora marcada, a mesa vai estar disponível, mesmo com o lugar estando lotado.\n",
    "\n",
    "Trabalhar com variáveis em um programa funciona mais ou menos da mesma forma: ao se declarar uma variável em um programa, você ordena o seu computador fazer uma reserva de um endereço na memória RAM do seu computador, para que ele esteja disponível quando o seu programa precisar armazenar algum valor a ser utilizado pelo algoritmo.\n",
    "\n",
    "### E como funciona?\n",
    "\n",
    "Em tese, a variável é sua, e portanto é você que tem o trabalho de dar um nome a ela, que pode ser qualquer um, desde que algumas regras sejam obedecidas. São elas:\n",
    "\n",
    "- Não pode ser uma palavra reservada pelo sistema, como um comando já utilizado pela linguagem, por exemplo;\n",
    "- Não pode ter acento;\n",
    "- Não pode ter barras de espaço;\n",
    "- Não pode ter cedilha (ç);\n",
    "- Certos caracteres especiais são proibidos;\n",
    "- Não pode ser igual ao nome de outra variável;\n",
    "- Pode ter números, mas o nome não pode começar com um número.\n",
    "\n",
    "### Case Sensitive\n",
    "\n",
    "**Case Sensitive** é o nome que damos às linguagens que fazem distinção entre letras maiúsculas e letras minúsculas. Por exemplo: uma variável chamada `nome` é diferente da variável `Nome`, que por sua vez é diferente da variável `NOME`, e assim por diante.\n",
    "\n",
    "**Dito isso, tome cuidado ao digitar o nome dos comandos. Observe se eles são digitados totalmente em letras minúsculas ou se possuem alguma letra maiúscula, pois isso fará a diferença entre seu código funcionar ou não.**\n",
    "\n",
    "### Convenção de nomenclatura para variáveis em Python\n",
    "\n",
    "Em tese, você pode nomear as variáveis do jeito que achar necessário, mas para facilitar a leitura e manutenção do código-fonte, algumas convenções costumam ser adotadas. Por exemplo, procure dar nomes simples às suas variáveis, sempre com letras totalmente minúsculas: `nome`, `idade`, `cidade`, etc...\n",
    "\n",
    "Caso a sua variável seja um nome composto, separe os nomes por ***underscore*** (`_`). Por exemplo: `data_nascimento`, `idade_minima`, `valor_maximo`. Chamamos esse tipo de nomenclatura de **Snake Case**, e é o mais utilizado para a linguagem Python, diferentemente das outras linguagens de programação, que costumam utilizar o **Camel Case** para nomeação de variáveis. Evite também as letras maiúsculas no nome de suas variáveis.\n",
    "\n",
    "### Tipagem de variáveis no Python\n",
    "\n",
    "Python é uma linguagem de tipagem dinâmica, ou seja, diferentemente de outras linguagens, como o Java ou o C, não informamos o tipo de dado que a variável irá receber na sua declaração. Você simplesmente informa o nome desejado para a sua variável, e atribui a ela um valor, em um processo que chamamos de **inicialização de variável**, e é assim que declaramos, tipamos, e inicializamos uma variável: com um único e simples comando.\n",
    "\n",
    "Exemplo:\n",
    "- `texto = 'Este é um texto'`\n",
    "- `numero_inteiro = 12`\n",
    "- `ponto_flutuante = 15.5`\n",
    "- `valor_booleano = True`\n",
    "\n",
    "#### Tipos de dados\n",
    "\n",
    "Estes são os principais tipos de variáveis que trabalhamos em Python:\n",
    "\n",
    "- **String:** é como são chamados textos pequenos, de até 255 caracteres. Geralmente são representados por palavras simples, compostas, frases, no máximo um parágrafo. Sempre estão dentro de aspas, sejam elas simples ou duplas.\n",
    "- **Int:** são os números inteiros. Nunca são colocados dentro de aspas, e são representados apenas por números, nada mais. Nem vírgula, nem ponto, nem nenhum outro tipo de caractere.\n",
    "- **Pontos flutuantes:** são os números decimais. São chamados assim pois os valores que os representam estão \"flutuando\" entre um valor e outro. As suas casas decimais são **SEMPRE** separados por pontos, e nunca por vírgulas.\n",
    "- **Valores booleanos:** são valores binários de **VERDADEIRO** (`True`) ou **FALSO** (`False`), sempre com a inicial maiúscula. Uma variável desse tipo sempre vai receber um valor ou outro.\n",
    "\n",
    "#### Atribuições de valores\n",
    "\n",
    "É utilizado o sinal de igual (=) para atribuir um valor à uma variável. Lembre-se de que, na programação, o sinal de igual nunca significa igualdade, mas sim é usado para informar que algo recebeu um determinado valor.\n",
    "\n",
    "#### Type Annotation - Tipando variáveis em Python\n",
    "\n",
    "Embora Python seja uma linguagem de tipagem dinâmica, há a possibilidade de tipar manualmente as variáveis, igual às linguagens tipadas, como o C ou o Java, por exemplo.\n",
    "\n",
    "Mas se o Python tem tipagem dinâmica, por que eu precisaria informar o tipo da variável? Segue abaixo os motivos:\n",
    "\n",
    "- Prevenção de bugs.\n",
    "- Detecção de erros antecipados.\n",
    "- Facilidade de identificação por IDEs, que podem informar possíveis erros antes da execução.\n",
    "- Documentação de código-fonte e facilidade de compreensão.\n",
    "\n",
    "Segue abaixo um exemplo de **Type Annotation**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Este é um texto.\n",
      "10\n",
      "1.5\n"
     ]
    }
   ],
   "source": [
    "# variável do tipo texto\n",
    "texto: str = 'Este é um texto.'\n",
    "\n",
    "# variável do tipo inteiro\n",
    "numero: int = 10\n",
    "\n",
    "# variável do tipo decimal\n",
    "num_decimal: float = 1.5\n",
    "\n",
    "# saída de dados\n",
    "print(texto)\n",
    "print(numero)\n",
    "print(num_decimal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exibindo o valor de uma variável\n",
    "\n",
    "Isso pode ser feito utilizando o comando `print()`, mas informando o nome da variável dentro do parênteses sem as aspas. Segue o código-fonte abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Este é o texto que deverá ser exibido na saída.\n"
     ]
    }
   ],
   "source": [
    "# variável\n",
    "texto = 'Este é o texto que deverá ser exibido na saída.'\n",
    "\n",
    "# saída de dados\n",
    "print(texto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exibindo o tipo de uma variável\n",
    "\n",
    "Para identificar o tipo de uma variável, é possível usar o comando `type()` dentro de um `print()` em conjunto com uma variável. Segue o exemplo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "# variáveis\n",
    "nome = 'Alex'\n",
    "idade = 39\n",
    "altura = 1.72\n",
    "rico = False\n",
    "\n",
    "# saída dos tipos de variáveis\n",
    "print(type(nome))\n",
    "print(type(idade))\n",
    "print(type(altura))\n",
    "print(type(rico))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trocando o tipo de variável\n",
    "\n",
    "Caso seja necessário, há a possibilidade de trocar o tipo de variável, chamando o tipo para o qual deseja trocar como uma função.\n",
    "\n",
    "#### Exemplos:\n",
    "\n",
    "##### Trocando um número para string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numero = 10\n",
    "str(numero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Trocando de int para float:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numero = 10\n",
    "float(numero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Trocando de float para int:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numero = 10.5\n",
    "int(numero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenando string com variáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatenação é basicamente juntar valores. Em Python, há basicamente 4 formas de juntar strings com variáveis.\n",
    "\n",
    "#### Forma 1: estilo do Java/JavaScript\n",
    "\n",
    "Aqui se usa o sinal de **+** para concatenar valores, na mesma linha do Java e do JavaScript. Nessa forma, os dados do tipo int e float não podem ser imprimidos pelo comando, sendo necessário trocar o tipo dos números para string. Segue o código abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, meu nome é Alex, tenho 39 anos, e tenho 1.72 metros de altura.\n"
     ]
    }
   ],
   "source": [
    "# variáveis\n",
    "nome = 'Alex'\n",
    "idade = 39\n",
    "altura = 1.72\n",
    "\n",
    "# saída de dados\n",
    "print('Olá, meu nome é ' + nome + ', tenho ' + str(idade) + ' anos, e tenho ' + str(altura) + ' metros de altura.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Forma 2: estilo C/C++/Portugol\n",
    "\n",
    "Nesse estilo de concatenação, é usado a tradicional vírgula (,) para concatenação. Entretanto, diferente de outras linguagens, aqui ele já adiciona o espaço nas concatenações. Nesse caso, não há a necessidade de trocar o tipo das variáveis. Segue o exemplo do códdigo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, meu nome é  Alex , tenho  39 anos, e tenho  1.72 metros de altura.\n"
     ]
    }
   ],
   "source": [
    "# variáveis\n",
    "nome = 'Alex'\n",
    "idade = 39\n",
    "altura = 1.72\n",
    "\n",
    "# saída de dados\n",
    "print('Olá, meu nome é ', nome, ', tenho ', idade, 'anos, e tenho ', altura, 'metros de altura.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Forma 3: String format\n",
    "\n",
    "Nessa forma, é usado a função `format()` para concatenar. É um pouco mais avançado, e não é recomendado para iniciantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, meu nome é Alex, tenho 39 anos, e tenho 1.72 metros de altura.\n"
     ]
    }
   ],
   "source": [
    "# variáveis\n",
    "nome = 'Alex'\n",
    "idade = 39\n",
    "altura = 1.72\n",
    "\n",
    "# saída de dados\n",
    "print('Olá, meu nome é {}, tenho {} anos, e tenho {} metros de altura.'.format(nome, idade, altura))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Forma 4: f-string\n",
    "\n",
    "Essa é a forma mais usada pelos devs Python, pois deixa o código mais limpo e elegante. Se adiciona a letra **f** minúscula antes da string, e as variáveis são embutidas dentro das chaves, que por usa vez vão dentro das strings. **Obs:** essa será a forma mais utilizada durante o curso. Segue o exemplo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, meu nome é Alex, tenho 39 anos, e tenho 1.72 metros de altura.\n"
     ]
    }
   ],
   "source": [
    "# variáveis\n",
    "nome = 'Alex'\n",
    "idade = 39\n",
    "altura = 1.72\n",
    "\n",
    "# saída de dados\n",
    "print(f'Olá, meu nome é {nome}, tenho {idade} anos, e tenho {altura} metros de altura.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eliminando quebra de linha\n",
    "\n",
    "Diferente de outras linguagens, em Python você não precisa executar a famosa **quebra de linha** (`\\n`) para exibir valores na tela. O problema é que nem sempre você deseja fazer essa quebra de linha, e quando isso acontece, esse recurso do Python se torna indesejado. Se for do seu desejo não fazer a quebra de linha entre dois `print()`, o algoritmo abaixo poderá ajudar a resolver esse problema, ao usar o comando `end=''` no final de uma string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O Sábio sabia que o sabiá sabia assobiar.\n"
     ]
    }
   ],
   "source": [
    "print('O Sábio sabia ', end='')\n",
    "print('que o sabiá sabia assobiar.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alterando número de casas decimais de pontos flutuantes\n",
    "\n",
    "Caso seja necessário, há uma forma de definir quantas casas decimais um valor flutuante pode ter. Para isso, siga o exemplo do código abaixo, que pega o valor de uma variável com várias casas decimais, e diminui para apenas duas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.23\n"
     ]
    }
   ],
   "source": [
    "valor = 1.233456789\n",
    "\n",
    "# exibindo o valor com duas casas decimais\n",
    "print(f'{valor:,.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Entrada de dados do Python\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como aprendemos em Informática Básica, qualquer sistema informático realiza 3 funções básicas em uma sequência específica:"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na aula de hoje, já aprendemos como fazer a parte da **saída de dados** em Python através da função `print()`. Mas todos os dados que passaram pela saída de dados foram produzidas pelo próprio algoritmo. E se o usuário quiser ele mesmo entrar com uma informação? Nesse caso, o programador não tem como saber qual valor ele irá informar para colocar no programa. É aí onde entra o comando de **entrada de dados** do Python. Para que a entrada de dados funcione, é importante que na execução do programa, o usuário receba uma informação, ou seja, um texto indicando o que deve ser feito, para que ele saiba que tipo de informação ele pode inserir no programa. Nas outras linguagens de programação, isso é feito inserindo um comando de saída de dados com a informação antes do comando de entrada de dados associado à variável que irá armazenar a informação digitada pelo usuário. Em Python, tudo isso pode ser feito pelo mesmo comando usando a função `input()`. Veja o exemplo à seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alex Machado\n"
     ]
    }
   ],
   "source": [
    "# variável é declarada e recebe um input por parte do usuário\n",
    "nome = input('Informe o seu nome:')\n",
    "\n",
    "# programa exibe o dado informado pelo usuário\n",
    "print(nome)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alterando vírgula para ponto\n",
    "\n",
    "Conforme visto anteriormente, o ponto é o que separa as casas decimais, e não a vírgula. Acontece que o usuário final não sabe disso, nem é obrigado a saber, e por isso, caso ele seja solicitado a informar um número decimal, ele inevitavelmente irá informá-lo separando as casas decimais com vírgula, o que fará nosso programa retornar um erro. Para evitar isso, podemos \"converter\" a vírgula digitada pelo usuário para o ponto, usando a função `replace()`, e depois convertendo para um `float`. Veja a seguir como usar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.25\n"
     ]
    }
   ],
   "source": [
    "valor_decimal = input('Inform um número decimal: ')\n",
    "valor_decimal = valor_decimal.replace(',', '.')\n",
    "valor_decimal = float(valor_decimal)\n",
    "\n",
    "print(valor_decimal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercícios\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Crie um arquivo **.py** e faça um algoritmo que receba do usuário o nome, idade e profissão, e imprima na tela essas informações."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: jogue o código aqui"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}