Lists.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7aa4f6df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Listas\n",
    "\n",
    "    Introdução às Listas\n",
    "        Definição e utilidade das listas em Python.\n",
    "        Diferença entre listas e outros tipos de dados.\n",
    "\n",
    "    Criando e Acessando Listas\n",
    "        Como criar uma lista: minha_lista = [1, 2, 3]\n",
    "        Acessando elementos pelo índice.\n",
    "        Índices negativos para acessar elementos do final da lista.\n",
    "\n",
    "    Operações Básicas com Listas\n",
    "        Adicionar elementos: append(), insert()\n",
    "        Remover elementos: remove(), pop()\n",
    "        Concatenar listas: +, extend()\n",
    "        Repetir listas: *\n",
    "        Verificar se um item está na lista: in\n",
    "\n",
    "    Métodos de Listas\n",
    "        sort(): ordena a lista in-place.\n",
    "        reverse(): inverte a ordem dos elementos in-place.\n",
    "        count(): conta o número de ocorrências de um elemento.\n",
    "        index(): retorna o índice da primeira ocorrência de um elemento.\n",
    "\n",
    "    Slicing de Listas\n",
    "        Como acessar subconjuntos de listas: minha_lista[1:3]\n",
    "        Omissão de índices iniciais ou finais: minha_lista[:2], minha_lista[2:]\n",
    "        Slicing com passos: minha_lista[::2]\n",
    "\n",
    "    List Comprehensions\n",
    "        Uma maneira concisa de criar listas: [x**2 for x in range(10) if x % 2 == 0]\n",
    "\n",
    "    Listas Aninhadas (listas de listas)\n",
    "        Criando e acessando listas dentro de listas.\n",
    "        Utilizando loops aninhados para iterar sobre elas.\n",
    "\n",
    "    Copiando Listas\n",
    "        Cópia rasa (shallow copy): copy(), slicing.\n",
    "        Cópia profunda (deep copy): usando o módulo copy.\n",
    "\n",
    "    Utilidades e Funções com Listas\n",
    "        len(): retorna o número de elementos na lista.\n",
    "        max(): retorna o maior valor.\n",
    "        min(): retorna o menor valor.\n",
    "        sum(): retorna a soma dos elementos.\n",
    "\n",
    "    Iteração em Listas\n",
    "        Usando o loop for.\n",
    "        Usando enumerate() para obter índice e valor ao iterar.\n",
    "\n",
    "    Listas e Strings\n",
    "        Conversão de strings para listas: list(), split().\n",
    "        Conversão de listas para strings: join().\n",
    "\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45a401eb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "06b19297",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[85, 90, 78, 92, 88]\n",
      "<class 'int'>\n",
      "<class 'list'>\n",
      "<class 'str'>\n",
      "['Olá', 'Mundo']\n",
      "<class 'list'>\n",
      "\n",
      "[100, 50, 3]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Introdução às Listas: Definição e utilidade\n",
    "\n",
    "Listas são uma das estruturas de dados mais fundamentais em Python. Elas são \n",
    "coleções ordenadas de itens (que podem ser de qualquer tipo) e são muito versáteis.\n",
    "\n",
    "Vamos supor que você quer armazenar as notas de um aluno em diferentes \n",
    "matérias. Uma lista é perfeita para isso!\n",
    "\"\"\"\n",
    "\n",
    "# Definindo uma lista de notas de um aluno\n",
    "notas_aluno = [85, 90, 78, 92, 88]\n",
    "print(notas_aluno)\n",
    "\n",
    "\"\"\"\n",
    "A utilidade das listas em Python é vasta, elas podem ser usadas para armazenar \n",
    "conjuntos de dados relacionados, manipular esses dados e percorrê-los.\n",
    "\n",
    "Diferença entre listas e outros tipos de dados\n",
    "\n",
    "Para entender as diferenças, vamos comparar listas com alguns outros tipos de \n",
    "dados em Python:\n",
    "\"\"\"\n",
    "\n",
    "#1. Listas vs. Inteiros/Floats: Inteiros e floats representam números, enquanto \n",
    "#listas podem armazenar múltiplos itens, que podem ser números ou outros tipos de dados.\n",
    "\n",
    "\n",
    "numero = 5\n",
    "print(type(numero))  # <class 'int'>\n",
    "\n",
    "lista_de_numeros = [5, 10, 15]\n",
    "print(type(lista_de_numeros))  # <class 'list'>\n",
    "\n",
    "#Listas vs. Strings: Strings são sequências de caracteres. Listas, por outro \n",
    "#lado, podem armazenar caracteres, números, e até outras listas!\n",
    "\n",
    "mensagem = \"Olá\"\n",
    "print(type(mensagem))  # <class 'str'>\n",
    "\n",
    "lista_de_strings = [\"Olá\", \"Mundo\"]\n",
    "print(lista_de_strings)  # <class 'list'>\n",
    "print(type(lista_de_strings))  # <class 'list'>\n",
    "\n",
    "\n",
    "#Listas vs. Tuplas: Ambas podem armazenar múltiplos itens, mas as listas \n",
    "#são mutáveis (você pode alterar seu conteúdo), enquanto as tuplas são imutáveis.\n",
    "lista = [1, 2, 3]\n",
    "lista[0] = 100  # Isso é válido\n",
    "lista[1] = 50  # Isso é válido\n",
    "\n",
    "print()\n",
    "print(lista)\n",
    "\n",
    "tupla = (1, 2, 3)\n",
    "#tupla[0] = 100  # Isso geraria um erro, porque tuplas são imutáveis!\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Este é apenas um breve exemplo que destaca a definição, utilidade e \n",
    "diferenças das listas em relação a outros tipos de dados em Python. A profundidade e \n",
    "amplitude do tópico podem variar de acordo com o contexto e o público-alvo.\n",
    "\"\"\"\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "840cf75a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "55f9e05f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40, 50]\n",
      "['maçã', 'banana', 'cereja']\n",
      "[10, 'Olá', 2.5, ['a', 'b'], True]\n",
      "maçã\n",
      "cereja\n",
      "damasco\n",
      "cereja\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Criando e Acessando Listas\n",
    "        Como criar uma lista: minha_lista = [1, 2, 3]\n",
    "        Acessando elementos pelo índice.\n",
    "        Índices negativos para acessar elementos do final da lista.\n",
    "\"\"\"\n",
    "\n",
    "#Criar uma lista é tão simples quanto colocar diferentes \n",
    "#valores separados por vírgulas entre colchetes [].\n",
    "\n",
    "\n",
    "# Criando uma lista de números\n",
    "numeros = [10, 20, 30, 40, 50]\n",
    "print(numeros)  # Saída: [10, 20, 30, 40, 50]\n",
    "\n",
    "# Criando uma lista de strings\n",
    "frutas = [\"maçã\", \"banana\", \"cereja\"]\n",
    "print(frutas)  # Saída: ['maçã', 'banana', 'cereja']\n",
    "\n",
    "# Criando uma lista mista\n",
    "mista = [10, \"Olá\", 2.5, [\"a\", \"b\"], True]\n",
    "print(mista)  # Saída: [10, 'Olá', 2.5, ['a', 'b'], True]\n",
    "\n",
    "\n",
    "#Acessando elementos pelo índice\n",
    "\n",
    "#O índice de uma lista em Python começa em 0. Portanto, para acessar o \n",
    "#primeiro item de uma lista, você usaria índice 0, para o segundo item você \n",
    "#usaria índice 1, e assim por diante.\n",
    "\n",
    "frutas = [\"maçã\", \"banana\", \"cereja\", \"damasco\"]\n",
    "\n",
    "# Acessando o primeiro elemento (índice 0)\n",
    "print(frutas[0])  # Saída: maçã\n",
    "\n",
    "# Acessando o terceiro elemento (índice 2)\n",
    "print(frutas[2])  # Saída: cereja\n",
    "\n",
    "\n",
    "#Índices negativos para acessar elementos do final da lista\n",
    "\n",
    "#Índices negativos em Python são uma forma elegante de acessar elementos \n",
    "#a partir do final da lista. Por exemplo, um índice de -1 refere-se ao último \n",
    "#item, -2 ao penúltimo e assim por diante.\n",
    "\n",
    "frutas = [\"maçã\", \"banana\", \"cereja\", \"damasco\"]\n",
    "\n",
    "# Acessando o último elemento\n",
    "print(frutas[-1])  # Saída: damasco\n",
    "\n",
    "# Acessando o penúltimo elemento\n",
    "print(frutas[-2])  # Saída: cereja\n",
    "\n",
    "\"\"\"\n",
    "Esses são os conceitos básicos sobre como criar e acessar listas \n",
    "em Python. Com essa base, você pode explorar ainda mais as operações e \n",
    "métodos disponíveis para listas.\n",
    "\"\"\"\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a25c5fe7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "9ffe8fef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maçã\n",
      "cereja\n",
      "figo\n",
      "damasco\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Criando e Acessando Listas\n",
    "\n",
    "Objetivo: Familiarizar-se com a criação de listas e o acesso a seus \n",
    "elementos usando índices positivos e negativos.\n",
    "\n",
    "Passo 1: Crie uma lista chamada frutas contendo os seguintes \n",
    "itens: \"maçã\", \"banana\", \"cereja\", \"damasco\" e \"figo\".\n",
    "\n",
    "Passo 2: Imprima a primeira fruta da lista.\n",
    "\n",
    "Passo 3: Imprima a terceira fruta da lista.\n",
    "\n",
    "Passo 4: Imprima a última fruta da lista usando um índice negativo.\n",
    "\n",
    "Passo 5: Tente acessar um índice que não existe na \n",
    "lista (por exemplo, índice 10) e observe o erro gerado.\n",
    "\n",
    "Passo 6: Usando índices negativos, imprima a segunda última fruta da lista.\n",
    "\"\"\"\n",
    "\n",
    "#Solução\n",
    "\n",
    "#Passo 1: Crie uma lista chamada frutas contendo os seguintes \n",
    "#itens: \"maçã\", \"banana\", \"cereja\", \"damasco\" e \"figo\".\n",
    "frutas = [\"maçã\", \"banana\", \"cereja\", \"damasco\", \"figo\"]\n",
    "\n",
    "#Passo 2: Imprima a primeira fruta da lista.\n",
    "print(frutas[0])\n",
    "\n",
    "#Passo 3: Imprima a terceira fruta da lista.\n",
    "print(frutas[2])\n",
    "\n",
    "#Passo 4: Imprima a última fruta da lista usando um índice negativo.\n",
    "print(frutas[-1])\n",
    "\n",
    "#Passo 5: Tente acessar um índice que não existe na \n",
    "#lista (por exemplo, índice 10) e observe o erro gerado.\n",
    "#print(frutas[10])\n",
    "\n",
    "#Passo 6: Usando índices negativos, imprima a segunda última fruta da lista.\n",
    "print(frutas[-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d12deab3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "f75aa429",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['maçã', 'banana', 'cereja']\n",
      "['maçã', 'abacate', 'banana', 'cereja']\n",
      "['maçã', 'cereja']\n",
      "['maçã', 'cereja']\n",
      "['maçã']\n",
      "[1, 2, 3, 4, 5, 6]\n",
      "[1, 2, 3, 4, 5, 6]\n",
      "['a', 'b', 'a', 'b', 'a', 'b']\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Operações Básicas com Listas\n",
    "        Adicionar elementos: append(), insert()\n",
    "        Remover elementos: remove(), pop()\n",
    "        Concatenar listas: +, extend()\n",
    "        Repetir listas: *\n",
    "        Verificar se um item está na lista: in\n",
    "\"\"\"\n",
    "\n",
    "#1. Adicionar elementos\n",
    "\n",
    "#a. append() - Adiciona um item ao final da lista:\n",
    "frutas = [\"maçã\", \"banana\"]\n",
    "frutas.append(\"cereja\")\n",
    "print(frutas)  # Saída: ['maçã', 'banana', 'cereja']\n",
    "\n",
    "#b. insert() - Insere um item em uma posição específica:\n",
    "frutas = [\"maçã\", \"banana\", \"cereja\"]\n",
    "frutas.insert(1, \"abacate\")  # Insere \"abacate\" na posição de índice 1\n",
    "print(frutas)  # Saída: ['maçã', 'abacate', 'banana', 'cereja']\n",
    "\n",
    "\n",
    "#2. Remover elementos\n",
    "\n",
    "#a. remove() - Remove o primeiro item da lista que tem o valor especificado:\n",
    "frutas = [\"maçã\", \"banana\", \"cereja\"]\n",
    "frutas.remove(\"banana\")\n",
    "print(frutas)  # Saída: ['maçã', 'cereja']\n",
    "\n",
    "#b. pop() - Remove o item da posição especificada (ou o último \n",
    "#item, se o índice não for especificado):\n",
    "frutas = [\"maçã\", \"banana\", \"cereja\"]\n",
    "frutas.pop(1)  # Remove o item de índice 1\n",
    "print(frutas)  # Saída: ['maçã', 'cereja']\n",
    "\n",
    "frutas.pop()  # Remove o último item\n",
    "print(frutas)  # Saída: ['maçã']\n",
    "\n",
    "#3. Concatenar listas\n",
    "\n",
    "#a. + - Une duas listas:\n",
    "lista1 = [1, 2, 3]\n",
    "lista2 = [4, 5, 6]\n",
    "uniao = lista1 + lista2\n",
    "print(uniao)  # Saída: [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "#b. extend() - Adiciona os elementos de uma \n",
    "#lista (ou qualquer iterável) ao final da lista atual:\n",
    "lista1 = [1, 2, 3]\n",
    "lista2 = [4, 5, 6]\n",
    "lista1.extend(lista2)\n",
    "print(lista1)  # Saída: [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "#4. Repetir listas\n",
    "\n",
    "#* - Repete a lista um número específico de vezes:\n",
    "repeticao = [\"a\", \"b\"] * 3\n",
    "print(repeticao)  # Saída: ['a', 'b', 'a', 'b', 'a', 'b']\n",
    "\n",
    "#5.  Verificar se um item está na lista\n",
    "\n",
    "#in - Retorna True se um elemento está presente na lista, \n",
    "#caso contrário retorna False:\n",
    "frutas = [\"maçã\", \"banana\", \"cereja\"]\n",
    "print(\"banana\" in frutas)  # Saída: True\n",
    "print(\"uva\" in frutas)     # Saída: False\n",
    "\n",
    "\"\"\"\n",
    "Estes são exemplos práticos de operações básicas que você pode \n",
    "realizar com listas em Python. Ao dominar essas operações, você estará bem \n",
    "equipado para manipular e trabalhar com listas de forma eficaz.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48c2fc52",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "49c45f03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "['gato', 'cachorro', 'pássaro']\n",
      "['gato', 'peixe', 'cachorro', 'pássaro']\n",
      "['peixe', 'cachorro', 'pássaro']\n",
      "['peixe', 'cachorro']\n",
      "pássaro\n",
      "['tartaruga', 'hamster']\n",
      "['peixe', 'cachorro', 'tartaruga', 'hamster']\n",
      "['peixe', 'cachorro', 'tartaruga', 'hamster', 'peixe', 'cachorro', 'tartaruga', 'hamster']\n",
      "Cachorro está na lista!\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Operações Básicas com Listas\n",
    "\n",
    "Objetivo: Familiarizar-se com operações fundamentais em listas, como \n",
    "adicionar, remover elementos, concatenar listas, repetir e verificar a presença de um item.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Comece com uma lista vazia chamada animais.\n",
    "\n",
    "    2. Adicione os seguintes animais à lista usando o método \n",
    "    append(): \"gato\", \"cachorro\" e \"pássaro\".\n",
    "\n",
    "    3. Insira \"peixe\" na segunda posição da lista usando \n",
    "    o método insert().\n",
    "\n",
    "    4. Remova \"gato\" da lista usando o método remove().\n",
    "\n",
    "    5. Remova o último animal da lista usando o método pop() e armazene-o \n",
    "    em uma variável chamada animal_removido.\n",
    "\n",
    "    6. Crie uma segunda lista chamada novos_animais com os \n",
    "    valores \"tartaruga\" e \"hamster\".\n",
    "\n",
    "    7. Concatene as duas listas (animais e novos_animais) usando o \n",
    "    operador + e armazene o resultado na lista todos_animais.\n",
    "\n",
    "    8. Duplique os elementos da lista todos_animais usando o \n",
    "    operador * e armazene o resultado em animais_duplicados.\n",
    "\n",
    "    9. Verifique se \"cachorro\" está na lista todos_animais usando o \n",
    "    operador in e imprima o resultado.\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "#1. Comece com uma lista vazia chamada animais.\n",
    "animais = []\n",
    "print(animais)\n",
    "\n",
    "#2. Adicione os seguintes animais à lista usando o método \n",
    "#append(): \"gato\", \"cachorro\" e \"pássaro\".\n",
    "animais.append(\"gato\")\n",
    "animais.append(\"cachorro\")\n",
    "animais.append(\"pássaro\")\n",
    "print(animais)\n",
    "\n",
    "#3. Insira \"peixe\" na segunda posição da lista usando \n",
    "#o método insert().\n",
    "animais.insert(1, \"peixe\")\n",
    "print(animais)\n",
    "\n",
    "#4. Remova \"gato\" da lista usando o método remove().\n",
    "animais.remove(\"gato\")\n",
    "print(animais)\n",
    "\n",
    "#5. Remova o último animal da lista usando o método pop() e armazene-o \n",
    "#em uma variável chamada animal_removido.\n",
    "animal_removido = animais.pop() # Remove o último item\n",
    "print(animais)\n",
    "print(animal_removido)\n",
    "\n",
    "#6. Crie uma segunda lista chamada novos_animais com os \n",
    "#valores \"tartaruga\" e \"hamster\".\n",
    "novos_animais = [\"tartaruga\", \"hamster\"]\n",
    "print(novos_animais)\n",
    "\n",
    "#7. Concatene as duas listas (animais e novos_animais) usando o \n",
    "#operador + e armazene o resultado na lista todos_animais.\n",
    "todos_animais = animais + novos_animais\n",
    "print(todos_animais)\n",
    "\n",
    "#8. Duplique os elementos da lista todos_animais usando o \n",
    "#operador * e armazene o resultado em animais_duplicados.\n",
    "animais_duplicados = todos_animais * 2\n",
    "print(animais_duplicados)\n",
    "\n",
    "#9. Verifique se \"cachorro\" está na lista todos_animais usando o \n",
    "#operador in e imprima o resultado.\n",
    "\n",
    "if \"cachorro\" in todos_animais:\n",
    "    \n",
    "    print(\"Cachorro está na lista!\")\n",
    "    \n",
    "else:\n",
    "    \n",
    "    print(\"Cachorro não está na lista!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "806f232e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "72297565",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 1, 45, 6, 12]\n",
      "[1, 6, 12, 23, 45]\n",
      "\n",
      "['banana', 'maçã', 'banana', 'cereja', 'maçã', 'damasco']\n",
      "['banana', 'banana', 'cereja', 'damasco', 'maçã', 'maçã']\n",
      "\n",
      "[45, 23, 12, 6, 1]\n",
      "\n",
      "-------------\n",
      "\n",
      "[1, 6, 12, 23, 45]\n",
      "['maçã', 'maçã', 'damasco', 'cereja', 'banana', 'banana']\n",
      "2\n",
      "1\n",
      "4\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Métodos de Listas\n",
    "        sort(): ordena a lista in-place.\n",
    "        reverse(): inverte a ordem dos elementos in-place.\n",
    "        count(): conta o número de ocorrências de um elemento.\n",
    "        index(): retorna o índice da primeira ocorrência de um elemento.\n",
    "\"\"\"\n",
    "\n",
    "#Métodos de Listas\n",
    "\n",
    "#Suponhamos que temos uma lista de números e uma lista de frutas:\n",
    "numeros = [23, 1, 45, 6, 12]\n",
    "frutas = [\"banana\", \"maçã\", \"banana\", \"cereja\", \"maçã\", \"damasco\"]\n",
    "\n",
    "#1. sort(): ordena a lista in-place\n",
    "\n",
    "#O método sort() ordena os itens da lista em uma ordem crescente por \n",
    "#padrão. Para números, isso é uma ordem numérica e para strings, é uma ordem alfabética.\n",
    "print(numeros)\n",
    "numeros.sort()\n",
    "print(numeros)  # Saída: [1, 6, 12, 23, 45]\n",
    "\n",
    "print()\n",
    "\n",
    "print(frutas)\n",
    "frutas.sort()\n",
    "print(frutas)  # Saída: ['banana', 'banana', 'cereja', 'damasco', 'maçã', 'maçã']\n",
    "\n",
    "print()\n",
    "\n",
    "#Para ordenar em ordem decrescente, podemos usar o argumento reverse=True:\n",
    "numeros.sort(reverse=True)\n",
    "print(numeros)  # Saída: [45, 23, 12, 6, 1]\n",
    "\n",
    "#2. reverse(): inverte a ordem dos elementos in-place.\n",
    "\n",
    "print(\"\\n-------------\\n\")\n",
    "\n",
    "#O método reverse() simplesmente inverte a ordem dos elementos da lista.\n",
    "numeros.reverse()\n",
    "print(numeros)  # Saída: [1, 6, 12, 23, 45] (supondo que estivesse em ordem decrescente antes de chamarmos reverse())\n",
    "\n",
    "frutas.reverse()\n",
    "print(frutas)  # Saída: ['maçã', 'maçã', 'damasco', 'cereja', 'banana', 'banana']\n",
    "\n",
    "#3. count(): conta o número de ocorrências de um elemento.\n",
    "\n",
    "#O método count() retorna o número de vezes que um elemento aparece na lista.\n",
    "ocorrencias_banana = frutas.count(\"banana\")\n",
    "print(ocorrencias_banana) # Saída 2\n",
    "\n",
    "ocorrencias_numero_6 = numeros.count(6)\n",
    "print(ocorrencias_numero_6) #Saída 1\n",
    "\n",
    "#4. index(): retorna o índice da primeira ocorrência de um elemento.\n",
    "\n",
    "#O método index() retorna o índice da primeira ocorrência do elemento \n",
    "#especificado. Se o elemento não estiver presente, ele gerará um erro.\n",
    "indice_banana = frutas.index(\"banana\")\n",
    "print(indice_banana)  # Saída: 4 (pois nós invertemos a lista anteriormente com reverse())\n",
    "\n",
    "indice_23 = numeros.index(23)\n",
    "print(indice_23) #Saída: 3\n",
    "\n",
    "\"\"\"\n",
    "Esses são os métodos fundamentais das listas em Python e seus usos \n",
    "práticos. Ao trabalhar com listas, é útil estar familiarizado(a) com esses \n",
    "métodos, pois eles são frequentemente empregados para manipulação e análise de dados.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4aed0de8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "88cf4002",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista normal: [23, 11, 89, 34, 11, 56, 78, 90, 23, 45]\n",
      "Lista ordenada: [11, 11, 23, 23, 34, 45, 56, 78, 89, 90]\n",
      "Lista invertida: [90, 89, 78, 56, 45, 34, 23, 23, 11, 11]\n",
      "O número 11 aparece 2 vezes na lista.\n",
      "O número 78 aparece pela primeira vez no indice 2.\n",
      "O número 100 não está na lista.\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Métodos de Listas\n",
    "\n",
    "Objetivo: Aprofundar a compreensão sobre os métodos específicos das listas em Python.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Crie uma lista chamada números contendo os \n",
    "    valores: 23, 11, 89, 34, 11, 56, 78, 90, 23, 45.\n",
    "\n",
    "    2. Ordene a lista em ordem crescente usando o \n",
    "    método sort() e imprima o resultado.\n",
    "\n",
    "    3. Use o método reverse() para inverter a ordem dos elementos \n",
    "    da lista e imprima o resultado.\n",
    "\n",
    "    4. Conte quantas vezes o número 11 aparece na lista usando o \n",
    "    método count() e imprima o resultado.\n",
    "\n",
    "    5. Encontre o índice da primeira ocorrência do número 78 usando o \n",
    "    método index() e imprima o resultado.\n",
    "\n",
    "    6. Tente encontrar o índice de um número que não está na \n",
    "    lista (por exemplo, 100) e capture a exceção usando um \n",
    "    bloco try-except para exibir uma mensagem amigável.\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "#1. Crie uma lista chamada números contendo os \n",
    "#valores: 23, 11, 89, 34, 11, 56, 78, 90, 23, 45.\n",
    "numeros = [23, 11, 89, 34, 11, 56, 78, 90, 23, 45]\n",
    "\n",
    "print(f\"Lista normal: {numeros}\")\n",
    "\n",
    "#2. Ordene a lista em ordem crescente usando o \n",
    "#método sort() e imprima o resultado.\n",
    "numeros.sort()\n",
    "\n",
    "print(f\"Lista ordenada: {numeros}\")\n",
    "\n",
    "#3. Use o método reverse() para inverter a ordem dos elementos \n",
    "#da lista e imprima o resultado.\n",
    "numeros.reverse()\n",
    "\n",
    "print(f\"Lista invertida: {numeros}\")\n",
    "\n",
    "#4. Conte quantas vezes o número 11 aparece na lista usando o \n",
    "#método count() e imprima o resultado.\n",
    "contagem = numeros.count(11)\n",
    "\n",
    "print(f\"O número 11 aparece {contagem} vezes na lista.\")\n",
    "\n",
    "#5. Encontre o índice da primeira ocorrência do número 78 usando o \n",
    "#método index() e imprima o resultado.\n",
    "indice = numeros.index(78)\n",
    "\n",
    "print(f\"O número 78 aparece pela primeira vez no indice {indice}.\")\n",
    "\n",
    "#6. Tente encontrar o índice de um número que não está na \n",
    "#lista (por exemplo, 100) e capture a exceção usando um \n",
    "#bloco try-except para exibir uma mensagem amigável.\n",
    "\n",
    "try:\n",
    "    \n",
    "    indice_nao_existente = numeros.index(100)\n",
    "    \n",
    "    print(indice_nao_existente)\n",
    "    \n",
    "except ValueError:\n",
    "    \n",
    "    print(\"O número 100 não está na lista.\")\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b03ed99",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f1faaa25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[0, 1]\n",
      "[2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 2, 4, 6, 8]\n",
      "[2, 4, 6]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Slicing de Listas\n",
    "        Como acessar subconjuntos de listas: minha_lista[1:3]\n",
    "        Omissão de índices iniciais ou finais: minha_lista[:2], minha_lista[2:]\n",
    "        Slicing com passos: minha_lista[::2]\n",
    "        \n",
    "O \"slicing\" (fatiamento) é uma maneira poderosa de acessar subconjuntos de \n",
    "listas. \n",
    "\n",
    "Vamos explorar isso com exemplos práticos.\"\"\"\n",
    "\n",
    "#Considere a seguinte lista para nossos exemplos:\n",
    "minha_lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "\n",
    "#licing de Listas\n",
    "#1. Como acessar subconjuntos de listas\n",
    "\n",
    "#Para obter um subconjunto de elementos da lista, especificamos os \n",
    "#índices de início e fim separados por dois pontos :. Lembre-se de que o índice \n",
    "#de início é inclusivo, enquanto o índice de término é exclusivo.\n",
    "\n",
    "subconjunto = minha_lista[1:4]\n",
    "print(subconjunto)  # Saída: [1, 2, 3]\n",
    "\n",
    "#2. Omissão de índices iniciais ou finais\n",
    "\n",
    "#Se omitirmos o índice inicial, o Python começará o fatiamento desde o início \n",
    "#da lista. Se omitirmos o índice final, ele continuará até o final da lista.\n",
    "# Pega todos os elementos até o índice 2 (exclusivo)\n",
    "\n",
    "primeiros_elementos = minha_lista[:2]\n",
    "print(primeiros_elementos)  # Saída: [0, 1]\n",
    "\n",
    "# Pega todos os elementos a partir do índice 2\n",
    "elementos_depois_do_indice_2 = minha_lista[2:]\n",
    "print(elementos_depois_do_indice_2) # Saída: [2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "#3. Slicing com passos\n",
    "\n",
    "#Podemos também especificar um passo (ou incremento) para o fatiamento. \n",
    "#Por exemplo, um passo de 2 pegaria todos os outros elementos.\n",
    "# Pega todos os elementos com um passo de 2 (pegando alternadamente)\n",
    "\n",
    "elementos_alternados = minha_lista[::2]\n",
    "print(elementos_alternados)  # Saída: [0, 2, 4, 6, 8]\n",
    "\n",
    "# Podemos combinar isso com índices iniciais e finais também\n",
    "subconjunto_alternado = minha_lista[2:8:2]\n",
    "print(subconjunto_alternado)  # Saída: [2, 4, 6]\n",
    "\n",
    "\"\"\"\n",
    "Vamos detalhar a operação de slicing minha_lista[2:8:2].\n",
    "\n",
    "No slicing, o formato geral é lista[início:fim:passo].\n",
    "\n",
    "    Início (início): É onde o slicing começa. Se especificado, como neste \n",
    "    caso, o slice começará neste índice.\n",
    "\n",
    "    Fim (fim): É onde o slicing termina, mas é exclusivo, o que significa que \n",
    "    o índice de término especificado não será incluído no slice.\n",
    "\n",
    "    Passo (passo): É o intervalo entre os índices. Isso define de quantos em \n",
    "    quantos índices a lista será \"fatiada\".\n",
    "\n",
    "Usando a nossa lista exemplo:\n",
    "minha_lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "Quando fazemos:\n",
    "subconjunto = minha_lista[2:8:2]\n",
    "\n",
    "Isso pode ser lido como: \"A partir da lista minha_lista, pegue todos os elementos \n",
    "começando no índice 2 até o índice 8 (mas não inclua o índice 8) em intervalos de 2 índices.\"\n",
    "\n",
    "Então, isso nos dá:\n",
    "\n",
    "    minha_lista[2] é 2\n",
    "    minha_lista[4] é 4 (pulamos o índice 3 por causa do passo de 2)\n",
    "    minha_lista[6] é 6 (novamente pulamos o índice 5 por causa do passo de 2)\n",
    "\n",
    "Assim, o subconjunto resultante será: [2, 4, 6]\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "O \"slicing\" de listas em Python é uma ferramenta extremamente útil, que \n",
    "permite manipular e acessar os dados de maneiras versáteis. Dominar essa técnica \n",
    "pode facilitar significativamente muitas operações de manipulação de dados.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4dd2dc15",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "43edac7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista de cores: ['vermelho', 'verde', 'azul', 'amarelo', 'laranja', 'roxo', 'marrom', 'cinza']\n",
      "Cores entre verde e azul: ['verde', 'azul']\n",
      "As duas primeiras cores são: ['vermelho', 'verde']\n",
      "Cores a partir do amarelo: ['amarelo', 'laranja', 'roxo', 'marrom', 'cinza']\n",
      "Cores em posição impares: ['vermelho', 'azul', 'laranja', 'marrom']\n",
      "Cores na ordem inversa: ['cinza', 'marrom', 'roxo', 'laranja', 'amarelo', 'azul', 'verde', 'vermelho']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Slicing de Listas\n",
    "\n",
    "Objetivo: Familiarizar-se com o conceito de \"slicing\" em listas, acessando \n",
    "subconjuntos de listas e utilizando passos para selecionar elementos específicos.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Crie uma lista chamada cores com os seguintes \n",
    "    elementos: \"vermelho\", \"verde\", \"azul\", \"amarelo\", \"laranja\", \"roxo\", \"marrom\", \"cinza\".\n",
    "\n",
    "    2. Acesse e imprima as cores \"verde\" e \"azul\" usando slicing.\n",
    "\n",
    "    3. Imprima as duas primeiras cores da lista utilizando slicing.\n",
    "\n",
    "    4. Imprima todas as cores a partir da cor \"amarelo\" usando slicing.\n",
    "\n",
    "    5. Imprima todas as cores em posições ímpares na \n",
    "    lista (ou seja, \"vermelho\", \"azul\", \"laranja\", \"marrom\") usando slicing com passos.\n",
    "\n",
    "    6. Inverta a ordem das cores na lista usando slicing e imprima o resultado.\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "#1. Crie uma lista chamada cores com os seguintes \n",
    "#elementos: \"vermelho\", \"verde\", \"azul\", \"amarelo\", \"laranja\", \"roxo\", \"marrom\", \"cinza\".\n",
    "cores = [\"vermelho\", \"verde\", \"azul\", \"amarelo\", \"laranja\", \"roxo\", \"marrom\", \"cinza\"]\n",
    "print(f\"Lista de cores: {cores}\")\n",
    "\n",
    "#2. Acesse e imprima as cores \"verde\" e \"azul\" usando slicing.\n",
    "subconjunto = cores[1:3]\n",
    "\n",
    "print(f\"Cores entre verde e azul: {subconjunto}\")\n",
    "\n",
    "#3. Imprima as duas primeiras cores da lista utilizando slicing.\n",
    "primeiras = cores[:2]\n",
    "\n",
    "print(f\"As duas primeiras cores são: {primeiras}\")\n",
    "\n",
    "#4. Imprima todas as cores a partir da cor \"amarelo\" usando slicing.\n",
    "a_partir_amarelo = cores[3:]\n",
    "\n",
    "print(f\"Cores a partir do amarelo: {a_partir_amarelo}\")\n",
    "\n",
    "#5. Imprima todas as cores em posições ímpares na \n",
    "#lista (ou seja, \"vermelho\", \"azul\", \"laranja\", \"marrom\") usando slicing com passos.\n",
    "\n",
    "cores_impares = cores[::2]\n",
    "\n",
    "print(f\"Cores em posição impares: {cores_impares}\")\n",
    "\n",
    "#6. Inverta a ordem das cores na lista usando slicing e imprima o resultado.\n",
    "\n",
    "inverso = cores[::-1]\n",
    "print(f\"Cores na ordem inversa: {inverso}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4abbb28a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "78428e21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "\n",
      "[0, 4, 16, 36, 64]\n",
      "[0, 4, 16, 36, 64]\n",
      "\n",
      "[(1, 4), (2, 3), (3, 2), (4, 1)]\n",
      "[(1, 4), (2, 3), (3, 2), (4, 1)]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "List Comprehensions\n",
    "        Uma maneira concisa de criar listas: [x**2 for x in range(10) if x % 2 == 0]\n",
    "        \n",
    "\"List Comprehensions\" são uma das características mais úteis e elegantes de Python. \n",
    "\n",
    "Elas oferecem uma maneira concisa de criar listas, e são frequentemente \n",
    "mais compreensíveis e mais eficientes do que usar loops.\"\"\"\n",
    "\n",
    "#1. Exemplo básico:\n",
    "\n",
    "#Vamos começar com um exemplo simples. Imagine que queremos \n",
    "#criar uma lista dos quadrados dos números de 0 a 9:\n",
    "quadrados = [x**2 for x in range(10)]\n",
    "print(quadrados)\n",
    "# Saída: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
    "\n",
    "#Exemplo básico e tradicional\n",
    "\n",
    "# Inicializando uma lista vazia chamada \"quadrados\"\n",
    "quadrados = []\n",
    "\n",
    "# Loop através de números de 0 a 9 (pois range(10) gera números de 0 até 9)\n",
    "for x in range(10):\n",
    "    \n",
    "    # Calculando o quadrado do número atual e adicionando à lista \"quadrados\"\n",
    "    quadrados.append(x**2)\n",
    "\n",
    "# Imprimindo a lista \"quadrados\"\n",
    "print(quadrados)\n",
    "\n",
    "#-----------------------------------------------------\n",
    "\n",
    "print()\n",
    "\n",
    "#2. Tradicional\n",
    "\n",
    "#Se quisermos criar uma lista dos quadrados dos números, mas apenas para os números pares de 0 a 9:\n",
    "quadrados_pares = [x**2 for x in range(10) if x % 2 == 0]\n",
    "print(quadrados_pares)\n",
    "# Saída: [0, 4, 16, 36, 64]\n",
    "\n",
    "#Aqui, x % 2 == 0 é uma condição que verifica se o número é par. Portanto, \n",
    "#estamos pegando o quadrado de x apenas para valores de x que são pares.\n",
    "\n",
    "#Exemplo Com condicional e tradicional\n",
    "\n",
    "# Inicializando uma lista vazia chamada \"quadrados_pares\"\n",
    "quadrados_pares = []\n",
    "\n",
    "# Loop através de números de 0 a 9 (pois range(10) gera números de 0 até 9)\n",
    "for x in range(10):\n",
    "    \n",
    "    # Verificando se o número atual é par\n",
    "    if x % 2 == 0:\n",
    "        \n",
    "        # Calculando o quadrado do número par atual e adicionando à lista \"quadrados_pares\"\n",
    "        quadrados_pares.append(x**2)\n",
    "\n",
    "# Imprimindo a lista \"quadrados_pares\"\n",
    "print(quadrados_pares)\n",
    "\n",
    "#------------------------------------------------------\n",
    "\n",
    "print()\n",
    "\n",
    "#3. Exemplo adicional com duas variáveis:\n",
    "\n",
    "#Vamos supor que temos duas listas de números e queremos criar uma \n",
    "#lista de todos os pares possíveis de números que somam 5:\n",
    "a = [1, 2, 3, 4]\n",
    "b = [1, 2, 3, 4]\n",
    "\n",
    "combinacoes = [(x, y) for x in a for y in b if x + y == 5]\n",
    "print(combinacoes)\n",
    "\n",
    "# Definindo duas listas a e b\n",
    "a = [1, 2, 3, 4]\n",
    "b = [1, 2, 3, 4]\n",
    "\n",
    "# Inicializando uma lista vazia chamada \"combinacoes\"\n",
    "combinacoes = []\n",
    "\n",
    "# Loop através de cada elemento em 'a'\n",
    "for x in a:\n",
    "    \n",
    "    # Loop através de cada elemento em 'b'\n",
    "    for y in b:\n",
    "        \n",
    "        # Verificando se a soma de x e y é igual a 5\n",
    "        if x + y == 5:\n",
    "            \n",
    "            # Se for verdade, adiciona a combinação (x, y) à lista \"combinacoes\"\n",
    "            combinacoes.append((x, y))\n",
    "\n",
    "# Imprimindo a lista \"combinacoes\"\n",
    "print(combinacoes)\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48da5bcb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "186a41b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Os dez primeiros números elevados ao cubo: [0, 1, 8, 27, 64, 125, 216, 343, 512, 729]\n",
      "Os dez primeiros números elevados ao cubo: [0, 1, 8, 27, 64, 125, 216, 343, 512, 729]\n",
      "Números de 1 a 20 divisíveis por 3: [3, 6, 9, 12, 15, 18]\n",
      "Números de 1 a 20 divisíveis por 3: [3, 6, 9, 12, 15, 18]\n",
      "\n",
      "Frutas com mais de 5 caracteres: ['banana', 'abacaxi', 'laranja']\n",
      "Frutas com mais de 5 caracteres: ['banana', 'abacaxi', 'laranja']\n",
      "\n",
      "Notas acima de 75: [89, 92, 78, 90, 99, 76, 80, 82]\n",
      "Notas acima de 75: [89, 92, 78, 90, 99, 76, 80, 82]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: List Comprehensions\n",
    "\n",
    "Objetivo: Familiarizar-se com a criação de listas usando a notação \n",
    "concisa de \"List Comprehensions\" em Python.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Use uma list comprehension para criar uma lista dos dez primeiros \n",
    "    números elevados ao cubo e imprima o resultado.\n",
    "\n",
    "    2. Use uma list comprehension para criar uma lista contendo todos os números \n",
    "    de 1 a 20 que são divisíveis por 3. Imprima o resultado.\n",
    "\n",
    "    3. Dada a lista de palavras frutas = [\"maçã\", \"banana\", \"manga\", \"uva\", \"abacaxi\", \"laranja\"], \n",
    "    use uma list comprehension para criar uma lista com as frutas que possuem mais de 5 caracteres. \n",
    "    Imprima o resultado.\n",
    "\n",
    "    4. Dada a lista notas = [89, 92, 56, 78, 45, 34, 90, 99, 65, 76, 80, 82], use \n",
    "    uma list comprehension para obter todas as notas acima de 75 e imprima o resultado.\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "#1. Use uma list comprehension para criar uma lista dos dez primeiros \n",
    "#números elevados ao cubo e imprima o resultado.\n",
    "\n",
    "cubos = [x**3 for x in range(10)]\n",
    "print(f\"Os dez primeiros números elevados ao cubo: {cubos}\")\n",
    "\n",
    "\n",
    "#Exemplo tradicional\n",
    "\n",
    "# Inicializando uma lista vazia chamada \"cubos\"\n",
    "cubos = []\n",
    "\n",
    "# Loop através de números de 0 a 9 (pois range(10) gera números de 0 até 9)\n",
    "for x in range(10):\n",
    "    \n",
    "    # Calculando o cubo do número atual e adicionando à lista \"cubos\"\n",
    "    cubos.append(x**3)\n",
    "\n",
    "# Imprimindo a lista \"cubos\" formatada\n",
    "print(f\"Os dez primeiros números elevados ao cubo: {cubos}\")\n",
    "\n",
    "\n",
    "#2. Use uma list comprehension para criar uma lista contendo todos os números \n",
    "#de 1 a 20 que são divisíveis por 3. Imprima o resultado.\n",
    "\n",
    "divisiveis_por_3 = []\n",
    "\n",
    "#Exemplo tradicional\n",
    "\n",
    "divisiveis_por_3 = [x for x in range(1, 21) if x % 3 == 0]\n",
    "print(f\"Números de 1 a 20 divisíveis por 3: {divisiveis_por_3}\")\n",
    "\n",
    "#Exemplo tradicional\n",
    "\n",
    "# Inicializando uma lista vazia chamada \"divisiveis_por_3\"\n",
    "divisiveis_por_3 = []\n",
    "\n",
    "# Loop através de números de 1 a 20 (pois range(1, 21) gera números de 1 até 20)\n",
    "for x in range(1, 21):\n",
    "    \n",
    "    # Verificando se o número atual é divisível por 3\n",
    "    if x % 3 == 0:\n",
    "        \n",
    "        # Se for verdade, adiciona o número à lista \"divisiveis_por_3\"\n",
    "        divisiveis_por_3.append(x)\n",
    "\n",
    "# Imprimindo a lista \"divisiveis_por_3\" formatada\n",
    "print(f\"Números de 1 a 20 divisíveis por 3: {divisiveis_por_3}\")       \n",
    "        \n",
    "\n",
    "print()\n",
    "\n",
    "#3. Dada a lista de palavras frutas = [\"maçã\", \"banana\", \"manga\", \"uva\", \"abacaxi\", \"laranja\"], \n",
    "#use uma list comprehension para criar uma lista com as frutas que possuem mais de 5 caracteres. \n",
    "#Imprima o resultado.\n",
    "\n",
    "\n",
    "\n",
    "frutas = [\"maçã\", \"banana\", \"manga\", \"uva\", \"abacaxi\", \"laranja\"]\n",
    "\n",
    "frutas_longas = [fruta for fruta in frutas if len(fruta) > 5]\n",
    "\n",
    "print(f\"Frutas com mais de 5 caracteres: {frutas_longas}\")\n",
    "\n",
    "#Exemplo tradicional\n",
    "\n",
    "# Inicializando uma lista vazia chamada \"frutas_longas\"\n",
    "frutas_longas = []\n",
    "\n",
    "# Loop através de cada fruta na lista \"frutas\"\n",
    "for fruta in frutas:\n",
    "    \n",
    "    # Verificando se o comprimento da fruta atual é maior que 5\n",
    "    if len(fruta) > 5:\n",
    "        \n",
    "        # Se for verdade, adiciona a fruta à lista \"frutas_longas\"\n",
    "        frutas_longas.append(fruta)\n",
    "\n",
    "# Imprimindo a lista \"frutas_longas\" formatada\n",
    "print(f\"Frutas com mais de 5 caracteres: {frutas_longas}\")\n",
    "\n",
    "#--------------------------------------------------------\n",
    "\n",
    "print()\n",
    "\n",
    "\n",
    "#4. Dada a lista notas = [89, 92, 56, 78, 45, 34, 90, 99, 65, 76, 80, 82], use \n",
    "#uma list comprehension para obter todas as notas acima de 75 e imprima o resultado.\n",
    "\n",
    "notas = [89, 92, 56, 78, 45, 34, 90, 99, 65, 76, 80, 82]\n",
    "notas_altas = [nota for nota in notas if nota > 75]\n",
    "print(f\"Notas acima de 75: {notas_altas}\")\n",
    "\n",
    "#Exemplo tradicional\n",
    "\n",
    "# Inicializando uma lista vazia chamada \"notas_altas\"\n",
    "notas_altas = []\n",
    "\n",
    "# Loop através de cada nota na lista \"notas\"\n",
    "for nota in notas:\n",
    "    \n",
    "    # Verificando se a nota atual é maior que 75\n",
    "    if nota > 75:\n",
    "        \n",
    "        # Se for verdade, adiciona a nota à lista \"notas_altas\"\n",
    "        notas_altas.append(nota)\n",
    "\n",
    "# Imprimindo a lista \"notas_altas\" formatada\n",
    "print(f\"Notas acima de 75: {notas_altas}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2b5d5ba",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d3e6e6c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "1 2 3 \n",
      "4 5 6 \n",
      "7 8 9 \n",
      "[[1, 4, 7], [2, 5, 8], [3, 6, 9]]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Listas Aninhadas (listas de listas)\n",
    "        Criando e acessando listas dentro de listas.\n",
    "        Utilizando loops aninhados para iterar sobre elas.\n",
    "        \n",
    "Listas aninhadas, ou listas de listas, são basicamente listas que \n",
    "têm outras listas como seus elementos. Elas são úteis em muitas situações, \n",
    "especialmente ao representar estruturas bidimensionais como matrizes.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#1. Criando Listas Aninhadas:\n",
    "\n",
    "#Vamos considerar que queremos representar uma matriz 3x3:\n",
    "matriz = [\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "]\n",
    "\n",
    "#Aqui, matriz é uma lista de 3 elementos, onde cada elemento é, por sua vez, uma lista de 3 números.\n",
    "\n",
    "#2. Acessando Listas Aninhadas:\n",
    "\n",
    "#Para acessar um elemento específico, você precisa especificar dois índices: o índice \n",
    "#da lista externa e o índice da lista interna.\n",
    "\n",
    "#Por exemplo, para acessar o número 5:\n",
    "elemento = matriz[1][1]\n",
    "print(elemento)\n",
    "\n",
    "#O primeiro índice [1] refere-se à segunda lista [4, 5, 6], e o segundo \n",
    "#índice [1] refere-se ao segundo elemento dessa lista, que é 5.\n",
    "\n",
    "#3. Utilizando Loops Aninhados para Iterar:\n",
    "\n",
    "# Para iterar sobre cada elemento da matriz, usamos loops for aninhados:\n",
    "# Loop externo: itera sobre cada linha da matriz\n",
    "for linha in matriz:\n",
    "    \n",
    "    # Loop interno: itera sobre cada número (ou elemento) dentro da linha atual\n",
    "    for numero in linha:\n",
    "        \n",
    "        # Imprime o número atual seguido por um espaço, sem mudar de linha devido ao parâmetro \"end=' '\"\n",
    "        print(numero, end=' ')\n",
    "    \n",
    "    # Uma vez que todos os números de uma linha são impressos, esta linha imprime uma quebra de linha\n",
    "    # para separar visualmente as linhas da matriz ao imprimir\n",
    "    print()  \n",
    "\n",
    "#Aqui, o loop externo itera sobre cada linha da matriz, enquanto o loop \n",
    "#interno itera sobre cada numero dentro da respectiva linha.\n",
    "\n",
    "\n",
    "\n",
    "#4. Exemplo Prático:\n",
    "\n",
    "#Vamos supor que queremos calcular a transposta dessa matriz. \n",
    "#A transposta de uma matriz é obtida trocando suas linhas por colunas:\n",
    "\n",
    "# Inicializando uma lista vazia chamada \"transposta\"\n",
    "transposta = []\n",
    "\n",
    "# Loop através de cada coluna da matriz original\n",
    "for i in range(len(matriz[0])):\n",
    "    \n",
    "    # Inicializa uma linha temporária para construir uma linha da matriz transposta\n",
    "    linha_temporaria = []\n",
    "    \n",
    "    # Loop através de cada linha da matriz original\n",
    "    for j in range(len(matriz)):\n",
    "        \n",
    "        # Adiciona o elemento da posição j,i (transposto) à linha temporária\n",
    "        linha_temporaria.append(matriz[j][i])\n",
    "        \n",
    "    # Adiciona a linha temporária completa à matriz transposta\n",
    "    transposta.append(linha_temporaria)\n",
    "\n",
    "\"\"\"\n",
    "matriz = [\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "]\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f7fcbad",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "01621fb6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valor na segunda linha e terceira coluna: 6\n",
      "Soma dos valores da matriz: 45\n",
      "\n",
      "1\t2\t3\t\n",
      "4\t5\t6\t\n",
      "7\t8\t9\t\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Listas Aninhadas\n",
    "\n",
    "Objetivo: Aprofundar o entendimento sobre listas dentro de listas e como interagir com elas usando loops aninhados.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    Crie uma matriz 3x3 chamada matriz com os seguintes valores:\n",
    "    \n",
    "1, 2, 3\n",
    "4, 5, 6\n",
    "7, 8, 9\n",
    "\n",
    "Represente essa matriz como uma lista de listas.\n",
    "\n",
    "1. Acesse e imprima o valor localizado na segunda linha e terceira coluna (deve ser o número 6).\n",
    "\n",
    "2. Utilizando loops aninhados, calcule e imprima a soma de todos os valores presentes na matriz.\n",
    "\n",
    "3. Usando loops aninhados, imprima a matriz linha por linha, e cada elemento separado por uma tabulação (\\t).\n",
    "\n",
    "Valor na segunda linha e terceira coluna: 6\n",
    "Soma dos valores da matriz: 45\n",
    "Matriz:\n",
    "1\t2\t3\t\n",
    "4\t5\t6\t\n",
    "7\t8\t9\t\n",
    "\n",
    "Esse exercício oferece uma prática abrangente sobre a interação com listas \n",
    "aninhadas e a manipulação de elementos dentro de matrizes.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#Solução\n",
    "\n",
    "#Crie uma matriz 3x3 chamada matriz com os seguintes valores:\n",
    "\n",
    "#Vamos considerar que queremos representar uma matriz 3x3:\n",
    "matriz = [\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "]\n",
    "\n",
    "#1. Acesse e imprima o valor localizado na \n",
    "#segunda linha e terceira coluna (deve ser o número 6).\n",
    "\n",
    "valor = matriz[1][2]\n",
    "\n",
    "print(f\"Valor na segunda linha e terceira coluna: {valor}\") # Saída: 6\n",
    "\n",
    "#2. Utilizando loops aninhados, calcule e imprima a soma de todos\n",
    "#os valores presentes na matriz.\n",
    "\n",
    "# Inicializando a variável \"soma\" com 0. Esta variável armazenará a soma total de todos os números na matriz.\n",
    "soma = 0\n",
    "\n",
    "# Loop externo: itera sobre cada linha da matriz\n",
    "for linha in matriz:\n",
    "    \n",
    "    # Loop interno: itera sobre cada número (ou elemento) dentro da linha atual\n",
    "    for numero in linha:\n",
    "        \n",
    "        # Adiciona o valor do número atual à variável \"soma\"\n",
    "        #soma = soma + numero\n",
    "        soma += numero\n",
    "\n",
    "# Após a conclusão dos loops, a variável \"soma\" contém a soma total de todos os números da matriz.\n",
    "print(f\"Soma dos valores da matriz: {soma}\")  # Saída: 45\n",
    "\n",
    "print()\n",
    "\n",
    "#3. Usando loops aninhados, imprima a matriz linha por linha, \n",
    "#e cada elemento separado por uma tabulação (\\t).\n",
    "\n",
    "print(\"Matriz:\")\n",
    "\n",
    "# Loop externo: itera sobre cada linha da matriz\n",
    "for linha in matriz:\n",
    "\n",
    "    # Loop interno: itera sobre cada número (ou elemento) dentro da linha atual\n",
    "    for numero in linha:\n",
    "    \n",
    "        # Imprime o número atual seguido por uma tabulação (representada por \"\\t\"), \n",
    "        # mantendo os números na mesma linha ao imprimir\n",
    "        print(numero, end=\"\\t\")\n",
    "    \n",
    "    # Uma vez que todos os números de uma linha são impressos, \n",
    "    # esta linha imprime uma quebra de linha para separar as linhas da matriz visualmente ao imprimir\n",
    "    print()  \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8ac0c7f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "553a4c94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 3, 8, 15, 2, 7, 14]\n",
      "O número de elementos na lista é: 7\n",
      "O maior valor na lista é: 15\n",
      "O menor valor na lista é: 2\n",
      "A soma dos elementos na lista é: 55\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Utilidades e Funções com Listas\n",
    "        len(): retorna o número de elementos na lista.\n",
    "        max(): retorna o maior valor.\n",
    "        min(): retorna o menor valor.\n",
    "        sum(): retorna a soma dos elementos.\n",
    "\"\"\"\n",
    "\n",
    "#Exemplo Prático:\n",
    "\n",
    "#Considere a seguinte lista de números:\n",
    "numeros = [6, 3, 8, 15, 2, 7, 14]\n",
    "print(numeros)\n",
    "\n",
    "#len() - Contando o número de elementos:\n",
    "\n",
    "#Esta função retorna o número de elementos na lista.\n",
    "tamanho = len(numeros)\n",
    "print(f\"O número de elementos na lista é: {tamanho}\")\n",
    "\n",
    "\n",
    "#max(): retorna o maior valor.\n",
    "\n",
    "#Esta função retorna o maior valor na lista.\n",
    "maior_valor = max(numeros)\n",
    "print(f\"O maior valor na lista é: {maior_valor}\")\n",
    "\n",
    "\n",
    "#min(): retorna o menor valor.\n",
    "\n",
    "#Esta função retorna o menor valor na lista.\n",
    "menor_valor = min(numeros)\n",
    "print(f\"O menor valor na lista é: {menor_valor}\")\n",
    "\n",
    "#sum() - Somando os elementos:\n",
    "\n",
    "#Esta função retorna a soma total dos elementos na lista.\n",
    "soma_total = sum(numeros)\n",
    "print(f\"A soma dos elementos na lista é: {soma_total}\")\n",
    "\n",
    "\"\"\"\n",
    "Juntas, essas funções oferecem uma maneira rápida e eficaz \n",
    "de obter informações básicas sobre os conteúdos de uma lista em Python.\n",
    "\"\"\"\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3df370d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d38147bc",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 45, 67, 89, 12, 56, 78, 90, 34, 56]\n",
      "O número de elementos na lista de valores é: 10\n",
      "O maior valor na lista de valores é: 90\n",
      "O menor valor na lista de valores é: 12\n",
      "A som dos elementos da lista de valores é: 550\n",
      "\n",
      "[58.5, 63.2, 71.3, 69.4, 68.2]\n",
      "A média dos pesos é: 66.12\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Utilidades e Funções com Listas\n",
    "\n",
    "Objetivo: Compreender e aplicar funções úteis que interagem \n",
    "com listas em Python.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    Dada a lista valores = [23, 45, 67, 89, 12, 56, 78, 90, 34, 56], determine \n",
    "    e imprima o número de elementos na lista usando a função len().\n",
    "\n",
    "    Ainda utilizando a lista valores, encontre e imprima o maior e o menor valor \n",
    "    presente na lista usando as funções max() e min().\n",
    "\n",
    "    Calcule e imprima a soma de todos os elementos na lista valores \n",
    "    usando a função sum().\n",
    "\n",
    "    Crie uma lista pesos com os seguintes valores: 58.5, 63.2, 71.3, 69.4, 68.2. \n",
    "    Calcule e imprima a média dos pesos usando as funções sum() e len().\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "#Dada a lista valores = [23, 45, 67, 89, 12, 56, 78, 90, 34, 56], determine \n",
    "#e imprima o número de elementos na lista usando a função len().\n",
    "\n",
    "valores = [23, 45, 67, 89, 12, 56, 78, 90, 34, 56]\n",
    "print(valores)\n",
    "\n",
    "numero_elementos = len(valores)\n",
    "print(f\"O número de elementos na lista de valores é: {numero_elementos}\")\n",
    "\n",
    "#Ainda utilizando a lista valores, encontre e imprima o maior e o menor valor \n",
    "#presente na lista usando as funções max() e min().\n",
    "\n",
    "maior_valor = max(valores)\n",
    "menor_valor = min(valores)\n",
    "\n",
    "print(f\"O maior valor na lista de valores é: {maior_valor}\")\n",
    "print(f\"O menor valor na lista de valores é: {menor_valor}\")\n",
    "\n",
    "#Calcule e imprima a soma de todos os elementos na lista valores \n",
    "#usando a função sum().\n",
    "\n",
    "soma_valores = sum(valores)\n",
    "\n",
    "print(f\"A som dos elementos da lista de valores é: {soma_valores}\")\n",
    "\n",
    "#Crie uma lista pesos com os seguintes valores: 58.5, 63.2, 71.3, 69.4, 68.2. \n",
    "#Calcule e imprima a média dos pesos usando as funções sum() e len().\n",
    "\n",
    "print()\n",
    "pesos = [58.5, 63.2, 71.3, 69.4, 68.2]\n",
    "\n",
    "print(pesos)\n",
    "\n",
    "media_pesos = sum(pesos) / len(pesos)\n",
    "\n",
    "print(f\"A média dos pesos é: {media_pesos:.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f39fadf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "03dfa109",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maçã\n",
      "banana\n",
      "cereja\n",
      "damasco\n",
      "figo\n",
      "Fruta no índice 0 é maçã\n",
      "Fruta no índice 1 é banana\n",
      "Fruta no índice 2 é cereja\n",
      "Fruta no índice 3 é damasco\n",
      "Fruta no índice 4 é figo\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Iteração em Listas\n",
    "        Usando o loop for.\n",
    "        Usando enumerate() para obter índice e valor ao iterar.\n",
    "\"\"\"\n",
    "\n",
    "#Exemplo prático\n",
    "\n",
    "#Vamos considerar a seguinte lista de frutas:\n",
    "frutas = [\"maçã\", \"banana\", \"cereja\", \"damasco\", \"figo\"]\n",
    "\n",
    "#Usando o loop for para iterar sobre os valores da lista:\n",
    "\n",
    "#Neste exemplo, vamos imprimir cada fruta da lista.\n",
    "for fruta in frutas:\n",
    "    \n",
    "    print(fruta)\n",
    "    \n",
    "#Usando enumerate() para obter índice e valor ao iterar:\n",
    "\n",
    "#A função enumerate() retorna tanto o índice quanto o valor ao iterar \n",
    "#sobre uma lista. Isso é útil quando você quer saber a posição (índice) \n",
    "#de cada item na lista enquanto itera.\n",
    "\n",
    "for indice, fruta in enumerate(frutas):\n",
    "    print(f\"Fruta no índice {indice} é {fruta}\")\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Nota: Em Python, a indexação começa em 0, então a primeira \n",
    "fruta \"maçã\" está no índice 0, a segunda \"banana\" no índice 1 e assim por diante.\n",
    "\n",
    "Com essas técnicas, você pode facilmente iterar sobre listas em Python, acessando \n",
    "não apenas os valores dos itens, mas também seus índices.\n",
    "\"\"\"\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0837780",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "fd407430",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', 'Bruno', 'Clara', 'Daniel', 'Eduarda']\n",
      "Alice\n",
      "Bruno\n",
      "Clara\n",
      "Daniel\n",
      "Eduarda\n",
      "\n",
      "1: Alice\n",
      "2: Bruno\n",
      "3: Clara\n",
      "4: Daniel\n",
      "5: Eduarda\n",
      "\n",
      "[85, 90, 78, 92, 88]\n",
      "['Alice', 'Bruno', 'Clara', 'Daniel', 'Eduarda']\n",
      "Alice obteve nota 85\n",
      "Bruno obteve nota 90\n",
      "Clara obteve nota 78\n",
      "Daniel obteve nota 92\n",
      "Eduarda obteve nota 88\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Iteração em Listas\n",
    "\n",
    "Objetivo: Familiarizar-se com a iteração através de listas usando o \n",
    "loop for e a função enumerate() para acessar o índice e o valor dos elementos.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    Dada a lista nomes = [\"Alice\", \"Bruno\", \"Clara\", \"Daniel\", \"Eduarda\"], use um \n",
    "    loop for para imprimir cada nome na lista.\n",
    "\n",
    "    Utilizando a mesma lista nomes, imprima o nome juntamente com a sua posição na \n",
    "    lista (índice). Para isso, utilize a função enumerate().\n",
    "\n",
    "    Dada a lista notas = [85, 90, 78, 92, 88], use a função enumerate() para imprimir o \n",
    "    nome do aluno da lista nomes e a sua respectiva nota da lista notas.\n",
    "    \n",
    "Este exercício permite praticar a iteração em listas e combinar informações \n",
    "de múltiplas listas usando índices, tudo isso enquanto se familiarizam com a função útil enumerate().\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "#Dada a lista nomes = [\"Alice\", \"Bruno\", \"Clara\", \"Daniel\", \"Eduarda\"], use um \n",
    "#loop for para imprimir cada nome na lista.\n",
    "\n",
    "nomes = [\"Alice\", \"Bruno\", \"Clara\", \"Daniel\", \"Eduarda\"]\n",
    "\n",
    "print(nomes)\n",
    "\n",
    "for nome in nomes:\n",
    "    \n",
    "    print(nome)\n",
    "\n",
    "#Utilizando a mesma lista nomes, imprima o nome juntamente com a sua posição na \n",
    "#lista (índice). Para isso, utilize a função enumerate().\n",
    "\n",
    "print()\n",
    "\n",
    "for indice, nome in enumerate(nomes):\n",
    "    \n",
    "    print(f\"{indice + 1}: {nome}\")\n",
    "\n",
    "#Dada a lista notas = [85, 90, 78, 92, 88], use a função enumerate() para imprimir o \n",
    "#nome do aluno da lista nomes e a sua respectiva nota da lista notas.\n",
    "\n",
    "notas = [85, 90, 78, 92, 88]\n",
    "\n",
    "print()\n",
    "\n",
    "print(notas)\n",
    "print(nomes)\n",
    "\n",
    "for indice, nome in enumerate(nomes):\n",
    "    \n",
    "    print(f\"{nome} obteve nota {notas[indice]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "483b82c2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "5b53e0dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['o', 'l', 'á']\n",
      "['Python', 'é', 'divertido']\n",
      "['12', '10', '2023']\n",
      "\n",
      "Python é incrível\n",
      "['25', '12', '2023']\n",
      "25/12/2023\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Listas e Strings\n",
    "        Conversão de strings para listas: list(), split().\n",
    "        Conversão de listas para strings: join().\n",
    "\"\"\"\n",
    "\n",
    "#Exemplo prático\n",
    "\n",
    "#Conversão de strings para listas\n",
    "\n",
    "#A) Usando list():\n",
    "\n",
    "#Ao usar a função list() em uma string, cada caractere da string \n",
    "#será um elemento da lista resultante.\n",
    "s = \"olá\"\n",
    "lista_s = list(s)\n",
    "print(lista_s)  # Saída: ['o', 'l', 'á']\n",
    "\n",
    "#B) split():\n",
    "\n",
    "#A função split() é usada para dividir uma string em uma lista com \n",
    "#base em um delimitador especificado. Se nenhum delimitador for especificado, ela \n",
    "#dividirá a string nos espaços em branco.\n",
    "frase = \"Python é divertido\"\n",
    "palavras = frase.split()\n",
    "print(palavras)  # Saída: ['Python', 'é', 'divertido']\n",
    "\n",
    "data = \"12/10/2023\"\n",
    "elementos_data = data.split(\"/\")\n",
    "print(elementos_data)\n",
    "\n",
    "#Conversão de listas para strings\n",
    "\n",
    "#Usando join():\n",
    "\n",
    "print()\n",
    "\n",
    "#A função join() é usada para converter uma lista em uma string. Ela une \n",
    "#os elementos de uma lista em uma única string com base em um delimitador especificado.\n",
    "lista_palavras = ['Python', 'é', 'incrível']\n",
    "\n",
    "frase_juntada = ' '.join(lista_palavras)\n",
    "print(frase_juntada)  # Saída: \"Python é incrível\"\n",
    "\n",
    "lista_data = [\"25\", \"12\", \"2023\"]\n",
    "\n",
    "print(lista_data)\n",
    "\n",
    "data_juntada = '/'.join(lista_data)\n",
    "print(data_juntada)\n",
    "\n",
    "\"\"\"\n",
    "Essas são operações comuns quando estamos trabalhando com processamento de texto \n",
    "ou manipulação de dados em Python. Conhecer como converter entre strings e \n",
    "listas é essencial para muitas tarefas!\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cacc357d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "cf1661f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista de caracteres: ['P', 'y', 't', 'h', 'o', 'n']\n",
      "Lista de palavras: ['Aprendendo', 'Python', 'é', 'divertido!']\n",
      "Frase resconstruída: Aprendendo Python é divertido!\n",
      "String de itens: maçã, banana, cereja\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Listas e Strings\n",
    "\n",
    "Objetivo: Familiarizar-se com as operações de conversão entre \n",
    "listas e strings, usando métodos como list(), split(), e join().\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    Dada a string palavra = \"Python\", converta-a para uma lista de \n",
    "    caracteres e imprima a lista resultante. Use o método list() para isso.\n",
    "\n",
    "    Dada a frase frase = \"Aprendendo Python é divertido!\", divida-a em uma \n",
    "    lista de palavras e imprima a lista resultante. Utilize o método split().\n",
    "\n",
    "    Usando a lista do Passo 2, junte as palavras para formar a frase original \n",
    "    novamente e imprima-a. Utilize o método join().\n",
    "\n",
    "    Dada a lista itens = [\"maçã\", \"banana\", \"cereja\"], converta-a em uma string onde \n",
    "    cada item é separado por uma vírgula e um espaço e imprima a string resultante. \n",
    "    \n",
    "    Por exemplo: \"maçã, banana, cereja\".\n",
    "    \n",
    "Saída esperada:\n",
    "\n",
    "Lista de caracteres: ['P', 'y', 't', 'h', 'o', 'n']\n",
    "Lista de palavras: ['Aprendendo', 'Python', 'é', 'divertido!']\n",
    "Frase reconstruída: Aprendendo Python é divertido!\n",
    "String de itens: maçã, banana, cereja\n",
    "\n",
    "Este exercício ajuda os alunos a entender e praticar as transformações \n",
    "entre listas e strings, utilizando os métodos comuns para tais operações.\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "#Dada a string palavra = \"Python\", converta-a para uma lista de \n",
    "#caracteres e imprima a lista resultante. Use o método list() para isso.\n",
    "\n",
    "palavra = \"Python\"\n",
    "\n",
    "lista_palavra = list(palavra)\n",
    "\n",
    "print(\"Lista de caracteres:\", lista_palavra)\n",
    "\n",
    "#Dada a frase frase = \"Aprendendo Python é divertido!\", divida-a em uma \n",
    "#lista de palavras e imprima a lista resultante. Utilize o método split().\n",
    "\n",
    "frase = \"Aprendendo Python é divertido!\"\n",
    "\n",
    "lista_palavras = frase.split()\n",
    "\n",
    "print(\"Lista de palavras:\", lista_palavras)\n",
    "\n",
    "#Usando a lista do Passo 2, junte as palavras para formar a frase original \n",
    "#novamente e imprima-a. Utilize o método join().\n",
    "\n",
    "frase_recontruida = \" \".join(lista_palavras)\n",
    "\n",
    "print(\"Frase resconstruída:\", frase_recontruida)\n",
    "\n",
    "#Dada a lista itens = [\"maçã\", \"banana\", \"cereja\"], converta-a em uma string onde \n",
    "#cada item é separado por uma vírgula e um espaço e imprima a string resultante. \n",
    "\n",
    "itens = [\"maçã\", \"banana\", \"cereja\"]\n",
    "\n",
    "string_itens = \", \".join(itens)\n",
    "\n",
    "print(\"String de itens:\", string_itens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f351cb2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "e6ac7253",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 1\n",
      "Digite o item que deseja adiciona à lista: Amarelo\n",
      "Item adicionado à lista\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 1\n",
      "Digite o item que deseja adiciona à lista: Verde\n",
      "Item adicionado à lista\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 1\n",
      "Digite o item que deseja adiciona à lista: Cinza\n",
      "Item adicionado à lista\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 3\n",
      "Lista de compras\n",
      "-  Amarelo\n",
      "-  Verde\n",
      "-  Cinza\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 1\n",
      "Digite o item que deseja adiciona à lista: Branco\n",
      "Item adicionado à lista\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 3\n",
      "Lista de compras\n",
      "-  Amarelo\n",
      "-  Verde\n",
      "-  Cinza\n",
      "-  Branco\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 2\n",
      "Digite o item que deseja remover da lista: Verde\n",
      "Item removido da lista!\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 3\n",
      "Lista de compras\n",
      "-  Amarelo\n",
      "-  Cinza\n",
      "-  Branco\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 2\n",
      "Digite o item que deseja remover da lista: Amarelo\n",
      "Item removido da lista!\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 3\n",
      "Lista de compras\n",
      "-  Cinza\n",
      "-  Branco\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 2\n",
      "Digite o item que deseja remover da lista: Branco\n",
      "Item removido da lista!\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 3\n",
      "Lista de compras\n",
      "-  Cinza\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 2\n",
      "Digite o item que deseja remover da lista: Cinza\n",
      "Item removido da lista!\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 3\n",
      "Lista de compras\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 2\n",
      "A lista de compras está vazia.\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 1\n",
      "Digite o item que deseja adiciona à lista: A\n",
      "Item adicionado à lista\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 3\n",
      "Lista de compras\n",
      "-  A\n",
      "\n",
      "Menu:\n",
      "1. Adicionar item à lista\n",
      "2. Remover item da lista\n",
      "3. Exibir lista de compras\n",
      "4. Sair\n",
      "Escolha uma opção: 4\n",
      "Saindo...\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Lista de Compras\n",
    "\n",
    "Crie um programa em Python que permita ao usuário adicionar \n",
    "itens a uma lista de compras. O programa deve exibir um menu com as seguintes opções:\n",
    "\n",
    "    1. Adicionar item à lista\n",
    "    2. Remover item da lista\n",
    "    3. Exibir lista de compras\n",
    "    4. Sair\n",
    "\n",
    "O programa deve continuar executando até que o usuário escolha a opção 4 para sair.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "# Inicializa a lista de compras vazia\n",
    "lista_compras = []\n",
    "\n",
    "# Loop principal para manter o programa em execução\n",
    "while True:\n",
    "    \n",
    "    print(\"\\nMenu:\")\n",
    "    print(\"1. Adicionar item à lista\")\n",
    "    print(\"2. Remover item da lista\")\n",
    "    print(\"3. Exibir lista de compras\")\n",
    "    print(\"4. Sair\")\n",
    "\n",
    "    # Solicita ao usuário que escolha uma opção do menu\n",
    "    opcao = int(input(\"Escolha uma opção: \"))\n",
    "\n",
    "    # Se a opção escolhida for 1:\n",
    "    if opcao == 1:\n",
    "        \n",
    "        # Solicita o item a ser adicionado\n",
    "        item = input(\"Digite o item que deseja adicionar à lista: \")\n",
    "        \n",
    "        # Adiciona o item à lista de compras utilizando o método append()\n",
    "        lista_compras.append(item)\n",
    "        \n",
    "        print(\"Item adicionado à lista!\")\n",
    "\n",
    "    # Se a opção escolhida for 2:\n",
    "    elif opcao == 2:\n",
    "        \n",
    "        # Verifica se a lista de compras está vazia\n",
    "        if len(lista_compras) == 0:\n",
    "            \n",
    "            print(\"A lista de compras está vazia.\")\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            # Solicita o item a ser removido\n",
    "            item = input(\"Digite o item que deseja remover da lista: \")\n",
    "            \n",
    "            # Verifica se o item está presente na lista\n",
    "            if item in lista_compras:\n",
    "            \n",
    "                # Remove o item da lista utilizando o método remove()\n",
    "                lista_compras.remove(item)\n",
    "                \n",
    "                print(\"Item removido da lista!\")\n",
    "                \n",
    "            else:\n",
    "                \n",
    "                print(\"O item não está na lista.\")\n",
    "\n",
    "    # Se a opção escolhida for 3:\n",
    "    elif opcao == 3:\n",
    "        \n",
    "        print(\"\\nLista de Compras:\")\n",
    "        \n",
    "        # Itera sobre os itens da lista de compras\n",
    "        for item in lista_compras:\n",
    "            \n",
    "            # Imprime cada item com um hífen no início\n",
    "            print(\"-\", item)\n",
    "\n",
    "    # Se a opção escolhida for 4:\n",
    "    elif opcao == 4:\n",
    "        \n",
    "        print(\"Saindo...\")\n",
    "        \n",
    "        # Encerra o loop e sai do programa\n",
    "        break\n",
    "\n",
    "    # Se a opção escolhida não for válida:\n",
    "    else:\n",
    "        \n",
    "        print(\"Opção inválida. Escolha uma opção válida.\")\n",
    "\n",
    "    # Adiciona uma linha em branco após cada operação\n",
    "    print()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0e1327b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "2360ae44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número: 23\n",
      "Digite um número: 5\n",
      "Digite um número: 9\n",
      "Digite um número: 45\n",
      "Digite um número: 34\n",
      "Números em ordem crescente: [5, 9, 23, 34, 45]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Classificação de Números\n",
    "\n",
    "Seu desafio é escrever um programa que faça o seguinte:\n",
    "\n",
    "    Peça ao usuário para inserir 5 números inteiros, um por um.\n",
    "    Armazene esses números em uma lista.\n",
    "    Classifique os números na lista em ordem crescente.\n",
    "    Imprima a lista classificada.\n",
    "\n",
    "Requisitos:\n",
    "\n",
    "    Utilize um loop (como um for ou while) para coletar os números do usuário.\n",
    "    Utilize o método append da lista para adicionar cada número à lista.\n",
    "    Utilize o método sort da lista para classificar os números.\n",
    "\n",
    "Dicas:\n",
    "\n",
    "    Você pode utilizar um loop for com range(5) para repetir um bloco de \n",
    "    código 5 vezes, uma vez para cada número a ser inserido.\n",
    "\n",
    "Exemplo de Saída:\n",
    "\n",
    "Digite um número: 4\n",
    "Digite um número: 2\n",
    "Digite um número: 5\n",
    "Digite um número: 1\n",
    "Digite um número: 3\n",
    "Números em ordem crescente: [1, 2, 3, 4, 5]\n",
    "\"\"\"\n",
    "\n",
    "# Inicializa uma lista vazia para armazenar os números\n",
    "numeros = []\n",
    "\n",
    "# Usa um loop for para repetir o bloco de código 5 vezes\n",
    "for i in range(5):\n",
    "    \n",
    "    # Pede ao usuário para inserir um número\n",
    "    numero = int(input(\"Digite um número: \"))\n",
    "    \n",
    "    # Adiciona o número inserido pelo usuário à lista de números\n",
    "    numeros.append(numero)\n",
    "\n",
    "# Classifica os números na lista em ordem crescente\n",
    "numeros.sort()\n",
    "\n",
    "# Imprime a lista classificada\n",
    "print(\"Números em ordem crescente:\", numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09642937",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4db8ccee",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16993793",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5caa53c5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "219073d1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b1419dd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f4df9c0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37a962fa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78895287",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b586d7a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd2d3ca2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ffbb1672",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9afbb974",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "baff74e8",
   "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
}