Aula 5 - Desafio em grupo - Gabarito.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![tera.png](images/tera.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula #5 - Desafio em Grupo & Checkpoint #1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O que veremos hoje?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Lógica de programação\n",
    "* Funções\n",
    "* Tipos inputs\n",
    "* Controles de fluxo\n",
    "* Bibliotecas\n",
    "* Python!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O que não veremos hoje?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Machine Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![no.gif](images/no.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup para o bootcamp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![plat.png](images/plat.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recapitulando o DataCamp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!['datacamp.png'](images/datacamp.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![line.png](images/line.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Desafio da aula!\n",
    "## Mercado de Adquirencia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![acquirer.png](images/acquirer.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Para que serve a bandeira?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![fun_with_flags.png](images/fun_with_flags.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fluxo da informação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![fluxo_informacao.png](images/fluxo_informacao.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O desafio da aula de hoje é criar o fluxo de informações durante uma transação.\n",
    "\n",
    "Se o cliente a seguir for passar o cartão, os dados devem ser verificados com o emissor para aprovar a transação."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dados do cartão do cliente e valor da transação\n",
    "\n",
    "\n",
    "| Nº Cartão |     Portador    | Emissor |  Bandeira  | Senha | Valor |\n",
    "|-----------|-----------------|---------|------------|-------|-------|\n",
    "|    4695   | Thales Oliveira |  Nubank | MasterCard |  9259 | R$ 35 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lembrando que o desafio deve ser resolvido em grupo!\n",
    "Vamos ver na nossa aula todas as ferramentas que precisamos pare resolver esse desafio!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![line.png](images/line.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vamos começar?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linguagem de programação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quem já programa na turma? Quais linguagem vocês conhecem?\n",
    "\n",
    "https://pt.wikipedia.org/wiki/Lista_de_linguagens_de_programa%C3%A7%C3%A3o"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Por que Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![why.gif](images/why.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Em C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "int main(void)\n",
    "{\n",
    "    printf(\"hello, world\\n\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Em Java"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HelloWorldApp {\n",
    "    public static void main(String[] args) {\n",
    "        System.out.println(\"Hello World!\"); \n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Em Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estruturas:\n",
    "### Strings, integers, float, listas, tuplas, conjuntos e dicionários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String\n",
    "`String` é o formato que insere no código conteudos de texto. Para declarar uma `string` só precisamos colocar o texto entre aspas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "startup = 'tera'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tipo de dado: <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print('Tipo de dado: {0}'.format(type(startup)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tera\n"
     ]
    }
   ],
   "source": [
    "print(startup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acessar cada letra individualmente em uma `string`. Vamos somente mostrar a letra `T`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'t'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "startup[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A letra `t`da Tera é maiuscula, será que podemos alterar após a declaração?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' 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-20-d93b15fa0468>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mstartup\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'T'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "startup[0] = 'T'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As `strings` são imutáveis, então, se quisermos alterar uma `string` precisamos declara-la novamente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "startup = 'Tera'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tera'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "startup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Onde as caracteristicas das `strings` podem influenciar no seu dia-a-dia?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integers\n",
    "Integers ou `int` em python são os números inteiros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "idade = 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tipo de dado: <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print('Tipo de dado: {0}'.format(type(idade)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Float\n",
    "`float` são os números que não são inteiros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "valor = 12.55"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.55"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "valor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tipo de dado: <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print('Tipo de dado: {0}'.format(type(valor)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Será que os dados declarados como `int` ou `float` podem ser alterados?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "idade = 21.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21.4"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "valor = 22"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "valor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuplas\n",
    "`tuplas` são estruturas que podem conter vários tipos de dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "key_words = ('python', 'data science', 'machine learning', 'programação', 'jupiter', 2019)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tipo de dado: <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "print('Tipo de dado: {0}'.format(type(key_words)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Escrevi o nome do ambiente errado, ao invés de `jupyter`eu escrevi `jupiter`.\n",
    "Vamos tentar substitui-lo?\n",
    "\n",
    "Nesse caso, vamos tentar aplicar os indices como fizemos na tentativa da `string`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key_words[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em python, os índices começam em `zero`. Então no caso da `tupla` que criamos, a palavra `jupiter` está na no indice `4`\n",
    "\n",
    "Porem, como ele é o penúltimo item da nossa tupla, podemos usar também o `-2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jupiter - jupiter\n"
     ]
    }
   ],
   "source": [
    "print(key_words[4], '-', key_words[-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "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-37-359c090a6036>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mkey_words\u001b[0m\u001b[1;33m[\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'jupyter'\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": [
    "key_words[-2] = 'jupyter'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim com as `strings` as `tuplas` também são imutáveis.\n",
    "\n",
    "Se quisermos declarar nossos dados com a intenção de ser mutável?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "key_words = ['python', 'data science', 'machine learning', 'programação', 'jupiter', 2019]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "key_words[-2] = 'jupyter'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['python', 'data science', 'machine learning', 'programação', 'jupyter', 2019]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key_words"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vimos como declarar variáveis e se quiseremos verificar igualdade poderiamos fazer como?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key_words[-2] == 'jupyter'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ta-dá"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desafio\n",
    "O que acontece se fizermos lista com tuplas, tuplas com listas, tuplas com tuplas e listas com listas?\n",
    "\n",
    "E se quisermos editar, quais conseguimos, quais não?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To do - Lista com tuplas\n",
    "lct = [1, 'a', (1, 2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To do - Tupla com lista\n",
    "tcl = ('a', 1, ['tera', 'code'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To do - Tupla com tupla\n",
    "tct = (1, 'pc', (4, 'X'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To do - Lista com lista\n",
    "lcl = ['tera', 42, ['Oi', 55]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dicionários\n",
    "Vamos conhecer mais um jeito de organizar nossas informações em Python, são os dicionários"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "informacoes = {'Nome' : 'Thales',\n",
    "               'Idade' : 25,\n",
    "               'Idiomas' : ['PT-BR EN']}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como podemos acessar o nome?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "0",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-47-d541447c734b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0minformacoes\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 0"
     ]
    }
   ],
   "source": [
    "informacoes[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Thales'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "informacoes['Nome']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dicionários são conjunto de dados chamados `chave-valor`, ou seja, para cara objeto chave, temos um dado correspondente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "informacoes['Nome'] = 'THALES'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conseguimos selecionar somente um conjunto específico de letras dentro do nome?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THA'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "informacoes['Nome'][:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os idiomas estão contidos e uma lista, como separar os idiomas em duas string e criar uma nova lista para o dicionário?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "informacoes['Idiomas'] = informacoes['Idiomas'][0].split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['PT-BR', 'EN']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "informacoes['Idiomas']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesse caso, como estamos acessando uma lista, primeiro selecionamos o índice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PT-BR'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "informacoes['Idiomas'][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Caso queira imprimir somente uma parte do texto, após acessar o elemento da lista, é só selecionar os indices na palavra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BR'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "informacoes['Idiomas'][0][3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desafio\n",
    "Faça com que o jupyter só mostre a palavra `Tera` do dicionário abaixo, em seguida subistitua-o por `Somos Tera`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "desafio =  {'Cor' : ['Verde', 'Preto'], 'Casas' : [101, ('Olá', 1_044_34, ['2A', 9/3])], 'E@' : ['jupyter', 111, ['aret', (1, ['Tera'])]]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Cor': ['Verde', 'Preto'],\n",
       " 'Casas': [101, ('Olá', 104434, ['2A', 3.0])],\n",
       " 'E@': ['jupyter', 111, ['aret', (1, ['Tera'])]]}"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "desafio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tera'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "desafio['E@'][2][1][1][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "desafio['E@'][2][1][1][0] = 'Somos Tera'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Cor': ['Verde', 'Preto'],\n",
       " 'Casas': [101, ('Olá', 104434, ['2A', 3.0])],\n",
       " 'E@': ['jupyter', 111, ['aret', (1, ['Somos Tera'])]]}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "desafio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![show.gif](images/show.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Voltando para o desafio principal da aula"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Nº Cartão |     Portador    | Emissor |  Bandeira  | Senha | Valor |\n",
    "|-----------|-----------------|---------|------------|-------|-------|\n",
    "|    4695   | Thales Oliveira |  Nubank | MasterCard |  9259 | R$ 35 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos declarar essas variáveis? Quais tipos de dados teremos?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "numero_do_cartao = 4695\n",
    "portador = 'Thales Oliveira'\n",
    "emissor = 'Nubank'\n",
    "senha = 9259\n",
    "valor = 35"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esses são os dados que precisamos ser capturados pela maquina e repassados ao banco para realizar a transação.\n",
    "\n",
    "Alguma sugestão de como podemos fazer isso?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![suggestion.gif](images/suggestion.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funções\n",
    "O que precisamos para declarar uma função em python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos criar nossa primeira função em python! Ela deve retornar uma saudação para um nome que você escoher?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def welcome(nome) :\n",
    "    return('Olá ' + nome + '!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos testar a nossa função!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'Thales' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-62-8e181203b6c8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mwelcome\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mThales\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'Thales' is not defined"
     ]
    }
   ],
   "source": [
    "welcome(Thales)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por que deu erro?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Olá Thales!'"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "welcome('Thales')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos sim dar o input como uma variável. Vamos usar a variável `portador` que declaramos acima"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Olá Thales Oliveira!'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "welcome(portador)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existe uma outra maneira de criar funções? \n",
    "\n",
    "Vou dar uma dica!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![lambda.jpeg](images/lambda.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda 👅\n",
    "Lambda são funções anonimas criadas com `lambda`, ao contrário das funeções normais, que são escritas com `def`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "welcome = lambda nome: print('Olá ' + nome + '!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá Thales!\n"
     ]
    }
   ],
   "source": [
    "welcome('Thales')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que tal criarmos uma função que calcula a média de saldo dos usuários de um banco?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primeiro vamos importar o banco de dados de uma das instituições financeiras. Dentro da pasta da `Aula 5` tem uma pasta chamada `data`\n",
    "\n",
    "Lá temos três bancos de dados de três bancos diferentes (Nubank, Neon e Original). Alguma sugestão de como podemos usa-los no python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_nubank = pd.read_csv('../data/db_nubank.csv', sep = ';')\n",
    "df_neon = pd.read_csv('../data/db_neon.csv', sep = ';')\n",
    "df_original = pd.read_csv('../data/db_original.csv', sep = ';')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como podemos visualizar a estrutura dos nossos dados?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>bandeira</th>\n",
       "      <th>Emissor</th>\n",
       "      <th>portador</th>\n",
       "      <th>senha</th>\n",
       "      <th>saldo</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>804</td>\n",
       "      <td>MasterCard</td>\n",
       "      <td>Nubank</td>\n",
       "      <td>Jose Silva</td>\n",
       "      <td>8697</td>\n",
       "      <td>4850</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>7003</td>\n",
       "      <td>MasterCard</td>\n",
       "      <td>Nubank</td>\n",
       "      <td>Luisa Falcioni</td>\n",
       "      <td>9997</td>\n",
       "      <td>3513</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4695</td>\n",
       "      <td>MasterCard</td>\n",
       "      <td>Nubank</td>\n",
       "      <td>Thales Oliveira</td>\n",
       "      <td>9259</td>\n",
       "      <td>243</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3373</td>\n",
       "      <td>MasterCard</td>\n",
       "      <td>Nubank</td>\n",
       "      <td>Cleber Ferraz</td>\n",
       "      <td>5049</td>\n",
       "      <td>1285</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>7667</td>\n",
       "      <td>MasterCard</td>\n",
       "      <td>Nubank</td>\n",
       "      <td>Antonia Alcantara</td>\n",
       "      <td>1729</td>\n",
       "      <td>2231</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     id    bandeira Emissor           portador  senha  saldo\n",
       "0   804  MasterCard  Nubank         Jose Silva   8697   4850\n",
       "1  7003  MasterCard  Nubank     Luisa Falcioni   9997   3513\n",
       "2  4695  MasterCard  Nubank    Thales Oliveira   9259    243\n",
       "3  3373  MasterCard  Nubank      Cleber Ferraz   5049   1285\n",
       "4  7667  MasterCard  Nubank  Antonia Alcantara   1729   2231"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_nubank.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hora de criarmos a função que calcula a media!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "def media(x) :\n",
    "    return(sum(x)/len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3106.5714285714284"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "media(df_nubank['saldo'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tá-daa!\n",
    "\n",
    "Conseguimos criar a função e ela fez o que nós queriamos. Qual alternativa podemos utilizar ao inves de criar uma a uma?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3106.5714285714284"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(df_nubank['saldo'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3106.5714285714284"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_nubank['saldo'].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Condicionais: \n",
    "### If, elif, else, while, for e range "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se quisermos controlar como uma função vai se comportar dado uma situação em específico, podemos usar controladores de fluxo, os quais vão ditar as regras do jogo dentro da nossa função\n",
    "\n",
    "Vamos criar uma função que simule um semaforo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semaforo(cor) :\n",
    "    if cor == 'verde' :\n",
    "        acao = 'Prosseguir!'\n",
    "    elif cor == 'vermelho' :\n",
    "        acao = 'Parar!'\n",
    "    else :\n",
    "        acao = 'Atenção!'\n",
    "    return(acao)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Prosseguir!'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "semaforo('verde')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Atenção!'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "semaforo('amarelo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Parar!'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "semaforo('vermelho')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nós quem definimos as tomadas de decisões, então podemos fazer como quisermos as funções"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semaforo(cor) :\n",
    "    if cor == 'verde' :\n",
    "        acao = 'Prosseguir'\n",
    "    elif cor == 'amarelo' or cor == 'vermelho' :\n",
    "        acao = 'Parar!'\n",
    "    else :\n",
    "        acao = 'Atenção'\n",
    "        \n",
    "    return(acao)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Atenção'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "semaforo('desligado')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quais situações apresentadas a você seriam possíveis de resolver com essa ferramenta?\n",
    "\n",
    "Que tal se aplicarmos no nosso banco de dados?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desafio\n",
    "Crie uma função que a partir das informações do cliente, nosso código retorne o banco que ele usa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To do\n",
    "\n",
    "def qual_banco(emissor) :\n",
    "    if emissor == 'Nubank' :\n",
    "        print('O banco é o Nubank')\n",
    "    elif emissor == 'Neon' :\n",
    "        print('O banco é o Neon')\n",
    "    elif emissor == 'Original' :\n",
    "        print('O banco é o Original')\n",
    "    else :\n",
    "        print('Banco não cadastrado!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos testar nossa função com o dados do cliente que inserimos anteriormente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A resposta que esperamos é : Nubank\n"
     ]
    }
   ],
   "source": [
    "print('A resposta que esperamos é : {0}'.format(emissor))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O banco é o Nubank\n"
     ]
    }
   ],
   "source": [
    "qual_banco(emissor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos testar para um usuário aleatório do banco de dados?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Original'"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_original.loc[1,'Emissor']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "emissor2 = df_original.iloc[1]['Emissor']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos consultar direto do nosso dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O banco é o Original\n"
     ]
    }
   ],
   "source": [
    "qual_banco(emissor2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voltando ao exemplo do `semaforo`,vamos fazer uma contagem regressiva para ele mudar da cor `Vermelha` para a `Verde`\n",
    "\n",
    "Qual condicionais vocês usariam?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contagem_regressiava_while(tempo) :\n",
    "    while (tempo > 0) :\n",
    "        print(tempo)\n",
    "        tempo = tempo - 1\n",
    "    print('Go go go!!!!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "1\n",
      "Go go go!!!!\n"
     ]
    }
   ],
   "source": [
    "contagem_regressiava_while(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar o `for` e o `range` para ter o mesmo efeito de contagem regressiva"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contagem_regressiva_for(tempo):\n",
    "    for numero in range(tempo, 0, -1):\n",
    "        print(numero)\n",
    "    print('Go go go!!!!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "1\n",
      "Go go go!!!!\n"
     ]
    }
   ],
   "source": [
    "contagem_regressiva_for(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desafio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos fazer uma contagem regresiva reversa? Vamos fazer os números aparecerem na ordem crescente!\n",
    "\n",
    "Coloque um `print` da sua escolha no final, para garantir que deu certo! Uhulllll!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contagem_reversa(tempo):\n",
    "    while tempo < 4:\n",
    "        print(tempo)\n",
    "        tempo = tempo + 1\n",
    "    print(\"Go go go!!!!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "Go go go!!!!\n"
     ]
    }
   ],
   "source": [
    "contagem_reversa(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contagem_reversa(tempo):\n",
    "    for numero in range(1, tempo + 1, 1):\n",
    "        print(numero)\n",
    "    print(\"Go go go!!!!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "Go go go!!!!\n"
     ]
    }
   ],
   "source": [
    "contagem_reversa(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Voltando ao nosso desafio!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Já temos os bancos de dados de três bancos, precisamos agora criar nosso código para que o fluxo da informação seja completo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aqui vão algumas dicas:\n",
    "* O desafio é em grupo, aproveite a troca com o coleguinha\n",
    "* Utilize funções\n",
    "* Crie uma função para cada um dos participantes do fluxo da informação no pagamento\n",
    "* Não esqueça de verificar se o saldo disponível é compativel com o valor da compra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Façam o teste com os dados do cliente que inserimos anteriormente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dados do cartão do cliente e valor da transação\n",
    "\n",
    "numero_do_cartao = 4695\n",
    "portador = \"Thales Oliveira\"\n",
    "emissor = \"Nubank\"\n",
    "bandeira = \"MasterCard\"\n",
    "senha = 9259\n",
    "valor = 35"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crie aqui a função da Stone (Adquirente)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crie a função da adquirente, lembre-se que a função dela é comunicar com a bandeira do usuário e transmitir os dados\n",
    "\n",
    "def Stone(numero_do_cartao, portador, emissor, bandeira, senha, valor) :\n",
    "    \n",
    "    # Condicional usado para fazer o direcionamento de dados para cada uma das bandeiras\n",
    "    \n",
    "    if bandeira == 'MasterCard' :\n",
    "        MasterCard(numero_do_cartao, portador, emissor, senha, valor)\n",
    "    \n",
    "    elif bandeira == 'Visa' :\n",
    "        Visa(numero_do_cartao, portador, emissor, senha, valor)\n",
    "    \n",
    "    else :\n",
    "        print('Falha de comunicação com a bandeira ' + bandeira)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crie aqui a função das bandeiras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crie a função das bandeiras, lembre-se que a função delas é comunicar com o banco que emite o cartão e transmitir os dados\n",
    "\n",
    "def MasterCard(numero_do_cartao, portador, emissor, senha, valor) :\n",
    "    \n",
    "    # Condicional para direcionar os dados para cada um dos bancos emissores\n",
    "    \n",
    "    if emissor == 'Nubank' :\n",
    "        Nubank(numero_do_cartao, portador, senha, valor)\n",
    "    \n",
    "    elif emissor == 'Neon' :\n",
    "        Neon(numero_do_cartao, portador, senha, valor)\n",
    "    \n",
    "    elif emissor == 'Original' :\n",
    "        Original(numero_do_cartao, portador, senha, valor)\n",
    "    \n",
    "    else :\n",
    "        print('Falha de comunicação com o emissor ' + emissor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crie aqui a função dos emissores (bancos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crie a função dos emissores, onde eles recebem os dados do cliente e validam as informaçoes de segunraça e saldo do cliente\n",
    "\n",
    "\n",
    "def Nubank(numero_do_cartao, portador, senha, valor) :\n",
    "\n",
    "    # Descobrindo qual linha do banco de dados nosso cliente está\n",
    "    \n",
    "    index = \n",
    "    df_nubank[df_nubank['id'] == numero_do_cartao].index[0]\n",
    "    \n",
    "    # Condicional para verificação de nome, dentro dela verificamos a senha e por fim o saldo\n",
    "    \n",
    "    # Verificação do nome do portador\n",
    "    if df_nubank.iloc[index]['portador'] == portador :\n",
    "        print('Nome verificado!')\n",
    "        \n",
    "        # Verificação da senha do portador\n",
    "        if df_nubank.iloc[index]['senha'] == senha:\n",
    "            print('Senha verificada!')\n",
    "            \n",
    "            # Verificação do Saldo do cliente\n",
    "            if df_nubank.iloc[index]['saldo'] >= valor :\n",
    "\n",
    "                print('Compra de R$' + str(valor) + ' aprovada!')\n",
    "                \n",
    "                # Caso aprovada, o saldo é atualizado\n",
    "                df_nubank.loc[index,'saldo'] = df_nubank.loc[index,'saldo'] - valor\n",
    "                \n",
    "                print('Seu saldo final é: R$' + str(df_nubank.iloc[index]['saldo']))\n",
    "            \n",
    "            else :\n",
    "                print('Saldo insuficiente!')\n",
    "                \n",
    "        else :\n",
    "            print('Senha invalida!')\n",
    "    \n",
    "    else :\n",
    "        print('Nome invalido')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nome verificado!\n",
      "Senha verificada!\n",
      "Compra de R$35 aprovada!\n",
      "Seu saldo final é: R$173\n"
     ]
    }
   ],
   "source": [
    "Stone(numero_do_cartao, portador, emissor, bandeira, senha, valor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}