Aula_2_shePY.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Aula 2 - shePY.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPQ3L3/AW2FLk9f2XYA1VGH",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/victoriapaganotto/shepy/blob/main/Aula_2_shePY.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yLsmKQOjRAr_"
      },
      "source": [
        "## Aula 2 - shePY\n",
        "\n",
        "Conceitos trabalhados em aula: **strings, listas, tuplas** e **dicionários** em Python.\n",
        "Além disso, será trabalhado como importar módulos e bibliotecas.\n",
        "\n",
        "### Utilizando módulos:\n",
        "\n",
        "Até o momento, nós aprendemos como realizar as operações básicas com o Python, mas agora podemos começar a aprender a usar módulos/bibliotecas, para ir além!\n",
        "\n",
        "* Uma biblioteca é um conjunto de módulos.\n",
        "* Módulos são programas feitos para serem reaproveitados em outros programas.\n",
        "* Há diversos módulos do Python que fazem parte de uma biblioteca padrão.\n",
        "\n",
        "Se eu precisar de algumas funcionalidades que as funções básicas não estão conseguindo realizar na aplicação que eu estou construindo, eu preciso **importar** algumas funcionalidades de fora.\n",
        "\n",
        "Exemplo de biblioteca padrão do Python: **math**.\n",
        "O **math** fornece acesso às funções matemáticas.\n",
        "Algumas funcionalidades:\n",
        "* *ceil*: arredonda o valor para cima;\n",
        "* *floor*: arredonda o valor para baixo;\n",
        "* *sqrt*: retorna a raiz quadrada;\n",
        "* *pow*: potenciação.\n",
        "\n",
        "**Exemplo:** biblioteca: todas as bebidas do mercado\n",
        "\n",
        "**import** bebidas **from** bebidas **import** *refrigerante*\n",
        "\n",
        "Até a forma como você vai referenciar muda um pouco dependendo da forma de como você utiliza esses comandos.\n",
        "Comando utilizando **from** economiza um pouco mais de memória.\n",
        "\n",
        "Se eu quisesse achar a raíz quadrada de 9:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BMxWdVYmQZwG",
        "outputId": "df00c2c3-ed20-4192-a97b-692fe5314a24"
      },
      "source": [
        "raiz = 9 ** (1/2)\n",
        "print(raiz)"
      ],
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xoPoX9MDU11j",
        "outputId": "a869b2d8-fe3f-4ffb-baf6-35e9fe7ff1f8"
      },
      "source": [
        "import math # Importando a Lib inteira!\n",
        "raiz = math.sqrt(9)\n",
        "print(raiz)"
      ],
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n-xxKBnOVSlZ",
        "outputId": "77bc0211-c7d2-4d2f-f677-d85cbddd0a68"
      },
      "source": [
        "from math import sqrt # Nesse momento está sendo importado somente a funcionalidade de raíz quadrada\n",
        "raiz = sqrt(9)\n",
        "print(raiz)"
      ],
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kK-A1ENaViQB"
      },
      "source": [
        "# Se eu quiser utilizar várias funcionalidades?\n",
        "# Caso queira, é interessante importar tudo com o comando **import**\n",
        "\n",
        "import math"
      ],
      "execution_count": 80,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hEpzdorPV2SD",
        "outputId": "0b36f10e-7736-4085-ebc9-af414d112fe0"
      },
      "source": [
        "number = float(input('Digite um número:'))\n",
        "raiz = math.sqrt(number)\n",
        "potencia = math.pow(number, 2)\n",
        "print('A raíz quadrada de {} é {} e ao elevarmos {} por 2 o resultado é de {}'.format(number, raiz, number, potencia))"
      ],
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Digite um número:9\n",
            "A raíz quadrada de 9.0 é 3.0 e ao elevarmos 9.0 por 2 o resultado é de 81.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C8sVn3_eWwTq"
      },
      "source": [
        "# Para economizar memória, pode-se importar apenas **sqrt** e **pow**\n",
        "\n",
        "from math import sqrt, pow"
      ],
      "execution_count": 82,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sh1QVJrHW8Qq",
        "outputId": "5da49d22-9198-4a5d-a78e-61bfd7b2fa72"
      },
      "source": [
        "number = float(input('Digite um número:'))\n",
        "raiz = sqrt(number)\n",
        "potencia - pow(number, 2)\n",
        "print('A raíz quadrada de {} é {} e ao elevarmos {} por 2 o resultado é de {}'. format(number, raiz, number, potencia))"
      ],
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Digite um número:9\n",
            "A raíz quadrada de 9.0 é 3.0 e ao elevarmos 9.0 por 2 o resultado é de 81.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9cb2mwQdX0hf"
      },
      "source": [
        "## Módulo random:\n",
        "\n",
        "Gera números pseudo aleatórios para várias distribuições."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s0p20xO0YCQJ",
        "outputId": "e9c10a40-bc48-425a-eac3-39e9185032af"
      },
      "source": [
        "import random\n",
        "aluno1 = str(input('Primeira aluna: '))\n",
        "aluno2 = str(input('Segunda aluna: '))\n",
        "aluno3 = str(input('Terceira aluna: '))\n",
        "aluno4 = str(input('Quarta aluna: '))\n",
        "\n",
        "lista_alunas = [aluno1, aluno2, aluno3, aluno4]\n",
        "\n",
        "escolhida = random.choice(lista_alunas)\n",
        "print('A pessoa escolhida foi: {}'.format(escolhida))"
      ],
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Primeira aluna: Valentina\n",
            "Segunda aluna: Maria\n",
            "Terceira aluna: Ana\n",
            "Quarta aluna: Madalena\n",
            "A pessoa escolhida foi: Valentina\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DC3M3zxKY9lf",
        "outputId": "cc7dfbb6-e145-4f31-8f88-e750b1b0a641"
      },
      "source": [
        "import random\n",
        "lista_alunas = ['Maria', 'Michelle', 'Ana', 'Joana']\n",
        "\n",
        "escolhida = random.choice(lista_alunas)\n",
        "print('A pessoa escolhida foi: {}'. format(escolhida))"
      ],
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A pessoa escolhida foi: Michelle\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u95hw_dfZVx2"
      },
      "source": [
        "## Utilizamos listas nos exercícios anteriores, mas o que são listas?\n",
        "\n",
        "Lista é uma coleção de elementos (de tamanho dinâmico).\n",
        "Cada elemento possui uma posição dentro da lista, essa posição é chamada de índice. O primeiro elemento fica armazenado no índice 0 e o último elemento no índice n-1.\n",
        "\n",
        "**Observação:** \"n\" é a quantidade de elementos presente na lista.\n",
        "\n",
        "**Criando listas!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XCl_VxD0aCrN"
      },
      "source": [
        "lista_reais = [1.5, -2,13, 5.14]\n",
        "lista_strings = ['Java', 'R', 'Python', 'Javascript']\n",
        "lista_booleanos = [True, True, False, True]\n",
        "lista_misturada = [1, 2, 3.14159, 'teste']"
      ],
      "execution_count": 86,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M4DVnT5HapOa",
        "outputId": "e3ea9d99-ddf3-40bb-ebd3-89b51920d0ce"
      },
      "source": [
        "type(lista_reais)"
      ],
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DaTeNZLXasSg",
        "outputId": "5a78a967-a0c1-416f-e7dc-54a7cc84d5ad"
      },
      "source": [
        "lista_reais"
      ],
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1.5, -2, 13, 5.14]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZSfKDqyPax9r"
      },
      "source": [
        "**Acessando elementos de uma lista:**\n",
        "\n",
        "Você deve passar o nome da lista que deseja acessar e passar o pindice do elementos desejado entre colchetes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "16xTKbaJa0uc",
        "outputId": "595fc1ab-2277-4505-92c7-bf27574279f0"
      },
      "source": [
        "# Acessando o primeiro elemento presente na lista\n",
        "lista_reais[0]"
      ],
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4QUk0FQybI79",
        "outputId": "338417c6-0b11-460a-8528-1f16e8181164"
      },
      "source": [
        "# Acessando o pultimo elemento presente na lista\n",
        "lista_reais[-1]"
      ],
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nMYex5EwbQm1"
      },
      "source": [
        "**Como acessar 'Python' dentro da lista de strings criada?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EeB7PCDlbWJZ",
        "outputId": "9ef04b74-26bb-41b5-a3cd-cbc1da332ffc"
      },
      "source": [
        "lista_strings[2:3]"
      ],
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Python']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 91
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WAEnULCIbYgO",
        "outputId": "20ccbf8f-0865-493d-dca1-01be7b8460f3"
      },
      "source": [
        "# Percebemos que não conseguimos acessar o Javascript\n",
        "lista_strings[2:4]"
      ],
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Python', 'Javascript']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UF0H2vFBbvrO",
        "outputId": "b4741ffe-d11c-42ed-edf8-4ccbb07618a7"
      },
      "source": [
        "lista_strings[2:]"
      ],
      "execution_count": 93,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Python', 'Javascript']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CKdUizAsb2UE"
      },
      "source": [
        "**Posso atribuis novos valores para elementos de uma lista?** \n",
        "\n",
        "A resposta é: **SIM!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J-aoym9ub53h",
        "outputId": "1e6b3c98-3ecb-421b-cb86-998282397dcf"
      },
      "source": [
        "lista_strings"
      ],
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Java', 'R', 'Python', 'Javascript']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Oijdudc0cDpZ",
        "outputId": "d8413528-8c7c-4846-f34e-e18c2fd1be74"
      },
      "source": [
        "# Substrituindo Java por C++\n",
        "lista_strings[0] = 'C++'\n",
        "lista_strings"
      ],
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['C++', 'R', 'Python', 'Javascript']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 95
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z5xz0oy6cUBc"
      },
      "source": [
        "**Funções aplicáveis a uma lista:**\n",
        "\n",
        "Função |    Descrição                                     |  Exemplo\n",
        "-------|--------------------------------------------------|--------------\n",
        "len    |  Retorma a quantidade de elementos de uma lista  |  *len (lista)*\n",
        "max    |  Retorma o maior elemento de uma lista           |  *max (lista)*\n",
        "min    |  Retorma o menor elemento de uma lista           |  *min (lista)*\n",
        "sum    |  Retorna o somatório dos elementos de uma lista  |  *sum (lista)*\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fQI4IXvIfyPH",
        "outputId": "e8e06201-78d5-40e6-e58c-73e63359371e"
      },
      "source": [
        "lista_reais"
      ],
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1.5, -2, 13, 5.14]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5ZAMU85wgLDG",
        "outputId": "d7ff81b2-d330-42bb-8cdf-150f0ac7ae3c"
      },
      "source": [
        "len(lista_strings)"
      ],
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 97
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lICCwJRBgymq",
        "outputId": "c5d07de2-47f9-4477-eabd-96bf7d85726e"
      },
      "source": [
        "max(lista_reais)"
      ],
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "13"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 98
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K6W-54awg0W9",
        "outputId": "69da26bc-eaf4-4189-87cf-bf5dc055c836"
      },
      "source": [
        "min(lista_reais)"
      ],
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 99
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AhpHrEEhg4oi",
        "outputId": "0941ed10-3d9a-4920-f822-6359ffdbd170"
      },
      "source": [
        "sum(lista_reais)"
      ],
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "17.64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wUkNqm8-hDVu"
      },
      "source": [
        "**Principais métodos de um objeto de uma lista:**\n",
        "\n",
        "* *append*: adiciona um elemento no final da lista:\n",
        "\n",
        "``` lista.append(10)```\n",
        "* *clear*: apaga todos os elementos de uma lista:\n",
        "\n",
        "```lista.clear()```\n",
        "* *copy*: retorna uma cópia dos elementos da lista:\n",
        "\n",
        "```copia = lista.copy()```\n",
        "* *count*: retorna a quantidade de ocorrências de um elemento na lista:\n",
        "\n",
        "```qt = lista.extend(outra_lista)```\n",
        "* *extend*: adiciona elementos de outra lista passada por parâmetro:\n",
        "\n",
        "```lista.extend(outra_lista)```\n",
        "* *index*: retorna o índice do elemento passado por parâmtro (primeira posição):\n",
        "\n",
        "```pos5 = lista.index(5)```\n",
        "* *insert*: adiciona um elemento em uma posição passada por parâmetro (adiciona no final, caso a posição não exista):\n",
        "\n",
        "```lista.insert(3, \"Maria\")```\n",
        "* *pop*: remove o elemento na posição passada por parâmetro (provoca um erro caso a posição não exista);\n",
        "\n",
        "```elemento = lista.pop(3)```\n",
        "\n",
        "* *remove*: remove o elemento passado por parâmetro (provoca um erro caso o elemento não exista):\n",
        "\n",
        "```lista.remove(5)```\n",
        "* *reverse*: inverte a ordem dos elementos de uma lista:\n",
        "\n",
        "```lista.reverse()```\n",
        "* *sort*: ordena os objetos de uma lista:\n",
        "\n",
        "```lista.sort()```\n",
        "\n",
        "```lista.sort(reverse = True)```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XTiaycwtg8yu"
      },
      "source": [
        "lista_gatos = ['SRD', 'Siames', 'Persa'] "
      ],
      "execution_count": 101,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q33fhcBgkNQq"
      },
      "source": [
        "Adicionando a raça **Sphynx** no fim da lista de gatos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "58eceY31kpJM"
      },
      "source": [
        "lista_gatos.append('Sphynx')"
      ],
      "execution_count": 102,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lMmKRKVzk0pI",
        "outputId": "fd88ad6f-88fe-4f31-ca4f-8668097920d7"
      },
      "source": [
        "lista_gatos"
      ],
      "execution_count": 103,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['SRD', 'Siames', 'Persa', 'Sphynx']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 103
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zszczbPTlsLC"
      },
      "source": [
        "Contando quantas vezes a palavras **Persa** aparece na lista!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0J4ZFIlxlxXG",
        "outputId": "093b17b1-25c6-4a21-d413-782560843c26"
      },
      "source": [
        "lista_gatos.count('Persa')"
      ],
      "execution_count": 104,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 104
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dHQ0oHC6mMf6"
      },
      "source": [
        "Adicionando a raça **Himalaia** no começo da lista de gatos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O4cG3t9bmR5v",
        "outputId": "ac468766-756f-4dd7-a484-4b9b0b1b3717"
      },
      "source": [
        "lista_gatos.insert(0, 'Himalaia') # Importante, a lista inicia do 0\n",
        "lista_gatos"
      ],
      "execution_count": 105,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Himalaia', 'SRD', 'Siames', 'Persa', 'Sphynx']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 105
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6xy5Wjwvm2uZ"
      },
      "source": [
        "E se quisermos remover o SRD da nossa lista? \n",
        "\n",
        "Alguma ideia? \n",
        "\n",
        "Temos dois modos:\n",
        "* pop\n",
        "* remove"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bw10XE8Dm6C7",
        "outputId": "d91b25b0-76e8-4519-dd80-4ebb0e1f8074"
      },
      "source": [
        "# EXEMPLO: utilização do pop, que remove o elemento na posição passada por parâmetro\n",
        "lista_gatos.pop(1)\n",
        "lista_gatos"
      ],
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Himalaia', 'Siames', 'Persa', 'Sphynx']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 106
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E544uS-onTSA",
        "outputId": "11b72a44-4aa8-4c65-c9b3-929fb707ed84"
      },
      "source": [
        "lista_gatos.insert(1, 'SDR')\n",
        "lista_gatos"
      ],
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Himalaia', 'SDR', 'Siames', 'Persa', 'Sphynx']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sjuee1sQofSn"
      },
      "source": [
        "## Desafio:\n",
        "1. Crie uma lista contendo os seguintes nomes de filmes: 'As Branquelas', 'Vovózona', 'Meninas Malvadas',. Armazene essa lista na variável **filmes**;\n",
        "2. Adicione 'Zumbilândia' ao final da lista de filmes;\n",
        "3. Substitua o filme 'Vovózona' por 'Divertidamente'."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rf5NaGwmnZvl"
      },
      "source": [
        "filmes = ['As Branquelas', 'Vovózona', 'Meninas Malvadas']\n"
      ],
      "execution_count": 116,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L0503h5VpGG_",
        "outputId": "4f7bcdc0-37d0-47a3-99fe-44baa1a4078f"
      },
      "source": [
        "filmes.append('Zumbilândia')\n",
        "filmes"
      ],
      "execution_count": 117,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['As Branquelas', 'Vovózona', 'Meninas Malvadas', 'Zumbilândia']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 117
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3yYapd_LpLLb",
        "outputId": "0b0ea21b-50a8-41c3-974f-20d40a202391"
      },
      "source": [
        "filmes[1] = 'Divertidamente' #Substituição de de 'Vovózona' por 'Divertidamente'\n",
        "filmes"
      ],
      "execution_count": 118,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['As Branquelas', 'Divertidamente', 'Meninas Malvadas', 'Zumbilândia']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 118
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UIKqlUcOpYy1"
      },
      "source": [
        "## Tuplas:\n",
        "Assim como a Lista, uma Tupla em Python é uma coleção de elementos.\n",
        "* A principal diferença entre as estruturas é a propriedade de imutabilidade das tuplas. Isso significa que, uma vez definidos os seus elementos, a tupla não pode mais ser alterada.\n",
        "\n",
        "**Criando tuplas!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mbO8wQ0opbu7"
      },
      "source": [
        "tupla = (3, 19, 4, 21, 3, 5, 13)"
      ],
      "execution_count": 119,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6ALlmjztp0FW",
        "outputId": "a190c497-9cd2-41ba-cf95-c59d3f18dfca"
      },
      "source": [
        "type(tupla) # Como saber o tipo?"
      ],
      "execution_count": 120,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 120
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V16mSFmop68R"
      },
      "source": [
        "** Como acessar elementos de umaa tupla?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 180
        },
        "id": "DNc1S1OFp1PS",
        "outputId": "aad2ee6a-223d-49a0-e077-03ab40212aed"
      },
      "source": [
        "# Atribuindo o valor de 5 ao índice de 0 de tupla provocará um erro!\n",
        "tupla[0] = 5"
      ],
      "execution_count": 121,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-121-b18752c06ecf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Atribuindo o valor de 5 ao índice de 0 de tupla provocará um erro!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtupla\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vL_6hYNOqQLb"
      },
      "source": [
        "** Convertendo uma tupla em uma lista!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nVLIxekmqO4n",
        "outputId": "7718c1ad-4a95-4136-b948-86ab9450e0ef"
      },
      "source": [
        "nova_lista = list(tupla)\n",
        "nova_lista"
      ],
      "execution_count": 123,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3, 19, 4, 21, 3, 5, 13]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 123
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7efxY96uqgLa"
      },
      "source": [
        "## Dicionários \n",
        "* Um dicionário é uma coleção de elementos que possuem uma *chave* e um *valor*;\n",
        "* Ao invés de um índice, usamos a *chave* para recuperar um *valor*.\n",
        "\n",
        "Assim, o principal propósito de um dicionário é associar um valor (value) a uma chave (key).\n",
        "\n",
        "**Criando dicionários**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3Ewo-3_Pq38U",
        "outputId": "0d2bc7d0-8a39-4529-e11b-0a6fe641ebd5"
      },
      "source": [
        "# Criando dicionários com pares de chave e de valor\n",
        "\n",
        "# Dicionário de estados: chave é a sigla do estado e o valor é o nome completo\n",
        "dic_estados = {'MG':'Minas Gerais', 'PR':\"Paran\", 'BA':'Bahia', 'RN':'Rio Grande do Norte', 'SP':'São Paulo'}\n",
        "# IMPORTANTE! O nome dos estado do Paraná foi digitado errado de forma intencional!\n",
        "dic_estados"
      ],
      "execution_count": 124,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'BA': 'Bahia',\n",
              " 'MG': 'Minas Gerais',\n",
              " 'PR': 'Paran',\n",
              " 'RN': 'Rio Grande do Norte',\n",
              " 'SP': 'São Paulo'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 124
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CP88hIt3rl3j",
        "outputId": "28c6d286-f7fa-4503-c267-5e09e2f6341c"
      },
      "source": [
        "# Dicionário de produtos: chave é o código e o valor é a descrição do produto!\n",
        "dic_produtos = {1215:'Lápis', 3221:'Caneta', 2329:'Borracha', 1092:'Caderno', 7633:'Cola'}\n",
        "dic_produtos"
      ],
      "execution_count": 126,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{1092: 'Caderno',\n",
              " 1215: 'Lápis',\n",
              " 2329: 'Borracha',\n",
              " 3221: 'Caneta',\n",
              " 7633: 'Cola'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 126
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QoeK0ZqcsHps",
        "outputId": "3a5d012a-c85b-4534-fd60-36b96f75cbd7"
      },
      "source": [
        "# Dicionários de alunos: chave é o nome e o valor é uma lista com 3 notas do aluno\n",
        "dic_notas_alunos = {'João':[6, 8, 4], 'Maria':[10, 9, 10], 'José':[8, 9.5, 7]}\n",
        "dic_notas_alunos"
      ],
      "execution_count": 127,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'José': [8, 9.5, 7], 'João': [6, 8, 4], 'Maria': [10, 9, 10]}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 127
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u4Q9h6EWs2qC",
        "outputId": "d5f02c42-ad17-472a-e7c4-0d4e4b1ba872"
      },
      "source": [
        "# Dicionário de alunos 2: chave é o nome e o valor é o outro dicionário contendo 3 notas do aluno\n",
        "dic_notas_alunos2 = {'João': {'nota1': 6, 'nota2': 8, 'nota3': 4}, \n",
        "                     'Maria': {'nota1': 10, 'nota2': 9, 'nota3': 10}, \n",
        "                     'José': {'nota1': 8, 'nota2': 9.5, 'nota3': 7}, \n",
        "                    }\n",
        "dic_notas_alunos2"
      ],
      "execution_count": 128,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'José': {'nota1': 8, 'nota2': 9.5, 'nota3': 7},\n",
              " 'João': {'nota1': 6, 'nota2': 8, 'nota3': 4},\n",
              " 'Maria': {'nota1': 10, 'nota2': 9, 'nota3': 10}}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 128
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nfZzXr2buk_z"
      },
      "source": [
        "** Acessando um valor em um dicionário através de uma chave!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "i7Pgje5Sup3h",
        "outputId": "1bc11ff0-6741-4de4-e1c4-3b8d5acf5ede"
      },
      "source": [
        "# Acessando o valor associado à chave \"MG\"\n",
        "dic_estados['MG']"
      ],
      "execution_count": 129,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Minas Gerais'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 129
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "wqCJsHoluwbI",
        "outputId": "a033fc36-b8f7-4305-d737-8b86cc4530f8"
      },
      "source": [
        "# Acessando o valor associado à chave 2329\n",
        "dic_produtos[2329]"
      ],
      "execution_count": 130,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Borracha'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 130
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gKKHswJhu2rf",
        "outputId": "7873f881-ab5b-4f3a-d287-57799a2f95a6"
      },
      "source": [
        "# Acessando a nota da primeira prova do João, no dicionário dic_notas_alunos2\n",
        "dic_notas_alunos2['João']['nota1']"
      ],
      "execution_count": 131,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 131
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VgreDPL7v96N"
      },
      "source": [
        "** Alterando valores em dicionários**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L2IfQvK_vDrw",
        "outputId": "40ed58d4-0ece-4ab9-f47a-e187bfc9a260"
      },
      "source": [
        "# Corrigindo o nome do estado do Paraná!\n",
        "dic_estados['PR'] = 'Paraná'\n",
        "dic_estados"
      ],
      "execution_count": 132,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'BA': 'Bahia',\n",
              " 'MG': 'Minas Gerais',\n",
              " 'PR': 'Paraná',\n",
              " 'RN': 'Rio Grande do Norte',\n",
              " 'SP': 'São Paulo'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 132
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ruNcH6UVwEw1"
      },
      "source": [
        "**Principais métodos de um objeto dicionários**\n",
        "* *clear*: apaga todos os elementos de um dicionário:\n",
        "\n",
        "```dic.clear()```\n",
        "* *copy*: retorna uma copia dos elementos de um dicionário:\n",
        "\n",
        "```dic_copia = dic.copy()```\n",
        "* *fromkeys*: retorna um dicionário a partir de uma sequência de chaves:\n",
        "\n",
        "```exemplo = dic.fromkeys({'k1','k4','k5'}0```\n",
        "* *get*: retorna o valor associado a uma chave:\n",
        "\n",
        "```dic.get('k1, 0)```\n",
        "\n",
        "``` dic.get('k1', 0)```\n",
        "* *items*: retorna uma visão dos pares chave/valor de um dicionário:\n",
        "\n",
        "```dic.items()```\n",
        "* *leys*: retorna uma visão das chaves e um dicionário:\n",
        "\n",
        "```dic.keys()```\n",
        "* *pop*: remove e retorna o elemento associado à chave passada por parâmetro (provoca erro se a chave não existir):\n",
        "\n",
        "```dic.pop(2)```\n",
        "\n",
        "* *popitem*: remove e retorna o último elemento adicionado ao dicionário:\n",
        "\n",
        "```dic.popitem()```\n",
        "* *setdefault*: retorna o valor associado a uma chave (se existir). Caso não exista, insere a chave como o valor (opcional) no dicionário:\n",
        "\n",
        "```dic.setdefaul(2, 'dois')```\n",
        "* *update*: adiciona ao dicionário os pares de chave/valor de outro dicionário passado por parâmetro:\n",
        "\n",
        "```dic.update(dic2)```\n",
        "* *values*: retorna uma visão dos valores de um dicionário:\n",
        "\n",
        "```dic.values```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DASpOpvOyXw6",
        "outputId": "52f691ad-e456-44e0-b4a2-4bf4a91b41ba"
      },
      "source": [
        "dic_estados.items()"
      ],
      "execution_count": 133,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_items([('MG', 'Minas Gerais'), ('PR', 'Paraná'), ('BA', 'Bahia'), ('RN', 'Rio Grande do Norte'), ('SP', 'São Paulo')])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 133
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZVLZcHsBydVs"
      },
      "source": [
        "## Desafio:\n",
        "1. Crie um dicionário de **filmes_dic** contendo os seguintes nomes de filmes como **chave** (key): 'As Branquelas', 'Vovózona', 'Meninas Malvadas'. Como **valor** (value), busquem o ano que os filmes foram lançados.\n",
        "2. Crie um outro dicionário chamado **filmes_dic2**, contendo os filmes 'Divertidamente' e 'O Show de Truman', assim como os anos que foram lançados.\n",
        "Com o comando *update* atualize os dicionários **filmes_dic**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XS6aO3DczZZX",
        "outputId": "119254e1-7abb-4b6a-f17d-b3883cd6af6a"
      },
      "source": [
        "filmes_dic = {\n",
        "    'As Branquelas': 2004,\n",
        "    'Vovózona': 2000,\n",
        "    'Meninas Malvadas': 2004\n",
        "}\n",
        "\n",
        "filmes_dic"
      ],
      "execution_count": 134,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'As Branquelas': 2004, 'Meninas Malvadas': 2004, 'Vovózona': 2000}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 134
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LM4TMy6YzoDp",
        "outputId": "1b5cfb59-7137-4e2b-c17b-8255d8ef0eee"
      },
      "source": [
        "filmes_dic2 = {\n",
        "    'Divertidamente': 2015,\n",
        "    'O Show de Truman': 1998\n",
        "}\n",
        "\n",
        "filmes_dic.update(filmes_dic2)\n",
        "filmes_dic"
      ],
      "execution_count": 138,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'As Branquelas': 2004,\n",
              " 'Divertidamente': 2015,\n",
              " 'Meninas Malvadas': 2004,\n",
              " 'O Show de Truman': 1998,\n",
              " 'Vovózona': 2000}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 138
        }
      ]
    }
  ]
}