Aula_2_shePY.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Aula 2 - shePY.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPqBpO8NFAQ9tXHvZrGVlwP",
      "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/mariacmartins/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": "3IV49SHzreof"
      },
      "source": [
        "# Aula 2 - shePY"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "avi4Fe2rIZVv"
      },
      "source": [
        "Hoje nós iremos trabalhar conceitos de **strings, listas, tuplas e dicionários** em Python.\n",
        "\n",
        "Além disso, nós iremos entender como importar módulos e bibliotecas."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VSRdnr_9ryIm"
      },
      "source": [
        "## Utilizando módulos \n",
        "Até o momento, nós aprendemos como fazer as operações básicas com Python, mas agora podemos começar a aprender a usar módulos/bibliotecas para conseguir 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 da 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 estou construindo, eu preciso **importar** algumas funcionalidades de fora!\n",
        "\n",
        "Exemplo de biblioteca padrão do Python: **math**\n",
        "\n",
        "**math:** fornece acesso às funções matemáticas\n",
        "\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"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7eSz8Zu2xxXx"
      },
      "source": [
        "Exemplo:\n",
        "biblioteca: todas as bebidas do mercado\n",
        "\n",
        "import bebidas\n",
        "from bebidas import refrigerante\n",
        "\n",
        "Até a forma como você vai referenciar muda um pouco dependendo da forma como vc utiliza esses comandos. Comando utilizando from economiza um pouco mais a memória."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_zH7_ruq3ftn"
      },
      "source": [
        "Se eu quisesse achar a raíz quadrada de 9:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VKwr92Ll3Xow",
        "outputId": "223712e7-8e1d-40c3-da95-e9e2d2225c68"
      },
      "source": [
        "raiz = 9 ** (1/2)\n",
        "print(raiz)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M1T75wFPpyw4",
        "outputId": "b93f3945-855a-43b7-8fff-b1114024557e"
      },
      "source": [
        "import math #importando a lib inteira\n",
        "raiz = math.sqrt(9)\n",
        "print(raiz)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qjqAg2FV2pAs",
        "outputId": "1603f08c-d322-4376-ea1b-afb4303194c9"
      },
      "source": [
        "from math import sqrt #importando apenas a funcionalidade de raíz quadrada\n",
        "raiz = sqrt(9)\n",
        "print(raiz)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QDJtQpob5lAB"
      },
      "source": [
        "Se eu quiser utilizar várias funcionalidades, talvez compense importar tudo com o comando **import**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ntvXCj4D5tne"
      },
      "source": [
        "import math"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tXGC1pFN5v1_",
        "outputId": "45d7f1c6-c87f-4256-a593-529aa22bd96d"
      },
      "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": 5,
      "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": "LEhypxU36wjb"
      },
      "source": [
        "Ou nesse caso, para economizar memória, poderia importar apenas sqrt e pow..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q6T4bf-R6v3J"
      },
      "source": [
        "from math import sqrt, pow"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TkVE0wMK6_fD",
        "outputId": "5a31910b-4ecb-448d-9d84-e9da3e883c7f"
      },
      "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": 7,
      "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": "UbTPiRLK7gqG"
      },
      "source": [
        "Para conhecer mais sobre [math](https://docs.python.org/pt-br/3/library/math.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "caMLVq9B9JyD"
      },
      "source": [
        "### Módulo random\n",
        "Documentação: https://docs.python.org/pt-br/3/library/random.html"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HufBpx0O9yo3"
      },
      "source": [
        "**Exercício:** Faça um programa que ajude uma professora a escolher quem será a primeira aluna a apresentar seu trabalho.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uSi9W8jl9wNj",
        "outputId": "e3efa344-06fa-44ce-8830-135a3369ea91"
      },
      "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('Terceira aluna: '))\n",
        "\n",
        "lista_alunas = [aluno1, aluno2, aluno3, aluno4]\n",
        "\n",
        "escolhida = random.choice(lista_alunas)\n",
        "\n",
        "print('A pessoa escolhida foi: {}'.format(escolhida))"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Primeira aluna Maria\n",
            "Segunda aluna: Clara\n",
            "Terceira aluna: Viviane\n",
            "Terceira aluna: Sandra\n",
            "A pessoa escolhida foi: Viviane\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "brIFwIxBIJEl",
        "outputId": "7a04c5a1-36a1-4215-af85-8abc03d54491"
      },
      "source": [
        "import random\n",
        "\n",
        "lista_alunas = ['Maria', 'Michelle', 'Cláudia', 'Francisca']\n",
        "\n",
        "escolhida = random.choice(lista_alunas)\n",
        "\n",
        "print('A pessoa escolhida foi: {}'.format(escolhida))"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A pessoa escolhida foi: Cláudia\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sqqoe7t0NLer"
      },
      "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",
        "\n",
        "Cada elemento possui uma posição dentro de uma lista. Essa posição é chamada índice. O primeiro elemento fica armazenado no índice 0 e o último elemento no índice n-1 (n é a quantidade de elementos da lista)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Md21EAtRfdck"
      },
      "source": [
        "**Criando listas**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xRy6pE9rLwoA"
      },
      "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": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qY-v4lzvNHPs",
        "outputId": "9900d1aa-01e3-4d53-d082-192f6d75fdaa"
      },
      "source": [
        "type(lista_reais)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JXKaLJHxNaot",
        "outputId": "b625364a-2f06-4b74-8eb1-bb1a3977e68a"
      },
      "source": [
        "lista_reais"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1.5, -2.13, 5.14]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wsAg8pbJNfIv"
      },
      "source": [
        "**Acessando elementos de uma lista**:\n",
        "\n",
        "Você deve passar o nome da lista que deseja acessar e passar o índice do elemento desejado entre colchetes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3buMKrcENcG2",
        "outputId": "eb1114fa-107b-405d-8f92-7d3c76a69c0a"
      },
      "source": [
        "#Acessando o primeiro elemento da lista\n",
        "lista_reais[0]"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WROWc6jETUWO",
        "outputId": "871a9d21-f7f0-4dec-a5ef-bb860f06f16f"
      },
      "source": [
        "#Acessando o último elemento da lista\n",
        "lista_reais[-1]"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GxWAHgBzO4lz"
      },
      "source": [
        "**Como acessar 'Python' dentro da lista de strings criada?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "apxbZk59O9e9",
        "outputId": "c161e6b4-46eb-4f36-dd56-cdbb5b820384"
      },
      "source": [
        "lista_strings"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Java', 'R', 'Python', 'Javascript']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "AyW8n03sOCAk",
        "outputId": "4078aedd-f3aa-4692-8cd0-31509a7108d1"
      },
      "source": [
        "#Acessando o elemento \"Python\" da lista_strings\n",
        "lista_strings[2]"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Python'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D3x2RcNbSQm9"
      },
      "source": [
        "**Como acessar 'Python' e 'Javascript' dentro da lista de strings criada?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ofPwdalfSfN3",
        "outputId": "e977299a-3da8-4d26-adec-150814d61ac0"
      },
      "source": [
        "lista_strings[2:3]"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Python']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_9AgzqNGStmV"
      },
      "source": [
        "Não conseguimos acessar o Javascript, por que?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gKz5Je6kSnYj",
        "outputId": "f1d75c70-a8b5-4785-9ccb-c9a9394ab6d0"
      },
      "source": [
        "lista_strings[2:4]"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Python', 'Javascript']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rL_HzLBBS9eg",
        "outputId": "16c40115-bae3-43ce-893c-d368350bbc29"
      },
      "source": [
        "lista_strings[2:]"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Python', 'Javascript']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8rmh-rCnTM_C"
      },
      "source": [
        "**E se quisermos acessar todos elementos e ignorar Javascript?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2XIHcf7VTgQ2",
        "outputId": "844baa49-8127-43b1-eead-5d051f729cef"
      },
      "source": [
        "lista_strings[:3]"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Java', 'R', 'Python']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dfqdBFeLahfc"
      },
      "source": [
        "**Posso atribuir novos valores para elementos de uma lista?**\n",
        "\n",
        "**Sim!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vSVtIHZCaupd",
        "outputId": "989d2c3b-57f7-43fd-d954-0d4a42301a60"
      },
      "source": [
        "lista_strings"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Java', 'R', 'Python', 'Javascript']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MQqBS8EDa23M",
        "outputId": "153a2d26-0420-4355-9692-310a26113cb5"
      },
      "source": [
        "#Substituindo Java por C++\n",
        "lista_strings[0] = 'C++'\n",
        "lista_strings"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['C++', 'R', 'Python', 'Javascript']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZCjLlOy-Qdwy"
      },
      "source": [
        "**Funções aplicáveis a uma lista**\n",
        "\n",
        "Função | Descrição | Exemplo\n",
        ":----- | :-------- | :------\n",
        "len | Retorna a quantidade de elementos de uma lista | `len(lista)`\n",
        "max  | Retorna o maior elemento de uma lista | `max(lista)`\n",
        "min | Retorna o menor elemento de uma lista | `min(lista)`\n",
        "sum | Retorna o somatório dos elementos de uma lista | `sum(lista)`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "01c9OpMuQ2kj",
        "outputId": "3cddd783-fd89-4a61-e8bb-cf33ba2ef269"
      },
      "source": [
        "lista_reais"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1.5, -2.13, 5.14]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Va7ZUHwBQnlN",
        "outputId": "03d96444-3975-41fe-96bd-88535fcd3c37"
      },
      "source": [
        "len(lista_strings)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f7Wc2qtWQsfF",
        "outputId": "1a65e55b-b917-4810-d72b-c83dd0f74a3a"
      },
      "source": [
        "max(lista_reais)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IpHfWLPQQ6Lg",
        "outputId": "b0b7c638-bc8b-4e41-db1f-17bc92dc972e"
      },
      "source": [
        "min(lista_reais)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-2.13"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NuqOdgrNRkBR",
        "outputId": "9d506273-07fb-49f4-b312-695603931c74"
      },
      "source": [
        "sum(lista_reais)"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4.51"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ztEeIdUHRyA0"
      },
      "source": [
        "**Principais métodos de um objeto lista**\n",
        "\n",
        "Método | Descrição | Exemplo\n",
        ":----- | :-------- | :------\n",
        "append | Adiciona um elemento no final da lista | `lista.append(10)`\n",
        "clear  | Apaga todos os elementos de uma lista | `lista.clear()`\n",
        "copy | Retorna uma cópia dos elementos da lista | `copia = lista.copy()`\n",
        "count | Retorna a quantidade de ocorrências de um elemento na lista | `qt = lista.count(5)`\n",
        "extend | Adiciona os elementos de outra lista passada por parâmetro | `lista.extend(outra_lista)`\n",
        "index | Retorna o índice do elemento passado por parâmetro (primeira posição) | `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)| `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)| `elemento = lista.pop(3)`\n",
        "remove | Remove o elemento passado por parâmetro (provoca um erro caso o elemento não exista)| `lista.remove(5)`\n",
        "reverse | Inverte a ordem dos elementos de uma lista | `lista.reverse()`\n",
        "sort | Ordena os objetos de uma lista | `lista.sort()`\n",
        " | | `lista.sort(reverse=True)`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D4ArAFamR0fp"
      },
      "source": [
        "lista_gatos = ['SRD', 'Siames', 'Persa']"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jfmKtlZPVULE"
      },
      "source": [
        "Adicionando a raça Sphynx no fim da lista de gatos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Tzt3SXxVW3L"
      },
      "source": [
        "lista_gatos.append('Sphynx')"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mDgrnG9BVa9U",
        "outputId": "27a98820-4bbd-4d4d-fdc4-cb06b8213b1c"
      },
      "source": [
        "lista_gatos"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['SRD', 'Siames', 'Persa', 'Sphynx']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "osBGmB1oWaH6"
      },
      "source": [
        "Contando quantas vezes a palavra Persa aparece na lista"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QJ1xYRcEWd-e",
        "outputId": "f0b32df9-0f1a-4bbd-95c0-2ea35cbe02d4"
      },
      "source": [
        "lista_gatos.count('Persa')"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7MuizMVmXVIV"
      },
      "source": [
        "Adicionando a raça Himalaia no começo da lista de gatos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AoarNaJaXUrf",
        "outputId": "276f34e1-a050-4440-b42e-bc381edebf67"
      },
      "source": [
        "lista_gatos.insert(0, 'Himalaia')\n",
        "lista_gatos"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Himalaia', 'SRD', 'Siames', 'Persa', 'Sphynx']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K69zXeJNYOyn"
      },
      "source": [
        "E se quisermos remover SRD da lista? Alguma ideia?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0AWTQ33PYbL-"
      },
      "source": [
        "Temos dois jeitos:\n",
        "- pop\n",
        "- remove"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c-nYtCD1Yalc",
        "outputId": "b4fb712e-0e52-4420-db9f-7c820de517ea"
      },
      "source": [
        "# pop - Remove o elemento na posição passada por parâmetro\n",
        "lista_gatos.pop(1)\n",
        "lista_gatos"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Himalaia', 'Siames', 'Persa', 'Sphynx']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PgsO76KFY0m6",
        "outputId": "0e11e6e4-1536-4467-8d61-2ad33d3a89a0"
      },
      "source": [
        "lista_gatos.insert(1, 'SDR')\n",
        "lista_gatos"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Himalaia', 'SDR', 'Siames', 'Persa', 'Sphynx']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1v7NEmXSZK5V",
        "outputId": "3682a965-3cf5-468b-8c9f-292082697a3b"
      },
      "source": [
        "# remove - Remove o elemento passado por parâmetro \n",
        "lista_gatos.remove('SDR')\n",
        "lista_gatos"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Himalaia', 'Siames', 'Persa', 'Sphynx']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MkIGCwdhbGxm"
      },
      "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 o filme 'Zumbilândia' ao final da lista filmes.\n",
        "3. Substitua o filme Vovózona por 'Divertidamente'."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V_fjMFO7indf"
      },
      "source": [
        "filmes = ['As Branquelas', 'Vovózona', 'Meninas Malvadas']"
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IEbA3Nz8itbH",
        "outputId": "5eb72350-3204-45bc-bf10-442b5113c1c0"
      },
      "source": [
        "filmes.append('Zumbilândia')\n",
        "filmes"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['As Branquelas', 'Vovózona', 'Meninas Malvadas', 'Zumbilândia']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rH-nphzDizcu",
        "outputId": "aa313f6e-4bcd-4b14-87e8-ee05e3b3ed4c"
      },
      "source": [
        "filmes[1] = 'Divertidamente'\n",
        "filmes"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['As Branquelas', 'Divertidamente', 'Meninas Malvadas', 'Zumbilândia']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eicIXUSBZuAr"
      },
      "source": [
        "## **Tuplas:**\n",
        "Assim como a Lista, uma Tupla em Python é uma coleção de elementos\n",
        "- A principal diferença entre essas estruturas é a propriedade de imutabilidade das tuplas. Isso significa que, uma vez definidos os seus elementos, a tupla não pode mais ser alterada."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "krHt72pAfWvl"
      },
      "source": [
        "**Criando tuplas**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wkSsk46zdX_l"
      },
      "source": [
        "tupla = (3, 19, 4, 21, 3, 5, 13)"
      ],
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gSoiwu0Ydas-",
        "outputId": "a0cdfe1e-1fee-4e91-fc16-c677149881bb"
      },
      "source": [
        "type(tupla)"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZTS-hUEZdhKz"
      },
      "source": [
        "**Como acessar elementos de uma tupla:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w_mr86bjddJu",
        "outputId": "a1785225-ab03-4752-f907-ab7c54c3b285"
      },
      "source": [
        "tupla[3]"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "21"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2wtovBjqdqSA"
      },
      "source": [
        "**A imutabilidade de uma tupla**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 178
        },
        "id": "IuWfBgMcdtSj",
        "outputId": "1f41c540-47df-4e4b-ec12-2b154b0338c7"
      },
      "source": [
        "# Atribuindo o valor 5 ao índice 0 de tupla1 provocará um erro\n",
        "tupla[0] = 5"
      ],
      "execution_count": 42,
      "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-42-b4e0bebfe1ae>\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 5 ao índice 0 de tupla1 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": "NC8NljWEd3kk"
      },
      "source": [
        "**Convertendo uma tupla em lista**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e5tFDfJZd5Ic",
        "outputId": "ed52ae7f-3ffb-4bbe-e60c-f200bc23826a"
      },
      "source": [
        "nova_lista = list(tupla)\n",
        "nova_lista"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3, 19, 4, 21, 3, 5, 13]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rHYtsFeYeZGW"
      },
      "source": [
        "## **Dicionários**\n",
        "\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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "40KxsL6RfQzm"
      },
      "source": [
        "**Criando dicionários**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z1t9Za7MfA6i",
        "outputId": "4d9bba8d-77e7-4c24-e448-2f468aece63d"
      },
      "source": [
        "# Criando dicionários com pares chave/valor\n",
        "\n",
        "# Dicionário de estados: chave é a sigla do estado e valor é o nome completo\n",
        "dic_estados = { \"MG\":\"Minas Gerais\", \"PR\": \"Paran\", \"BA\": \"Bahia\", \"RN\": \"Rio Grande do Norte\", \"SP\": \"São Paulo\"}\n",
        "# Obs: o nome do estado do Paraná foi digitado errado de forma intencional\n",
        "dic_estados"
      ],
      "execution_count": 44,
      "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": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ntIopcJ5gmOU",
        "outputId": "8d723635-7873-4d6b-8a46-8e6cf13a2e78"
      },
      "source": [
        "# Dicionário de produtos: chave é o código e 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": 45,
      "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": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cySx4fjCf8IA",
        "outputId": "4c3b518e-f8be-4d00-eba1-0d228b79fa22"
      },
      "source": [
        "# Dicionário de alunos: chave é o nome e 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": 46,
      "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": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "29ALhu2egAQ9",
        "outputId": "d7969bb7-eeb9-4e96-8b19-4849bfc7b467"
      },
      "source": [
        "# Dicionário de alunos 2: chave é o nome e valor é um outro dicionário contendo as 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": 47,
      "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": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eg9pQP4ogL-p"
      },
      "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": "S3D72jz4gSlC",
        "outputId": "a00b0a1c-2d1f-458f-838c-715dda170335"
      },
      "source": [
        "# Acessando o valor associado à chave \"MG\"\n",
        "dic_estados['MG']"
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Minas Gerais'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "mzueS450gt8J",
        "outputId": "25b36be4-6769-41dd-f8cd-3791e0a33329"
      },
      "source": [
        "# Acessando o valor associado à chave 2329\n",
        "dic_produtos[2329]"
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Borracha'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8T1fMK4ig0Ak"
      },
      "source": [
        "Acessando a nota da primeira prova do João no dicionário dic_notas_alunos2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MSQeo--7g1l8",
        "outputId": "0b12b78a-0f50-4ce3-f068-d1b45f72ec07"
      },
      "source": [
        "dic_notas_alunos2['João']['nota1']"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fCZa5XpnhsRq"
      },
      "source": [
        "**Alterando valores em dicionários**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cKOSX03fiUTX",
        "outputId": "d623ba2c-19b5-46c4-d929-9040ff3ff1d9"
      },
      "source": [
        "# Corrigindo o nome do estado do Paraná\n",
        "dic_estados[\"PR\"] = \"Paraná\"\n",
        "dic_estados"
      ],
      "execution_count": 51,
      "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": 51
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AVjES2wrjJKN"
      },
      "source": [
        "**Principais métodos de um objeto dicionário**\n",
        "\n",
        "Método | Descrição | Exemplo\n",
        ":----- | :-------- | :------\n",
        "clear  | Apaga todos os elementos de um dicionário | `dic.clear()`\n",
        "copy | Retorna uma cópia dos elementos de um dicionário | `dic_copia = dic.copy()`\n",
        "fromkeys | Retorna um dicionário a partir de uma sequência de chaves | `exemplo = dic.fromkeys({\"k1\", \"k4\", \"k5\"})`\n",
        "get | Retorna o valor associado a uma chave | `dic.get(\"k1\")`\n",
        " |  | `dic.get(\"k1\", 0)`\n",
        "items | Retorna uma visão dos pares chave/valor de um dicionário | `dic.items()`\n",
        "keys | Retorna uma visão das chaves de um dicionário | `dic.keys()`\n",
        "pop | Remove e retorna o elemento associado à chave passada por parâmetro (provoca erro se a chave não existir) | `dic.pop(2)`\n",
        "popitem | Remove e retorna o último elemento adicionado ao dicionário | `dic.popitem()`\n",
        "setdefault | Retorna o valor associado a uma chave (se a chave existir). Caso não exista, insere a chave com o valor (opcional) no dicionário | `dic.setdefault(2, \"dois\")`\n",
        "update | Adiciona ao dicionário os pares de chave/valor de outro dicionário passado por parâmetro | `dic.update(dic2)`\n",
        "values | Retorna uma visão dos valores de um dicionário | `dic.values`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wkCOByy_jda-",
        "outputId": "5dd62037-bfe4-440a-ee72-026f837c6996"
      },
      "source": [
        "dic_estados.items()"
      ],
      "execution_count": 52,
      "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": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xttcPhZvjxgt"
      },
      "source": [
        "### Desafio\n",
        "1. Crie um dicionário **filmes_dic** contendo os seguintes nomes de filmes como **chave** (key): As Branquelas, Vovózona, Meninas Malvadas. Como **valor** (value), busque o ano que os filmes foram lançados. \n",
        "2. Crie um outro dicionários chamados **filmes_dic2** contendo os filmes Divertidamente e O Show de Truman e os anos que foram lançados e com o comando update atualize o dicionários filmes_dic."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T6pvwly3kzYf",
        "outputId": "24c0c255-8f65-4d39-f1fc-00b5c0a99165"
      },
      "source": [
        "filmes_dic = {\n",
        "    \"As Branquelas\": 2004,\n",
        "    \"Vovózona\": 2000,\n",
        "    \"Meninas Malvadas\": 2004\n",
        "}\n",
        "\n",
        "filmes_dic"
      ],
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'As Branquelas': 2004, 'Meninas Malvadas': 2004, 'Vovózona': 2000}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CNBj7Hr2mqYG"
      },
      "source": [
        "filmes_dic2 = {\n",
        "    \"Divertidamente\": 2015,\n",
        "    \"O Show de Truman\": 1998\n",
        "}\n"
      ],
      "execution_count": 54,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LeI8PVWvm54m",
        "outputId": "d829da5d-815c-47ea-f2ed-f848ea286959"
      },
      "source": [
        "filmes_dic.update(filmes_dic2)\n",
        "filmes_dic"
      ],
      "execution_count": 55,
      "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": 55
        }
      ]
    }
  ]
}