content.py

conteudo = [
    {
        "topico": "Introdução",
        "subtopicos": [
            {
                "titulo": "O que é Python?",
                "texto": "Python é uma linguagem de programação de alto nível, interpretada, de fácil leitura e escrita. Foi projetada para ser simples e eficiente, permitindo que os desenvolvedores escrevam código limpo e legível, o que facilita o aprendizado e o desenvolvimento rápido de software. Sua versatilidade a torna adequada para uma ampla gama de aplicações, como desenvolvimento web, análise de dados, inteligência artificial e automação.",
                "blocos": [],
                "observacoes": []
            },
            {
                "titulo": "História",
                "texto": "Python foi criado por **Guido van Rossum** e lançado em **1991**. A primeira versão, Python 1, evoluiu ao longo dos anos até a versão 2, que se tornou amplamente popular. Em 2008, foi lançada a versão 3, com melhorias na sintaxe e desempenho. Embora o Python 2 tenha sido descontinuado em 2020, a transição para o Python 3 é importante, pois oferece recursos modernos e continua a ser a versão recomendada para novos projetos.",
                "blocos": [],
                "observacoes": []
            }
        ]
    },
    {
        "topico": "Sintaxe Básica",
        "subtopicos": [
            {
                "titulo": "Comentários",
                "texto": "Comentários são trechos de texto no código que o interpretador Python ignora. Eles servem para adicionar explicações ou notas sobre o código que faz.",
                "blocos": [
                    {
                        "descricao": "**Comentários de uma linha:** Use o símbolo `#` antes do texto do comentário.",
                        "codigo": "# Este é um comentário de uma linha"
                    },
                    {
                        "descricao": "**Comentários de múltiplas linhas:** Em Python, não existe uma sintaxe específica para comentários de múltiplas linhas, mas você pode usar strings de múltiplas linhas (aspas triplas) para criar esse tipo de comentário. Essas aspas podem ser tanto simples `'''` quanto duplas `\"\"\"`.",
                        "codigo": "'''Este é um comentário de múltiplas linhas\nusando aspas triplas simples.'''"
                    }
                ],
                "observacoes": []
            },
            {
                "titulo": "Print",
                "texto": "A função `print()` é usada para exibir informações na tela. Você pode usá-la para mostrar valores, mensagens ou resultados de cálculos.",
                "blocos": [
                    {
                        "descricao": "**Exibindo texto simples:** Para exibir uma mensagem ou texto na tela, você passa uma string (texto entre aspas) como argumento para a função `print()`.",
                        "codigo": 'print("Olá, Mundo!") # Isso vai exibir: Olá, Mundo!'
                    },
                    {
                        "descricao": "**Exibindo variáveis:** Você pode passar diretamente o nome da variável para a função `print()` para exibir seu valor.",
                        "codigo": 'nome = "Maria"\nidade = 30\nprint(nome) # Isso vai exibir: Maria\nprint(idade) # Isso vai exibir: 30'
                    },
                    {
                        "descricao": "**Exibindo múltiplos valores:** A função `print()` pode receber vários valores e exibi-los ao mesmo tempo. Eles são separados por um espaço padrão.",
                        "codigo": 'nome = "Maria"\nidade = 30\nprint(nome, idade) # Isso vai exibir: Maria 30'
                    },
                    {
                        "descricao": "**Alterando o separador:** O Python coloca um espaço entre os valores exibidos. Se você quiser usar outro separador, pode usar o argumento `sep`.",
                        "codigo": 'print("Python", "é", "divertido", sep="-")\n# Isso vai exibir: Python-é-divertido'
                    },
                    {
                        "descricao": "**Mudando o final da linha:** O `print()` termina com uma nova linha por padrão. Você pode mudar isso com o argumento **end**, que define o que será colocado no final da saída.",
                        "codigo": 'print("Primeira linha", end=" ")\nprint("Segunda linha")\n# Isso vai exibir: Primeira linha Segunda linha'
                    },
                    {
                        "descricao": "**Exibindo variáveis e textos juntos:** Você pode exibir texto junto com variáveis passando tudo dentro da função `print()`. O Python automaticamente separa os itens com espaços.",
                        "codigo": 'nome = "Maria"\nidade = 30\nprint("Nome:", nome, "Idade:", idade)\n# Isso vai exibir: Nome: Maria Idade: 30'
                    },
                    {
                        "descricao": "**Concatenando strings:** Concatenar strings significa juntar duas ou mais strings em uma única. Você pode usar o operador `+` para concatenar strings.",
                        "codigo": 'nome = "Maria"\nsobrenome = "Silva"\nprint(nome + " " + sobrenome)\n# Isso vai exibir: Maria Silva'
                    },
                    {
                        "descricao": "**f-strings:** As **f-strings** são uma maneira elegante de incluir variáveis dentro de uma string. Elas são simples e mais eficientes do que concatenar as variáveis.",
                        "codigo": 'nome = "Maria"\nidade = 30\nprint(f"Nome: {nome}, Idade: {idade}")\n# Isso vai exibir: Nome: Maria, Idade: 30'
                    },
                    {
                        "descricao": r"**Quebra de linha:** Para criar uma quebra de linha, usamos o caractere especial `\n`, que indica ao programa que deve começar uma nova linha ao imprimir o texto.",
                        "codigo": 'print("Primeira linha\\nSegunda linha")\n# Isso vai exibir:\n# Primeira linha\n# Segunda linha'
                    }
                ],
                "observacoes": []
            },
            {
                "titulo": "Variáveis",
                "texto": 'Variáveis são como "caixas" onde você armazena dados. Não é necessário declarar explicitamente o tipo de dado de uma variável, pois é determinado automaticamente o tipo com base no valor atribuído.',
                "blocos": [
                    {
                        "descricao": "**Declaração:** Para declarar uma variável, basta dar um nome para ela e atribuir um valor.",
                        "codigo": 'nome = "Maria" # A variável "nome" recebe o valor "Maria"\nidade = 30 # A variável "idade" recebe o valor 30'
                    },
                    {
                        "descricao": "**Alterando valor:** Você pode mudar o valor de uma variável a qualquer momento, simplesmente atribuindo um novo valor a ela.",
                        "codigo": "numero = 10 # A variável 'numero' tem o valor 10\nnumero = 15 # Agora a variável 'numero' tem o valor 15"
                    }
                ],
                "observacoes": [
                    "**Nomes de variáveis:** Os nomes das variáveis devem começar com uma letra ou um sublinhado e podem conter letras, números e sublinhados, mas não podem começar com números e nem usar palavras reservadas (como `if`, `for`, `while`)."
                ]
            },
            {
                "titulo": "Tipos de Dados",
                "texto": "Os tipos de dados são classificados em categorias, e cada tipo de dado tem suas próprias características.",
                "blocos": [
                    {
                        "descricao": "**Inteiros:** São números inteiros, ou seja, sem casas decimais.",
                        "codigo": "numero = 10 # Um número inteiro"
                    },
                    {
                        "descricao": "**Ponto flutuante:** São números que possuem casas decimais.",
                        "codigo": "numero = 19.99 # Um número com ponto flutuante"
                    },
                    {
                        "descricao": "**Strings:** São sequências de caracteres, usadas para armazenar texto. Strings podem ser delimitadas por aspas simples `(' ')` ou duplas `(\" \")`.",
                        "codigo": 'nome = "João" # Uma string\nnome = \'João\' # Outra string'
                    },
                    {
                        "descricao": "**Booleanos:** São valores lógicos, que podem ser apenas **True** (verdadeiro) ou **False** (falso).",
                        "codigo": "esta_chovendo = True # Um valor booleano\nesta_ensolarado = False # Outro valor booleano"
                    },
                    {
                        "descricao": "**Verificar tipo:** Você pode usar a função `type()` para descobrir qual é o tipo de dado de uma variável.",
                        "codigo": "x = 10\nprint(type(x)) # Vai exibir: <class 'int'>\n\ny = 'Python'\nprint(type(y)) # Vai exibir: <class 'str'>"
                    },
                    {
                        "descricao": "**Conversão de tipos:** Você pode converter uma variável de um tipo para outro, usando funções de conversão, como `int()`, `float()`, `str()`, etc.",
                        "codigo": 'numero_str = "123"\nnumero_int = int("123")\n# Converte a string "123" para o número inteiro 123\nprint(type(numero_int)) # Vai exibir: <class \'int\'>'
                    }
                ],
                "observacoes": []
            }
        ]
    },
    {
        "topico": "Estruturas de Controle",
        "subtopicos": [
            {
                "titulo": "Condicionais",
                "texto": "As estruturas condicionais são usadas para controlar o fluxo de execução do programa, decidindo qual bloco de código será executado com base em condições específicas. As principais instruções condicionais são `if`, `elif` e `else`.",
                "blocos": [
                    {
                        "descricao": "**Sintaxe Básica:**",
                        "codigo": "if condição:\n    # Código a ser executado se a condição for verdadeira\nelif condição:\n    # Código a ser executado se a condição anterior for falsa, mas essa for verdadeira\nelse:\n    # Código a ser executado se todas as condições anteriores forem falsas"
                    },
                    {
                        "descricao": "**Exemplo:**",
                        "codigo": "idade = 18\n\nif idade < 18:\n    print('Menor de idade')\nelif idade == 18:\n    print('Você tem 18 anos!')\nelse:\n    print('Maior de idade')\n\n# Saída: Você tem 18 anos!"
                    }
                ],
                "observacoes": [
                    "**if:** Verifica se a primeira condição é verdadeira. Se for, o código dentro do bloco if é executado.",
                    "**elif:** Caso a condição anterior seja falsa, o Python verifica a condição do elif. Se for verdadeira, executa o código dentro desse bloco.",
                    "**else:** Caso todas as condições anteriores sejam falsas, o código dentro do bloco else será executado."
                ]
            },
            {
                "titulo": "Laços de Repetição",
                "texto": "Os laços de repetição (ou laços de controle) são usados para executar um bloco de código repetidamente enquanto uma condição for verdadeira. Os dois tipos principais de laços são: `for` e `while`.",
                "blocos": [
                    {
                        "descricao": "**Laço for** — O laço `for` é utilizado para iterar sobre uma sequência (como uma lista, tupla, dicionário, string, etc.) e executar um bloco de código para cada item da sequência.\n\n**Sintaxe Básica:**",
                        "codigo": "for item in sequência:\n    # Código a ser executado para cada item"
                    },
                    {
                        "descricao": "**Exemplo:**",
                        "codigo": 'frutas = ["maçã", "banana", "laranja"]\n\nfor fruta in frutas:\n    print(f"A fruta é: {fruta}")\n\n# Saída:\n# A fruta é: maçã\n# A fruta é: banana\n# A fruta é: laranja'
                    },
                    {
                        "descricao": "**Laço while** — O laço `while` executa um bloco de código enquanto uma condição for verdadeira. A condição é verificada antes de cada execução do laço.\n\n**Sintaxe Básica:**",
                        "codigo": "while condição:\n    # Código a ser executado enquanto a condição for verdadeira"
                    },
                    {
                        "descricao": "**Exemplo:**",
                        "codigo": "contador = 0\n\nwhile contador < 5:\n    print(f'Contador: {contador}')\n\n# Saída:\n# Contador: 0\n# Contador: 1\n# Contador: 2\n# Contador: 3\n# Contador: 4"
                    }
                ],
                "observacoes": [
                    "O **for** percorre cada item da lista e, para cada item, executa o código dentro do bloco do for.",
                    "O **while** verifica se a condição é verdadeira antes de cada execução do bloco. No caso acima, a condição é contador < 5, então o laço vai rodar até que o valor de contador seja 5 ou maior.",
                    "**for:** Geralmente usado quando sabemos o número de iterações ou quando queremos iterar sobre uma sequência.",
                    "**while:** Usado quando não sabemos o número exato de iterações e queremos continuar enquanto uma condição for verdadeira."
                ]
            }
        ]
    },
    {
        "topico": "Estruturas de Dados",
        "subtopicos": [
            {
                "titulo": "Listas",
                "texto": "As **listas** são coleções ordenadas e mutáveis que podem armazenar elementos de diferentes tipos. Elas permitem a adição, remoção e modificação de itens, tornando-as versáteis para manipulação de dados.",
                "blocos": [
                    {
                        "descricao": "**Criando uma Lista:** Para criar uma **lista**, você usa colchetes `[ ]` e separa os elementos por vírgulas.",
                        "codigo": 'lista = [10, 20, 30, "quarenta", True]'
                    },
                    {
                        "descricao": "**Adicionando um Elemento:** Use o método **append( )** para adicionar um elemento ao final da lista.",
                        "codigo": "lista = [1, 2, 3]\nlista.append(4)\n# Após append(4): [1, 2, 3, 4]"
                    },
                    {
                        "descricao": "**Removendo um Elemento:** Use o método **remove( )** para remover um elemento específico da lista.",
                        "codigo": "lista = [1, 2, 3, 4]\nlista.remove(4) # Passar o valor do elemento\n# Após remove(4): [1, 2, 3]"
                    },
                    {
                        "descricao": "**Ordenando uma Lista:** Use o método **sort( )** para organizar os elementos da lista em ordem crescente.",
                        "codigo": "lista = [3, 1, 4, 2]\nlista.sort()\n# Lista ordenada: [1, 2, 3, 4]"
                    },
                    {
                        "descricao": "**Acessando Elementos:** Acesse elementos da lista usando **índices**. O primeiro elemento é acessado pelo **índice 0** e o último pelo **índice -1**.",
                        "codigo": 'lista = ["a", "b", "c", "s"]\nlista[0] # Acessa o primeiro elemento (a)\nlista[-1] # Acessa o último elemento (s)'
                    },
                    {
                        "descricao": "**Alterando um Elemento:** Altere um elemento da lista atribuindo um novo valor ao índice correspondente.",
                        "codigo": 'lista = ["a", "b", "x"]\nlista[2] = "c" # Altera o elemento do índice 2 para "c"\n# Após alteração: ["a", "b", "c"]'
                    },
                    {
                        "descricao": "**Inserindo um Elemento em uma Posição Específica:** Use o método **insert( )** para adicionar um elemento em uma posição específica da lista.",
                        "codigo": 'lista = ["a", "b", "c"]\nlista.insert(1, "novo elemento")\n# Após insert: ["a", "novo elemento", "b", "c"]'
                    }
                ],
                "observacoes": []
            },
            {
                "titulo": "Tuplas",
                "texto": "As **tuplas** são coleções ordenadas e imutáveis que contêm elementos de diferentes tipos. Elas são úteis para agrupar dados que não devem ser alterados, proporcionando segurança contra modificações acidentais.",
                "blocos": [
                    {
                        "descricao": "**Criando uma Tupla:** Para criar uma **tupla**, você usa parênteses `( )` e separa os elementos por vírgulas.",
                        "codigo": 'tupla = (1, 2, 3, "quatro", 5.0)'
                    },
                    {
                        "descricao": "**Acessando Elementos:** Acesse elementos de tuplas usando **índices**. O primeiro elemento é acessado pelo **índice 0** e o último pelo **índice -1**.",
                        "codigo": 'tupla = (1, 2, 3, "quatro", 5.0)\ntupla[0] # Acessa o primeiro elemento (1)\ntupla[-1] # Acessa o último elemento (5.0)'
                    },
                    {
                        "descricao": "**Fatiamento (Slicing):** Você pode obter uma parte da **tupla** utilizando a sintaxe de **fatiamento**.",
                        "codigo": 'tupla = (1, 2, 3, "quatro", 5.0)\ntupla[1:3] # Retorna (2, 3, "quatro")'
                    },
                    {
                        "descricao": "**Contando Elementos:** O método **count( )** retorna quantas vezes um elemento específico aparece na **tupla.**",
                        "codigo": "tupla = (1, 1, 1, 2)\ntupla.count(1) # Retorna 3"
                    },
                    {
                        "descricao": "**Encontrando o Índice:** O método **index( )** retorna o índice da primeira ocorrência de um elemento na **tupla.**",
                        "codigo": 'tupla = (1, 2, "a", "b")\ntupla.index("a") # Retorna 2'
                    }
                ],
                "observacoes": []
            },
            {
                "titulo": "Dicionários",
                "texto": "Os **dicionários** são coleções não ordenadas de pares chave-valor, permitindo o armazenamento de dados de forma estruturada. Eles facilitam a busca e a recuperação de informações através de chaves únicas, tornando o acesso a dados mais eficiente.",
                "blocos": [
                    {
                        "descricao": "**Criando um Dicionário:** Para criar um **dicionário**, você usa chaves `{}`.",
                        "codigo": 'dicionario = {\n    "nome": "Maria",\n    "idade": 28,\n    "cidade": "São Paulo"\n}'
                    },
                    {
                        "descricao": "**Acessando Valores Usando Chaves:** Acesse valores do dicionário utilizando suas chaves.",
                        "codigo": 'dicionario = {\n    "nome": "Maria",\n    "idade": 28,\n    "cidade": "São Paulo"\n}\ndicionario["nome"] # Retorna Maria\ndicionario["idade"] # Retorna 28'
                    },
                    {
                        "descricao": "**Adicionando um Novo Par Chave-Valor:** Para incluir novos dados, você simplesmente atribui um valor a uma nova chave.",
                        "codigo": 'dicionario = {} # Dicionário vazio\ndicionario["nome"] = "João"\n# Agora: dicionario = {"nome": "João"}'
                    },
                    {
                        "descricao": "**Removendo um Par Chave-Valor:** Para **eliminar** um **par chave-valor**, você pode usar a instrução `del`.",
                        "codigo": 'dicionario = {"nome": "João"}\ndel dicionario["nome"]\n# Agora: dicionario = {}'
                    },
                    {
                        "descricao": "**Listando Todas as Chaves:** O método `keys()` retorna uma **lista** de todas as **chaves** no dicionário.",
                        "codigo": 'dicionario = {\n    "nome": "Maria",\n    "idade": 28,\n    "cidade": "São Paulo"\n}\ndicionario.keys() # Retorna todas as chaves do dicionário'
                    },
                    {
                        "descricao": "**Listando Todos os Valores:** O método **values( )** retorna todos os **valores** armazenados, permitindo que você visualize rapidamente o conteúdo do **dicionário.**",
                        "codigo": 'dicionario = {\n    "nome": "Maria",\n    "idade": 28,\n    "cidade": "São Paulo"\n}\ndicionario.values() # Retorna todos os valores do dicionário'
                    },
                    {
                        "descricao": "**Listando Todos os Pares (Chave, Valor):** O método **items( )** fornece uma **lista** de todos os **pares** (chave, valor).",
                        "codigo": 'dicionario = {\n    "nome": "Maria",\n    "idade": 28,\n    "cidade": "São Paulo"\n}\ndicionario.items() # Retorna todos os pares chave-valor do dicionário'
                    }
                ],
                "observacoes": []
            },
            {
                "titulo": "Sets",
                "texto": "Os **sets** (ou conjuntos) são coleções não ordenadas de **elementos únicos**, o que significa que não permitem duplicatas. Eles são usados para armazenar itens de forma que não haja repetições e são úteis para operações matemáticas, como união, interseção e diferença.",
                "blocos": [
                    {
                        "descricao": "**Criando um Set:** Você pode criar um **set** usando chaves `{}` ou a função **set( )**.",
                        "codigo": "um_set = {1, 2, 3, 4}\noutro_set = set([3, 4, 5, 6])"
                    },
                    {
                        "descricao": "**Adicionando Elementos:** Use o método **add( )** para incluir um novo elemento.",
                        "codigo": "set = {1, 2, 3, 4}\nset.add(5) # set agora é {1, 2, 3, 4, 5}"
                    },
                    {
                        "descricao": "**Removendo Elementos:** Use o método **remove( )** para eliminar um elemento específico. Se o elemento não existir, isso resultará em um erro. Você também pode usar **discard( )**, que não gera erro se o elemento não estiver presente.",
                        "codigo": "set = {1, 2, 3, 4}\nset.remove(2) # set agora é {1, 3, 4}\nset.discard(10) # Não gera erro, mesmo que 10 não esteja no set"
                    },
                    {
                        "descricao": "**Verificando a Existência de um Elemento:** Você pode verificar se um elemento está presente em um set utilizando a palavra-chave `in`.",
                        "codigo": "set = {1, 2, 3, 4}\nexiste = 3 in set # Retorna True"
                    },
                    {
                        "descricao": "**União:** Combina dois sets, retornando todos os elementos únicos.",
                        "codigo": "set1 = {1, 2, 3}\nset2 = {3, 4, 5}\nuniao = set1.union(set2) # Resultado: {1, 2, 3, 4, 5}"
                    },
                    {
                        "descricao": "**Interseção:** Retorna os elementos que estão presentes em ambos os sets.",
                        "codigo": "set1 = {1, 2}\nset2 = {2, 3}\nintersecao = set1.intersection(set2) # Resultado: {2}"
                    },
                    {
                        "descricao": "**Diferença:** Retorna os elementos que estão no primeiro set, mas não no segundo.",
                        "codigo": "set1 = {1, 2, 3}\nset2 = {3, 4, 5}\ndiferenca = set1.difference(set2) # Resultado: {1, 2}"
                    }
                ],
                "observacoes": [
                    "**Elementos Únicos:** Um set não pode conter elementos duplicados. Se você tentar adicionar um elemento que já existe no set, ele será ignorado.",
                    "**Não Ordenados:** Os elementos em um set não têm uma ordem específica, e não é possível acessar os itens por índice.",
                    "**Mutáveis:** Embora os sets sejam mutáveis (você pode adicionar ou remover elementos), os elementos em um set devem ser imutáveis (como números, strings ou tuplas)."
                ]
            }
        ]
    },
    {
        "topico": "Funções",
        "subtopicos": [
            {
                "titulo": "Funções",
                "texto": "As **funções** são blocos de código reutilizáveis que realizam uma tarefa específica. Elas ajudam a organizar e modularizar o código, permitindo que você execute uma operação várias vezes sem reescrever o código.",
                "blocos": [
                    {
                        "descricao": "**Como Definir:** Uma função é definida usando a palavra-chave `def`, seguida pelo nome da função e parênteses. Dentro dos parênteses, você pode especificar parâmetros.",
                        "codigo": "def nome_da_funcao():\n    # Código a ser executado"
                    },
                    {
                        "descricao": "**Chamando Função:** Para executar uma função, você a chama pelo nome seguido de parênteses. Se a função tiver parâmetros, você deve passar os valores correspondentes.",
                        "codigo": "def nome_da_funcao():\n    # Código a ser executado\n\nnome_da_funcao() # Chama a função"
                    },
                    {
                        "descricao": "**Parâmetros:** Funções podem receber valores externos através de **parâmetros**. Você define os parâmetros dentro dos parênteses na definição da função.",
                        "codigo": "def funcao_com_parametros(param1, param2):\n    # Código que utiliza param1 e param2"
                    },
                    {
                        "descricao": "**Valores de Retorno:** As funções podem retornar valores usando a palavra-chave **return**. O valor retornado pode ser armazenado em uma variável ou utilizado diretamente.",
                        "codigo": 'def funcao_retorno():\n    return "Resultado"\n\nresultado = funcao_retorno() # Armazena o valor retornado'
                    },
                    {
                        "descricao": "**Exemplo Completo** — Aqui está um exemplo completo que combina definição, parâmetros e retorno:",
                        "codigo": "def calcular_area(base, altura):\n    return (base * altura) / 2\n\narea = calcular_area(10, 5) # area agora é 25.0\nprint(f'A área do triângulo é: {area}')"
                    }
                ],
                "observacoes": []
            }
        ]
    },
    {
        "topico": "Módulos e Bibliotecas",
        "subtopicos": [
            {
                "titulo": "Importação de Módulos",
                "texto": "**Módulos** são arquivos que contêm código Python, permitindo a organização e reutilização de funções e classes. **Bibliotecas** são coleções de módulos que oferecem funcionalidades específicas, facilitando a implementação de recursos em projetos. Ambas ajudam a estruturar o código e a evitar duplicação.\n\nPara usar um **módulo**, você precisa **importá-lo**. Isso pode ser feito de várias maneiras:",
                "blocos": [
                    {
                        "descricao": "**Importando o Módulo Inteiro:**",
                        "codigo": "import nome_do_modulo"
                    },
                    {
                        "descricao": "**Importando Funções Específicas:**",
                        "codigo": "from nome_do_modulo import funcao_especifica"
                    },
                    {
                        "descricao": "**Importando com Apelido:** Você pode dar um nome alternativo ao módulo importado para facilitar o uso.",
                        "codigo": "import nome_do_modulo as apelido"
                    }
                ],
                "observacoes": []
            },
            {
                "titulo": "Biblioteca math",
                "texto": "A biblioteca **math** fornece funções matemáticas básicas e constantes.",
                "blocos": [
                    {
                        "descricao": "**sqrt(x):** Retorna a raiz quadrada de x.",
                        "codigo": "import math\nresultado = math.sqrt(16) # Resultado: 4.0"
                    },
                    {
                        "descricao": "**factorial(x):** Retorna o fatorial de x.",
                        "codigo": "import math\nfatorial = math.factorial(5) # Resultado: 120"
                    },
                    {
                        "descricao": "**pow(x, y):** Retorna x elevado à potência y.",
                        "codigo": "import math\npotencia = math.pow(2, 3) # Resultado: 8.0"
                    },
                    {
                        "descricao": "**pi:** A constante π.",
                        "codigo": "import math\npi = math.pi # Resultado: 3.141592653589793"
                    },
                    {
                        "descricao": "**sin(x), cos(x), tan(x):** Funções trigonométricas.",
                        "codigo": "import math\n\n# Exemplo de seno\nseno = math.sin(math.pi / 2) # Resultado: 1.0\n\n# Exemplo de cosseno\ncosseno = math.cos(math.pi) # Resultado: -1.0\n\n# Exemplo de tangente\ntangente = math.tan(math.pi / 4) # Resultado: 1.0"
                    }
                ],
                "observacoes": []
            },
            {
                "titulo": "Biblioteca random",
                "texto": "A biblioteca **random** é utilizada para gerar números aleatórios e realizar operações relacionadas à aleatoriedade.",
                "blocos": [
                    {
                        "descricao": "**randint(a, b):** Retorna um número inteiro aleatório entre a e b (inclusivo).",
                        "codigo": "import random\nnumero = random.randint(1, 10) # Exemplo: 7"
                    },
                    {
                        "descricao": "**uniform(a, b):** Retorna um número de ponto flutuante aleatório entre a e b.",
                        "codigo": "import random\nnumero = random.uniform(1.0, 10.0) # Exemplo: 5.678"
                    },
                    {
                        "descricao": "**random():** Retorna um número de ponto flutuante aleatório entre 0.0 e 1.0.",
                        "codigo": "import random\nnumero = random.random() # Resultado: 0.374"
                    },
                    {
                        "descricao": "**choice(seq):** Retorna um elemento aleatório da sequência (lista, tupla e string).",
                        "codigo": "import random\nfrutas = ['maçã', 'banana', 'laranja']\nfruta = random.choice(frutas) # Exemplo: 'banana'"
                    },
                    {
                        "descricao": "**shuffle(x):** Embaralha a lista x in-place.",
                        "codigo": "import random\ncartas = [1, 2, 3, 4, 5]\nrandom.shuffle(cartas) # Exemplo: [3, 1, 5, 2, 4]"
                    },
                    {
                        "descricao": "**randrange(início, fim, [passo]):** Retorna um número inteiro aleatório dentro de um intervalo especificado, com um passo opcional.",
                        "codigo": "import random\nnumero = random.randrange(0, 100, 5) # Exemplo: 20"
                    }
                ],
                "observacoes": []
            }
        ]
    },
    {
        "topico": "Manipulação de Arquivos",
        "subtopicos": [
            {
                "titulo": "Abertura",
                "texto": "A função `open()` é utilizada para abrir um arquivo. Você deve especificar o nome do arquivo e o modo de abertura.",
                "blocos": [
                    {
                        "descricao": "**Exemplo:**",
                        "codigo": "with open('exemplo.txt') as arquivo:\n    # Arquivo aberto com sucesso."
                    }
                ],
                "observacoes": [
                    "`r` — Leitura (padrão). O arquivo deve existir.",
                    "`w` — Escrita. Cria um novo arquivo ou sobrescreve um existente.",
                    "`a` — Anexar. Adiciona ao final do arquivo existente.",
                    "A palavra `as` permite dar um nome ao arquivo que você abriu. Assim, você pode usar esse nome para ler ou escrever no arquivo."
                ]
            },
            {
                "titulo": "Leitura",
                "texto": "Após abrir um arquivo, você pode ler seu conteúdo usando o método **read( )**.",
                "blocos": [
                    {
                        "descricao": "**Exemplo:**",
                        "codigo": "with open('exemplo.txt', 'r') as arquivo:\n    conteudo = arquivo.read()\n    # Conteúdo lido com sucesso."
                    }
                ],
                "observacoes": []
            },
            {
                "titulo": "Escrita",
                "texto": "Para escrever em um arquivo, você deve abri-lo no modo de escrita (`'w'`) e usar o método **write( )**.",
                "blocos": [
                    {
                        "descricao": "**Exemplo:**",
                        "codigo": "with open('exemplo.txt', 'w') as arquivo:\n    arquivo.write('Primeira linha.\\n')\n    # Escrita concluída."
                    }
                ],
                "observacoes": []
            },
            {
                "titulo": "Anexação",
                "texto": "O modo de anexação (`'a'`) permite adicionar conteúdo ao final de um arquivo existente.",
                "blocos": [
                    {
                        "descricao": "**Exemplo:**",
                        "codigo": "with open('exemplo.txt', 'a') as arquivo:\n    arquivo.write('Adicionando uma nova linha.\\n')\n    # Nova linha adicionada."
                    }
                ],
                "observacoes": []
            }
        ]
    },
    {
        "topico": "Tratamento de Erros",
        "subtopicos": [
            {
                "titulo": "Exceções",
                "texto": "Exceções são problemas que ocorrem durante a execução do programa e podem interromper seu funcionamento. Para lidar com elas, utilizamos os blocos **try** e **except**.",
                "blocos": [
                    {
                        "descricao": "**Estrutura básica:**",
                        "codigo": "try:\n    # Código que pode gerar uma exceção\nexcept NomeDaExcecao:\n    # Código para tratar a exceção"
                    },
                    {
                        "descricao": "**Exemplo:**",
                        "codigo": "try:\n    resultado = 10 / 0\nexcept ZeroDivisionError:\n    print('Erro: Não é possível dividir por zero.')"
                    }
                ],
                "observacoes": [
                    "**Divisão por zero (ZeroDivisionError):** Ocorre quando você tenta dividir um número por zero.",
                    "**Acesso a índices inválidos (IndexError):** Acontece quando você tenta acessar um índice que não existe na lista.",
                    "**Erro de conversão (ValueError):** Ocorre quando uma operação ou função recebe um argumento que tem o tipo certo, mas um valor inadequado.",
                    "**Arquivo não encontrado (FileNotFoundError):** Acontece quando você tenta abrir um arquivo que não existe."
                ]
            }
        ]
    },
    {
        "topico": "POO",
        "subtopicos": [
            {
                "titulo": "Programação Orientada a Objetos",
                "texto": "A Programação Orientada a Objetos (POO) é um paradigma de programação que organiza o software como uma coleção de objetos que interagem entre si. Esses objetos são instâncias de classes, que definem a estrutura e o comportamento dos dados.",
                "blocos": [
                    {
                        "descricao": "**Classe:** Uma classe é um modelo para criar objetos. Ela define um conjunto de atributos e métodos que os objetos criados a partir da classe terão.",
                        "codigo": "class Carro:\n    pass # Classe vazia"
                    },
                    {
                        "descricao": "**Objeto:** Um objeto é uma instância de uma classe. Ele contém dados e pode executar funções definidas na classe.",
                        "codigo": "meu_carro = Carro() # Criando um objeto da classe Carro"
                    },
                    {
                        "descricao": "**Atributos:** São variáveis que pertencem a uma classe ou objeto.",
                        "codigo": "class Carro:\n    def __init__(self, marca):\n        self.marca = marca # Atributo marca"
                    },
                    {
                        "descricao": "**Métodos:** São funções definidas dentro de uma classe que podem manipular os atributos da classe.",
                        "codigo": "class Carro:\n    def __init__(self, marca):\n        self.marca = marca\n\n    def mostrar_marca(self): # Método\n        print(self.marca)"
                    },
                    {
                        "descricao": "**Herança:** É a capacidade de uma classe herdar atributos e métodos de outra classe.",
                        "codigo": "class Carro:\n    def __init__(self, marca):\n        self.marca = marca\n\nclass CarroEsportivo(Carro): # Herança\n    pass"
                    },
                    {
                        "descricao": "**Encapsulamento:** É o conceito de esconder os detalhes internos de uma classe e expor apenas o que é necessário.",
                        "codigo": "class Carro:\n    def __init__(self, marca):\n        self.marca = marca\n        self.__velocidade = 0 # Atributo privado\n\n    def acelerar(self):\n        self.__velocidade += 10\n\n    def obter_velocidade(self): # Método público\n        return self.__velocidade"
                    },
                    {
                        "descricao": "**Polimorfismo:** Permite que diferentes classes implementem métodos que podem ser chamados da mesma forma.",
                        "codigo": "class Carro:\n    def __init__(self, marca):\n        self.marca = marca\n\n    def acelerar(self):\n        print('Carro acelerando.')\n\nclass CarroEsportivo(Carro):\n    def acelerar(self): # Sobrescrevendo o método\n        print('Carro esportivo acelerando!')\n\n    def teste_acelerar(carro):\n        carro.acelerar() # Chama o método"
                    }
                ],
                "observacoes": [
                    "**`__init__`:** É o método construtor de uma classe em Python, chamado automaticamente ao criar um novo objeto. Ele inicializa os atributos do objeto.",
                    "**`self`:** É uma referência ao próprio objeto. Usado dentro de métodos para acessar atributos e outros métodos da mesma instância da classe."
                ]
            }
        ]
    }
]