diff --git a/book/06-estruturas-de-dados/02-listas.ipynb b/book/06-estruturas-de-dados/02-listas.ipynb
index 068e4c2..7b76a63 100644
--- a/book/06-estruturas-de-dados/02-listas.ipynb
+++ b/book/06-estruturas-de-dados/02-listas.ipynb
@@ -234,7 +234,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Append"
+    "#### `append`"
    ]
   },
   {
@@ -274,7 +274,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Extend"
+    "#### `extend`"
    ]
   },
   {
@@ -458,7 +458,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Insert"
+    "#### `insert`"
    ]
   },
   {
@@ -511,7 +511,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Remove"
+    "#### `remove`"
    ]
   },
   {
@@ -585,7 +585,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Pop"
+    "#### `pop`"
    ]
   },
   {
@@ -704,7 +704,40 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Informações sobre a lista"
+    "#### `clear`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "O método `clear` é simples. Ele limpa toda a lista, removendo todos os elementos. Aqui não há segredos."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[]\n"
+     ]
+    }
+   ],
+   "source": [
+    "frutas = [\"maçã\", \"banana\", \"laranja\", \"banana\"]\n",
+    "frutas.clear()\n",
+    "print(frutas)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Informações sobre a lista"
    ]
   },
   {
@@ -721,7 +754,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Index"
+    "#### `index`"
    ]
   },
   {
@@ -759,16 +792,384 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {"tags": [
-    "raises-exception"
-   ]},
-   "outputs": [],
+   "execution_count": 40,
+   "metadata": {
+    "tags": [
+     "raises-exception"
+    ]
+   },
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "'fruta inexistente' is not in list",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[40], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m frutas \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmaçã\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbanana\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlaranja\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbanana\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m----> 2\u001b[0m indice \u001b[38;5;241m=\u001b[39m \u001b[43mfrutas\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfruta inexistente\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMenor índice encontrado:\u001b[39m\u001b[38;5;124m\"\u001b[39m, indice)\n",
+      "\u001b[1;31mValueError\u001b[0m: 'fruta inexistente' is not in list"
+     ]
+    }
+   ],
    "source": [
     "frutas = [\"maçã\", \"banana\", \"laranja\", \"banana\"]\n",
-    "indice = frutas.index(\"banana\")\n",
+    "indice = frutas.index(\"fruta inexistente\")\n",
     "print(\"Menor índice encontrado:\", indice)"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### `count`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "O método `count` é similar ao que vimos em strings, para contar quantas vezes um dado elemento aparece na lista."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Quantidade de ocorrências de banana encontrada: 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "frutas = [\"maçã\", \"banana\", \"laranja\", \"banana\"]\n",
+    "contador = frutas.count(\"banana\")\n",
+    "print(\"Quantidade de ocorrências de banana encontrada:\", contador)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Ordenação e reversão"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Temos 2 métodos aqui:\n",
+    "\n",
+    "- `sort()`: Ordena os itens da lista.\n",
+    "- `reverse()`: Inverte a ordem dos itens na lista."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### `sort`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "O método `sort` ordena uma dada lista em ordem crescente ou decrescente. Para definir entre crescente e decrescente é possível usar o parâmetro `reverse`, que, por padrão, assume o valor `reverse=False`. Em outras palavras, o padrão de ordenação, quando nenhum parâmetro é passado, é crescente."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ordem crescente: [1, 1, 2, 3, 4, 5, 9]\n",
+      "Ordem decrescente: [9, 5, 4, 3, 2, 1, 1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "numeros = [3, 1, 4, 1, 5, 9, 2]\n",
+    "numeros.sort()\n",
+    "print(\"Ordem crescente:\", numeros)\n",
+    "\n",
+    "numeros.sort(reverse=True)\n",
+    "print(\"Ordem decrescente:\", numeros)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Quando os elementos são strings, a ordenação é feita de forma alfabética."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ordem alfabética: ['Antônio', 'Caio', 'Joaquim', 'Jonas', 'José', 'João']\n",
+      "Ordem alfabética reversa: ['João', 'José', 'Jonas', 'Joaquim', 'Caio', 'Antônio']\n"
+     ]
+    }
+   ],
+   "source": [
+    "nomes = [\"João\", \"José\", \"Jonas\", \"Joaquim\", \"Caio\", \"Antônio\"]\n",
+    "nomes.sort()\n",
+    "print(\"Ordem alfabética:\", nomes)\n",
+    "\n",
+    "nomes.sort(reverse=True)\n",
+    "print(\"Ordem alfabética reversa:\", nomes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Quando os tipos de dados da lista são misturados, não é possível fazer a ordenação."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "tags": [
+     "raises-exception"
+    ]
+   },
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "'<' not supported between instances of 'str' and 'int'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[7], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m tipos_misturados \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m1\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m1\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHenrique\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;241m4.0\u001b[39m]\n\u001b[1;32m----> 2\u001b[0m \u001b[43mtipos_misturados\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msort\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mOrdem crescente:\u001b[39m\u001b[38;5;124m'\u001b[39m, tipos_misturados)\n",
+      "\u001b[1;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'int'"
+     ]
+    }
+   ],
+   "source": [
+    "tipos_misturados = [1, \"1\", \"Henrique\", 4.0]\n",
+    "tipos_misturados.sort()\n",
+    "print(\"Ordem crescente:\", tipos_misturados)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### `reverse`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "O método `reverse` inverte uma dada lista ao contrário. É diferente do `sort`, que ordena."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Lista invertida: [4.0, 'Henrique', '1', 1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "tipos_misturados = [1, \"1\", \"Henrique\", 4.0]\n",
+    "tipos_misturados.reverse()\n",
+    "print(\"Lista invertida:\", tipos_misturados)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Outras operações com listas"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Pertencimento"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "É possível verificar se um dado elemento está ou não em uma lista usando os operadores `not` e `in`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "nomes = [\"João\", \"José\", \"Jonas\", \"Joaquim\", \"Caio\", \"Antônio\"]\n",
+    "print(\"João\" in nomes)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "nomes = [\"João\", \"José\", \"Jonas\", \"Joaquim\", \"Caio\", \"Antônio\"]\n",
+    "print(\"Nome inexistente\" not in nomes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Comprimento"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Como já vimos em strings, é possível usar a função `len` para mensurar o tamanho de uma lista."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A lista tem 6 nomes\n"
+     ]
+    }
+   ],
+   "source": [
+    "nomes = [\"João\", \"José\", \"Jonas\", \"Joaquim\", \"Caio\", \"Antônio\"]\n",
+    "quantidade_nomes = len(nomes)\n",
+    "print(f\"A lista tem {quantidade_nomes} nomes.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```{admonition} Lembrete (len é função e não método)\n",
+    ":class: hint\n",
+    "\n",
+    "A esta altura do livro você deve estar confortável em saber porque usamos `len(nomes)` e não `nomes.len()`. O motivo: `len()´ é uma função e não um método de lista, conforme vimos na seção [reforço prático - métodos vs funções](reforco-pratico-metodos-vs-funcoes).\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Iterando pela lista"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Podemos já adiantar um tema que vamos detalhar mais em capítulos futuros, o laço `for`. Basicamente, e de forma simplificada, podemos iterar pelos elementos de uma lista."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "João\n",
+      "José\n",
+      "Jonas\n",
+      "Joaquim\n",
+      "Caio\n",
+      "Antônio\n"
+     ]
+    }
+   ],
+   "source": [
+    "nomes = [\"João\", \"José\", \"Jonas\", \"Joaquim\", \"Caio\", \"Antônio\"]\n",
+    "for nome in nomes:\n",
+    "    print(nome)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "No exemplo acima, estamos usando uma variável temporária `nome`, que recebe cada um dos nomes da lista `nomes`. Cada item da lista é impresso na tela.\n",
+    "\n",
+    "```{admonition} Nota (identação)\n",
+    ":class: note\n",
+    "\n",
+    "Reparem bem na linha `    print(nome)`. Há vários espaços em branco à direita dela. Pela primeira vez estamos usando identação no código.\n",
+    "\n",
+    "Em Python, a identação são espaços que colocamos no começo das linhas. Ela ajuda o computador a entender que partes do código pertencem juntas. \n",
+    "\n",
+    "A linha `print(nome)` está indentada, o que significa que ela pertence ao bloco do laço de repetição `for` da linha acima. O que está indentado aqui é a ação que queremos realizar para cada nome na lista. Nesse caso, a ação é imprimir o nome na tela.\n",
+    "\n",
+    "Vamos detalhar mais a fundo a identação quando começarmos a estudar estruturas de decisão `if-else` e laços de repetição `for` e `while`.\n",
+    "\n",
+    "O que você precisa entender por agora é que a identação é obrigatória, caso contrário o código vai gerar um erro. Experimente executar o trecho abaixo e veja você mesmo o erro:\n",
+    "\n",
+    "```python\n",
+    "nomes = [\"João\", \"José\", \"Jonas\", \"Joaquim\", \"Caio\", \"Antônio\"]\n",
+    "for nome in nomes:\n",
+    "print(nome)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
   }
  ],
  "metadata": {