Tuples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1f25f70f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Tuplas:\n",
    "\n",
    "    Definição de Tuplas:\n",
    "        Tuplas são uma das estruturas de dados embutidas no Python. São similares às \n",
    "        listas, mas são imutáveis, o que significa que uma vez definidas, os elementos \n",
    "        não podem ser modificados.\n",
    "\n",
    "    Criação de Tuplas:\n",
    "        Como criar uma tupla usando parênteses: t = (1, 2, 3)\n",
    "        Tupla com um único elemento: t = (1,)\n",
    "        Tupla sem parênteses: t = 1, 2, 3\n",
    "        Uso da função tuple(): t = tuple([1, 2, 3])\n",
    "\n",
    "    Acesso aos Elementos:\n",
    "        Como acessar elementos usando índices: t[0]\n",
    "        Fatiamento de tuplas: t[1:3]\n",
    "\n",
    "    Imutabilidade:\n",
    "        Tentativas de alterar um elemento de uma tupla resultarão em um erro.\n",
    "        Mas se um elemento da tupla for mutável, como uma lista, você pode modificar esse elemento.\n",
    "\n",
    "    Operações com Tuplas:\n",
    "        Concatenação: (1, 2) + (3, 4)\n",
    "        Repetição: (1, 2) * 3\n",
    "        Verificar se um elemento está na tupla: 2 in (1, 2, 3)\n",
    "\n",
    "    Métodos de Tuplas:\n",
    "        count(): conta o número de vezes que um elemento aparece na tupla.\n",
    "        index(): retorna o índice do primeiro elemento que corresponde ao valor especificado.\n",
    "\n",
    "    Desempacotamento de Tuplas:\n",
    "        Atribuindo valores de uma tupla a múltiplas variáveis: a, b, c = (1, 2, 3)\n",
    "\n",
    "    Aplicações Práticas:\n",
    "        Retornando múltiplos valores de uma função usando tuplas.\n",
    "        Uso de tuplas em loops for: for a, b in [(1,2), (3,4)]:\n",
    "        Trocando valores entre duas variáveis: a, b = b, a\n",
    "\n",
    "    Comparando Tuplas:\n",
    "        Tuplas podem ser comparadas usando operadores de comparação: (1, 2) < (1, 3)\n",
    "\n",
    "    Diferenças entre Listas e Tuplas:\n",
    "\n",
    "    Quando e por que usar uma em vez da outra.\n",
    "\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "114a7f43",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5c6bec15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A Arte da Guerra\n",
      "Sun Tzu\n",
      "978-8572835080\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Definição de Tuplas:\n",
    "        Tuplas são uma das estruturas de dados embutidas no Python. São similares às \n",
    "        listas, mas são imutáveis, o que significa que uma vez definidas, os elementos \n",
    "        não podem ser modificados.\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Exemplo Prático: Informações de um Livro\n",
    "\n",
    "Suponha que você esteja criando um sistema para uma biblioteca. Uma \n",
    "das tarefas é representar informações sobre um livro. Você pode escolher \n",
    "tuplas para representar essas informações porque, uma vez que um livro é adicionado \n",
    "ao sistema, certas informações sobre ele, como o título, autor e ISBN, geralmente não mudam.\n",
    "\n",
    "Portanto, para um livro com título \"A Arte da Guerra\", autor \"Sun Tzu\" e \n",
    "ISBN \"978-8572835080\", você pode representar essas informações como uma tupla:\n",
    "\"\"\"\n",
    "\n",
    "livro = (\"A Arte da Guerra\", \"Sun Tzu\", \"978-8572835080\")\n",
    "\n",
    "\n",
    "#Agora, vamos tentar algumas operações:\n",
    "\n",
    "#Acessar informações:\n",
    "\n",
    "titulo = livro[0]  # Acessa o título do livro\n",
    "autor = livro[1]   # Acessa o autor do livro\n",
    "isbn = livro[2]    # Acessa o ISBN do livro\n",
    "\n",
    "print(titulo)  # Saída: A Arte da Guerra\n",
    "print(autor)   # Saída: Sun Tzu\n",
    "print(isbn)    # Saída: 978-8572835080\n",
    "\n",
    "#Tentar modificar uma informação:\n",
    "#Se você tentar modificar o título do livro, por exemplo, você\n",
    "#encontrará um erro devido à imutabilidade das tuplas.\n",
    "\n",
    "#livro[0] = \"A Arte da Estratégia\"  # Isso causará um erro!\n",
    "\n",
    "\"\"\"\n",
    "Ao executar o código acima, você receberá um TypeError informando \n",
    "que as tuplas não suportam a atribuição de item.\n",
    "\n",
    "Essa imutabilidade pode ser útil para garantir a integridade dos dados em \n",
    "cenários em que as informações não devem ser alteradas após serem definidas.\n",
    "\"\"\"\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4d70bce",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bf5bca36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Paris', 'França', 5)\n",
      "('Kyoto',)\n",
      "('Roma', 'Itália', 4)\n",
      "('Nova Yourk', 'EUA', 7)\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Criação de Tuplas:\n",
    "\n",
    "        1. Como criar uma tupla usando parênteses: t = (1, 2, 3)\n",
    "        2. Tupla com um único elemento: t = (1,)\n",
    "        3. Tupla sem parênteses: t = 1, 2, 3\n",
    "        4. Uso da função tuple(): t = tuple([1, 2, 3])\n",
    "        \n",
    "Vamos criar um exemplo prático relacionado ao planejamento de viagens.\n",
    "\n",
    "Exemplo Prático: Planejando uma Viagem\n",
    "\n",
    "Imagine que você está planejando uma viagem e deseja armazenar informações \n",
    "sobre diferentes cidades que deseja visitar, como o nome da cidade, o país e \n",
    "o número estimado de dias que planeja ficar.\n",
    "\"\"\"\n",
    "\n",
    "#1. Criando uma tupla usando parênteses:\n",
    "\n",
    "#Você decide visitar Paris por 5 dias.\n",
    "\n",
    "destino1 = (\"Paris\", \"França\", 5)\n",
    "print(destino1)  # Saída: ('Paris', 'França', 5)\n",
    "\n",
    "#2. Tupla com um único elemento:\n",
    "\n",
    "#Suponhamos que você só saiba o nome da cidade por enquanto e \n",
    "#ainda não decidiu por quanto tempo ficará ou até mesmo em qual país \n",
    "#está localizada. Então, você cria uma tupla com apenas um elemento.\n",
    "\n",
    "destino_indefinido = (\"Kyoto\",)\n",
    "print(destino_indefinido)  # Saída: ('Kyoto',)\n",
    "\n",
    "#3. Tupla sem parênteses:\n",
    "\n",
    "#Você decide visitar Roma na Itália por 4 dias, e decide \n",
    "#usar uma sintaxe simplificada para criar a tupla.\n",
    "\n",
    "destino2 = \"Roma\", \"Itália\", 4\n",
    "print(destino2)  # Saída: ('Roma', 'Itália', 4)\n",
    "\n",
    "\n",
    "#4. Uso da função tuple():\n",
    "\n",
    "#Você tem uma lista das cidades dos EUA que deseja visitar, e a \n",
    "#quantidade de dias que deseja ficar em cada uma delas. Você decide \n",
    "#convertê-la em uma tupla para garantir que os dados não sejam modificados acidentalmente.\n",
    "\n",
    "lista_destinos_EUA = [\"Nova York\", \"EUA\", 7]\n",
    "destino3 = tuple(lista_destinos_EUA)\n",
    "print(destino3)  # Saída: ('Nova York', 'EUA', 7)\n",
    "\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d01c8775",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0f5bd22a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Orgulho e Preconceito', 'Jane Austen', 1813)\n",
      "('O Pequeno Príncipe',)\n",
      "('1984', 'George Orwell', 1949)\n",
      "('O Senhor dos Anéis', 'J.R.R. Tolkien', 1954)\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Armazenando Informações sobre Livros\n",
    "\n",
    "Contexto: Você administra uma pequena biblioteca e decide \n",
    "armazenar informações sobre seus livros usando tuplas para garantir \n",
    "que os dados sejam consistentes e imutáveis.\n",
    "\n",
    "Objetivo: Crie tuplas para representar informações de livros usando \n",
    "diferentes métodos de criação de tuplas.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Criar uma tupla usando parênteses:\n",
    "        Crie uma tupla chamada livro1 para armazenar informações sobre um \n",
    "        livro: título, autor e ano de publicação. \n",
    "        Use a seguinte informação: \"Orgulho e Preconceito\", \"Jane Austen\", 1813.\n",
    "\n",
    "    2. Tupla com um único elemento:\n",
    "        Você recebeu uma doação de um livro, mas só sabe o título por \n",
    "        enquanto. Crie uma tupla chamada livro_indefinido com apenas o título: \"O Pequeno Príncipe\".\n",
    "\n",
    "    3. Tupla sem parênteses:\n",
    "        Para o próximo livro, use uma sintaxe simplificada. Crie uma tupla \n",
    "        chamada livro2 para armazenar: \"1984\", \"George Orwell\", 1949.\n",
    "\n",
    "    4. Uso da função tuple():\n",
    "        Você tem uma lista de informações sobre um novo livro. Converta esta \n",
    "        lista em uma tupla para garantir sua imutabilidade. \n",
    "        \n",
    "        A lista é: [\"O Senhor dos Anéis\", \"J.R.R. Tolkien\", 1954]. Nomeie a tupla como livro3.\n",
    "\n",
    "    Teste suas tuplas:\n",
    "        Mostre cada uma das informações armazenadas usando a função print.\n",
    "\n",
    "Isso dara a você uma prática valiosa na criação de tuplas usando \n",
    "várias técnicas, bem como uma compreensão de por que e quando \n",
    "usar tuplas em vez de listas ou outros tipos de dados.\n",
    "\"\"\"\n",
    "\n",
    "#Resposta:\n",
    "\n",
    "#1. Criar uma tupla usando parênteses:\n",
    "#        Crie uma tupla chamada livro1 para armazenar informações sobre um \n",
    "#        livro: título, autor e ano de publicação. \n",
    "#        Use a seguinte informação: \"Orgulho e Preconceito\", \"Jane Austen\", 1813.\n",
    "\n",
    "livro1 = (\"Orgulho e Preconceito\", \"Jane Austen\", 1813)\n",
    "print(livro1)\n",
    "\n",
    "\n",
    "#    2. Tupla com um único elemento:\n",
    "#        Você recebeu uma doação de um livro, mas só sabe o título por \n",
    "#        enquanto. Crie uma tupla chamada livro_indefinido com apenas o título: \"O Pequeno Príncipe\".\n",
    "\n",
    "livro_indefinido = (\"O Pequeno Príncipe\",)\n",
    "print(livro_indefinido)\n",
    "\n",
    "#    3. Tupla sem parênteses:\n",
    "#        Para o próximo livro, use uma sintaxe simplificada. Crie uma tupla \n",
    "#        chamada livro2 para armazenar: \"1984\", \"George Orwell\", 1949.\n",
    "\n",
    "livro2 = \"1984\", \"George Orwell\", 1949\n",
    "print(livro2)\n",
    "\n",
    "\n",
    "#    4. Uso da função tuple():\n",
    "#        Você tem uma lista de informações sobre um novo livro. Converta esta \n",
    "#        lista em uma tupla para garantir sua imutabilidade. \n",
    "       \n",
    "#        A lista é: [\"O Senhor dos Anéis\", \"J.R.R. Tolkien\", 1954]. Nomeie a tupla como livro3.\n",
    "\n",
    "#    Teste suas tuplas:\n",
    "#        Mostre cada uma das informações armazenadas usando a função print.\n",
    "\n",
    "lista_livro3 = [\"O Senhor dos Anéis\", \"J.R.R. Tolkien\", 1954]\n",
    "livro3 = tuple(lista_livro3)\n",
    "print(livro3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fb129e5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d12c1535",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nome: João Silva\n",
      "Telefone: 123-456-7890\n",
      "Informações Relevantes: ('João Silva', '123-456-7890')\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Acesso aos Elementos:\n",
    "        Como acessar elementos usando índices: t[0]\n",
    "        Fatiamento de tuplas: t[1:3]\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Exemplo Prático: Agenda de Contatos\n",
    "\n",
    "Contexto: Você tem uma agenda onde armazena informações \n",
    "de seus contatos em tuplas. Cada tupla contém o nome do \n",
    "contato, o número de telefone e o endereço de e-mail. \n",
    "\n",
    "Você deseja acessar e exibir essas informações.\n",
    "\"\"\"\n",
    "\n",
    "#1. Como acessar elementos usando índices:\n",
    "\n",
    "#Vamos começar criando uma tupla com informações de um contato.\n",
    "\n",
    "contato = (\"João Silva\", \"123-456-7890\", \"joao.silva@email.com\")\n",
    "\n",
    "# Acessando o nome:\n",
    "nome = contato[0]\n",
    "print(\"Nome:\", nome)  # Saída: Nome: João Silva\n",
    "\n",
    "# Acessando o telefone:\n",
    "telefone = contato[1]\n",
    "print(\"Telefone:\", telefone)  # Saída: Telefone: 123-456-7890\n",
    "\n",
    "#2. Fatiamento de tuplas:\n",
    "\n",
    "#Imagine agora que você só quer mostrar o nome e o número de telefone, omitindo o e-mail.\n",
    "info_relevante = contato[:2]\n",
    "\n",
    "print(\"Informações Relevantes:\", info_relevante)  # Saída: Informações Relevantes: ('João Silva', '123-456-7890')\n",
    "\n",
    "\"\"\"\n",
    "Explicação: Usando o fatiamento [:2], pegamos todos os elementos da tupla \n",
    "desde o início até o índice 2 (exclusivo), que nos dá o nome e o telefone do contato.\n",
    "\n",
    "Este exemplo prático demonstra como as tuplas podem ser utilizadas para armazenar \n",
    "informações relacionadas e como acessar ou extrair essas informações usando índices e fatiamento.\n",
    "\"\"\"\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fdf92d3e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "00a2921b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Laptop', 10, 1500.0)\n",
      "Produto: Laptop - Quantidade em Estoque: 10\n",
      "Informações Relevante: ('Laptop', 10)\n",
      "\n",
      "a) Qual é o nome do produto? Laptop\n",
      "b) Quantos itens desse produto estão em estoque? 10\n",
      "c) Sem mostrar o preço, quais são as informações disponíveis sobre o produto? ('Laptop', 10)\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Gerenciando Inventário de Produtos\n",
    "\n",
    "Contexto: Você trabalha em um depósito e possui um inventário de produtos \n",
    "armazenados em tuplas. Cada tupla contém o nome do produto, a quantidade em \n",
    "estoque e o preço unitário. Sua tarefa é acessar e exibir certas informações desses produtos.\n",
    "\n",
    "Objetivo: Acesse e exiba informações específicas dos produtos usando índices e fatiamento de tuplas.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    Definindo um Produto:\n",
    "        Comece definindo uma tupla chamada produto com as seguintes \n",
    "        informações: \"Laptop\", 10 (quantidade em estoque), 1500.00 (preço em dólares).\n",
    "\n",
    "    Acessando elementos usando índices:\n",
    "        Exiba o nome do produto.\n",
    "        Em seguida, exiba a quantidade em estoque.\n",
    "\n",
    "    Fatiamento de tuplas:\n",
    "        Mostre as informações excluindo o preço (ou seja, nome e quantidade \n",
    "        em estoque) usando fatiamento de tuplas.\n",
    "\n",
    "Questões:\n",
    "\n",
    "a) Qual é o nome do produto?\n",
    "\n",
    "b) Quantos itens desse produto estão em estoque?\n",
    "\n",
    "c) Sem mostrar o preço, quais são as informações disponíveis sobre o produto?\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#1. Definindo um Produto:\n",
    "#      Comece definindo uma tupla chamada produto com as seguintes \n",
    "#      informações: \"Laptop\", 10 (quantidade em estoque), 1500.00 (preço em dólares).\n",
    "\n",
    "produto = (\"Laptop\", 10, 1500.00)\n",
    "print(produto)\n",
    "\n",
    "#2.    Acessando elementos usando índices:\n",
    "#        Exiba o nome do produto.\n",
    "#        Em seguida, exiba a quantidade em estoque.\n",
    "\n",
    "nome_produto = produto[0]\n",
    "quantidade_estoque = produto[1]\n",
    "print(f\"Produto: {nome_produto} - Quantidade em Estoque: {quantidade_estoque}\")\n",
    "\n",
    "#3.    Fatiamento de tuplas:\n",
    "#        Mostre as informações excluindo o preço (ou seja, nome e quantidade \n",
    "#        em estoque) usando fatiamento de tuplas.\n",
    "\n",
    "info_relevantes = produto[:2]\n",
    "print(f\"Informações Relevante: {info_relevantes}\")\n",
    "\n",
    "print()\n",
    "#Respostas às questões\n",
    "\n",
    "#a) Qual é o nome do produto?\n",
    "print(f\"a) Qual é o nome do produto? {nome_produto}\")\n",
    "\n",
    "#b) Quantos itens desse produto estão em estoque?\n",
    "\n",
    "print(f\"b) Quantos itens desse produto estão em estoque? {quantidade_estoque}\")\n",
    "\n",
    "#c) Sem mostrar o preço, quais são as informações disponíveis sobre o produto?\n",
    "print(f\"c) Sem mostrar o preço, quais são as informações disponíveis sobre o produto? {info_relevantes}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc2395fa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "0bcb4ff9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liquidos acima de 100ml', 'objetos cortantes', 'material explosivo', 'baterias de lítio']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Imutabilidade:\n",
    "        Tentativas de alterar um elemento de uma tupla resultarão em um erro.\n",
    "        Mas se um elemento da tupla for mutável, como uma lista, você pode modificar esse elemento.\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Exemplo Prático: Restrições de Segurança no Aeroporto\n",
    "\n",
    "Contexto: Em um sistema de aeroporto, você deseja armazenar regras \n",
    "de segurança em relação à bagagem de mão dos passageiros. \n",
    "\n",
    "Algumas regras são imutáveis (como dimensões da bagagem), enquanto \n",
    "outras, como os itens proibidos, podem ser atualizados periodicamente.\n",
    "\"\"\"\n",
    "\n",
    "#1. Tentativas de alterar um elemento de uma tupla resultarão em um erro:\n",
    "\n",
    "#Você tem uma tupla que armazena as dimensões máximas permitidas para a bagagem \n",
    "#de mão em centímetros (altura, largura, profundidade).\n",
    "dimensoes_bagagem = (55, 35, 25)\n",
    "\n",
    "#Agora, por alguma razão, você decide tentar alterar a altura máxima permitida:\n",
    "# Isto causará um erro!\n",
    "\n",
    "#dimensoes_bagagem[0] = 60\n",
    "\n",
    "#Se você tentar executar o código acima, obterá um TypeError, indicando que \n",
    "#os elementos da tupla não podem ser modificados.\n",
    "\n",
    "#2. Mas se um elemento da tupla for mutável, como uma lista, você pode modificar esse elemento:\n",
    "\n",
    "#No mesmo sistema do aeroporto, você possui uma tupla que armazena itens \n",
    "#proibidos na bagagem de mão. A lista de itens pode ser atualizada quando necessário.\n",
    "\n",
    "itens_proibidos = [\"líquidos acima de 100ml\", \"objetos cortantes\", \"material explosivo\"]\n",
    "regras_bagagem = (dimensoes_bagagem, itens_proibidos)\n",
    "\n",
    "# que uma nova regra seja implementada e agora é proibido transportar \n",
    "#baterias de lítio na bagagem de mão. Mesmo que a tupla regras_bagagem \n",
    "#seja imutável, o elemento itens_proibidos é uma lista, que é mutável. \n",
    "\n",
    "#Portanto, você pode adicionar à lista:\n",
    "\n",
    "regras_bagagem[1].append(\"baterias de lítio\")\n",
    "print(regras_bagagem[1])\n",
    "\n",
    "#Neste exemplo prático, podemos ver como as propriedades de \n",
    "#imutabilidade das tuplas funcionam, bem como a exceção quando um de \n",
    "#seus elementos é mutável, como uma lista.\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a8bce95",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "bf5a5db7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Smartphone', 1000.0, [2, 3, 4])\n",
      "\n",
      "('Smartphone', 1000.0, [2, 3, 4, 5])\n",
      "\n",
      "Questões:\n",
      "\n",
      "a) Ao tentar alterar o preço do Smartphone, qual erro você encontrou?\n",
      "O erro ao tentar alterar o preço do Smartphone é:\n",
      "TypeError: 'tuple' object does not support item assignment\n",
      "b) Vendas atualizadas: [2, 3, 4, 5]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Gerenciando Vendas de Produtos\n",
    "\n",
    "Contexto: Você é um gerente de vendas em uma loja de eletrônicos. Cada \n",
    "produto vendido é registrado em uma tupla que contém o nome do produto, seu \n",
    "preço fixo e uma lista das vendas realizadas durante o mês (quantidades vendidas a cada dia).\n",
    "\n",
    "Objetivo: Entenda a imutabilidade das tuplas enquanto gerencia o registro de vendas \n",
    "diárias de um produto específico.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Registro de Produto:\n",
    "    \n",
    "        Crie uma tupla chamada produto com as seguintes \n",
    "        \n",
    "        informações: \"Smartphone\", 1000.00 (preço em dólares), \n",
    "        [2, 3, 4] (vendas nos três primeiros dias do mês).\n",
    "\n",
    "    2. Tentativa de Alteração de Imutabilidade:\n",
    "        Tente alterar o preço do \"Smartphone\" para 1100.00.\n",
    "        Observe o erro gerado e explique por que ele ocorre.\n",
    "\n",
    "    3. Atualização de Vendas:\n",
    "        Um novo lote de \"Smartphone\" foi vendido e você vendeu mais \n",
    "        5 unidades no quarto dia. Adicione esse número à lista de vendas.\n",
    "        \n",
    "        Exiba a lista de vendas atualizada para o \"Smartphone\".\n",
    "\n",
    "Questões:\n",
    "\n",
    "a) Ao tentar alterar o preço do \"Smartphone\", qual erro você encontrou?\n",
    "\n",
    "b) Qual é o registro de vendas atualizado após adicionar as vendas do quarto dia?\n",
    "\n",
    "Este exercício visa ensinar sobre a imutabilidade das tuplas em \n",
    "um contexto prático de vendas. Ao tentar modificar o preço, enfrentarão um \n",
    "erro e, assim, compreenderá a natureza imutável das tuplas. No entanto, ao atualizar \n",
    "o registro de vendas, que é uma lista mutável dentro da tupla, aprenderá sobre a \n",
    "capacidade de modificar elementos mutáveis mesmo dentro de estruturas imutáveis.\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "#1. Registro de Produto:\n",
    "    \n",
    "#       Crie uma tupla chamada produto com as seguintes \n",
    "        \n",
    "#        informações: \"Smartphone\", 1000.00 (preço em dólares), \n",
    "#        [2, 3, 4] (vendas nos três primeiros dias do mês).\n",
    "\n",
    "produto = (\"Smartphone\", 1000.00, [2, 3, 4])\n",
    "print(produto)\n",
    "print()\n",
    "\n",
    "#2. Tentativa de Alteração de Imutabilidade:\n",
    "#        Tente alterar o preço do \"Smartphone\" para 1100.00.\n",
    "#        Observe o erro gerado e explique por que ele ocorre.\n",
    "\n",
    "# A seguinte linha causará um erro, pois tentamos modificar um elemento imutável de uma tupla.\n",
    "# Para demonstrar, a linha está comentada, mas se descomentada e executada, causaria um TypeError.\n",
    "# produto[1] = 1100.00\n",
    "\n",
    "# 3. Atualização de Vendas:\n",
    "#        Um novo lote de \"Smartphone\" foi vendido e você vendeu mais \n",
    "#        5 unidades no quarto dia. Adicione esse número à lista de vendas.\n",
    "        \n",
    "#        Exiba a lista de vendas atualizada para o \"Smartphone\".\n",
    "\n",
    "produto[2].append(5)\n",
    "vendas_atualizadas = produto[2]\n",
    "\n",
    "print(produto)\n",
    "\n",
    "print()\n",
    "\n",
    "print(\"Questões:\\n\")\n",
    "\n",
    "print(\"a) Ao tentar alterar o preço do Smartphone, qual erro você encontrou?\")\n",
    "print(\"O erro ao tentar alterar o preço do Smartphone é:\")\n",
    "print(\"TypeError: 'tuple' object does not support item assignment\")\n",
    "\n",
    "print(\"b) Vendas atualizadas:\", vendas_atualizadas)  # Saída: b) Vendas atualizadas: [2, 3, 4, 5]\n",
    "\n",
    "\"\"\"\n",
    "Nesta solução, comentamos a linha que tenta alterar o preço do \"Smartphone\", pois \n",
    "sabemos que isso causará um erro. O objetivo é que o aluno faça essa tentativa por \n",
    "conta própria para enfrentar o erro e, assim, compreender a imutabilidade das tuplas. \n",
    "\n",
    "Em seguida, demonstramos como modificar uma lista que está dentro da tupla, exibindo \n",
    "a natureza mutável das listas mesmo quando elas estão contidas em uma tupla imutável.\n",
    "\"\"\"\n",
    "\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed824330",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "35087c26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n",
      "(1, 2, 1, 2, 1, 2)\n",
      "True\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Operações com Tuplas:\n",
    "        Concatenação: (1, 2) + (3, 4)\n",
    "        Repetição: (1, 2) * 3\n",
    "        Verificar se um elemento está na tupla: 2 in (1, 2, 3)\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Exemplo Prático: Planejamento de Viagem\n",
    "\n",
    "Contexto: Imagine que você está planejando uma viagem por várias \n",
    "cidades. As cidades são representadas por números, e você deseja organizar a \n",
    "ordem das visitas, verificar cidades repetidas e ver se visitou uma cidade específica.\n",
    "\"\"\"\n",
    "\n",
    "#1. Concatenação de Tuplas - Adicionando destinos à sua viagem\n",
    "\n",
    "#Suponha que você já planejou visitar as cidades 1 e 2. \n",
    "#Depois de pensar um pouco, decidiu também visitar as cidades 3 e 4.\n",
    "primeiras_cidades = (1, 2)\n",
    "proximas_cidades = (3, 4)\n",
    "\n",
    "roteiro_viagem = primeiras_cidades + proximas_cidades\n",
    "print(roteiro_viagem)  # Saída: (1, 2, 3, 4)\n",
    "\n",
    "#2. Repetição - Visitando algumas cidades mais de uma vez:\n",
    "\n",
    "#Suponha que as cidades 1 e 2 sejam seus destinos favoritos e \n",
    "#você deseja visitá-las três vezes durante sua viagem.\n",
    "cidades_favoritas = (1, 2)\n",
    "\n",
    "roteiro_repetido = cidades_favoritas * 3\n",
    "print(roteiro_repetido)  # Saída: (1, 2, 1, 2, 1, 2)\n",
    "\n",
    "#3. Verificando se uma cidade está em seu roteiro:\n",
    "\n",
    "#Durante o planejamento, você se pergunta se incluiu a cidade 2 em seu roteiro.\n",
    "\n",
    "roteiro_total = (1, 2, 3, 4, 1, 2, 1, 2)\n",
    "\n",
    "cidade_inclusa = 2 in roteiro_total\n",
    "print(cidade_inclusa)  # Saída: True\n",
    "\n",
    "\"\"\"\n",
    "Neste exemplo prático, utilizamos as operações básicas com \n",
    "tuplas para organizar um roteiro de viagem. Concatenamos cidades para \n",
    "estender nosso roteiro, repetimos visitas a cidades favoritas e verificamos se uma \n",
    "cidade específica está incluída no planejamento.\n",
    "\"\"\"\n",
    "print()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a638bbd6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "ffebe3c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n",
      "(1, 2, 1, 2, 1, 2)\n",
      "True\n",
      "\n",
      "a) C = (1, 2, 3, 4)\n",
      "b) D = (1, 2, 1, 2, 1, 2)\n",
      "c) True\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Manipulando Sequências de Números\n",
    "\n",
    "Contexto: Você está trabalhando com sequências de números em um software \n",
    "de análise. Para isso, você utiliza tuplas, uma vez que as sequências são fixas \n",
    "e não precisam de alterações. Contudo, existem algumas operações com as sequências \n",
    "que você precisa realizar para obter novos conjuntos de dados.\n",
    "\n",
    "Objetivo: Utilize operações com tuplas para manipular e analisar sequências de números.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Concatenação de Sequências:\n",
    "        Você possui duas sequências: A = (1, 2) e B = (3, 4).\n",
    "        Crie uma nova sequência C combinando as sequências A e B.\n",
    "\n",
    "    2. Repetição de Sequências:\n",
    "        Suponha que você queira repetir a sequência A três vezes para criar uma nova sequência D.\n",
    "        Faça essa operação e registre o resultado em D.\n",
    "\n",
    "    3. Análise de Elemento em Sequência:\n",
    "        Utilizando a sequência E = (1, 2, 3, 4, 1, 2, 1, 2), verifique se o número 2 está presente.\n",
    "\n",
    "Questões:\n",
    "\n",
    "a) Qual é a sequência resultante C após a concatenação?\n",
    "\n",
    "b) Qual é a sequência D após repetir a sequência A três vezes?\n",
    "\n",
    "c) O número 2 está presente na sequência E?\n",
    "\n",
    "O exercício busca ensinar as operações básicas que podem ser \n",
    "realizadas com tuplas. Ao final, você deve ser capaz de manipular \n",
    "e combinar diferentes tuplas para obter novos conjuntos de dados.\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "#   1. Concatenação de Sequências:\n",
    "#       Você possui duas sequências: A = (1, 2) e B = (3, 4).\n",
    "#       Crie uma nova sequência C combinando as sequências A e B.\n",
    "\n",
    "A = (1, 2)\n",
    "B = (3, 4)\n",
    "\n",
    "C = A + B\n",
    "\n",
    "print(C)\n",
    "\n",
    "#   2. Repetição de Sequências:\n",
    "#      Suponha que você queira repetir a sequência A três vezes para criar uma nova sequência D.\n",
    "#      Faça essa operação e registre o resultado em D.\n",
    "\n",
    "D = A * 3\n",
    "\n",
    "print(D)\n",
    "\n",
    "#   3. Análise de Elemento em Sequência:\n",
    "#       Utilizando a sequência E = (1, 2, 3, 4, 1, 2, 1, 2), verifique se o número 2 está presente.\n",
    "\n",
    "E = (1, 2, 3, 4, 1, 2, 1, 2)\n",
    "\n",
    "numero_presente = 2 in E\n",
    "\n",
    "print(numero_presente)\n",
    "\n",
    "print()\n",
    "#Respostas as Questões:\n",
    "\n",
    "#a) Qual é a sequência resultante C após a concatenação?\n",
    "print(\"a) C =\", C)\n",
    "\n",
    "#b) Qual é a sequência D após repetir a sequência A três vezes?\n",
    "print(\"b) D =\", D)\n",
    "\n",
    "#c) O número 2 está presente na sequência E?\n",
    "print(\"c)\", numero_presente)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a6a7ec5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c5234051",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O produto 101 foi vendido 3 vezes.\n",
      "O produto 103 foi vendido pela primeira vez no 3° dia da semana.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Métodos de Tuplas:\n",
    "        count(): conta o número de vezes que um elemento aparece na tupla.\n",
    "        index(): retorna o índice do primeiro elemento que corresponde ao valor especificado.\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Exemplo Prático: Gerenciamento de Vendas de Produtos\n",
    "\n",
    "Contexto: Imagine que você é um gerente em uma loja de eletrônicos e deseja analisar \n",
    "as vendas dos produtos ao longo da semana. Cada produto vendido é representado por \n",
    "um código numérico.\n",
    "\"\"\"\n",
    "\n",
    "#1. Uso do método count():\n",
    "\n",
    "#Suponha que você tenha uma tupla que representa as vendas de produtos \n",
    "#durante a semana: vendas = (101, 102, 103, 101, 102, 101, 104), onde cada \n",
    "#número é um código de produto.\n",
    "\n",
    "#Se quisermos saber quantas vezes o produto de código 101 foi \n",
    "#vendido durante a semana, pode usar o método count():\n",
    "\n",
    "\n",
    "vendas = (101, 102, 103, 101, 102, 101, 104)\n",
    "vendas_produto_101 = vendas.count(101)\n",
    "print(f\"O produto 101 foi vendido {vendas_produto_101} vezes.\")\n",
    "\n",
    "#Uso do método index():\n",
    "\n",
    "#Agora, imagine que você queira saber quando o produto de \n",
    "#código 103 foi vendido pela primeira vez durante a semana. \n",
    "\n",
    "#Para isso, pode usar o método index():\n",
    "vendas = (101, 102, 103, 101, 102, 101, 104, 103)\n",
    "primeiro_dia_venda_103 = vendas.index(103) + 1\n",
    "print(f\"O produto 103 foi vendido pela primeira vez no {primeiro_dia_venda_103}° dia da semana.\")\n",
    "\n",
    "\"\"\"\n",
    "Neste exemplo, utilizamos os métodos count() e index() das tuplas para analisar \n",
    "as vendas de produtos em uma loja. O método count() nos ajudou a determinar a \n",
    "quantidade de vendas de um produto específico, enquanto o método index() nos \n",
    "informou quando um produto foi vendido pela primeira vez.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18f1518c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a1ae0f81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a) O filme recebeu 5 avaliações de 5 estrelas.\n",
      "b) A primeira avaliação de 1 estrela está na 11ª posição.\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Análise de Avaliações de Filmes\n",
    "\n",
    "Contexto: Você é um analista em uma plataforma de streaming e recebeu \n",
    "uma lista de avaliações de um filme recém-lançado. As avaliações são dadas como \n",
    "estrelas, variando de 1 a 5. Você deve analisar essas avaliações para fornecer \n",
    "insights sobre a recepção do filme.\n",
    "\n",
    "Dados fornecidos: avaliacoes = (5, 4, 4, 3, 5, 2, 4, 3, 5, 5, 1, 4, 3, 5, 2)\n",
    "\n",
    "Objetivo: Use os métodos de tupla para responder às seguintes perguntas:\n",
    "\n",
    "    Quantidade de Avaliações de 5 estrelas:\n",
    "        Quantas vezes o filme foi avaliado com 5 estrelas?\n",
    "    Primeira Avaliação de 1 estrela:\n",
    "        Em que posição da sequência aparece a primeira avaliação de 1 estrela?\n",
    "\n",
    "Instruções:\n",
    "\n",
    "a) Utilize o método count() para determinar o número de avaliações \n",
    "de 5 estrelas na tupla avaliacoes.\n",
    "\n",
    "b) Utilize o método index() para encontrar a posição da primeira \n",
    "avaliação de 1 estrela na tupla avaliacoes.\n",
    "\n",
    "Questões:\n",
    "\n",
    "a) Quantas avaliações de 5 estrelas o filme recebeu?\n",
    "\n",
    "b) Qual é a posição da primeira avaliação de 1 estrela?\n",
    "\n",
    "Este exercício tem como objetivo familiarizar com os métodos count() \n",
    "e index() de tuplas, aplicando-os em um contexto prático de análise de \n",
    "dados. \n",
    "\n",
    "Ao final, você deve ser capazes de utilizar esses métodos para \n",
    "extrair informações relevantes de uma tupla.\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "#Dados fornecidos\n",
    "avaliacoes = (5, 4, 4, 3, 5, 2, 4, 3, 5, 5, 1, 4, 3, 5, 2)\n",
    "\n",
    "#A) Quantas avaliações de 5 estrelas o filme recebeu?\n",
    "numero_de_cinco_estrelas = avaliacoes.count(5)\n",
    "\n",
    "print(f\"a) O filme recebeu {numero_de_cinco_estrelas} avaliações de 5 estrelas.\")\n",
    "\n",
    "#B) Qual é a posição da primeira avaliação de 1 estrela?\n",
    "posicao_primeira_uma_estrela = avaliacoes.index(1) + 1 # Adicionamos 1 porque os índices começam em 0\n",
    "\n",
    "print(f\"b) A primeira avaliação de 1 estrela está na {posicao_primeira_uma_estrela}ª posição.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3680852c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f6d39043",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nome do Estudante: João\n",
      "Idade: 20\n",
      "Nota Média: 85.5\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Desempacotamento de Tuplas:\n",
    "        Atribuindo valores de uma tupla a múltiplas variáveis: a, b, c = (1, 2, 3)\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Exemplo Prático: Gestão de Estudantes\n",
    "\n",
    "Contexto: Imagine que você é um professor e recebe informações de um estudante em \n",
    "forma de tupla. Essa tupla contém o nome do estudante, sua idade e sua nota média. \n",
    "\n",
    "Para facilitar o acesso a esses dados, você pode desempacotar a tupla em variáveis individuais.\n",
    "\"\"\"\n",
    "\n",
    "#Exemplo:\n",
    "\n",
    "#1. Dados fornecidos:\n",
    "\n",
    "#Suponha que você tenha a seguinte tupla com informações do estudante: \n",
    "\n",
    "estudante_info = (\"João\", 20, 85.5) # onde \"João\" é o nome do estudante, 20 \n",
    "                                    #é sua idade e 85.5 é sua nota média.\n",
    "    \n",
    "\n",
    "#2. Desempacotamento:\n",
    "\n",
    "#Agora, para desempacotar esses dados em variáveis individuais, você pode fazer o seguinte:\n",
    "\n",
    "\n",
    "nome, idade, nota_media = estudante_info\n",
    "\n",
    "print(f\"Nome do Estudante: {nome}\")\n",
    "print(f\"Idade: {idade}\")\n",
    "print(f\"Nota Média: {nota_media}\")\n",
    "\n",
    "\"\"\"\n",
    "Neste exemplo, através do desempacotamento de tuplas, conseguimos \n",
    "atribuir os valores contidos em estudante_info a três variáveis \n",
    "separadas (nome, idade e nota_media). Isso permite um acesso mais \n",
    "direto e claro aos valores individualmente.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9606e2e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3cc0cddb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a) Destino: Paris\n",
      "a) Número de Noites: 5\n",
      "a) Preço: R$ 1500\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Gestão de Pacotes de Viagem\n",
    "\n",
    "Contexto: Você trabalha em uma agência de turismo e tem pacotes \n",
    "de viagem que são representados como tuplas. Cada pacote contém o \n",
    "destino, o número de noites e o preço. Para facilitar o processamento \n",
    "desses pacotes, você precisa desempacotar os detalhes em variáveis individuais.\n",
    "\n",
    "Dados fornecidos:\n",
    "\n",
    "Considere o seguinte pacote de viagem: pacote_viagem = (\"Paris\", 5, 1500), onde:\n",
    "\n",
    "    \"Paris\" é o destino da viagem.\n",
    "    5 é o número de noites.\n",
    "    1500 é o preço do pacote em dólares.\n",
    "\n",
    "Objetivo: Desempacote os detalhes do pacote de viagem em variáveis individuais e imprima as informações.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    Atribua os valores da tupla pacote_viagem a três variáveis: destino, noites e preco.\n",
    "    Imprima o destino, o número de noites e o preço do pacote.\n",
    "\n",
    "Questões:\n",
    "\n",
    "a) Qual é o destino do pacote de viagem?\n",
    "b) Por quantas noites é o pacote?\n",
    "c) Qual é o preço do pacote?\n",
    "\n",
    "Este exercício visa ajudar a compreenderem e praticarem o desempacotamento \n",
    "de tuplas, uma técnica útil para atribuir múltiplos valores a variáveis de \n",
    "uma vez. Ao final, os alunos devem ser capazes de extrair informações de \n",
    "uma tupla e utilizá-las separadamente.\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "# Dados fornecidos\n",
    "pacote_viagem = (\"Paris\", 5, 1500)\n",
    "\n",
    "# Desempacotamento da tupla\n",
    "destino, noites, preco = pacote_viagem\n",
    "\n",
    "# Imprimir as informações do pacote\n",
    "print(f\"a) Destino: {destino}\")\n",
    "print(f\"a) Número de Noites: {noites}\")\n",
    "print(f\"a) Preço: R$ {preco}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2a6bd4f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d948b31f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Vendido: 185\n",
      "Produto Mais Vendido: A\n",
      "\n",
      "Vendas de A: 100, Vendas de B: 90\n",
      "Vendas de A: 110, Vendas de B: 115\n",
      "Vendas de A: 105, Vendas de B: 100\n",
      "\n",
      "Vendas Corrigidas - A: 85, B: 100\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    " Aplicações Práticas:\n",
    "        Retornando múltiplos valores de uma função usando tuplas.\n",
    "        Uso de tuplas em loops for: for a, b in [(1,2), (3,4)]:\n",
    "        Trocando valores entre duas variáveis: a, b = b, a\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Exemplo Prático: Analisando Vendas\n",
    "\n",
    "Contexto: Você é um analista em uma loja e precisa acompanhar as \n",
    "vendas diárias de dois produtos: A e B. Seu objetivo é calcular o total \n",
    "vendido e o produto mais vendido no dia.\n",
    "\"\"\"\n",
    "\n",
    "#1. Retornando múltiplos valores de uma função usando tuplas\n",
    "\n",
    "#Você quer criar uma função que retorna o total vendido e o produto mais vendido do dia.\n",
    "def analisar_vendas(vendas_A, vendas_B):\n",
    "    \n",
    "    total_vendido = vendas_A + vendas_B\n",
    "    mais_vendido = \"A\" if vendas_A > vendas_B else \"B\"\n",
    "    return total_vendido, mais_vendido\n",
    "\n",
    "total, top_produto = analisar_vendas(100, 85)\n",
    "print(f\"Total Vendido: {total}\")\n",
    "print(f\"Produto Mais Vendido: {top_produto}\")\n",
    "\n",
    "print()\n",
    "\n",
    "#2. Uso de tuplas em loops for\n",
    "\n",
    "#Suponha que você tenha uma lista de vendas de ambos os produtos em \n",
    "#pares para alguns dias, e você quer imprimir as vendas de cada dia.\n",
    "vendas = [(100, 90), (110, 115), (105, 100)]\n",
    "\n",
    "for vendas_A, vendas_B in vendas:\n",
    "    print(f\"Vendas de A: {vendas_A}, Vendas de B: {vendas_B}\")\n",
    "    \n",
    "print()\n",
    "\n",
    "#3. Trocando valores entre duas variáveis\n",
    "\n",
    "#No final do dia, você percebeu que confundiu as vendas dos \n",
    "#produtos A e B e precisa trocar os valores para corrigir.\n",
    "vendas_A = 100\n",
    "vendas_B = 85\n",
    "vendas_A, vendas_B = vendas_B, vendas_A\n",
    "print(f\"Vendas Corrigidas - A: {vendas_A}, B: {vendas_B}\")\n",
    "\n",
    "\"\"\"\n",
    "Esses são exemplos práticos de como as tuplas podem ser úteis \n",
    "em diferentes situações na programação, especialmente em Python, onde \n",
    "elas são amplamente utilizadas para desempacotamento, retorno múltiplo de funções e em iterações.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b475023",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9895fd9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total de Vendas: 150\n",
      "Produto Mais Vendido: smartphone\n",
      "\n",
      "Vendas de smartphones: 70, Vendas de smartwatches: 65\n",
      "Vendas de smartphones: 80, Vendas de smartwatches: 82\n",
      "Vendas de smartphones: 90, Vendas de smartwatches: 88\n",
      "\n",
      "Vendas corrigidas de segunda-feira - Smartphones: 70, Smartwatches: 65\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Gerenciamento de Estoque\n",
    "\n",
    "Contexto: Você trabalha no controle de estoque de uma empresa de \n",
    "eletrônicos. A empresa vende dois produtos populares: smartphones e smartwatches. \n",
    "\n",
    "Diariamente, você precisa calcular o total de produtos vendidos, identificar \n",
    "qual produto foi mais vendido e reorganizar os números caso haja algum erro nas entradas.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Retornando múltiplos valores de uma função usando tuplas.\n",
    "        - Crie uma função chamada resumo_vendas que aceite \n",
    "        dois argumentos: vendas_smartphones e vendas_smartwatches.\n",
    "        \n",
    "        - A função deve retornar o total de vendas e o nome do produto \n",
    "        mais vendido (seja \"smartphone\" ou \"smartwatch\").\n",
    "        \n",
    "        - Exemplo de entrada: 80 smartphones vendidos e 70 smartwatches vendidos.\n",
    "        - Pergunta: Qual é o total de vendas e qual produto foi mais vendido?\n",
    "\n",
    "    2. Uso de tuplas em loops for.\n",
    "        - Dada a lista vendas_semana = [(70, 65), (80, 82), (90, 88)], onde \n",
    "        cada tupla representa as vendas de smartphones e smartwatches em um dia, respectivamente.\n",
    "        \n",
    "        - Use um loop for para imprimir as vendas de smartphones e smartwatches para cada dia.\n",
    "        - Pergunta: Quais foram as vendas de smartphones e smartwatches para cada dia?\n",
    "\n",
    "    3. Trocando valores entre duas variáveis.\n",
    "        - Suponha que você cometeu um erro e registrou as vendas de segunda-feira \n",
    "        de forma invertida: vendas_segunda = (65, 70), onde o primeiro valor é para \n",
    "        smartwatches e o segundo para smartphones.\n",
    "        \n",
    "        - Corrija essa entrada invertendo os valores.\n",
    "        - Pergunta: Qual é a entrada corrigida para as vendas de segunda-feira?\n",
    "\n",
    "Nota: Este exercício visa ajudar a compreenderem a versatilidade e aplicabilidade \n",
    "das tuplas em diferentes cenários de programação. \n",
    "\n",
    "Ao final, você será capaz de usar tuplas para múltiplas finalidades e manipular dados de forma eficiente.\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "#1. Retornando múltiplos valores de uma função usando tuplas.\n",
    "\n",
    "def resumo_vendas(vendas_smartphones, vendas_smartwatches):\n",
    "    \n",
    "    total_vendas = vendas_smartphones + vendas_smartwatches\n",
    "    mais_vendido = \"smartphone\" if vendas_smartphones > vendas_smartwatches else \"smartwatch\"\n",
    "    \n",
    "\n",
    "    return total_vendas, mais_vendido\n",
    "\n",
    "\n",
    "total, top_produto = resumo_vendas(80, 70)\n",
    "\n",
    "print(f\"Total de Vendas: {total}\")\n",
    "print(f\"Produto Mais Vendido: {top_produto}\")\n",
    "\n",
    "print()\n",
    "\n",
    "#2. Uso de tuplas em loops for.\n",
    "\n",
    "vendas_semana = [(70, 65), (80, 82), (90, 88)]\n",
    "\n",
    "for smartphones, smartwatches in vendas_semana:\n",
    "    print(f\"Vendas de smartphones: {smartphones}, Vendas de smartwatches: {smartwatches}\")\n",
    "    \n",
    "print()\n",
    "\n",
    "#3. Trocando valores entre duas variáveis.\n",
    "\n",
    "vendas_segunda = (65, 70)\n",
    "\n",
    "#utiliza um recurso do Python chamado fatiamento (slicing). \n",
    "#Especificamente, o [::-1] é um atalho para inverter a ordem dos \n",
    "#elementos dentro de uma sequência (que pode ser uma lista, string, tupla, etc.).\n",
    "vendas_segunda = vendas_segunda[::-1]\n",
    "\n",
    "print(f\"Vendas corrigidas de segunda-feira - Smartphones: {vendas_segunda[0]}, Smartwatches: {vendas_segunda[1]}\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0563309",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "0e9a275b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Comparando Tuplas:\n",
    "        Tuplas podem ser comparadas usando operadores de comparação: (1, 2) < (1, 3)\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Exemplo Prático: Comparando Tuplas\n",
    "\n",
    "No Python, quando duas tuplas são comparadas, a comparação é realizada \n",
    "elemento por elemento, começando pelo primeiro. Assim que um par de \n",
    "elementos é encontrado onde um é menor (ou maior) que o outro, a comparação \n",
    "retorna True ou False e não prossegue para os próximos elementos. \n",
    "\n",
    "Se todos os elementos comparados forem iguais e uma das tuplas for mais curta \n",
    "que a outra, a tupla mais curta é considerada menor.\n",
    "\n",
    "Aqui estão alguns exemplos para ilustrar isso:\n",
    "\"\"\"\n",
    "\n",
    "#1. Comparando o Primeiro Elemento:\n",
    "t1 = (1, 2)\n",
    "t2 = (1, 3)\n",
    "print(t1 < t2)  # Isso imprimirá True, porque 2 (de t1) é menor que 3 (de t2).\n",
    "\n",
    "#2. Ignorando Elementos Iguais:\n",
    "t1 = (1, 2, 3)\n",
    "t2 = (1, 2, 4)\n",
    "print(t1 < t2)  # Isso imprimirá True, porque, apesar de 1 e 2 \n",
    "                #serem iguais em ambas as tuplas, 3 (de t1) é menor que 4 (de t2).\n",
    "    \n",
    "    \n",
    "#3. Comparando Tuplas de Diferentes tamanhos:\n",
    "t1 = (1, 2)\n",
    "t2 = (1, 2, 3)\n",
    "print(t1 < t2)  # Isso imprimirá True, porque t1 é mais curta \n",
    "                #que t2, mesmo que todos os seus elementos correspondentes sejam iguais.\n",
    "    \n",
    "#4. Comparação de Elementos de Diferentes Tipos:\n",
    "#Supondo que as tuplas tenham elementos de diferentes tipos, o Python irá \n",
    "#compará-los com base em suas ordens de classificação interna (por exemplo, int antes de string).\n",
    "t1 = (1, \"apple\")\n",
    "t2 = (2, \"banana\")\n",
    "print(t1 < t2)  # Isso imprimirá True porque 1 é menor que 2. \n",
    "                #A comparação não chega a comparar \"apple\" com \"banana\".\n",
    "\n",
    "\"\"\"\n",
    "Estes exemplos mostram como as tuplas são comparadas no Python. Esta forma \n",
    "de comparação é muito útil em diversas situações, como quando as tuplas são \n",
    "usadas como chaves em dicionários ou quando estão em uma lista e você quer ordená-las.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8d71545",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "f02de89b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. t1 é maior\n",
      "2. t3 é maior que t1? True\n",
      "3. t4 é menor\n",
      "4. t1 e t2 são iguais? True\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Comparação de Tuplas\n",
    "\n",
    "Dadas as seguintes tuplas:\n",
    "\n",
    "t1 = (3, 5)\n",
    "t2 = (3, 4, 10)\n",
    "t3 = (3, 6)\n",
    "t4 = (2, 100)\n",
    "t5 = (3, 5)\n",
    "\n",
    "Responda as seguintes questões:\n",
    "\n",
    "    1. Qual é maior: t1 ou t2?\n",
    "    2. t3 é maior que t1?\n",
    "    3. Compare t4 e t1. Qual é menor?\n",
    "    4. t1 e t5 são iguais?\n",
    "\n",
    "Nota: O objetivo deste exercício é fazer com que entendam o conceito\n",
    "de comparação de tuplas em profundidade, observando \n",
    "a ordem dos elementos e como os diferentes elementos em diferentes posições \n",
    "influenciam o resultado da comparação.\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "t1 = (3, 5)\n",
    "t2 = (3, 4, 10)\n",
    "t3 = (3, 6)\n",
    "t4 = (2, 100)\n",
    "t5 = (3, 5)\n",
    "\n",
    "#Repostas\n",
    "\n",
    "#1. Qual é maior: t1 ou t2?\n",
    "    \n",
    "if t1 > t2:\n",
    "    \n",
    "    r1 = \"t1\"\n",
    "\n",
    "else:\n",
    "    \n",
    "    r1 = \"t2\"\n",
    "    \n",
    "print(f\"1. {r1} é maior\")\n",
    "\n",
    "#2. t3 é maior que t1?\n",
    "\n",
    "r2 = t3 > t1\n",
    "\n",
    "print(f\"2. t3 é maior que t1? {r2}\")\n",
    "\n",
    "#3. Compare t4 e t1. Qual é menor?\n",
    "\n",
    "if t4 < t1:\n",
    "    \n",
    "    r3 = \"t4\"\n",
    "\n",
    "else:\n",
    "    \n",
    "    r3 = \"t1\"\n",
    "    \n",
    "print(f\"3. {r3} é menor\")\n",
    "\n",
    "#4. t1 e t5 são iguais?\n",
    "\n",
    "r4 = t1 == t5\n",
    "\n",
    "print(f\"4. t1 e t2 são iguais? {r4}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db4780fc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "3e6482ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['O Pequeno Príncipe', '1984', 'Dom Quixote', 'O Senhor dos Anéis']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Diferenças entre Listas e Tuplas:\n",
    "\n",
    "    Quando e por que usar uma em vez da outra\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Exemplo Prático sobre Diferenças entre Listas e Tuplas:\n",
    "\n",
    "Imagine que você é um desenvolvedor de software trabalhando em um \n",
    "sistema de gerenciamento para uma biblioteca. O sistema mantém um registro \n",
    "de todos os livros disponíveis na biblioteca. Cada livro tem atributos como \n",
    "título, autor, ISBN, ano de publicação, etc.\n",
    "\"\"\"\n",
    "\n",
    "#1. Listas:\n",
    "#Para os livros que são emprestados frequentemente, você deseja manter \n",
    "#uma lista de \"livros mais emprestados\". Esta lista é dinâmica; os livros podem \n",
    "#ser adicionados ou removidos com base em sua popularidade de empréstimo.\n",
    "livros_mais_emprestados = ['O Pequeno Príncipe', '1984', 'Dom Quixote']\n",
    "\n",
    "#Agora, suponha que 'O Senhor dos Anéis' se tornou um livro popular \n",
    "#recentemente e você deseja adicioná-lo à lista.\n",
    "livros_mais_emprestados.append('O Senhor dos Anéis')\n",
    "\n",
    "#Neste caso, as listas são ideais porque elas são mutáveis e você pode \n",
    "#facilmente alterar seu conteúdo.\n",
    "\n",
    "print(livros_mais_emprestados)\n",
    "\n",
    "#-------------------------------\n",
    "\n",
    "#Tuplas:\n",
    "#Para cada livro, as informações básicas, como título, autor e ISBN, são fixas. \n",
    "#Elas não mudam uma vez que o livro é adicionado ao sistema. Aqui, uma tupla é uma boa escolha.\n",
    "livro_info = ('O Pequeno Príncipe', 'Antoine de Saint-Exupéry', '978-3-16-148410-0')\n",
    "\n",
    "#Uma vez definida, você não pode alterar os detalhes do livro nesta tupla. \n",
    "#Isso garante a imutabilidade e a integridade dos dados. Se por algum motivo você \n",
    "#precisar atualizar essas informações, você teria que criar uma nova tupla.\n",
    "\n",
    "\"\"\"\n",
    "Quando e Por Que Usar Uma em Vez da Outra:\n",
    "\n",
    "    Listas:\n",
    "        - Quando os dados são dinâmicos e podem mudar ao longo do tempo.\n",
    "        - Quando você precisa de métodos como append(), remove(), etc.\n",
    "        - Para sequências de tamanho variável.\n",
    "        \n",
    "    Tuplas:\n",
    "        - Quando os dados não devem ser alterados (imutabilidade).\n",
    "        - Para garantir a integridade dos dados.\n",
    "        - Para usar como chave em dicionários (listas não podem ser usadas como chaves).\n",
    "        - Para melhorar a eficiência, pois tuplas são geralmente mais rápidas \n",
    "        para iteração e processamento do que listas, devido à sua imutabilidade.\n",
    "\n",
    "Espero que este exemplo tenha ajudado a entender as diferenças entre listas e tuplas e quando usar cada uma delas!\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "741c94e8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "232aa846",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Torre Eiffel', 'França', 'FR-001')\n",
      "\n",
      "['Maravilhoso!', 'A vista é espetacular.', 'Muito lotado durante a temporada alta.']\n",
      "\n",
      "['Maravilhoso!', 'A vista é espetacular.', 'Muito lotado durante a temporada alta.', 'Recomendo visitar à noite.']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Diferenças entre Listas e Tuplas\n",
    "\n",
    "Contexto:\n",
    "Você é o arquiteto de software de uma startup de turismo. Seu software \n",
    "precisa lidar com informações sobre destinos turísticos e os feedbacks \n",
    "dos usuários sobre esses destinos.\n",
    "\n",
    "Tarefas:\n",
    "\n",
    "    1. Destinos Turísticos:\n",
    "    Cada destino turístico tem informações fixas como nome, país, e um \n",
    "    código identificador único. Essas informações não mudam uma vez que o destino é adicionado ao sistema.\n",
    "    \n",
    "        Crie uma representação adequada para um destino turístico no sistema.\n",
    "\n",
    "    2. Feedbacks dos Usuários:\n",
    "    Os usuários do sistema podem adicionar feedbacks sobre os destinos \n",
    "    visitados. Estes feedbacks são dinâmicos, já que os usuários \n",
    "    podem adicionar, editar ou deletar seus comentários.\n",
    "        \n",
    "        Crie uma representação adequada para armazenar feedbacks de um destino turístico.\n",
    "\n",
    "    3. Análise:\n",
    "        Explique por que você escolheu a estrutura de dados \n",
    "        específica (lista ou tupla) para cada um dos casos acima.\n",
    "        \n",
    "        Dê um exemplo de uma situação em que seria desvantajoso usar a estrutura \n",
    "        de dados oposta em cada um dos casos.\n",
    "\n",
    "Objetivo:\n",
    "O principal objetivo deste exercício é fazer com que você pense sobre a natureza \n",
    "mutável das listas e a natureza imutável das tuplas, e como essa característica influencia \n",
    "a decisão de qual estrutura de dados usar em diferentes cenários práticos.\n",
    "\"\"\"\n",
    "\n",
    "#Solução: Diferenças entre Listas e Tuplas\n",
    "\n",
    "#1. Destinos Turísticos:\n",
    "\n",
    "#Como o nome, país e código identificador de um destino turístico \n",
    "#são fixos e não mudam uma vez que o destino é adicionado ao \n",
    "#sistema, é apropriado usar uma tupla.\n",
    "destino_turistico = (\"Torre Eiffel\", \"França\", \"FR-001\")\n",
    "\n",
    "print(destino_turistico)\n",
    "\n",
    "print()\n",
    "\n",
    "\n",
    "#2. Feedbacks dos Usuários\n",
    "\n",
    "#Os feedbacks dos usuários são dinâmicos, e é necessário ter \n",
    "#a capacidade de adicionar, editar ou remover comentários. Portanto, uma \n",
    "#lista é a estrutura de dados adequada.\n",
    "feedbacks_torre_eiffel = [\n",
    "    \"Maravilhoso!\",\n",
    "    \"A vista é espetacular.\",\n",
    "    \"Muito lotado durante a temporada alta.\"\n",
    "]\n",
    "\n",
    "print(feedbacks_torre_eiffel)\n",
    "\n",
    "print()\n",
    "\n",
    "#Para adicionar um novo feedback:\n",
    "feedbacks_torre_eiffel.append(\"Recomendo visitar à noite.\")\n",
    "\n",
    "\n",
    "print(feedbacks_torre_eiffel)\n",
    "\n",
    "\n",
    "#3. Análise:\n",
    "\n",
    "\"\"\"\n",
    "3. Análise:\n",
    "\n",
    "        - Para o Destino Turístico: Eu escolhi a tupla porque é imutável, \n",
    "        garantindo que os detalhes fundamentais do destino não sejam alterados \n",
    "        acidentalmente durante a execução do programa.\n",
    "\n",
    "        - Desvantagem de usar lista aqui: Se usássemos uma lista para representar \n",
    "        um destino turístico, correríamos o risco de modificar acidentalmente as \n",
    "        informações fundamentais, como o nome do destino ou seu código identificador. \n",
    "        Além disso, as tuplas são, em geral, mais leves em termos de uso de memória do que listas.\n",
    "\n",
    "        - Para os Feedbacks dos Usuários: Escolhi a lista porque permite mutabilidade, o \n",
    "        que é necessário para acomodar as adições, edições e remoções dinâmicas de \n",
    "        feedbacks dos usuários.\n",
    "\n",
    "        Desvantagem de usar tupla aqui: Se usássemos uma tupla para armazenar \n",
    "        feedbacks, cada vez que quiséssemos adicionar, editar ou remover um comentário, \n",
    "        teríamos que criar uma nova tupla. Isso não seria eficiente e tornaria o processo \n",
    "        de gerenciamento de feedbacks complicado e menos dinâmico.\n",
    "\n",
    "Espero que esta solução ajude a entender as considerações práticas ao escolher entre \n",
    "listas e tuplas em diferentes cenários!\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6835ecc3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17651f70",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a810b8e6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae7ed6ba",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8558e3b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6f4d6d9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}