From 47aadf5aaa730731d5aabeee7799066b909ebff1 Mon Sep 17 00:00:00 2001 From: Henrique Branco Date: Thu, 18 Jul 2024 08:09:45 -0300 Subject: [PATCH] =?UTF-8?q?feat:=20in=C3=ADcio=20cap=C3=ADtulo=20listas?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- book/06-estruturas-de-dados/01-strings.ipynb | 131 +++++++---- book/06-estruturas-de-dados/02-listas.ipynb | 221 +++++++++++++++++++ book/_toc.yml | 3 +- 3 files changed, 312 insertions(+), 43 deletions(-) create mode 100644 book/06-estruturas-de-dados/02-listas.ipynb diff --git a/book/06-estruturas-de-dados/01-strings.ipynb b/book/06-estruturas-de-dados/01-strings.ipynb index 1abdabc..5fffb37 100644 --- a/book/06-estruturas-de-dados/01-strings.ipynb +++ b/book/06-estruturas-de-dados/01-strings.ipynb @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -61,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": { "tags": [ "raises-exception" @@ -73,7 +73,7 @@ "evalue": "invalid syntax (1998578200.py, line 2)", "output_type": "error", "traceback": [ - "\u001b[1;36m Cell \u001b[1;32mIn[8], line 2\u001b[1;36m\u001b[0m\n\u001b[1;33m erro_de_sintaxe = \"Ela disse \"Olá mundo!\"\"\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" + "\u001b[1;36m Cell \u001b[1;32mIn[2], line 2\u001b[1;36m\u001b[0m\n\u001b[1;33m erro_de_sintaxe = \"Ela disse \"Olá mundo!\"\"\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" ] } ], @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -128,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -171,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -195,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -242,7 +242,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -267,7 +267,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -299,7 +299,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -366,7 +366,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -431,7 +431,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -471,7 +471,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -503,7 +503,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -552,7 +552,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -617,7 +617,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -647,7 +647,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -673,6 +673,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "(reforco-pratico-metodos-vs-funcoes)=\n", "### Reforço prático - métodos vs funções" ] }, @@ -689,7 +690,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 17, "metadata": { "tags": [ "raises-exception" @@ -703,7 +704,7 @@ "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[24], line 4\u001b[0m\n\u001b[0;32m 1\u001b[0m nome_comprido \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mJoão Antônio da Silva Sauro de Souza Silva Santos\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;66;03m# Contando a quantidade de caracteres deste nome enorme\u001b[39;00m\n\u001b[1;32m----> 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mnome_comprido\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlen\u001b[49m()) \u001b[38;5;66;03m# ... ops!\u001b[39;00m\n", + "Cell \u001b[1;32mIn[17], line 4\u001b[0m\n\u001b[0;32m 1\u001b[0m nome_comprido \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mJoão Antônio da Silva Sauro de Souza Silva Santos\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;66;03m# Contando a quantidade de caracteres deste nome enorme\u001b[39;00m\n\u001b[1;32m----> 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mnome_comprido\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlen\u001b[49m()) \u001b[38;5;66;03m# ... ops!\u001b[39;00m\n", "\u001b[1;31mAttributeError\u001b[0m: 'str' object has no attribute 'len'" ] } @@ -728,9 +729,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "49\n" + ] + } + ], "source": [ "nome_comprido = \"João Antônio da Silva Sauro de Souza Silva Santos\"\n", "\n", @@ -751,7 +760,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -780,6 +789,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "(fatiamento)=\n", "### Fatiamento (slicing)" ] }, @@ -796,6 +806,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "(indexacao-strings)=\n", "#### Indexação de strings" ] }, @@ -840,7 +851,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -879,16 +890,16 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "O último caracter do nome é o.\n", - "O penúltimo caracter do nome é r.\n", - "O antepenúltimo caracter do nome é i.\n" + "O último caracter do nome é a letra o.\n", + "O penúltimo caracter do nome é a letra r.\n", + "O antepenúltimo caracter do nome é a letra i.\n" ] } ], @@ -930,7 +941,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -964,7 +975,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -991,7 +1002,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -1028,7 +1039,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -1055,7 +1066,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -1082,9 +1093,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "O sobrenome é Monteiro\n" + ] + } + ], "source": [ "nome = \"Lucas Almeida Monteiro\"\n", "\n", @@ -1107,14 +1126,14 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "O sobrenome é Monteiro\n" + "O último sobrenome é Monteiro\n" ] } ], @@ -1159,7 +1178,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -1186,14 +1205,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Somente os caracteres de índice par: ua led otio\n" + "Somente os caracteres de índice ímpar: ua led otio\n" ] } ], @@ -1213,7 +1232,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -1240,7 +1259,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -1267,7 +1286,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -1284,6 +1303,34 @@ "nome_inverso_de_2_em_2 = nome[::-2]\n", "print(f\"Nome inverso de 2 em 2 caracteres: {nome_inverso_de_2_em_2}\")" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prática" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Agora você já é capaz de resolver os exercícios [6](exercicio-6), [7](exercicio-7) e [8](exercicio-8) da lista! O exercício 8 é um desafio! Encara? Boa prática!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusão" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vimos o básico (sim, somente o básico) de manipulação de strings! Ao longo deste capítulo, você ouviu falar brevemente de listas, e é esta estrutura que vamos aprender no próximo capítulo do livro!" + ] } ], "metadata": { diff --git a/book/06-estruturas-de-dados/02-listas.ipynb b/book/06-estruturas-de-dados/02-listas.ipynb new file mode 100644 index 0000000..15d3765 --- /dev/null +++ b/book/06-estruturas-de-dados/02-listas.ipynb @@ -0,0 +1,221 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Listas" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ao longo do capítulo anterior, surgiu uma outra estrutura de dados básica: listas. Vamos entrar mais em detalhes nesta estrutura ao longo deste capítulo." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Definição" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Listas são um dos tipos de dados mais fundamentais e versáteis em Python. Uma lista é uma sequência ordenada de elementos que pode conter uma variedade de tipos de dados, como números, strings, outras listas, objetos, e mais. As listas em Python são mutáveis, o que significa que seus elementos podem ser alterados após a sua criação.\n", + "\n", + "As listas possuem as seguintes caracterísicas:\n", + "\n", + "- **Ordenadas:** As listas mantêm a ordem dos elementos conforme são adicionados. \n", + "- **Mutáveis:** Diferente de alguns outros tipos de coleções que vamos ver na sequência, como tuplas, as listas podem ser modificadas após a sua criação. Você pode adicionar, remover ou alterar seus elementos.\n", + "- **Permite duplicatas:** Listas podem conter elementos duplicados. Cada elemento na lista mantém sua própria posição e pode ser acessado individualmente.\n", + "- **Heterogêneas:** Uma lista pode conter elementos de diferentes tipos de dados. Por exemplo, você pode ter uma lista que contém números, strings e até mesmo outras listas." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sintaxe básica" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "O exemplo mais simples é uma lista de inteiros, conforme vimos no capítulo anterior, no terceiro exemplo da seção [reforço prático - métodos vs funções](reforco-pratico-metodos-vs-funcoes)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[10, 50, 40, 65, 90, 70, 30, 156]\n" + ] + } + ], + "source": [ + "lista_de_numeros = [10, 50, 40, 65, 90, 70, 30, 156]\n", + "print(lista_de_numeros)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Uma lista é criada com colchetes (`[ ]`), cada elemento é separado por vírgula (`,`) e não necessariamente todos os elementos precisam ser do mesmo tipo." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[10, 25.1, 'um texto qualquer', True]\n" + ] + } + ], + "source": [ + "lista_heterogenea = [10, 25.1, \"um texto qualquer\", True]\n", + "print(lista_heterogenea)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Acessando elementos" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cada elemento tem uma posição (ou índice) na lista começando do índice 0 para o primeiro elemento. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "Olá\n" + ] + } + ], + "source": [ + "lista_acesso_elementos = [1, \"Olá\", 3.14, True]\n", + "\n", + "# Acessando elementos da lista\n", + "print(lista_acesso_elementos[0])\n", + "print(lista_acesso_elementos[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vimos fatiamento de sequencias no capítulo sobre strings, na seção [indexação de strings](indexacao-strings), lembra? É possível usar o fatiamento em listas da mesma forma. Podemos usar exatamente a mesma sintaxe `variavel[start:stop:step]`, com exatamente as mesmas características. Caso queira relembrar o conteúdo, retorne ao capítulo sobre [fatiamento de strings](fatiamento).\n", + "\n", + "Aqui vamos abordar apenas o caso que é diferente de strings, no qual temos uma lista de listas." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lista_de_listas = [[1], [2, 3], [4, 5, 6], [7, 8, 9, 10]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vamos começar com uma pergunta:\n", + "\n", + "```{dropdown} Quandos elementos tem a lista acima? Pense primeiro e clique para ver a resposta...\n", + "Resposta correta: 4 elementos. Execute o código abaixo para conferir.\n", + "\n", + "```python\n", + "lista_de_listas = [[1], [2, 3], [4, 5, 6], [7, 8, 9, 10]]\n", + "print(len(lista_de_listas))\n", + "```\n", + "\n", + "Porque? Se você contou apenas **os números de 1 a 10**, talvez você não tenha entendido o conceito de listas. Vamos detalhar mais.\n", + "\n", + "Reparem que a variável acima começa com `[[` e termina com `]]`. A lista mais externa contém outras listas internas. Listas de listas também são chamadas de listas aninhadas. É como se tivéssemos vários \"níveis\" de listas, indo por camadas." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Primeira lista interna: [1]\n", + "Segunda lista interna: [2, 3]\n", + "Terceira lista interna: [4, 5, 6]\n", + "Quarta lista interna: [7, 8, 9, 10]\n" + ] + } + ], + "source": [ + "lista_de_listas = [[1], [2, 3], [4, 5, 6], [7, 8, 9, 10]]\n", + "print(f\"Primeiro elemento da lista: {lista_de_listas[0]}\")\n", + "print(f\"Segundo elemento da lista: {lista_de_listas[1]}\")\n", + "print(f\"Terceiro elemento da lista: {lista_de_listas[2]}\")\n", + "print(f\"Quarto elemento da lista: {lista_de_listas[3]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "O caso mais simples que consigo trazer pra representar listas aninhadas é `lista = [primeiro_elemento, segundo_elemento, terceiro_elemento, quarto_elemento]` onde cada `_elemento` é também uma lista! Pode parecer confuso, mas creio que este exemplo ajude a esclarecer." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/book/_toc.yml b/book/_toc.yml index defc8c8..fd8ba75 100644 --- a/book/_toc.yml +++ b/book/_toc.yml @@ -36,9 +36,10 @@ parts: - file: 05-operacoes-basicas/03-precedencia-operadores.md - file: 05-operacoes-basicas/04-variaveis.md -- caption: Aprenda conceitos básicos +- caption: Estruturas de dados básicas chapters: - file: 06-estruturas-de-dados/01-strings.ipynb + - file: 06-estruturas-de-dados/02-listas.ipynb - caption: Pratique chapters: