Aula2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Universidade Federal do Rio Grande do Sul (UFRGS)   \n",
    "Programa de Pós-Graduação em Engenharia Civil (PPGEC)   \n",
    "\n",
    "\n",
    "# Python aplicado à análise de estruturas\n",
    "## Aula 2: A Linguagem Python\n",
    "\n",
    "\n",
    "\n",
    "[1. Entrada e Saída de dados](#section_1)\n",
    "\n",
    "[2. Tipos de variáveis](#section_2)\n",
    "\n",
    "[ 2.1. Numéricas](#section_21)\n",
    "\n",
    "[ 2.2. Textual](#section_22)\n",
    "\n",
    "[ 2.3. Booleanas](#section_23)\n",
    "\n",
    "[ 2.4. Listas, tuplas e dicionários](#section_24)\n",
    "\n",
    "[ 2.5. Extra: Formatando strings](#section_25)\n",
    "\n",
    "[3. Operadores](#section_3)\n",
    "\n",
    "[ 3.1. Aritiméticos](#section_31)\n",
    "\n",
    "[ 3.2. Atualização](#section_32)\n",
    "\n",
    "[ 3.3. Comparativos](#section_33)\n",
    "\n",
    "[ 3.4. Participação](#section_34)\n",
    "\n",
    "[ 3.5. Lógicos](#section_35)\n",
    "\n",
    "[4. Blocos](#section_4)\n",
    "\n",
    "[ 4.1. Condicionais](#section_41)\n",
    "\n",
    "[ 4.1. Repetição](#section_42)\n",
    "\n",
    "[5. Funções](#section_5)\n",
    "\n",
    "---\n",
    "\n",
    "_Eng. MSc Eduarto Pagnussat Titello_\n",
    "\n",
    "_Eng. Daniel Barbosa M. Matos_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ccmErSuvG-xN"
   },
   "source": [
    "# Entrada e Saída de dados <a name=\"section_1\"></a>\n",
    "\n",
    "Em Python, assim como todas as linguagens de programação, é possível solicitar dados e exibir informações na tela. Abaixo, será demonstrado a utiização dos comandos ```print``` e ```input```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "I41EwQ77G-xQ",
    "outputId": "80c78364-285b-4e61-cd3f-b297c6ef6aa9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite a sua idade\n",
      "A idade do usuário é: \n"
     ]
    }
   ],
   "source": [
    "a = input('Digite a sua idade')                     # Criação de uma variável a partir da entrada do usuário\n",
    "print( \"A idade do usuário é:\", a)                   # Exibição da variável na tela"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q1x1HPTeG-xa"
   },
   "source": [
    "Mais a frente, após a explicação dos tipos de variáveis, será ensinado como formatar as informações que serão printadas na tela."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ypUyBCwgG-xb"
   },
   "source": [
    "# Tipos de variáveis <a name=\"section_2\"></a>\n",
    "As variáveis em Python possuem tipagem dinâmica, portanto, não há a necessidade de declara-las no ínicio do programa e, é possível, também, mudar o seu tipo ao longo do desenvolvimento do código. \n",
    "\n",
    "## Numéricas <a name=\"section_21\"></a>\n",
    "A linguagem Python possui três tipos de variáveis para o armazenamento de números : os ```int```, os ```float``` e os ```complex```. As variáveis do tipo ```int``` armazenam apenas números inteiros, os ```floats``` armazenam números reais e os ```complex``` armazenam números complexos. **O divisor de décimais é marcado por um \".\" e o número complexo é indicado por \"j\"**. Abaixo são declaradas três variáveis, e seus tipos são exibidos na tela a patir do comando `type`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "PmCRnwHbG-xc",
    "outputId": "9e6a96ac-35a1-4ee7-df04-e712fc927947"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 1.\n",
    "c = 1+1j\n",
    "\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8nQ1hEraG-xi"
   },
   "source": [
    "## Textual  <a name=\"section_22\"></a>\n",
    "\n",
    "Para o armazenamento de uma sequência de caracteres, utiliza-se uma variável do tipo ```string```, em que esta sequência deve ser declarada entre aspas simples ou duplas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "PrL21S2IG-xj",
    "outputId": "7814d186-0e64-43c9-f842-8f338b56b213"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "a = 'oi, mundo'\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "psWxy_wAG-xo"
   },
   "source": [
    "Perceba que a variável a foi declarada novamente, mudando o seu tipo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "diVtGpRMG-xp"
   },
   "source": [
    "## Booleanas <a name=\"section_23\"></a>\n",
    "A linguagem Python também é dotada de operadores booleanos, ou seja ```True``` e ```False```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ZYVqw210G-xp",
    "outputId": "9fc33e1e-be80-49b9-e80f-76203213a0d1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "y = a > 10\n",
    "print(y, type(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rA9J_lAlG-xu"
   },
   "source": [
    "## Listas, tuplas e dicionários  <a name=\"section_24\"></a>\n",
    "É possível, também, armazenar diversos valores dentro de uma só variável. As variáveis que possuem essa característica são as ```lists```, as ```tuples``` e os ```dictionarys```. As lists são sequências de variáveis que podem ser alteradas ao longo do código e são declaradas com o uso de colchetes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "U5ub_tFmG-xv",
    "outputId": "f385c9b7-b76b-4fe7-b92d-0a4ab1e63ee3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'oi', 7.15, (1+2j)] <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 'oi', 7.15 ,1+2j]\n",
    "print(a, type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "syTM_2RJG-x0"
   },
   "source": [
    "As ```tuples```,diferentemente das ```lists```, são imutáveis, ou seja, não podem ter seus valores alterados ao longo da execução."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "in8_ggafG-x1",
    "outputId": "96fc3125-c17f-46a5-96d1-f25da4b0452e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 'oi') <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "b = (1, 2, 'oi')\n",
    "print(b, type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LVQ7_PNpG-x7"
   },
   "source": [
    "Para acessar um termo específico de uma lista ou de uma tupla, basta utilizar o seus nome seguido do seu \"indexing\" entre colchetes. Por exemplo, vamos acessar o **terceiro** termo da lista `a`. O último termo de uma sequência pode ser acessada utilizando `-1` como índice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "-zpuZeCBG-x8",
    "outputId": "091d9156-3eb9-4308-c428-adf6af851044"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oi\n",
      "(1+2j)\n"
     ]
    }
   ],
   "source": [
    "print(a[2])\n",
    "print(a[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ArgTwXgIG-yA"
   },
   "source": [
    "Em python, a contagem do indexing começa de zero, portanto, se você quer utilizar o terceiro termo de uma lista ou tupla, deve-se utilizar o indexing = 2. \n",
    "\n",
    "É possível acessar os termos da lista e alterar seus valores específicos, como se mostra abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "GXpg578YG-yB",
    "outputId": "ce0fcee4-6e2a-485b-b985-566fcf97b9d5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'tchau', 7.15, (1+2j)]\n"
     ]
    }
   ],
   "source": [
    "a[2] = 'tchau'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ROJ3898ZG-yI"
   },
   "source": [
    "Perceba que não é possível fazer o mesmo com uma tupla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "Urhlo1LgG-yJ",
    "outputId": "6ea4199f-c828-4095-9786-5bb24d124ec3"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-0a2d922de335>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mb\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'tchau'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "b[2] = 'tchau'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VzmagkLFG-yQ"
   },
   "source": [
    "Além de poder chamar um valor específico da lista, também é possível realizar a chamada de um intervalo, da seguinte forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "DqB8mc7rG-yQ",
    "outputId": "562acad9-10b3-4713-8802-09f16a1ad8cf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'tchau']\n"
     ]
    }
   ],
   "source": [
    "print(a[0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p1-t-HeGG-yT"
   },
   "source": [
    "Perceba que foram extraídos apenas os 3 primeiros números da lista.\n",
    "\n",
    "É possível, ainda, escolher variáveis em um intervalo específico. Por exemplo, vamos escolher as variáveis de 2 em 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "jG2kxpf4G-yU",
    "outputId": "4b21b318-fb84-484b-824c-033616ad7d3b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'tchau', (1+2j)]\n"
     ]
    }
   ],
   "source": [
    "print(a[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IEWg2BDaG-yX"
   },
   "source": [
    "Para inverter a sequência de uma lista, pode-se utilizar o comando reversed, ou simplesmente..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "8mTOZBaxG-yY",
    "outputId": "99e2ae99-204e-46f6-b9dd-ec7cdb2b2ebf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1+2j), 7.15, 'tchau', 2, 1]\n"
     ]
    }
   ],
   "source": [
    "print(a[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8jcQsusnG-yd"
   },
   "source": [
    "As variáveis do tipo `dictionary` são como listas onde os índices podem ser quaisquer tipos de valores. Dicionáros são criados fazendo o uso de chaves (`{}`), onde é fornecido o indíce (key) e seu valor seguido de `:`. Os valores dos dicionários são mutáveis e esses são expansíveis, conforme os exemplos a seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "fsZtzB2WG-yd",
    "outputId": "854d3edc-3cc0-4590-b9a0-eb1dd97ab9e7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 30: 0, (2, 3): 77}\n",
      "1\n",
      "77\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "d = {'a': 1, \n",
    "     'b': 2,\n",
    "      30: 0,\n",
    "     (2,3): 77}\n",
    "\n",
    "print(d)\n",
    "print(d['a'])\n",
    "print(d[2,3])\n",
    "print(d[30])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OGeqWmuNG-yj"
   },
   "source": [
    "A mutação e a adiçao de valores ao dicionário são realizadas na forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "3vzYaa3zG-yj",
    "outputId": "cc2d86b8-78c2-4012-860c-60165be14d1a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 30: 0, (2, 3): 77, 'Python': 'Olá PPGEC!'}\n"
     ]
    }
   ],
   "source": [
    "d['Python'] = 'Olá PPGEC!'\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LDqC4gwQG-yo"
   },
   "source": [
    "Para remover valores é usado o comando `d.pop(key)` fornecendo a key a ser removida, esse retornará o valor removido. Por exemplo removendo o elemento `b` a função retorna 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "Ej-g3yfsG-yp",
    "outputId": "b0f5f16d-13ff-484b-a4a1-8398e8c13673"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.pop('b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "P5UiZ4cNG-yt",
    "outputId": "b7479bc2-5309-43da-e2e7-256e6c35432d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 30: 0, (2, 3): 77, 'Python': 'Olá PPGEC!'}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SVDo-1wnG-yy"
   },
   "source": [
    "Outro tipo de variável importante no Python é o `None`, que significa nenhum. Esse tipo de variável é bastante útil para representar a ausência de valores, visto que `0` tem significado em alguns casos. Vamos declarar uma variável como `None` e verificar seu tipo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "bo1Of_N9G-yy",
    "outputId": "1b5355df-2385-4b7f-df1f-50d39a422028"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None <class 'NoneType'>\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = None            # a é None\n",
    "print(a, type(a))   # printa seu valor e seu tipo\n",
    "print(a == 0)       # None e 0 não são a mesma coisa!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2-kKcyCoG-y2"
   },
   "source": [
    "## Extra: Formatando strings <a name=\"section_25\"></a>\n",
    "Strings são muito úteis na comunicação do programa com o usuário, através delas um conteúdo pré-determinado pode ser combinado com os valores de algumas variáveis resultando em uma saída formata como:\n",
    "\n",
    "        'A raiz da função é x=1.234 com um erro absoluto de 1.2E-4.'\n",
    "\n",
    "Definindo os valores da raiz e do erro manualmente podemos obter o resultado anterior através de:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "eR9T8ZzxG-y3",
    "outputId": "fa1e4cb1-a91d-4bd9-b44d-cee0e396912b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A raiz da função é x=1.235 com um erro absoluto de 1.2E-04.\n"
     ]
    }
   ],
   "source": [
    "raiz = 1.23456789123\n",
    "erro = 1.2154656E-4\n",
    "msg = 'A raiz da função é x={:.3f} com um erro absoluto de {:.1E}.'.format(raiz, erro)\n",
    "print(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9cF1fW6lG-y6"
   },
   "source": [
    "Enquanto com a impressão sem formatação adotada até então temos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "MsvV0kffG-y6",
    "outputId": "c07e1d0c-db4e-4dce-9598-ee9bd62834ff"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A raiz da função é x= 1.23456789123  com um erro absoluto de  0.00012154656 .\n"
     ]
    }
   ],
   "source": [
    "print('A raiz da função é x=', raiz,' com um erro absoluto de ', erro, '.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8fURlC5LG-y-"
   },
   "source": [
    "Onde observamos que todas as casas decimais dos valores são impressas, mesmo não havendo necessidade de tamanha precisão. \n",
    "\n",
    "A inserção de valores de variáveis em strings é realizada através da inserção de `{}` na posição do resultado no interior da string e da adição do comando `.format(variavel1, variavel2, ..., variaveln)`.\n",
    "No interior das chaves podem ser adicionadas informações como posição da variável à ser impressa e formato de impressão, no formato `posicao:formato`, onde ambas são opcionais. \n",
    "\n",
    "A posição informada na formatação é a posição em que o variável a ser impressa consta em `.format()`, usualmente as variáveis são impressas na ordem em que são informadas, nesse caso a posição pdoe ser mantida em branco, como no exemplo anterior onde foi utilizado apenas `{:fomato}`. Vamos então executar o exemplo anterior alterando a ordem das variáveis e informando ou não a posição dos resultados à serem printados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "0tc6Z3TtG-y-",
    "outputId": "13431352-aa3a-4e7d-b55e-4e4d9f82d145"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A raiz da função é x=0.000 com um erro absoluto de 1.2E+00.\n",
      "A raiz da função é x=1.235 com um erro absoluto de 1.2E-04.\n"
     ]
    }
   ],
   "source": [
    "msg1 = 'A raiz da função é x={:.3f} com um erro absoluto de {:1.1E}.'.format(erro, raiz)\n",
    "print(msg1) \n",
    "\n",
    "msg2 = 'A raiz da função é x={1:.3f} com um erro absoluto de {0:1.1E}.'.format(erro, raiz)\n",
    "print(msg2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vq35ZAUWG-zB"
   },
   "source": [
    "No primeiro caso a string obtida apresentou os valores trocados, conforme esperado, no segundo a ordem de impressão foi fornecida e os resultados voltaram a ser condizentes.\n",
    "\n",
    "Outra forma de organização dos valores para formatação é a denominação de nomes para as variáveis durante sua chamada em `.format()`, essas podem então ser posicionadas conforme seus nomes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "JDfPaoDPG-zD",
    "outputId": "597927e3-2716-456f-b487-b48a652c9522"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A raiz da função é x=1.235 com um erro absoluto de 1.2E-04.\n"
     ]
    }
   ],
   "source": [
    "print('A raiz da função é x={x:.3f} com um erro absoluto de {e:.1E}.'.format(e=erro, x=raiz))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0jDyAflaG-zH"
   },
   "source": [
    "Os principais formatos para impressão de números são:\n",
    "* `Xd` para impressão de números inteiros, onde X é o número mínimo de digitados reservados no espaço;\n",
    "* `.Xf` para impressão de números reais, onde X é o número de casas decimais;\n",
    "* `.Xe` e `.XE` para impressão de números reais na potencia 10, onde X é o número de casas decimais.\n",
    "\n",
    "Vamos definir alguns números e printar esses formatados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "idhnF5xrG-zJ",
    "outputId": "93fe6344-f51b-4db2-8491-55ff2eaa5afa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: 3, 3,        3, 3.00\n",
      "b: 3.14159, 3.141590, 3.14, 3.14159000\n",
      "c: 123456789123.45679, 123456789123.456787, 123456789123.46, 1.2E+11, 1.23457e+11\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "b = 3.14159\n",
    "c = 123456789123.456789\n",
    "\n",
    "print('a: {a}, {a:d}, {a:8d}, {a:.2f}'.format(a=a)) # terceiro caso reserva 8 digitos na tela e deixa em branco!\n",
    "print('b: {b}, {b:f}, {b:.2f}, {b:.8f}'.format(b=b))\n",
    "print('c: {c}, {c:f}, {c:.2f}, {c:.1E}, {c:.5e}'.format(c=c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rBO7QEOrG-zM"
   },
   "source": [
    "Os formatos não se limitam à impressão de números, esses permitem ainda a configuração de simbolos, alinhamentos e etc, e podem ser combinados em alguns casos. Maiores informações sobre formatos podem encontradas [aqui](https://docs.python.org/3/library/string.html#format-string-syntax) e [aqui](https://www.w3schools.com/python/ref_string_format.asp)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RAk4DNBrG-zN"
   },
   "source": [
    "# Operadores <a name=\"section_3\"></a>\n",
    "\n",
    "## Aritiméticos <a name=\"section_31\"></a>\n",
    "Os operadores aritiméticos do Python são:\n",
    "* `+`, `-`, `*`, `/` para adição, subtração, multiplicação e divisão;\n",
    "* `**` para exponenciação (`3^2` em Python é `3**2`);\n",
    "* `//` e `%` para divisão de inteiros e cálculo do seu resto. Por exemplo, `14/5 = 2.8`, já `14//5=2` (inteiro) e `14%5=4` (resto), logo `14=2*5+4`.\n",
    "\n",
    "## Atualização <a name=\"section_32\"></a>\n",
    "Todos os operadores aritiméticos anteriores podem ser combinados com o símbolo de atribuição (`=`), obtendo operadores que atualizam o valores das variáveis. São exemplos `+=`, `*=`, `**=`, exemplíficados a seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "4xZvh1_QG-zN",
    "outputId": "9d5545b9-8bb6-46a9-93df-eeafb85b6e29"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=7\n",
      "b=27\n",
      "c=8\n"
     ]
    }
   ],
   "source": [
    "a = 2       # Define a como 2\n",
    "a += 5      # Atribuí mais 5 a `a`, 2+5=7.\n",
    "print('a={}'.format(a))\n",
    "\n",
    "b = 3       # Define b como 3\n",
    "b *= 9      # Multiplica valor de b por 9, 3*9=27\n",
    "print('b={}'.format(b))\n",
    "\n",
    "c = 2       # Define c como 2\n",
    "c **= 3     # Eleva c ao cubo 2**3=8\n",
    "print('c={}'.format(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yhSMMM_RG-zR"
   },
   "source": [
    "## Comparativos <a name=\"section_33\"></a>\n",
    "O conteúdo de variáveis pode ser comparado através dos operadores:\n",
    "* `>`, `>=`, `<`, `<=` para verificar se uma é maior, maior igual, menor ou menor igual;\n",
    "* `==` para verificar são iguais;\n",
    "* `!=` para verificar são diferentes.\n",
    "\n",
    "**Vale ressaltar que `=` significa atribuição, e não comparação.**\n",
    "\n",
    "Por exemplo, usando as variáveis `a`, `b` e `c` anteriores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "TY5yWC3GG-zR",
    "outputId": "2ee9da42-89d1-49ec-a711-94a6bc4c29fb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a<b?  True\n",
      "c<a?  False\n",
      "a=b?  False\n",
      "a<>b?  True\n",
      "b=b?  True\n"
     ]
    }
   ],
   "source": [
    "print('a<b? ', a<b)\n",
    "print('c<a? ', c<a)\n",
    "print('a=b? ', a==b)\n",
    "print('a<>b? ', a!=b)\n",
    "print('b=b? ', b==b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vEssHWJvG-zW"
   },
   "source": [
    "## Participação <a name=\"section_34\"></a>\n",
    "\n",
    "A participação de um valor em um elemento (lista, dicionário, tupla, array) pode ser verificada através do comando `in`, conforme exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "Tu4FOiWjG-zX",
    "outputId": "bdae37ba-843b-4f53-8015-9fd1b7aa4ad7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temos 1 em a? True\n",
      "Temos 8 em a? False\n"
     ]
    }
   ],
   "source": [
    "a = [1, 3, 5, 7, 9]\n",
    "print('Temos 1 em a?', 1 in a)\n",
    "print('Temos 8 em a?', 8 in a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "k8q88TfhG-zc"
   },
   "source": [
    "## Lógicos <a name=\"section_35\"></a>\n",
    "Os operadores lógicos trabalham em conjunto com as operações booleanas, eles são `and`, `or` e `not` que tem como significado seus próprios nomes. Através desses podemos comparar operações para avaliar condições (vistas na próxima seção). \n",
    "\n",
    "Como exemplo vamos adotar a lista `a` anterior, três escalares `b=0`, `c=5`, `d=88`, e fazer alguams verificações:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "iFZ4xAXtG-zd",
    "outputId": "6fee8285-eb99-41f0-eab8-c242978dcb7a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True False True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "b = 0\n",
    "c = 5\n",
    "d = 88\n",
    "\n",
    "# Verificações\n",
    "V1 = b <= c # b é menor ou igual à c? Sim\n",
    "V2 = d in a # d está em a? Não\n",
    "V3 = c in a # c está em a? Sim\n",
    "print(V1, V2, V3)\n",
    "\n",
    "# Agora vamos imaginar que precisamos saber se: `b<=c` (V1) e `c` (V3) participa de `a`\n",
    "V4 = V1 and V3 # Equivalente à `(b<=c) and (c in a)`\n",
    "print(V4) # True pq ambas condições são verdadeias\n",
    "\n",
    "# Agora supondo que queremos saber se `d` NÃO está em `a`\n",
    "V5 = d not in a # Mesmo que `not V2`\n",
    "print(V5) # True pq `d` NÃO está mesmo em `a`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0bXyc4EwG-zh"
   },
   "source": [
    "# Blocos <a name=\"section_4\"></a>\n",
    "\n",
    "## Condicionais <a name=\"section_41\"></a>\n",
    "Se imaginarmos um fluxograma, um bloco condicional é um separador de fluxo definido por uma condição imposta pelo usuário. Por exemplo, vamos imaginar que você precisa validar uma senha de 8 dígitos, a primeira condição a ser verificada é o tamanho da senha, **se** essa condição for verdadeira a senha deve ser confirmada, **se** as senhas forem iguais e tiverem mais de 8 dígitos é informado ao usuário que a senha foi aceita."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NrtEE9aMG-zi",
    "outputId": "b7d7a609-c16d-43f5-c5c2-dd0c5931d70b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite uma senha no mínimo 8 dígitos:12345678\n",
      "Por favor, confirme sua senha:12345678\n",
      "Senha aceita.\n"
     ]
    }
   ],
   "source": [
    "senha1 = input(\"Digite uma senha no mínimo 8 dígitos:\")\n",
    "if len(senha1) < 8:\n",
    "  print(\"Senha inválida, a senha precisa ter no mínimo 8 digitos.\")\n",
    "else:\n",
    "  senha2 = input(\"Por favor, confirme sua senha:\")\n",
    "  if senha1 == senha2:\n",
    "    print(\"Senha aceita.\")\n",
    "  elif len(senha2) < 8:\n",
    "    print(\"Senha inválida, a senha precisa ter no mínimo 8 digitos.\")\n",
    "  else:\n",
    "    print(\"As senhas inseridas são diferentes!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p2iPB084I7oS"
   },
   "source": [
    "No código anterior aplicamos as estruturas `if`, `elif` e `else`. A estrutura `if` inicia a verificação de uma condição, caso essa não seja verdadeira o código passa para a próxima condição contida em `elif`. O comando `else` é ativado quando nenhuma das condições anteriores é satisfeita. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gKa3mlA_NB2O"
   },
   "source": [
    "## Repetição <a name=\"section_42\"></a>\n",
    "\n",
    "Observando o exemplo acima, veja que ele não faz sentido visto que se a senha digitada não for válida o código apenas termina sem a possibilidade de inserçõa de uma nova senha. A forma correta de executar o código acima é dentro de um loop em que esse loop só acabará quando a condição for satisfeita. Vamos então usar o artíficio `while True:` onde o código é repetido infinitamente até que o loop seja quebrado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "-2N9eCl1Nqma",
    "outputId": "3e1075c8-a5b8-4dc5-84b1-b92fd24576ae"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite uma senha no mínimo 8 dígitos:12345679\n",
      "Por favor, confirme sua senha:12345679\n",
      "Senha aceita.\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "  senha1 = input(\"Digite uma senha no mínimo 8 dígitos:\")\n",
    "  if len(senha1) < 8:\n",
    "    print(\"Senha inválida, a senha precisa ter no mínimo 8 digitos.\")\n",
    "  else:\n",
    "    senha2 = input(\"Por favor, confirme sua senha:\")\n",
    "    if senha1 == senha2:\n",
    "      print(\"Senha aceita.\")\n",
    "      break # Quebra o loop\n",
    "    elif len(senha2) < 8:\n",
    "      print(\"Senha inválida, a senha precisa ter no mínimo 8 digitos.\")\n",
    "    else:\n",
    "      print(\"As senhas inseridas são diferentes!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dSaF3t-SOHtV"
   },
   "source": [
    "Outras condições, como as utilizadas em `if`, podem ser consideradas pelo comando `while`. Como por exemplo `while x1!=x2` irá repetir o bloco de código até que `x1` seja igual à `x2`, sem a necessidade de uso do `break`. \n",
    "\n",
    "Para iterar uma lista ou sequência pode ser usado o comando `for`. Diferentemente de outras linguagens de programação, o comando `for` tem como entrada um objeto iterável (como uma lista, tupla, dicionário ou sequencias). \n",
    "\n",
    "Por exemplo vamos criar uma lista de valores e percorrer esta, onde em cada loop um elemento da lista é acessado e tem seu valor passado para a variável `n`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "120Jz2IrN1iO",
    "outputId": "5b75f97b-ea40-4fd2-ecd4-17045e1ccdb7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "1\n",
      "23\n",
      "42\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "lista = [3, 4, 1, 23, 42, 5]\n",
    "for n in lista:\n",
    "  print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-dEE43lfThgJ"
   },
   "source": [
    "Esse comando é muito utilizado para acessar e percorrer arrays, realizar processo iterativos e muito mais. Para criar um `for` tradicional, ou seja, em que a variável `n` segue uma sequencia de números inteiros pode ser usado o comando `range(inicio, fim, passo)` ou `range(fim)`, conforme exemplos à seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ZtrU5sW_TdPj",
    "outputId": "86fba0c2-74ef-447d-9b71-879cdb4dbd2c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "for n in range(10,20): # Passo não informado, adota padrão =1\n",
    "  print(n)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9PfCW08BWqI7",
    "outputId": "4d9ab534-e472-4081-c7f8-eeeadd7ab1ab"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "for n in range(10,20,2): # O passo agora é 2\n",
    "  print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_1d5M67sU4DM",
    "outputId": "90cfa0b3-2dbe-4471-9ec2-b4861dd45b1b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "for i in range(7):\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vZxGKZ8LVD8M"
   },
   "source": [
    "Podemos observar que o iterador `range()` cria uma sequencia de números inteiros a partir de um intervalo definido, matemáticamente falando temos um invervalo fechado-aberto. \n",
    "\n",
    "Para numerar os termos de uma lista podemos acrescentar a função `enumerate` na chamada do `for`, conforme o exemplo a seguir, utilizando a lista dos exemplos anteriores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "0qoMbEsdVCtv",
    "outputId": "7ae77a40-979f-4949-953f-53337cc66446"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O termo 0 é 3.\n",
      "O termo 1 é 4.\n",
      "O termo 2 é 1.\n",
      "O termo 3 é 23.\n",
      "O termo 4 é 42.\n",
      "O termo 5 é 5.\n"
     ]
    }
   ],
   "source": [
    "for i, n in enumerate(lista):\n",
    "  print('O termo {} é {}.'.format(i,n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bEgsy7PvX23S"
   },
   "source": [
    "# Funções <a name=\"section_5\"></a>\n",
    "\n",
    "Uma função é um bloco que realiza uma operação pré-definida que será realizada sempre que chamada pelo usuário. Podemos criar funções para representar expressões matemáticas, ou mesmo operações mais trabalhosas. Funções apresentar valores de retorno. Adotando equações de segundo grau no formato $y=ax^2+bx+c$ vamos definir uma função `quad(x,a,b,c)` e uma função `raizes(a,b,c)`, onde a primeira retorna o valor de `y` em um dado `x` e a segunda através da formula de Bhaskara retorna as raizes. \n",
    "\n",
    "Funções são declaradas no formato `def nome(arg1, arg2, arg3, ...):` e quando possuem retorno a última linha do bloco de função deve conter `return saida1, saida2, ...`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "id": "wJTfduJdX7v0"
   },
   "outputs": [],
   "source": [
    "# Função quad que retorna valor de y\n",
    "def quad(x, a, b, c):\n",
    "  y = a*x**2 + b*x + c\n",
    "  return y\n",
    "\n",
    "def raizes(a, b, c):\n",
    "  delta = b**2-4*a*c\n",
    "  if delta >= 0:\n",
    "    x1 = (-b+delta**0.5)/(2*a)\n",
    "    x2 = (-b-delta**0.5)/(2*a)\n",
    "  else:\n",
    "    print('As raizes da expressão são complexas.')\n",
    "    x1, x2 = None, None\n",
    "\n",
    "  return x1, x2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mwixV_D6bDrr"
   },
   "source": [
    "Perceba que na definição da função nada é executado, agora chamando essas teremos alguns resultados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "sFXzSDunbDAb",
    "outputId": "92f2fb0d-2ac7-42d3-d830-279a6e311299"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0 1.0\n"
     ]
    }
   ],
   "source": [
    "r1, r2 = raizes(1, -3, 2)\n",
    "print(r1, r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mdXRRfIAbfIt"
   },
   "source": [
    "Como resultado a função retornou nas variáveis `r1` e `r2` as raizes da equação. Podemos agora aplicar `r1` ou `r2` em `quad` e verificar se `y` é realmente zero nas raizes. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9im-7Og-aHrS",
    "outputId": "bc9d3572-8973-4f9b-9d60-9484be083e75"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "y = quad(r1, 1, -3, 2)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u002efIAcRau"
   },
   "source": [
    "Os argumentos das funções podem ter valores pré-definidos, dessa forma seu preenchimento é opcional. Além disso, na chamada das funções deve-se respeitar a ordem dos argumentos ou deve ser especificado o argumento que recebe cada valor. \n",
    "\n",
    "Vamos então redefinir a função `quad` com argumentos padrões (`a=1`, `b=c=0`) e chama-la embaralhando seus argumentos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "wk8Z0KabcH25"
   },
   "outputs": [],
   "source": [
    "def quad(x, a=1, b=0, c=0):\n",
    "  y = a*x**2 + b*x + c\n",
    "  return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bfkUpnNpdd70"
   },
   "source": [
    "Chamando a função fornecendo apenas o valor de `x` essa usará a expressão padrão $y=x^2$, dados os valores de `a,b,c`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "N6YfyUFYcP6l",
    "outputId": "0fce289f-2fed-48be-bc49-647c36a6b92f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quad(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "quEJu0G5dtTd"
   },
   "source": [
    "Agora embaralhando os argumentos podemos verificar a outra raiz obtida anteriormente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "i38hJfcBdTXj",
    "outputId": "40ce68fa-3017-4693-e82d-01ed57ec5fa2",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quad(c=2, x=r2, a=1, b=-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BFlfU4WVd-U8"
   },
   "source": [
    "Ok! A função retornou o valor esperado."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Cópia de Aula2.ipynb",
   "provenance": []
  },
  "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}