From 7d6bc926ce8dd1f0b50ee9d5922df030484c3aaa Mon Sep 17 00:00:00 2001 From: Henrique Branco Date: Thu, 25 Jul 2024 08:17:26 -0300 Subject: [PATCH] =?UTF-8?q?feat:=20finaliza=C3=A7=C3=A3o=20cap=C3=ADtulo?= =?UTF-8?q?=20tuplas?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../03-precedencia-operadores.md | 1 + book/06-estruturas-de-dados/03-tuplas.ipynb | 133 +++++++++++++++++- book/exercicios.ipynb | 85 +++++++++++ 3 files changed, 218 insertions(+), 1 deletion(-) diff --git a/book/05-operacoes-basicas/03-precedencia-operadores.md b/book/05-operacoes-basicas/03-precedencia-operadores.md index 273b90e..44fac7d 100644 --- a/book/05-operacoes-basicas/03-precedencia-operadores.md +++ b/book/05-operacoes-basicas/03-precedencia-operadores.md @@ -34,6 +34,7 @@ O conceito mais simples de programação seria: Bom, no nosso programa, temos basicamente duas operações: `-` (subtração) e `**` (potenciação). Só que o nosso programa não é executado sempre na sequência linear de leitura, da esquerda para direita. Dependendo dos operadores, alguns podem ser executados antes de outros, como uma fila de prioridade. E é justamente o caso que acontece aqui. +(tabela-precedencia)= ## A tabela de precedência | Operador | Descrição | diff --git a/book/06-estruturas-de-dados/03-tuplas.ipynb b/book/06-estruturas-de-dados/03-tuplas.ipynb index 965d9f7..dc81266 100644 --- a/book/06-estruturas-de-dados/03-tuplas.ipynb +++ b/book/06-estruturas-de-dados/03-tuplas.ipynb @@ -49,7 +49,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Tuplas começam e terminam com `( )`, e seus elementos são separados com vírugla (`,`) assim como nas listas." + "Tuplas começam e terminam com parênteses `( )`, e seus elementos são separados com vírugla (`,`) assim como nas listas." ] }, { @@ -70,6 +70,103 @@ "print(tupla_de_numeros)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Como os parênteses `( )` existem também para priorizar operações matemática (lembra da [tabela de precedência](tabela-precedencia)?) o único caso que pode ser um tanto quanto confuso é a criação de tuplas com um único elemento. Observem o caso abaixo." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "tupla_de_um_elemento = (1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Eu faço a seguinte pergunta, a variável `tupla_de_um_elemento` acima é uma tupla? Por incrível que pareça **não é**! Como podemos confirmar? Vamos checar essa informação ssando a função `type`, conforme já aprendemos." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "tupla_de_um_elemento = (1)\n", + "print(type(tupla_de_um_elemento))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "O trecho de código acima confirma que a variável `tupla_de_um_elemento` não é uma tupla mas sim um inteiro, apesar da existência dos parênteses `( )`.\n", + "\n", + "Por que? Como tuplas são sequências, elas precisam da existência da vírgula `,` para separar os elementos, por mais que exista apenas um único elemento.\n", + "\n", + "Portanto, uma tupla de um único elemento seria representada desta forma:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "tupla_de_um_elemento = (1,)\n", + "print(type(tupla_de_um_elemento))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{admonition} Dica (tipo do elemento)\n", + ":class: tip\n", + "\n", + "O que mencionei acima sobre tuplas de um elemento é válido para qualquer tipo de dado dentro da tupla. Quer ver só? Qual seria o tipo de dado da variável abaixo? string ou tupla?\n", + "\n", + "```python\n", + "variavel = (\"uma string qualquer\")\n", + "```\n", + "\n", + "Se você disse tupla, eu lhe pergunto, onde está a vírgula `,` separando os elementos? No final ela acaba sendo uma string!\n", + "\n", + "Para transformarmos essa variável acima em tupla, precisamos adicionar a vírgula ao final.\n", + "\n", + "```python\n", + "variavel = (\"uma string qualquer\",)\n", + "```\n", + "\n", + "Você pode conferir o que estou dizendo usando a função `type` da mesma forma que fiz nos exemplos acima.\n", + "```\n", + "\n", + "Por mais que seja estranho o formato `(elemento,)`, esta é a forma que o Python usa para distinguir parenteses `( )` usados em tuplas e em operações matemáticas." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -316,6 +413,40 @@ "source": [ "Em resumo, a nossa sequencia de meses está totalmente protegida de modificações indesejadas. E é exataente isso que queremos!" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prática (desafio)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Agora que você aprendeu a manipular listas e tuplas, eu criei um exercício desafio para você! Vamos realizar uma análise de vendas no [exercício 9](exercicio-9)?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusão" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nestes 2 últimos capítulo, exploramos as listas e tuplas em Python, duas estruturas de dados fundamentais. São as duas principais estruturas básicas para trabalharmos com dados ordenados.\n", + "As listas, com sua natureza mutável, oferecem flexibilidade para armazenar, modificar e gerenciar coleções de itens de forma dinâmica. \n", + "Já as tuplas, com sua imutabilidade, garantem a integridade dos dados, tornando-se ideais para armazenar informações que não devem ser alteradas. \n", + "Ambas desempenham papéis cruciais em diversas situações, desde a manipulação simples de dados até a construção de estruturas mais complexas. \n", + "Espero que você tenha compreendido principalmente a diferença entre listas e tuplas e sobre quando e como usar cada uma delas.\n", + "\n", + "No próximo capítulo vamos aprender sobre a primeira estrutura de dados não ordenada, os dicionários!" + ] } ], "metadata": { diff --git a/book/exercicios.ipynb b/book/exercicios.ipynb index 3aa33a0..39b0631 100644 --- a/book/exercicios.ipynb +++ b/book/exercicios.ipynb @@ -397,6 +397,91 @@ "\n", "print(f\"O crime foi motivado por: {motivo}!\")" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(exercicio-9)=\n", + "### Exercício 9 - análise de vendas\n", + "\n", + "Uma empresa de varejo quer analisar as vendas históricas de seus produtos para tomar decisões estratégicas. As vendas são armazenadas no seguinte formato, com nome do produto, quantidade vendida e preço unitário em R$:\n", + "\n", + "```python\n", + "vendas_diarias = (\n", + " [\"Produto A\", 10, 100],\n", + " [\"Produto B\", 5, 250],\n", + " [\"Produto C\", 2, 150],\n", + ")\n", + "```\n", + "\n", + "**9.1** - As informações de vendas diárias são mutáveis ou imutáveis? A estrutura de dados usada é a mais adequada? Justifique sua resposta.\n", + "\n", + "```{dropdown} Resposta 9.1\n", + "\n", + "A estrutura usada para vendas diárias é uma tupla, portanto, imutável. Não é a estrutura mais adequada, pois não permite a inserção de novas vendas na estrutura.\n", + "\n", + "A estrutura usada para armazenar cada informação dos produtos é uma lista, portanto mutável. Também não é a estrutura mais adequada pois permite uma certa flexibilidade que pode ser indesejada, como, por exemplo, adicionar ao produto A um item a mais de categoria e os outros produtos não terem.\n", + "\n", + "Além disso, sendo listas, é possível não só acrescentar itens como alterá-los após a criação da estrutura de vendas. Como são dados históricos, não há motivos para tais alterações, sendo uma lista uma estrutura mutável indesejada.\n", + "```\n", + "\n", + "**9.2** - As informações específicas de cada produto são mutáveis ou imutáveis? A estrutura de dados usada é a mais adequada? Justifique sua resposta.\n", + "\n", + "```{dropdown} Resposta 9.2\n", + "A estrutura usada para armazenar cada informação dos produtos (nome, quantidade e preço) é uma lista, portanto mutável. Também não é a estrutura mais adequada pois permite uma certa flexibilidade que pode ser indesejada, como, por exemplo, adicionar ao produto A um item a mais de categoria e os outros produtos não terem.\n", + "\n", + "Além disso, sendo listas, é possível não só acrescentar itens como alterá-los após a criação da estrutura de vendas. Como são dados históricos, não há motivos para tais alterações, sendo uma lista uma estrutura mutável indesejada.\n", + "```\n", + "\n", + "**9.3** - Caso as estruturas sejam inadequadas, como você sugeriria?\n", + "\n", + "```{dropdown} Resposta 9.3\n", + "A estrutura externa de vendas diárias deveria ser uma lista para eventual acréscimo de mais vendas e a estrutura interna dos produtos como sendo tuplas para garantir que não haja modificações.\n", + "\n", + "```python\n", + "vendas_diarias = [\n", + " (\"Produto A\", 10, 100),\n", + " (\"Produto B\", 5, 250),\n", + " (\"Produto C\", 2, 150),\n", + "]\n", + "```\n", + "\n", + "**9.4** - Faça um código que traga o faturamento da empresa (quantidade total de vendas em R$)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "tags": [ + "hide-cell" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "O faturamento da empresa foi de R$ 2050\n" + ] + } + ], + "source": [ + "vendas_diarias = [\n", + " (\"Produto A\", 10, 100),\n", + " (\"Produto B\", 5, 250),\n", + " (\"Produto C\", 2, 150),\n", + "]\n", + "\n", + "total_produto_a = vendas_diarias[0][1] * vendas_diarias[0][2]\n", + "total_produto_b = vendas_diarias[1][1] * vendas_diarias[2][2]\n", + "total_produto_c = vendas_diarias[2][1] * vendas_diarias[2][2]\n", + "\n", + "faturamento = total_produto_a + total_produto_b + total_produto_c\n", + "\n", + "print(f\"O faturamento da empresa foi de R$ {faturamento}\")" + ] } ], "metadata": {