{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Estudando a Linguagem de Programação Python\n",
    "#### Neste notebook, vamos analisar as estruturas básicas da linguagem de programação Python. É pertinente saber que tal linguagem possui bastante uso atualmente e ela é uma das mais simples de usar, mas graças a colaboratividade dos usuário, temos inúmeras bibliotecas prontas para uso que nos possibilitam executar tarefas complexas na programação."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos começar o nosso estudo em **Python** por uma definição que resume os ideais dessa linguagem de programação:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **\"Python é uma linguagem de programação de alto nível, interpretada, de script, imperativa, orientada a objetos, funcional, de tipagem dinâmica e forte. Foi lançada por Guido van Rossum em 1991. Atualmente possui um modelo de desenvolvimento comunitário, aberto e gerenciado pela organização sem fins lucrativos Python Software Foundation.\"** (Wikipédia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dissecando a Definição"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acima foi copiado um pequeno trecho da **Wikipédia** que fala sobre a **linguagem de programação Python**. Nele, podemos aprender diversas características da linguagem em sí, tais como:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|**Características da Linguagem de Programação Python**|\n",
    "|:---------------|\n",
    "|**Linguagem de Progamação de Alto Nível:** Python é uma linguagem que sua escrita é bem próxima da linguagem humana usando como idioma principal o inglês, dado que é a sua linguagem nativa. Dessa forma, podemos nos comunicar com a máquina através de um forte e intuitivo interpretador.|\n",
    "|**Linguagem Interpretada:** o código fonte nessa linguagem é executado por um programa de computador chamado interpretador, que em seguida é executado pelo sistema operacional ou processador. Método esse que difere das linguagens que são compiladas para a linguagem de máquina, tais como a linguagem de progamação C e suas derivadas.|\n",
    "|**Linguagem de Script:** é básicamente o ato de desenvolver um algoritmo para automatizar a execução de tarefas que poderiam alternativamente ser executadas uma por vez por um operador humano.|\n",
    "|**Linguagem Imperativa:** Trata do ato de usar ações para dar ordens, ou seja, através de comandos podemos dar ordens para serem executadas determinadas ações pelo programa. Desse modo, surgem os laços de repetição, estruturas condicionais, atribuição de valor à variáveis e controle de estado para implementar melhor essa ideia de imperatividade.|\n",
    "|**Linguagem Orientada a Objetos:** Trata da ideia de se ter uma linguagem de programação voltada ao conceito de \"objetos\", usando para isso atributos (dados na forma de campo) e métodos (procedimentos de execução).|\n",
    "|**Linguagem Funcional:** Trata da ideia de possuir uma linguagem com avaliação de funções para executar determinadas ações. Especificamente o Python, possui inúmeras bibliotecas repletas de funções para serem importadas e usadas, dando ênfase a inúmeros campos de estudo na qual a programação se aplica.|\n",
    "|**Linguagem de Tipagem Dinâmica:** sendo uma caracteristica positiva para o Python, esse tipo de tipagem permite o uso de variáveis que não exigem declarações de tipos de dados, pois são capazes de escolher que tipo utilizar dinamicamente para cada variável, podendo alterá-lo durante a compilação ou a execução do programa.|\n",
    "|**Linguagem forte:** Python é uma linguagem de programação multiplataforma e atualmente está presente em diversos sistemas operacionais, seja eles embarcados ou não. Temos a Microsoft usando nos consoles Xbox, de mesmo modo a Sony nos consoles Playstation, a empresa Apple a utiliza nos seus sistema operacionais IOS ou macOS, está presente em inúmeras SmartTvs, presente em operações para realizar automações em residências, automação industrial e várias outras aplicações.|\n",
    "|**Além disso:** o recurso de ponto e vírgula para paradas de comandos foi substituido pelo recuo utilizado na construção do código, juntamente com os dois pontos (:) usando para delimitar subcomandos de operações maiores.|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora, vamos ver como funciona a linguagem de progamação Python. Vale a pena lembrar que esse progama está sendo escrito levando em consideração que o leitor já foi introduzido a programação e, dado a amplitude de recursos que o Python possui, vamos nos ater somente a comandos básicos que permitem um bom início com ela, visando trazer todo o conhecimento necessário para lidar com os outros programas utilizados nesse repositório."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imprimindo Dados de Saída (Outputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos utilizar diretamente o **prompt de comando** do Python para imprimir dados de saída simples como"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# imprimindo dados diretamente no prompt de comando (soma númerica)\n",
    "3 + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou até"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Álgebra Linear'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# imprimindo dados diretamente no prompt de comando (concatenação de string)\n",
    "\"Álgebra\" + \" Linear\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entretanto, esse tipo de impressão dos dados de saída na tela é demasiadamente utilizado em operações simples, sendo de maior uso para testar recursos triviais que podem ser implementados em funções maiores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando lidamos com progamas mais bem estruturados, com scripts bem definidos, devemos utilizar o comando **\"print\"**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# imprimindo dados usando o comando print (soma numérica)\n",
    "print(3 + 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Álgebra Linear\n"
     ]
    }
   ],
   "source": [
    "# imprimindo dados usando o comando print (concatenação de strings)\n",
    "print(\"Álgebra\" + \" Linear\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais adiante vamos ver outras formar de imprimir os dados de saída na tela usando o comando **\"print\"**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipagem Dinâmica: Tipos de Dados em Variáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como foi explanado anteriormente, na linguagem de programação Python, não há mais a necessidade de se inicializar variáveis, pois usamos um recurso chamado **Tipagem Dinâmica**, esse que permite o uso de variáveis que não exigem declarações de **Tipos de Dados**, pois a linguagem é capaz de escolher que tipo utilizar dinamicamente para cada variável, podendo ser alterado em qualquer momento do programa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos agora aprender a trabalhar com **variáveis** no Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|**Tipos de Dados Básicos**|**Comandos**|\n",
    "|--------------------------|------------|\n",
    "|Números|int, long, float e complex|\n",
    "|Strings|str|\n",
    "|Lista e Tuplas|list, tuple|\n",
    "|Dicionários|dict|\n",
    "|Arquívos|file|\n",
    "|Booleanos|bool(True, False)|\n",
    "|Conjuntos|set, frozenset|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definindo variáveis com diversos tipos de dados sem precisar inicializá-las\n",
    "\n",
    "# variável com dados do tipo números inteiros (int) \n",
    "inteiro = 12\n",
    "# variável com dados do tipo números flutuantes (float) \n",
    "flutuante = 3.1434489\n",
    "# variável com dados do tipo string (str)\n",
    "string = \"Eu prefiro morrer do que perder a vida!\"\n",
    "# variável que armazena uma lista com diferentes tipos de dados\n",
    "lista = [1, 2, 3, \"cachorro\", 3.14, \"tchubirabirum\", 5, 6]\n",
    "# variável que armazena uma tupla com um único tipo de dado (int)\n",
    "tupla1 = (1, 2, 3, 4, 5, 6)\n",
    "# variável que armazena uma tupla com um único tipo de dado (str)\n",
    "tupla2 = (\"cachorro\", \"gato\", \"galinha\", \"estudante\")\n",
    "# variável que armazena uma tupla com um único tipo de dado (float)\n",
    "tupla3 = (3.13, 3.14, 3.6756)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja acima os principais tipos de dado que podem ser utilizados em Python. Vamos verificar a forma como eles estão armazenados usando a função **\"type\"**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# usando a função type para identificar o tipo de dado armazenado em uma variável\n",
    "type(inteiro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# usando a função type para identificar o tipo de dado armazenado em uma variável\n",
    "type(flutuante)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# usando a função type para identificar o tipo de dado armazenado em uma variável\n",
    "type(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# usando a função type para identificar o tipo de dado armazenado em uma variável\n",
    "type(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# usando a função type para identificar o tipo de dado armazenado em uma variável\n",
    "type(tupla1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além disso, a definição de tipagem dinâmica garante que é possível alterar o tipo de dado de uma variável a qualquer momento do progama, então podemos ter o seguinte processo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "# imprimindo o dado armazenado na variável inteiro\n",
    "print(inteiro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mundando o tipo de dado da variável inteiro\n",
    "inteiro = \"Álgebra Linear\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Álgebra Linear\n"
     ]
    }
   ],
   "source": [
    "# imprimindo o dado armazenado na variável inteiro\n",
    "print(inteiro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# usando a função type para identificar o tipo de dado armazenado em uma variável\n",
    "type(inteiro)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logo, a tipagem dinâmica nos permite mais versatilidade na criação dos nossos progamas. De modo que não há necessida de se manter preso ao cuidado de não alterar o tipo de dado de uma variável. Todavia, o mesmo recurso que pode ser de grande ajuda também pode permitir erros lógicos, sendo necessário ter todo cuidado necessário para se evitar erros lógicos durante a execução do código. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas e Tuplas, qual a principal diferença entre elas?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma confusão muito comum quando se usa uma **Lista** ou uma **Tupla** em Python é saber diferenciar cada uma delas. Do ponto de vista conceitual devemos utilizar tuplas para montar estruturas de dados heterogêneos enquanto a lista deveria ser usada para dados homogêneos, ou seja, todos seus elementos deveriam ser do mesmo tipo. Veja que a lista contém diferentes tipos de dados armazenados em uma única variável."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'> <class 'str'> <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# vendo os tipos de dados dos elementos usados na lista\n",
    "print(type(lista[0]), type(lista[3]), type(lista[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja acima que foi definido uma lista com diferentes tipos de dados. Além disso, podemos acessar cada elemento individual das listas, tuplas ou arrays sabendo que os elementos são númerados de 0 até (quantidade de elementos - 1), dado que o último elemento é o número de parada. A sintaxe é: **lista[número do elemento]**, **tupla[número do elemento]** ou **array[número da linha][número da coluna]**. Sobre arrays vamos discutir mais detalhadamente em outro progama, dado que é o principal alvo do estudo no nosso repositório e na **Álgebra Linear**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'> <class 'str'> <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# vendo o tipo de dado dos elementos usados na lista\n",
    "print(type(tupla1[0]), type(tupla2[0]), type(tupla3[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja que nas tuplas, devemos iniciar uma variável diferente para cada tipo de dado, diferentemente das listas. Além disso, as tuplas não permitem adicionar ou remover elementos, fato esse que também pode ser feito em uma lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adicionando elemetos a lista usando a função append\n",
    "lista.append(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'cachorro', 3.14, 'tchubirabirum', 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "# imprimindo a variável lista\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja que o número 7 foi adicionado a lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# removendo um elemento da lista usando a função remove\n",
    "lista.remove(lista[8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'cachorro', 3.14, 'tchubirabirum', 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# imprimindo a variável lista\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora veja que o número 7 foi devidamente removido da lista, mostrando que ela é totalmente mutável."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-21-610288ec2f10>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# tentando adicionar um elemento a tupla de dados do tipo inteiro usando a função append\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mtupla1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m6\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "# tentando adicionar um elemento a tupla de dados do tipo inteiro usando a função append\n",
    "tupla1.append(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'remove'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-22-3676f7efa11c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# tentando remover um elemento a tupla de dados do tipo inteiro usando a função remove\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mtupla1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtupla1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'remove'"
     ]
    }
   ],
   "source": [
    "# tentando remover um elemento a tupla de dados do tipo inteiro usando a função remove\n",
    "tupla1.remove(tupla1[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja que não é possível adicionar ou remover nenhum elemento da tupla. Portanto, essas são as principais diferenças entre listas e tuplas no Python. Ou seja, em relação a mutabilidade a lista é plástica e a tupla é rígida."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores Aritméticos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|**Operadores Aritméticos**|**Comando**|\n",
    "|--------------------------|-----------|\n",
    "|Soma                      |+          |\n",
    "|Subtração                 |-          |\n",
    "|Multiplicação             |*          |\n",
    "|Divisão                   |/          |\n",
    "|Exponenciação             |**         |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como já dizia **Bill Gates**, progamar não é nada mais e nada menos do que somar, subtrair, multiplicar e dividir. De fato, a partir desses princípios matemáticos básicos podemos desenvolver qualquer operação complexa sob tutela da manipulações aritméticas. Então, vamos mostrar exemplos de uso para cada operador individualmente. Antes de fazermos isso, é importante saber a ordem pela qual as operações são realizadas, visando contornar erros lógicos em seus progamas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|**Ordem de Precedência dos Operadores Aritméticos**|\n",
    "|---------------------------------------------------|\n",
    "|1 - Parentêses                                     |\n",
    "|2 - Exponenciação                                  |\n",
    "|3 - Multiplicação e Divisão                        |\n",
    "|4 - Soma e Subtração                               |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os operadores com a mesma precedência são avaliados da esquerda para a direita. Quando essa ordem não for tão clara assim, opte por usar parênteses para forçar as ordens das operações, seja por motivos de esquecimentos ou motivos propositais."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# usando operadores aritméticos: soma\n",
    "print(7 + 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# usando operadores aritméticos: subtração\n",
    "print(7 - 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "# usando operadores aritméticos: multiplicação\n",
    "print(7 * 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3333333333333335\n"
     ]
    }
   ],
   "source": [
    "# usando operadores aritméticos: divisão\n",
    "print(7 / 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "343\n"
     ]
    }
   ],
   "source": [
    "# usando operadores aritméticos: exponenciação\n",
    "print(7 ** 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funções da biblioteca Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A própia linguagem de progamação Python oferece inúmeras **funções** para implentar em nossos progamas. Não nos cabe listar todas elas aqui, pois ao longo dos progamas desenvolvidos no nosso repositório elas vão sendo usados e bem comentadas, permitindo o seu aprendizado mais aprofundado nos recursos da linguagem. Vale salientar que podemos utilizar a função **\"dir\"** para saber quais funções estão disponíveis para um tipo de variável. Veja abaixo como utilizar esse recurso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isascii',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# vendo quais funções estão disponíveis para uma variável qualquer\n",
    "# nesse exemplo, vamos ver as funções disponíveis para uma variável que armazena um número inteiro (int)\n",
    "dir(inteiro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__iadd__',\n",
       " '__imul__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__reversed__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'append',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'count',\n",
       " 'extend',\n",
       " 'index',\n",
       " 'insert',\n",
       " 'pop',\n",
       " 'remove',\n",
       " 'reverse',\n",
       " 'sort']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# vendo quais funções estão disponíveis para uma variável qualquer\n",
    "# nesse exemplo, vamos ver as funções disponíveis para uma variável que armazena uma lista (list)\n",
    "dir(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim, de acordo com a necessidade de implementação de recursos em um progama, podemos usar a função **\"dir\"** para conseguir olhar todos os **atributos/propiedades** e **funções/métodos disponíveis** para uma determinada variável."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imprimindo Usando o comando \"print\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que você já sabe sobre as variáveis e o método de tipagem dinâmica com Python, vamos apresentar outras melhores formas de se usar o comando **\"print\"**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "# adicionando um número inteiro do tipo de dado (int) a variável inteiro\n",
    "inteiro = 12\n",
    "\n",
    "# imprimindo uma variável unicamente\n",
    "print(inteiro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 + 6 =  12\n"
     ]
    }
   ],
   "source": [
    "# imprimindo uma variável com uma string explicando-a\n",
    "print(\"6 + 6 = \", inteiro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 + 6 = 12\n"
     ]
    }
   ],
   "source": [
    "# imprimindo uma variável alocando-a adequadamente no local definido para saída de dados\n",
    "print(\"6 + 6 = {}\".format(inteiro))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1434489\n"
     ]
    }
   ],
   "source": [
    "# imprimindo um número flutuante\n",
    "print(\"{}\".format(flutuante))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.143\n"
     ]
    }
   ],
   "source": [
    "# imprimindo um número flutuante com números de casas decimais bem definidas\n",
    "# nesse exemplo, 3 casa decimais após a vírgula\n",
    "print(\"{:.3f}\".format(flutuante))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " string: Eu prefiro morrer do que perder a vida!, número inteiro: 12 e número real: 3.143\n"
     ]
    }
   ],
   "source": [
    "# imprimindo uma saída de dados com mais variáveis alocadas nos espaços desejados\n",
    "print(\" string: {}, número inteiro: {} e número real: {:.3f}\".format(string, inteiro, flutuante))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recebendo Dados de Entrada"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos usar a função **\"input\"** para receber um dado de entrada e adicinar esses dados em variáveis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Insira Algo:  Álgebra Linear é uma disciplina importante\n"
     ]
    }
   ],
   "source": [
    "# recebendo um dado de entrada usando a função \"input\" e armazenando em uma variável\n",
    "entrada = input(\"Insira Algo: \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Álgebra Linear é uma disciplina importante\n"
     ]
    }
   ],
   "source": [
    "# imprimindo o conteúdo informado na variável usando a função \"print\"\n",
    "print(entrada)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# verificando o tipo da variável usando a função \"type\"\n",
    "type(entrada)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que foi digitado um número inteiro, mas foi armazenado como uma string. Isso ocorre pois a função **\"input\"** não funciona com tipagem dinâmica, diferentemente se a variável for inicializada diretamente no progama. Caso seja necessário receber algum tipo de dado do usuário, devemos ter em mente qual tipo de dado será solicitado e inicializá-lo. Veja um exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Insira um número real:  3.14159\n"
     ]
    }
   ],
   "source": [
    "# recebendo um dado de entrada do tipo de dado float e atribuindo a uma variável\n",
    "entrada = float(input(\"Insira um número real: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14159\n"
     ]
    }
   ],
   "source": [
    "# imprimindo o dado usando na variável entrada usando a função \"print\"\n",
    "print(entrada)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# verificando o tipo de dado armazenado na variável entrada\n",
    "type(entrada)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desse modo, caso não seja especificado o tipo de dado a ser inicializado na variável, automaticamente ele será armazenado como uma string. Por esse motivo, especificar o tipo de dado a ser requerido do usuário usando na função **\"input\"** é uma boa prática de programação."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fatiamento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O **fatiamento** pode ser utilizado principalmente em **strings** (que são cadeias de caracteres), **listas**, **tuplas** e **arrays** (esse que será estudado com maior profundidade em outro progama). Basicamente, trata-se do ato de pegar uma parte do todo de qualquer um desses elementos citados acima. Para fazer isso, vamos utilizar os exemplos já criados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eu prefiro\n"
     ]
    }
   ],
   "source": [
    "# fatiando uma string\n",
    "print(string[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na cadeia de caracteres que a string continha, pegamos  o primeiro elemento, começando a contagem em 0, até o elemento 9. Desse modo, a frase \"Eu prefiro morrer do que perder a vida!\" foi fragmentada. Vale a pena lembrar, que a estrutura **\"string[0:10]\"** não está indo até o 10º elemento quando se conta a partir do 0, mas sim até o 9º elemento. Isso ocorre porque nessa situação o último caractere assume o valor de caractere de parada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 'cachorro']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fatiando uma lista\n",
    "# lembrando que começamos a contar a partir do 0 e vamos do 2º elemento até o 3º elemento, \n",
    "# nesse exemplo\n",
    "lista[2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fatiando uma tupla\n",
    "# lembrando que começamos a contar a partir do 0 e vamos do 1º elemento até o 2º elemento, \n",
    "# nesse exemplo\n",
    "lista[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores Lógicos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|**Operadores Lógicos**|**Comandos**|\n",
    "|----------------------|------------|\n",
    "|Igual                 |==          |\n",
    "|Diferente             |!=          |\n",
    "|Menor                 |<           |\n",
    "|Maior                 |>           |\n",
    "|Menor igual           |<=          |\n",
    "|Maior Igual           |>=          |\n",
    "|Booleanos             |True, False |\n",
    "|Conectivos            |and, or     |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os **operadores lógicos** são usados para representar situações lógicas responsáveis por ajudar na tomada de decisões pela máquina e escolhas de opções definidas. Também são chamados conectivos lógicos por unirem duas expressões simples numa composta. Dessa forma, podemos ter ótimas ferramentas computacionais para realizar os nossos algoritmos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# analisando o operador lógico de igualdade\n",
    "7 == 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# analisando o operador lógico de igualdade\n",
    "7 == 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# analisando o operador lógico de diferença\n",
    "7 != 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# analisando o operador lógico de diferença\n",
    "7 != 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# analisando o operador lógico de menor\n",
    "8 < 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# analisando o operador lógico de menor ou igual\n",
    "5 <= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# analisando o operador lógico de maior\n",
    "8 > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# analisando o operador lógico de maior ou igual\n",
    "5 >= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# analisando o concectivo and (e)\n",
    "(7 == 8 and 5 != 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# analisando o conectivo or (ou)\n",
    "(7 == 8 or 5 != 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estrutura de Decisão"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos agora ver estruturas responsáveis por tomadas de decisões, como **\"if\"**, **\"elif\"** e **\"else\"**. Basicamente podemos entender esses comandos, respectivamente, da seguinte forma: se, se não se e caso contrário."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja isso em um exemplo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Insira um primeiro número inteiro:  3\n",
      "Insira um segundo número inteiro:  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "número 01 = 3 e número 02 = 4\n",
      "\n",
      "3 é menor a 4\n"
     ]
    }
   ],
   "source": [
    "# recebendo o valor do primeiro número inteiro (int)\n",
    "numero1 = int(input(\"Insira um primeiro número inteiro: \"))\n",
    "# recebendo o valor do segundo número inteiro (int)\n",
    "numero2 = int(input(\"Insira um segundo número inteiro: \"))\n",
    "\n",
    "# imprimindo os dois números informados pelo usuário\n",
    "print(\"\\nnúmero 01 = {} e número 02 = {}\\n\".format(numero1, numero2))\n",
    "\n",
    "# se o primeiro número informado for maior que o primeiro...\n",
    "if(numero1 > numero2):\n",
    "    # imprime que o primeiro número é maior que o segundo número\n",
    "    print(\"{} é maior a {}\".format(numero1, numero2))\n",
    "# se não for maior, testar se não é igual..\n",
    "elif(numero1 == numero2):\n",
    "    # imprime que o primeiro número é igual ao segundo número\n",
    "    print(\"{} é igual a {}\".format(numero1, numero2))\n",
    "# caso nenhuma sentença acima seja verdadeira...\n",
    "else:\n",
    "    # imprime que o primeiro número é menor que o segundo número\n",
    "    print(\"{} é menor a {}\".format(numero1, numero2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesse exemplo, observe que os comandos **\"if\"**, **\"elif\"** e **\"else\"** devem estar acompanhados por **dois pontos** para indicar o momento pelo qual o conteúdo para cada decisão deve ser implementado. Além disso, observe o **recuo** entre as linhas de código, esse que muito além de estilístico, é usado para indicar **subcomandos de comandos superiores**, sendo obrigatório o seu uso. Além disso, o comando **\"\\n\"** indica ao progama uma quebra de linha."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estrutura de Repetição: for"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A estrutura de repetição **\"for\"** é utilizada quando se deseja repetir determinados passos programados em um número determinando de vezes previamente conhecidos. E para esse fim, geralmente deve-se utilizar o comando auxiliar **\"range\"**, esse que recebe dois comandos de entrada: o número inicial da contagem e o número pela qual deve-se parar. Veja abaixo um exemplo simples de como deve-se usar a estrutura de repetição **\"for\"**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# estrutura de repetição for que vai de 0 - 10\n",
    "for indice in range(0,11):\n",
    "    # imprime o número atual da repetição\n",
    "    print(indice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Você construiu uma máquina do tempo com um Delorean ? "
     ]
    }
   ],
   "source": [
    "# definindo uma lista\n",
    "frase = [\"Você\", \"construiu\", \"uma\", \"máquina\", \"do\", \"tempo\", \"com\", \"um\", \"Delorean\", \"?\"]\n",
    "# estrutura de repetição for que vai de 0 - a quantidade de elementos da lista (função len)\n",
    "for indice in range(0, len(frase)):\n",
    "    # imprime cada elemento da lista no respectivo valor que estiver o indice\n",
    "    # o  comando end = \" \" indica que o progama ao invés de ir para a próxima linha quando terminar o\n",
    "    # subcomando no instante de uma das repetições, ele irá adicionar um caractere em branco\n",
    "    print(frase[indice], end = \" \")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estrutura de repetição: While"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A estrutura de repetição **\"while\"** ela está nas mesmas condições que a estrutura de repetição **\"for\"**. A diferença notável entre as duas é que a **ordem de parada** do **\"for\"** é previsível e a do **\"while\"** não. Por esse motivo, devemos criar uma estrutura de condição para a ordem de parada em uma estrutura de repetição **\"while\"**. Veja um exemplo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1, 1\n",
      "2, 3\n",
      "4, 9\n",
      "8, 27\n",
      "16, 81\n",
      "32, 243\n"
     ]
    }
   ],
   "source": [
    "# inicializando as variáveis \"a\" e \"b\" com o número inteiro (int) 1\n",
    "a, b = 1, 1\n",
    "# enquanto a repetição for verdadeira...\n",
    "while True:\n",
    "    # imprime os valores armazenados nas variáveis \"a\" e \"b\"\n",
    "    print(\"{}, {}\".format(a, b))\n",
    "    # \"a\" é incrementado com \"a * 2\" \n",
    "    a *= 2\n",
    "    # \"b\" é incrementado com \"b * 2\" \n",
    "    b *= 3\n",
    "    # se \"a\" ou \"b\" tiverem um valor armazenado em sua variável menor que 500...\n",
    "    if(a >= 500 or b >= 500):\n",
    "        # para a estrutura de repetição while\n",
    "        break\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja que foi definido a estrutura de repetição **\"while\"** como verdadeira a todo momento. Caso não fosse especificado uma ordem de parada, responsável por quebrar essa repetição, ela entraria em um **laço loop**, tendo como consequência a execução desenfreada dos subcomandos do **\"while\"**. Para contornar esse problema, usamos o comando **\"break\"**, que vamos falar mais um pouco sobre ele agora."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comandos: break e continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O uso de comandos **\"break\"** e **\"continue\"** são grandes aliados para se usar em estruturas de repetições. Com o **\"break\"** o comando irá parar de vez, vamos pensar nele como um freio de mão de um carro, que o faz parar e não é mais possível acelerá-lo. Já o comando **\"continue\"** ele permite dar uma pausa para depois continuar na execução do comando, vamos pensar nele como se fosse um freio de um carro, que o faz desacelerar, mas após isso podemos continuar o processo de aceleração do automóvel. Vamos usar a estrutura de repetição **\"for\"** para tornar essa ideia mais clara."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# estrutura de repetição que vai de 1 - 10\n",
    "for indice in range(1, 11):\n",
    "    # imprime o valor atribuido a variável indice em cada repetição\n",
    "    print(indice)\n",
    "    # se indice for igual a 5...\n",
    "    if(indice == 5):\n",
    "        # comando de parada\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# estrutura de repetição que vai de 1 - 10\n",
    "for indice in range(1, 11):\n",
    "    # imprime o valor atribuido a variável indice em cada repetição\n",
    "    print(indice)\n",
    "    # se indice for igual a 5...\n",
    "    if(indice == 5):\n",
    "        # comando de continuar \n",
    "        continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que para ambos os exemplos definimos uma estrutura de decisão quando a **variável \"indice\"** estivesse armazenando o número inteiro 5. No primeiro exemplo, usamos o subcomando  **\"break\"** para a estrutura de decisão. Desse modo, a estrutura de repetição **\"for\"** parou de executar quando a variável indice armazenava o valor inteiro 5. No segundo exemplo, usamos o mesmo algoritmo, mas o invés de usar o comando de parada **\"break\"**, foi usando o comando de prosseguir **\"continue\"**. Assim, quando a variável indice tinha armazenada o inteiro 5, a estrutura de decisão executou o subcomando **\"continue\"**, indicando que a estrutura de repetição **\"for\"** deveria continuar a executar suas repetições. Logo, os comandos **\"break\"** e **\"continue\"** são ferramentas eficazes em estruturas de repetição."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Criando Suas Própias Funções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como já foi visto, a linguagem de progamação Python é muito rica por possuir inúmeras **funções** prontas para uso. Entretanto, sempre é necessário criar funções própias para finalidades específicas, possibilitando a criação de inúmeros progamas para diversos fins. Vamos analisar como se dá a estrutura de uma função. Para isso, vamos trabalhar com o algoritmo da **sequência de fibonacci** pelo **método recursivo** (função que chama ela mesma, com uma ordem específica de parada)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definindo uma função de nome fibonacci, cujo parâmetro de entrada é o termo que se deseja obter da \n",
    "# sequência\n",
    "def fibonacci (termo):\n",
    "    # caso o termo seja o primeiro, a sequência de fibonacci para esse termo é 1\n",
    "    if(termo == 1):\n",
    "        # a função retorna o valor 1 quando é chamada e se a estrutura de decisão desse subcomando é \n",
    "        #verdadeira\n",
    "        return 1\n",
    "    # caso o termo seja o segundo, a sequência de fibonacci para esse termo é 1\n",
    "    elif(termo == 2):\n",
    "        # a função retorna o valor 1 quando é chamada e se a estrutura de decisão desse subcomando é \n",
    "        #verdadeira\n",
    "        return 1\n",
    "    # caso o termo não seja o primeiro nem o segundo, realiza uma função recursiva para a sequência de \n",
    "    #fibonacci\n",
    "    else:\n",
    "        # explicando a recursão: a função abaixo ela vai recebendo os termos (termo - 1) + (termo - 2) +\n",
    "        # (termo - 2) + (termo - 3) + (termo - 3) + (termo - 4) + (termo - n) + (termo - m), de forma que\n",
    "        # quando (termo - n) == 2 e (termo - m) == 1, teremos uma ordem de parada e a função original que\n",
    "        # fez a recursão terá o número preciso da sequência de fibonacci no termo solicitado\n",
    "        return fibonacci(termo - 1) + fibonacci(termo - 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como toda operação com funções, precisamos de uma **função principal** para organizar o nosso progama. No nosso repositório, essa ideia não será tão relevante, pois estamos mais interessados em mostrar processos da programação aplicados em Álgebra Linear do que em desenvolver um produto final. Entretanto, é importante mostrar como se faz a chamada da função principal, dado que para montar um bom progama, esse quesito faz parte da necessidade do mesmo e é uma boa prática de programação."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definindo a função principal do nosso exemplo\n",
    "def main():\n",
    "    # dando um título ao nosso progama exemplo\n",
    "    print(\"Programa Sequência de Gibonacci.\\n\\n\")\n",
    "    \n",
    "    n = int(input(\"Digite o termo da sequência desejada, em números inteiros: \"))\n",
    "    \n",
    "    # estrutura de repetição for para mostrar a sequência de fibonacci até o termo de parada\n",
    "    for indice in range(1, n + 1):\n",
    "        # imprime os termos de fibonacci que serão definidos na função chamada\n",
    "        # o  comando end = \" \" indica que o progama ao invés de ir para a próxima linha quando terminar o\n",
    "        # subcomando no instante de uma das repetições, ele irá adicionar um caractere em branco\n",
    "        print(fibonacci(indice), \",\", end  = \"\")\n",
    "    \n",
    "    # indicando que a função principal terminou com sucesso\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por fim, após definir que a função principal está chamado a função fibonacci definida, vamos agora fazer a chamada da função principal para executar o progama exemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Programa Sequência de Gibonacci.\n",
      "\n",
      "\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Digite o termo da sequência desejada, em números inteiros:  10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ,1 ,2 ,3 ,5 ,8 ,13 ,21 ,34 ,55 ,"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    main() # chamada da função main"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Há um problema no GitHub que não é possível visualizar os dados de entrada que o usuário digita, mas para exemplicar foi digitado o número inteiro 10, equivalente a quantidade de números da sequência desejada."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alguma Dúvida? Entre em Contato Comigo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Me envie um e-mail](mailto:alysson.barbosa@ee.ufcg.edu.br);"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}