python_for_beginners.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "4595c765",
   "metadata": {},
   "source": [
    "## **Uma visão geral dos conceitos básicos de programação. A programação é o processo de escrever instruções para um computador executar uma tarefa específica. Aqui estão alguns conceitos fundamentais:**\n",
    "\n",
    "1. **Linguagens de programação**: As linguagens de programação são usadas para escrever programas. Elas têm sua própria sintaxe e regras que devem ser seguidas para criar um código válido. Exemplos populares incluem Python, Java, C++ e JavaScript.\n",
    "\n",
    "2. **Variáveis e tipos de dados**: As variáveis são usadas para armazenar dados na memória do computador. Os tipos de dados definem o tipo de valor que uma variável pode armazenar, como números inteiros, números de ponto flutuante, strings (cadeias de caracteres), booleanos, entre outros.\n",
    "\n",
    "3. **Estruturas de controle**: As estruturas de controle permitem controlar o fluxo de execução de um programa. As estruturas básicas incluem condicionais (como o \"if-else\" e o \"switch-case\") e loops (como o \"for\" e o \"while\").\n",
    "\n",
    "4. **Funções**: As funções são blocos de código que executam uma tarefa específica. Elas podem receber parâmetros (dados de entrada) e retornar um valor. As funções ajudam a organizar o código e reutilizá-lo em diferentes partes do programa.\n",
    "\n",
    "5. **Estruturas de dados**: As estruturas de dados são usadas para armazenar e organizar coleções de dados. Exemplos comuns incluem arrays (vetores), listas, conjuntos, pilhas e filas. Cada estrutura tem suas próprias propriedades e métodos para manipulação dos dados.\n",
    "\n",
    "6. **Algoritmos**: Os algoritmos são sequências de passos que resolvem um problema específico. Eles são a base da programação e envolvem a lógica necessária para realizar uma determinada tarefa. Os programadores projetam algoritmos eficientes para melhorar o desempenho e a qualidade dos programas.\n",
    "\n",
    "7. **Orientação a objetos**: A programação orientada a objetos (POO) é um paradigma de programação que organiza o código em objetos, que são instâncias de classes. As classes são estruturas que definem atributos (dados) e métodos (comportamentos) dos objetos. A POO enfatiza a reutilização de código e a abstração de dados.\n",
    "\n",
    "Esses são apenas alguns dos conceitos básicos da programação. À medida que você avança, encontrará tópicos mais avançados, como gerenciamento de memória, manipulação de arquivos, programação de rede e muito mais. A prática é fundamental para desenvolver habilidades de programação, então comece a experimentar e construir seus próprios programas para aprimorar seu conhecimento."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e06e5918",
   "metadata": {},
   "source": [
    "## **Conceitos Básicos**"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "55eb42ed",
   "metadata": {},
   "source": [
    "- ### Tipos de dados\n",
    "Python suporta vários tipos de dados embutidos, que podem ser usados para armazenar diferentes tipos de informações. É importante lembrar que Python é uma linguagem de tipagem dinâmica, o que significa que as variáveis não precisam ser declaradas com um tipo específico. O tipo de dado é inferido automaticamente com base no valor atribuído à variável."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "4282898e",
   "metadata": {},
   "source": [
    "1. **Inteiros (int)**: Representam números inteiros, positivos ou negativos, sem parte fracionária. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "d7b6f657",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 6, 8697, 23344)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 , 6 , 8697, 23344"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "01d63e22",
   "metadata": {},
   "source": [
    "2. **Números de ponto flutuante (float)**: Representam números reais com parte fracionária."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "97f4845e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(45566.556, 3.6, 788.8888)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "45566.556, 3.6, 788.8888"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "87c9aa69",
   "metadata": {},
   "source": [
    "3. **Booleanos (bool)**: Representam valores lógicos verdadeiro ou falso. Os valores possíveis são `True` e `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "f57e32d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 20 \n",
    "b = 40\n",
    "print(a>b) # a é maior que b ?\n",
    "print(a<b) # a é menor que b ?\n",
    "print(a==b) # a é igual b ?\n",
    "print(a!=b) # a é diferente de b?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "8d3a27a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(20=40) # erro de sintaxe , troque \"=\" por \"==\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f06899eb",
   "metadata": {},
   "source": [
    "4. **Strings (str)**: Representam sequências de caracteres. Os caracteres podem ser letras, números, símbolos, etc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "a770e866",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Olá padawan !!! $@%&'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Olá padawan !!! $@%&'"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0d5361e9",
   "metadata": {},
   "source": [
    "4. **Listas (list)**: São coleções ordenadas e mutáveis de elementos. Os elementos podem ser de diferentes tipos.\n",
    "\n",
    "5. **Tuplas (tuple)**: São coleções ordenadas e imutáveis de elementos. Os elementos podem ser de diferentes tipos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "e7dadb7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4] ['a', 'b', 'c'] --> listas são escritas entre cochetes\n",
      "(1, 2, 3) ('a', 'b', 'c') --> tuplas são escritas entre parênteses\n"
     ]
    }
   ],
   "source": [
    "print([1, 2, 3, 4], ['a', 'b', 'c'], '--> listas são escritas entre cochetes')\n",
    "print((1, 2, 3), ('a', 'b', 'c'), '--> tuplas são escritas entre parênteses')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b51dc015",
   "metadata": {},
   "source": [
    "6. **Dicionários (dict)**: São coleções de pares chave-valor, onde cada valor é associado a uma chave única. Os elementos não possuem uma ordem específica.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "4301f0a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nome': 'João', 'idade': 25, 'cidade': 'São Paulo'} --> dicionários são escritas entre chaves\n"
     ]
    }
   ],
   "source": [
    "print({'nome': 'João', 'idade': 25, 'cidade': 'São Paulo'}, '--> dicionários são escritas entre chaves')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "dc0e05ca",
   "metadata": {},
   "source": [
    "- ### Visualizando o tipo da variável \n",
    "\n",
    "A função `type()` em Python é usada para obter o tipo de dado de um objeto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "4a59e969",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "nome =  'Arya Stark'\n",
    "print(type(nome))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "20c40fab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "idade = 16\n",
    "print(type(idade))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "2108bd2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "peso = 52.5\n",
    "print(type(peso))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "2ae9b466",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "Personagem = {'nome': 'Arya Stark', 'idade': 16, 'peso': 52.5}\n",
    "print(type(Personagem))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0b120d10",
   "metadata": {},
   "source": [
    "- ### Operadores aritméticos básicos"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a34dee3f",
   "metadata": {},
   "source": [
    "1. **Adição (+)**: Realiza a adição entre dois valores.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "2282e5c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "11.459\n"
     ]
    }
   ],
   "source": [
    "print(2+6)\n",
    "print(3.56+7.899)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e29c13dd",
   "metadata": {},
   "source": [
    "2. **Subtração (-)**: Realiza a subtração entre dois valores.\n",
    "   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "40850d42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-4\n",
      "-4.339\n"
     ]
    }
   ],
   "source": [
    "print(2-6)\n",
    "print(3.56-7.899)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5fa1ca4c",
   "metadata": {},
   "source": [
    "\n",
    "3. **Multiplicação (\\*)**: Realiza a multiplicação entre dois valores.\n",
    "   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "530d36f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "28.120440000000002\n"
     ]
    }
   ],
   "source": [
    "print(2*6)\n",
    "print(3.56*7.899)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f3d8313f",
   "metadata": {},
   "source": [
    "\n",
    "5. **Divisão (/)**: Realiza a divisão entre dois valores. O resultado é um número de ponto flutuante.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "2827f136",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3333333333333333\n",
      "0.4506899607545259\n"
     ]
    }
   ],
   "source": [
    "print(2/6)\n",
    "print(3.56/7.899)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c5e5a2b4",
   "metadata": {},
   "source": [
    "\n",
    "6. **Divisão inteira (//)**: Realiza a divisão entre dois valores e retorna o resultado como um número inteiro, truncando a parte fracionária.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "0639d8be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "print(2//6)\n",
    "print(3.56//7.899)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "28ffcf3a",
   "metadata": {},
   "source": [
    "7. **Módulo (%)**: Retorna o resto da divisão entre dois valores.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "c12a62bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "0.6610000000000005\n"
     ]
    }
   ],
   "source": [
    "print(6%4)\n",
    "print(8.56%7.899)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "4a333374",
   "metadata": {},
   "source": [
    "8. **Potência (\\*\\*)**: Calcula o valor de um número elevado a uma potência."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "3d1dfb26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n",
      "7246.861909283472\n"
     ]
    }
   ],
   "source": [
    "print(2**6)\n",
    "print(3.56**7)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "92048ba3",
   "metadata": {},
   "source": [
    "- ### Operadores lógicos\n",
    "\n",
    "Os operadores lógicos são usados para realizar operações de avaliação e comparação entre valores lógicos (verdadeiro ou falso) em Python."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9d2d0597",
   "metadata": {},
   "source": [
    "1. **Operador \"and\"**\n",
    "\n",
    "O operador `and` retorna `True` se todas as expressões avaliadas forem verdadeiras, caso contrário, retorna `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "c7233b76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = 10\n",
    "z = 7\n",
    "resultado = (x < y) and (z > y)\n",
    "print(resultado)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "483e79e3",
   "metadata": {},
   "source": [
    "Neste exemplo, `(x < y)` é verdadeiro, mas `(z > y)` é falso. Portanto, o resultado final é `False`.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e135162a",
   "metadata": {},
   "source": [
    "2. **Operador \"or\"**\n",
    "\n",
    "O operador `or` retorna `True` se pelo menos uma das expressões avaliadas for verdadeira. Se todas as expressões forem falsas, retorna `False`. Veja um exemplo:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "c0c31510",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "idade = 25\n",
    "possui_cartao = True\n",
    "possui_limite = False\n",
    "\n",
    "aprovado = (idade >= 18) or (possui_cartao and possui_limite)\n",
    "print(aprovado)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6c24e26e",
   "metadata": {},
   "source": [
    "Neste exemplo, a primeira expressão `(idade >= 18)` é verdadeira, portanto, o resultado final é `True`, mesmo que a segunda expressão `(possui_cartao and possui_limite)` seja falsa.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "37becd2b",
   "metadata": {},
   "source": [
    "\n",
    "3. **Operador \"not\"**\n",
    "\n",
    "O operador `not` é usado para negar o valor de uma expressão. Ele inverte o valor lógico de uma expressão. Veja um exemplo:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "c3a8d9a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "temperatura = 30\n",
    "clima_quente = not (temperatura < 25)\n",
    "print(clima_quente)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fd0f6bed",
   "metadata": {},
   "source": [
    "\n",
    "Neste exemplo, `(temperatura < 25)` é falso, mas `not (temperatura < 25)` inverte o valor para `True`.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5060343e",
   "metadata": {},
   "source": [
    "\n",
    "- Precedência dos operadores lógicos\n",
    "\n",
    "A precedência dos operadores lógicos segue a seguinte ordem: `not` > `and` > `or`. No entanto, é recomendável usar parênteses para evitar ambiguidades e tornar o código mais legível.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "6a5a3a57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resultado = (x < y) and (z > y) or (x == z)\n",
    "resultado"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6e4f96fe",
   "metadata": {},
   "source": [
    "\n",
    "Neste exemplo, os parênteses são usados para definir claramente a ordem das operações.\n",
    "\n",
    "Os operadores lógicos são úteis em construções condicionais, como instruções `if` e loops, para controlar o fluxo do programa com base em condições lógicas."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "414800a2",
   "metadata": {},
   "source": [
    "- ### Combinando String com outras variáveis\n",
    "  \n",
    "Em Python, você pode combinar strings e outras variáveis para criar mensagens personalizadas, exibir resultados formatados ou construir conteúdo dinâmico.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d2e6de09",
   "metadata": {},
   "source": [
    "1. **Concatenação de Strings**\n",
    "\n",
    "A forma mais simples de combinar strings e variáveis é através da concatenação, que é a união de duas ou mais strings em sequência. Você pode usar o operador de adição (+) para concatenar strings. Veja o exemplo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "478b8472",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, meu nome é Maria e tenho 30 anos.\n"
     ]
    }
   ],
   "source": [
    "nome = \"Maria\"\n",
    "idade = 30\n",
    "\n",
    "mensagem = \"Olá, meu nome é \" + nome + \" e tenho \" + str(idade) + \" anos.\"\n",
    "print(mensagem) "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "269a4b95",
   "metadata": {},
   "source": [
    "Neste exemplo, a variável `mensagem` é criada concatenando as strings com os valores das variáveis `nome` e `idade`. É importante converter a variável `idade` para uma string usando a função `str()` para que possa ser concatenada com as outras strings."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fe27f81a",
   "metadata": {},
   "source": [
    "2. **Formatação de Strings (f-strings)**\n",
    "\n",
    "A partir do Python 3.6, você pode usar as f-strings (formatted string literals) para combinar strings e variáveis de forma mais conveniente e legível. As f-strings permitem incluir expressões Python dentro de strings formatadas, colocando-as dentro de chaves {}.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "5570394d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, meu nome é João e tenho 25 anos.\n"
     ]
    }
   ],
   "source": [
    "nome = \"João\"\n",
    "idade = 25\n",
    "\n",
    "mensagem = f\"Olá, meu nome é {nome} e tenho {idade} anos.\"\n",
    "print(mensagem)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0ed42efe",
   "metadata": {},
   "source": [
    "Neste exemplo, as variáveis `nome` e `idade` são inseridas dentro das chaves {} na string formatada. O valor das variáveis é automaticamente convertido em strings e combinado na mensagem."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1f6bf650",
   "metadata": {},
   "source": [
    "3. **Método format()**\n",
    "\n",
    "Outra forma de combinar strings e variáveis é usando o método `format()`. Você pode criar uma string com espaços reservados (placeholders) e, em seguida, chamar o método `format()` para preencher esses espaços com os valores das variáveis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "68b8c593",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A camisa custa 29.99 reais.\n"
     ]
    }
   ],
   "source": [
    "produto = \"camisa\"\n",
    "preco = 29.99\n",
    "\n",
    "mensagem = \"A {} custa {:.2f} reais.\".format(produto, preco)\n",
    "print(mensagem)  # Saída: O camisa custa 29.99 reais.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c900ba17",
   "metadata": {},
   "source": [
    "\n",
    "Neste exemplo, o espaço reservado `{}` é preenchido com os valores das variáveis `produto` e `preco` usando o método `format()`. A notação `:.2f` é usada para formatar o valor do preço com duas casas decimais."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a697814e",
   "metadata": {},
   "source": [
    "- ### Recebendo input do usuário\n",
    "\n",
    "Você pode receber entrada do usuário utilizando a função `input()`. Essa função aguarda o usuário digitar algum valor no console e retorna a entrada como uma string. Veja o exemplo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "6247fb55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, ana! Bem-vindo!\n"
     ]
    }
   ],
   "source": [
    "nome = input(\"Digite o seu nome: \")\n",
    "print(\"Olá, \" + nome + \"! Bem-vindo!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7bb96914",
   "metadata": {},
   "source": [
    "Neste exemplo, a função `input(\"Digite o seu nome: \")` exibe a mensagem \"Digite o seu nome: \" no console e aguarda o usuário digitar o seu nome. O valor digitado pelo usuário é armazenado na variável `nome`. Em seguida, a mensagem de saudação é exibida, utilizando a variável `nome` para personalizar a mensagem.\n",
    "\n",
    "Lembre-se de que a função `input()` sempre retorna uma string, mesmo que o usuário digite um número. Se você precisar converter a entrada do usuário para um tipo diferente, como um número inteiro ou de ponto flutuante, você pode usar as funções `int()` ou `float()`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "eb4553e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O dobro da sua idade é: 28\n"
     ]
    }
   ],
   "source": [
    "idade = int(input(\"Digite a sua idade: \"))\n",
    "dobro_idade = idade * 2\n",
    "print(\"O dobro da sua idade é:\", dobro_idade)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "43856d6a",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Neste exemplo, a função `int()` é usada para converter a entrada do usuário em um número inteiro. Em seguida, o valor da idade é multiplicado por 2 e exibido na mensagem de saída.\n",
    "\n",
    "Tenha em mente que a função `input()` aguarda a entrada do usuário antes de prosseguir com a execução do programa. Portanto, o programa ficará \"pausado\" até que o usuário forneça uma entrada."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a541e647",
   "metadata": {},
   "source": [
    "- ### Indexação, indexação negativa, comprimento da string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "c3766f87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I\n",
      "o\n",
      "o\n",
      "m\n",
      "so não é um t\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "frase = \"Isso não é um treinamento\"\n",
    "print(frase[0])        \n",
    "print(frase[3])       \n",
    "print(frase[-1])    \n",
    "print(frase[-5])  \n",
    "print(frase[2:15])\n",
    "print(len(frase))  "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6859bf7a",
   "metadata": {},
   "source": [
    "\n",
    "A frase \"Isso não é um treinamento\" é atribuída à variável `frase`. Em seguida, mostramos como realizar a indexação para acessar caracteres individuais:\n",
    "\n",
    "- `frase[0]` retorna o primeiro caractere da frase, que é 'I'.\n",
    "- `frase[3]` retorna o quinto caractere da frase, que é 'o'.\n",
    "\n",
    "Também utilizamos a indexação negativa para acessar caracteres a partir do final da string:\n",
    "\n",
    "- `frase[-1]` retorna o último caractere da frase, que também é 'o'.\n",
    "- `frase[-5]` retorna o quinto caractere a partir do final da frase, que é 'm'.\n",
    "- `frase[2:15]` retorna os caractere a partir do terceiro caractere até décimo sexto da frase.\n",
    "\n",
    "Finalmente, utilizamos a função `len()` para obter o comprimento da string:\n",
    "\n",
    "- `len(frase)` retorna o comprimento da frase, que é igual a 25.\n",
    "\n",
    "Observe que a indexação começa em 0, enquanto a indexação negativa começa em -1. O comprimento da string é obtido com a função `len()`, que retorna o número total de caracteres da string."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f253b4cb",
   "metadata": {},
   "source": [
    "- ### Operações nas strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "4a6ee4e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ISSO NÃO É UM TREINAMENTO\n"
     ]
    }
   ],
   "source": [
    "# Converter para letras maiúsculas\n",
    "frase_maiusculas = frase.upper()\n",
    "print(frase_maiusculas)  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "b5bb9585",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "isso não é um treinamento\n"
     ]
    }
   ],
   "source": [
    "# Converter para letras minúsculas\n",
    "frase_minusculas = frase.lower()\n",
    "print(frase_minusculas)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "55b630e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# Contar a ocorrência de um determinado caractere ou substring\n",
    "ocorrencias_o = frase.count(\"o\")\n",
    "print(ocorrencias_o)     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "5444df29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Isso sim é um treinamento\n"
     ]
    }
   ],
   "source": [
    "# Substituir uma substring por outra\n",
    "frase_substituida = frase.replace(\"não\", \"sim\")\n",
    "print(frase_substituida) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "80ff44dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Isso', 'não', 'é', 'um', 'treinamento']\n"
     ]
    }
   ],
   "source": [
    "# Dividir a frase em palavras\n",
    "palavras = frase.split()\n",
    "print(palavras)          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "aab40e53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Isso não é um treinamento . Atirem, atirem !!!!\n"
     ]
    }
   ],
   "source": [
    "# Concatenar com outra frase\n",
    "outra_frase = \". Atirem, atirem !!!!\"\n",
    "frase_concatenada = frase + \" \" + outra_frase\n",
    "print(frase_concatenada) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "7a1b55d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# checar se palavras especificas estão na frase\n",
    "print('não' in frase)\n",
    "print('cavalo' in frase)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "11f68d29",
   "metadata": {},
   "source": [
    "- ### Estruturas de controle:\n",
    "\n",
    "As estruturas de controle em Python são usadas para controlar o fluxo de execução do programa, permitindo que você tome decisões e repita blocos de código de acordo com certas condições. As principais estruturas de controle em Python são as estruturas condicionais (if-else) e os loops (for e while)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "619b5664",
   "metadata": {},
   "source": [
    "1. **Estruturas Condicionais (if-else)**\n",
    "\n",
    "A estrutura condicional `if-else` permite que você execute blocos de código com base em condições específicas.Você pode adicionar quantos blocos `elif` (abreviação de \"else if\") quiser para testar várias condições. Aqui está um exemplo: Aqui está a sintaxe básica:"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "if primiera condição:\n",
    "    # código a ser executado se a primeira condição for verdadeira\n",
    "elif segunda condição:\n",
    "    # código a ser executado se a primiera condição for falsa e a segunda condição for verdadeira\n",
    "elif terceira condição:\n",
    "    # código a ser executado se a primiera e a segunda condição for falsa e a terceira condição for verdadeira\n",
    "else:\n",
    "    # código a ser executado se a condição for falsa\n",
    "```\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c903c132",
   "metadata": {},
   "source": [
    "Aqui está o exemplo do jogo de perguntas e respostas utilizando as estruturas condicionais `if-else`, foi usado método `lower()` para converter as respostas fornecidas pelo jogador em letras minúsculas antes de compará-las com as respostas corretas. Isso garante que a comparação seja feita sem levar em conta a diferenciação entre letras maiúsculas e minúsculas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "3e904d2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bem-vindo ao jogo de perguntas e respostas!\n",
      "\n",
      "Pergunta 1: Qual é a capital do Brasil?\n",
      "Resposta incorreta. A capital do Brasil é Brasília.\n",
      "\n",
      "Pergunta 2: Quantos planetas existem no sistema solar?\n",
      "Resposta incorreta. Existem 8 planetas no sistema solar.\n",
      "\n",
      "Pergunta 3: Qual é o maior mamífero terrestre?\n",
      "Resposta incorreta. O maior mamífero terrestre é o elefante.\n",
      "\n",
      "Pergunta 4: Quem pintou a Mona Lisa?\n",
      "Resposta incorreta. A Mona Lisa foi pintada por Leonardo da Vinci.\n",
      "\n",
      "Obrigado por jogar!\n"
     ]
    }
   ],
   "source": [
    "print(\"Bem-vindo ao jogo de perguntas e respostas!\")\n",
    "\n",
    "# Pergunta 1\n",
    "print(\"\\nPergunta 1: Qual é a capital do Brasil?\")\n",
    "resposta1 = input(\"Resposta: \")\n",
    "\n",
    "if resposta1.lower() == \"brasília\":\n",
    "    print(\"Resposta correta! Parabéns!\")\n",
    "else:\n",
    "    print(\"Resposta incorreta. A capital do Brasil é Brasília.\")\n",
    "\n",
    "# Pergunta 2\n",
    "print(\"\\nPergunta 2: Quantos planetas existem no sistema solar?\")\n",
    "resposta2 = input(\"Resposta: \")\n",
    "\n",
    "if resposta2.lower() == \"8\":\n",
    "    print(\"Resposta correta! Parabéns!\")\n",
    "else:\n",
    "    print(\"Resposta incorreta. Existem 8 planetas no sistema solar.\")\n",
    "\n",
    "# Pergunta 3\n",
    "print(\"\\nPergunta 3: Qual é o maior mamífero terrestre?\")\n",
    "resposta3 = input(\"Resposta: \")\n",
    "\n",
    "if resposta3.lower() == \"elefante\":\n",
    "    print(\"Resposta correta! Parabéns!\")\n",
    "else:\n",
    "    print(\"Resposta incorreta. O maior mamífero terrestre é o elefante.\")\n",
    "\n",
    "# Pergunta 4\n",
    "print(\"\\nPergunta 4: Quem pintou a Mona Lisa?\")\n",
    "resposta4 = input(\"Resposta: \")\n",
    "\n",
    "if resposta4.lower() == \"leonardo da vinci\":\n",
    "    print(\"Resposta correta! Parabéns!\")\n",
    "else:\n",
    "    print(\"Resposta incorreta. A Mona Lisa foi pintada por Leonardo da Vinci.\")\n",
    "\n",
    "print(\"\\nObrigado por jogar!\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7f8cd182",
   "metadata": {},
   "source": [
    "Essas estruturas condicionais permitem que você tome decisões lógicas no seu código, executando diferentes blocos de código com base em diferentes cenários ou condições. Elas são amplamente utilizadas para implementar lógica condicional em programas, permitindo que o programa se adapte e responda de acordo com diferentes situações."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5b58303d",
   "metadata": {},
   "source": [
    "2. **Loops**:\n",
    "\n",
    "Os loops são usados para executar repetidamente um bloco de código até que uma determinada condição seja atendida. Em Python, temos dois tipos principais de loops: `for` e `while`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3e47e43b",
   "metadata": {},
   "source": [
    "\n",
    "- Loop `for`:\n",
    "\n",
    "O loop `for` é usado para iterar sobre uma sequência de elementos (como listas, strings, dicionários) ou um intervalo de números\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6336ad58",
   "metadata": {},
   "source": [
    "No exemplo abaixo, usamos um loop `for` para imprimir uma contagem regressiva de 10 a 1, com um intervalo de 1 segundo entre cada número. No final, exibimos \"Boom!\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "b06210ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Preparar...\n",
      "Apontar...\n",
      "Fogo!\n",
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "Boom!\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "print(\"Preparar...\")\n",
    "time.sleep(1)\n",
    "print(\"Apontar...\")\n",
    "time.sleep(1)\n",
    "print(\"Fogo!\")\n",
    "\n",
    "for i in range(10, 0, -1):\n",
    "    print(i)\n",
    "    time.sleep(1)\n",
    "\n",
    "print(\"Boom!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f91f1fe0",
   "metadata": {},
   "source": [
    "Neste exemplo, usamos um loop for para desenhar um triângulo de altura 5 usando asteriscos. Cada iteração do loop adiciona um asterisco a mais na linha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "0789ff6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "*\n",
      "**\n",
      "***\n",
      "****\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "altura = 5\n",
    "\n",
    "for i in range(altura + 1):\n",
    "    print(\"*\" * i)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "77745c48",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "- Loop `while`:\n",
    "\n",
    "O loop `while` é usado para repetir um bloco de código enquanto uma condição específica for verdadeira.\n",
    "\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1ea38861",
   "metadata": {},
   "source": [
    "Neste exemplo, usamos um loop while para criar um jogo de adivinhação. O jogador deve tentar adivinhar um número secreto gerado aleatoriamente. O loop continua até que o jogador acerte o número secreto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "57ef87ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bem-vindo ao jogo de adivinhação!\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tente um número menor!\n",
      "Tente um número maior!\n",
      "Tente um número menor!\n",
      "Tente um número menor!\n",
      "Tente um número menor!\n",
      "Tente um número menor!\n",
      "Tente um número maior!\n",
      "Tente um número maior!\n",
      "Tente um número maior!\n",
      "Tente um número maior!\n",
      "Tente um número maior!\n",
      "Tente um número maior!\n",
      "Tente um número maior!\n",
      "Tente um número maior!\n",
      "Tente um número menor!\n",
      "Tente um número menor!\n",
      "Tente um número menor!\n",
      "Tente um número menor!\n",
      "Parabéns! Você acertou em 19 tentativas.\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "numero_secreto = random.randint(1, 100)\n",
    "tentativas = 0\n",
    "acertou = False\n",
    "\n",
    "print(\"Bem-vindo ao jogo de adivinhação!\")\n",
    "\n",
    "while not acertou:\n",
    "    tentativa = int(input(\"Digite um número: \"))\n",
    "    tentativas += 1\n",
    "    \n",
    "    if tentativa == numero_secreto:\n",
    "        acertou = True\n",
    "        print(\"Parabéns! Você acertou em\", tentativas, \"tentativas.\")\n",
    "    elif tentativa < numero_secreto:\n",
    "        print(\"Tente um número maior!\")\n",
    "    else:\n",
    "        print(\"Tente um número menor!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2e7f42ea",
   "metadata": {},
   "source": [
    "Os loops infinitos são aqueles em que a condição de parada nunca é atingida, resultando em um loop que continua executando indefinidamente. Embora os loops infinitos possam ser úteis em certos casos específicos, é importante usá-los com cuidado, pois podem levar ao consumo excessivo de recursos do sistema ou a travamentos do programa.\n",
    "Neste exemplo, usamos um loop while para criar um efeito de rolagem de texto. O texto \"Hello, World!\" é repetidamente impresso, deslocando-se um caractere para a direita a cada iteração do loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "fd2f5e36",
   "metadata": {},
   "outputs": [],
   "source": [
    "# texto = \"Hello, World!\"\n",
    "# posicao = 0\n",
    "\n",
    "# while True:\n",
    "#     print(texto[posicao:] + texto[:posicao])\n",
    "#     posicao = (posicao + 1) % len(texto)\n",
    "#     time.sleep(0.5)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8511b287",
   "metadata": {},
   "source": [
    "- ### Listas\n",
    "\n",
    "As listas são usadas para armazenar coleções de itens em uma ordem específica. Elas são mutáveis, o que significa que você pode modificar, adicionar ou remover elementos conforme necessário. Uma lista é uma coleção ordenada de itens, separados por vírgulas e delimitados por colchetes. Os elementos em uma lista podem ser de diferentes tipos, como números, strings, booleanos e até mesmo outras listas."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "87100203",
   "metadata": {},
   "source": [
    "- **Criando uma lista** : Para criar uma lista em Python, basta atribuir os elementos desejados a uma variável usando colchetes [ ]. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "5f4015eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "frutas = [\"maçã\", \"banana\", \"laranja\", \"abacaxi\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "31638c6f",
   "metadata": {},
   "source": [
    "- **Acessando elementos da lista** : Os elementos em uma lista são acessados por meio de seus índices, que indicam a posição do elemento na lista. O primeiro elemento tem índice 0, o segundo tem índice 1 e assim por diante.Para acessar um elemento específico, basta usar o índice correspondente dentro de colchetes `[ ]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "25ef282b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maçã\n",
      "laranja\n"
     ]
    }
   ],
   "source": [
    "frutas = [\"maçã\", \"banana\", \"laranja\", \"abacaxi\"]\n",
    "\n",
    "print(frutas[0])  # Acessando o primeiro elemento da lista\n",
    "print(frutas[2])  # Acessando o terceiro elemento da lista"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "76911896",
   "metadata": {},
   "source": [
    "- **Métodos em listas** :são funções embutidas em Python que permitem realizar operações específicas em uma lista. Esses métodos são aplicados diretamente a um objeto do tipo lista e permitem modificar, acessar ou manipular os elementos dentro da lista de forma conveniente.Os métodos em listas são chamados usando a sintaxe `lista.nome_do_metodo(argumentos)`, onde `lista` é o nome da lista na qual o método será aplicado, `nome_do_metodo` é o nome específico do método e `argumentos` são os valores opcionais que podem ser passados para o método.\n",
    "\n",
    "Aqui estão alguns exemplos de métodos em listas:"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "24e79279",
   "metadata": {},
   "source": [
    "1. `append`: Adiciona um elemento ao final da lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "18afdff5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['maçã', 'banana', 'laranja']\n"
     ]
    }
   ],
   "source": [
    "frutas = [\"maçã\", \"banana\"]\n",
    "frutas.append(\"laranja\")\n",
    "print(frutas) "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5a7cbf2e",
   "metadata": {},
   "source": [
    "2. `insert`: Insere um elemento em uma posição específica da lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "3546897d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['maçã', 'abacaxi', 'banana', 'laranja']\n"
     ]
    }
   ],
   "source": [
    "frutas = [\"maçã\", \"banana\", \"laranja\"]\n",
    "frutas.insert(1, \"abacaxi\")\n",
    "print(frutas) "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2011cf19",
   "metadata": {},
   "source": [
    "3. `remove`: Remove o primeiro elemento da lista que corresponde ao valor especificado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "ad9cdf07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['maçã', 'laranja']\n"
     ]
    }
   ],
   "source": [
    "frutas = [\"maçã\", \"banana\", \"laranja\"]\n",
    "frutas.remove(\"banana\")\n",
    "print(frutas) \n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1300a43c",
   "metadata": {},
   "source": [
    "4. `pop`: Remove e retorna o elemento em uma posição específica da lista. Se nenhum índice for especificado, o último elemento é removido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "b1e7d8a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n",
      "['maçã', 'laranja']\n"
     ]
    }
   ],
   "source": [
    "frutas = [\"maçã\", \"banana\", \"laranja\"]\n",
    "elemento = frutas.pop(1)\n",
    "print(elemento)\n",
    "print(frutas)   \n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "44d9f3ef",
   "metadata": {},
   "source": [
    "5. `index`: Retorna o índice do primeiro elemento na lista que corresponde ao valor especificado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "77b87602",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "frutas = [\"maçã\", \"banana\", \"laranja\"]\n",
    "índice = frutas.index(\"laranja\")\n",
    "print(índice) "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "11f00b55",
   "metadata": {},
   "source": [
    "6. `count`:  Retorna o número de ocorrências de um elemento na lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "1e2ee9ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "frutas = [\"maçã\", \"banana\", \"laranja\", \"banana\"]\n",
    "ocorrências = frutas.count(\"banana\")\n",
    "print(ocorrências)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "138aa20e",
   "metadata": {},
   "source": [
    "7. `sort()`: Ordena os elementos da lista em ordem crescente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "8275adca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "numeros = [4, 2, 7, 1, 5]\n",
    "numeros.sort()\n",
    "print(numeros) "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "01d9c92d",
   "metadata": {},
   "source": [
    "8. `reverse`(): Inverte a ordem dos elementos na lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "d91b0677",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['laranja', 'banana', 'maçã']\n"
     ]
    }
   ],
   "source": [
    "frutas = [\"maçã\", \"banana\", \"laranja\"]\n",
    "frutas.reverse()\n",
    "print(frutas)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "044880b5",
   "metadata": {},
   "source": [
    "Esses são apenas alguns dos métodos disponíveis para manipular listas em Python. Existem muitos outros métodos úteis que você pode explorar, como `extend()`, `clear()`, `copy()`, entre outros."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "18b11d12",
   "metadata": {},
   "source": [
    "9. Concatenando listas com o operador `+`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "d9ef97f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['maçã', 'banana', 'laranja', 'abacaxi']\n"
     ]
    }
   ],
   "source": [
    "frutas1 = [\"maçã\", \"banana\"]\n",
    "frutas2 = [\"laranja\", \"abacaxi\"]\n",
    "\n",
    "frutas = frutas1 + frutas2\n",
    "print(frutas) "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9da6d338",
   "metadata": {},
   "source": [
    "- ### Tuples\n",
    "\n",
    "Tuples são uma estrutura de dados semelhante às listas, mas com uma diferença fundamental: elas são imutáveis, o que significa que seus elementos não podem ser modificados depois de criados. As tuples são usadas para armazenar coleções de itens relacionados."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "546bb273",
   "metadata": {},
   "source": [
    "- **Criando Tuples**: As tuples são definidas usando parênteses `( )` e os elementos são separados por vírgulas. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "2330fe53",
   "metadata": {},
   "outputs": [],
   "source": [
    "frutas = (\"maçã\", \"banana\", \"laranja\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1fac23b2",
   "metadata": {},
   "source": [
    "Você também pode criar uma tuple sem os parênteses, separando os elementos por vírgulas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "752a361e",
   "metadata": {},
   "outputs": [],
   "source": [
    "frutas = \"maçã\", \"banana\", \"laranja\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a9a01f2d",
   "metadata": {},
   "source": [
    "- **Acessando elementos de uma Tuple**: Os elementos de uma tuple podem ser acessados usando índices, da mesma forma que nas listas. O índice do primeiro elemento é 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "d0f37864",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maçã\n",
      "banana\n",
      "laranja\n"
     ]
    }
   ],
   "source": [
    "frutas = (\"maçã\", \"banana\", \"laranja\")\n",
    "\n",
    "print(frutas[0])  \n",
    "print(frutas[1])  \n",
    "print(frutas[2])  "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "64d10e75",
   "metadata": {},
   "source": [
    "- **Comprimento de uma Tuple**: Você pode obter o comprimento de uma tuple usando a função embutida `len()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "8f7da270",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "frutas = (\"maçã\", \"banana\", \"laranja\")\n",
    "\n",
    "comprimento = len(frutas)\n",
    "print(comprimento)  # Output: 3\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "be8187c9",
   "metadata": {},
   "source": [
    "Embora não haja métodos para adicionar, remover ou modificar elementos diretamente em uma tuple, você pode realizar operações como concatenação de tuples, conversão de uma lista para uma tuple e slicing (fatiamento) em tuples. Vale ressaltar que, ao realizar essas operações, você está criando uma nova tuple, pois as tuples são imutáveis."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "79091b87",
   "metadata": {},
   "source": [
    "- **Concatenação de Tuples** : Você pode concatenar duas ou mais tuples usando o operador `+`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "b3b793a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('maçã', 'banana', 'laranja', 'abacaxi')\n"
     ]
    }
   ],
   "source": [
    "frutas1 = (\"maçã\", \"banana\")\n",
    "frutas2 = (\"laranja\", \"abacaxi\")\n",
    "\n",
    "frutas = frutas1 + frutas2\n",
    "print(frutas)  # Output: ('maçã', 'banana', 'laranja', 'abacaxi')\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7d553497",
   "metadata": {},
   "source": [
    "- **Converter uma lista em uma tuple utilizando a função embutida `tuple()`:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "34b00d0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "tup = tuple(lista)\n",
    "print(tup)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "611a615f",
   "metadata": {},
   "source": [
    "- **Por fim, você pode realizar o slicing (fatiamento) em uma tuple para obter uma parte específica dela:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "7cf704d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('banana', 'laranja')\n"
     ]
    }
   ],
   "source": [
    "frutas = (\"maçã\", \"banana\", \"laranja\", \"abacaxi\")\n",
    "parte = frutas[1:3]\n",
    "print(parte)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6116758c",
   "metadata": {},
   "source": [
    "- ### Dicionários\n",
    "  \n",
    "Os dicionários são uma estrutura de dados poderosa e flexível que permite armazenar valores em pares chave-valor. Eles são úteis quando você precisa associar informações relacionadas a uma determinada chave. Eles são definidos usando chaves `{}`, que contêm pares chave-valor separados por dois pontos `:` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "5cd1355b",
   "metadata": {},
   "outputs": [],
   "source": [
    "pessoa = {\"nome\": \"João\", \"idade\": 30, \"cidade\": \"São Paulo\"}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6e68c209",
   "metadata": {},
   "source": [
    "Tambem pode-se criar dicionários vazios e adicionar pares chave-valor posteriormente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "641702e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "pessoa = {}\n",
    "pessoa[\"nome\"] = \"João\"\n",
    "pessoa[\"idade\"] = 30\n",
    "pessoa[\"cidade\"] = \"São Paulo\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7f578b51",
   "metadata": {},
   "source": [
    "- **Acessando Valores em um dicionário** : Os valores em um Dicionário são acessados usando suas respectivas chaves. Você pode usar a sintaxe `nome_do_dicionário[chave]` para recuperar o valor associado a umas das chaves específicas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "692f1aad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "João\n",
      "30\n",
      "São Paulo\n"
     ]
    }
   ],
   "source": [
    "pessoa = {\"nome\": \"João\", \"idade\": 30, \"cidade\": \"São Paulo\"}\n",
    "print(pessoa[\"nome\"])\n",
    "print(pessoa[\"idade\"])\n",
    "print(pessoa[\"cidade\"])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ddace538",
   "metadata": {},
   "source": [
    "- **Adicionando e Modificando Valores** : Você pode adicionar um novo par chave-valor a um dicionário atribuindo um valor a uma nova chave"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "3f97553d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nome': 'João', 'idade': 45, 'cidade': 'Sergipe'}\n"
     ]
    }
   ],
   "source": [
    "pessoa = {\"nome\": \"João\", \"idade\": 30}\n",
    "pessoa[\"cidade\"] = \"Sergipe\" # adiconando um novo par chave-valor\n",
    "pessoa[\"idade\"] = 45 # modificando uma chave que já existe\n",
    "\n",
    "print(pessoa)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "34af573d",
   "metadata": {},
   "source": [
    "- **Removendo Valores**: Você pode remover um par chave-valor de um dicionário usando o comando `del` seguido da chave "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "2c6a7df2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maria: 150\n",
      "Pedro: 90\n",
      "Ana: 120\n"
     ]
    }
   ],
   "source": [
    "pontuacoes = {\"João\": 100, \"Maria\": 150, \"Pedro\": 80}\n",
    "\n",
    "# Adicionar pontuação para um novo jogador\n",
    "pontuacoes[\"Ana\"] = 120\n",
    "\n",
    "# Modificar a pontuação de um jogador existente\n",
    "pontuacoes[\"Pedro\"] = 90\n",
    "\n",
    "# Remover a pontuação de um jogador\n",
    "del pontuacoes[\"João\"]\n",
    "\n",
    "# Imprimir a pontuação atualizada\n",
    "for jogador, pontuacao in pontuacoes.items():\n",
    "    print(f\"{jogador}: {pontuacao}\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "118ba4ac",
   "metadata": {},
   "source": [
    "- **Metódos em Dicionários**: Dicionários em Python possuem vários métodos úteis para manipulação de dados. Aqui estão alguns dos principais métodos disponíveis para dicionários:"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "214ddcac",
   "metadata": {},
   "source": [
    "1. `keys()`: Retorna uma lista contendo todas as chaves do dicionário"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5ec05d04",
   "metadata": {},
   "source": [
    "Nesse exemplo, temos um dicionário chamado \"personagens\" que contém cinco personagens de Game of Thrones. Cada personagem é representado por uma chave e possui um dicionário como valor, contendo informações adicionais sobre o personagem, como casa, título e status."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "38ef53c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Jon Snow', 'Daenerys Targaryen', 'Tyrion Lannister', 'Arya Stark', 'Cersei Lannister'])\n"
     ]
    }
   ],
   "source": [
    "personagens = {\n",
    "    \"Jon Snow\": {\n",
    "        \"casa\": \"Stark\",   \n",
    "        \"título\": \"Rei do Norte\",\n",
    "        \"status\": \"Vivo\"\n",
    "    },\n",
    "    \"Daenerys Targaryen\": {\n",
    "        \"casa\": \"Targaryen\",\n",
    "        \"título\": \"Rainha dos Dragões\",\n",
    "        \"status\": \"Morta\"\n",
    "    },\n",
    "    \"Tyrion Lannister\": {\n",
    "        \"casa\": \"Lannister\",\n",
    "        \"título\": \"Mão da Rainha\",\n",
    "        \"status\": \"Vivo\"\n",
    "    },\n",
    "    \"Arya Stark\": {\n",
    "        \"casa\": \"Stark\",\n",
    "        \"título\": \"Sem Rosto\",\n",
    "        \"status\": \"Viva\"\n",
    "    },\n",
    "    \"Cersei Lannister\": {\n",
    "        \"casa\": \"Lannister\",\n",
    "        \"título\": \"Rainha Regente\",\n",
    "        \"status\": \"Morta\"\n",
    "    }\n",
    "}\n",
    "\n",
    "chaves = personagens.keys()\n",
    "print(chaves)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1d1890fc",
   "metadata": {},
   "source": [
    "2. `values()`: Retorna uma lista contendo todos os valores do dicionário."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "87cf6dd1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values([{'casa': 'Stark', 'título': 'Rei do Norte', 'status': 'Vivo'}, {'casa': 'Targaryen', 'título': 'Rainha dos Dragões', 'status': 'Morta'}, {'casa': 'Lannister', 'título': 'Mão da Rainha', 'status': 'Vivo'}, {'casa': 'Stark', 'título': 'Sem Rosto', 'status': 'Viva'}, {'casa': 'Lannister', 'título': 'Rainha Regente', 'status': 'Morta'}])\n"
     ]
    }
   ],
   "source": [
    "valores = personagens.values()\n",
    "print(valores)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f6c8a14e",
   "metadata": {},
   "source": [
    "3. `items()`: Retorna uma lista contendo tuplas (chave, valor) para cada item do dicionário."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "b986824f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('Jon Snow', {'casa': 'Stark', 'título': 'Rei do Norte', 'status': 'Vivo'}), ('Daenerys Targaryen', {'casa': 'Targaryen', 'título': 'Rainha dos Dragões', 'status': 'Morta'}), ('Tyrion Lannister', {'casa': 'Lannister', 'título': 'Mão da Rainha', 'status': 'Vivo'}), ('Arya Stark', {'casa': 'Stark', 'título': 'Sem Rosto', 'status': 'Viva'}), ('Cersei Lannister', {'casa': 'Lannister', 'título': 'Rainha Regente', 'status': 'Morta'})])\n"
     ]
    }
   ],
   "source": [
    "itens = personagens.items()\n",
    "print(itens)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5f5149ef",
   "metadata": {},
   "source": [
    "4. `get(chave, valor_default)`: Retorna o valor associado a uma chave especificada. Se a chave não existir, retorna um valor padrão (opcional)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "0d463b9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nome: Cersei Lannister\n",
      "Casa: Lannister\n",
      "Status: Morta\n"
     ]
    }
   ],
   "source": [
    "# Exemplo de uso do método get para acessar informações\n",
    "nome = \"Cersei Lannister\"\n",
    "casa = personagens.get(nome, {}).get(\"casa\")\n",
    "status = personagens.get(nome, {}).get(\"status\")\n",
    "\n",
    "print(f\"Nome: {nome}\")\n",
    "print(f\"Casa: {casa}\")\n",
    "print(f\"Status: {status}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "df52179f",
   "metadata": {},
   "source": [
    "5. `pop(chave, valor_default)`: Remove e retorna o valor associado a uma chave especificada. Se a chave não existir, retorna um valor padrão (opcional)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "bce9b47b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nome: Cersei Lannister\n",
      "Casa: Lannister\n",
      "Status: Morta\n",
      "{'Jon Snow': {'casa': 'Stark', 'título': 'Rei do Norte', 'status': 'Vivo'}, 'Daenerys Targaryen': {'casa': 'Targaryen', 'título': 'Rainha dos Dragões', 'status': 'Morta'}, 'Tyrion Lannister': {'casa': 'Lannister', 'título': 'Mão da Rainha', 'status': 'Vivo'}, 'Arya Stark': {'casa': 'Stark', 'título': 'Sem Rosto', 'status': 'Viva'}}\n"
     ]
    }
   ],
   "source": [
    "# uso do método pop para remover e obter informações de um personagem\n",
    "nome = \"Cersei Lannister\"\n",
    "personagem = personagens.pop(nome, {})\n",
    "\n",
    "if personagem:\n",
    "    casa = personagem.get(\"casa\", \"Informação não disponível\")\n",
    "    status = personagem.get(\"status\", \"Informação não disponível\")\n",
    "\n",
    "    print(f\"Nome: {nome}\")\n",
    "    print(f\"Casa: {casa}\")\n",
    "    print(f\"Status: {status}\")\n",
    "else:\n",
    "    print(f\"O personagem '{nome}' não existe no dicionário.\")\n",
    "\n",
    "print(personagens)  # Dicionário atualizado após o pop"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6d9f0ed2",
   "metadata": {},
   "source": [
    "Neste exemplo, usamos o método `pop()` para remover o personagem \"Cersei Lannister\" do dicionário de personagens. Ao mesmo tempo, armazenamos as informações do personagem em uma variável chamada personagem. Se o personagem existir no dicionário, podemos acessar suas informações normalmente. Caso contrário, exibimos uma mensagem informando que o personagem não existe no dicionário.\n",
    "\n",
    "O método `pop()` é útil quando precisamos remover um item específico de um dicionário e, ao mesmo tempo, obter suas informações. Se o item não existir no dicionário, podemos fornecer um valor padrão para retornar."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "284008d9",
   "metadata": {},
   "source": [
    "6. `update(dicionario)`: Atualiza o dicionário com os pares chave-valor de outro dicionário."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "be79baef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Jon Snow': {'casa': 'Stark', 'título': 'Rei do Norte', 'status': 'Vivo'}, 'Daenerys Targaryen': {'casa': 'Targaryen', 'título': 'Rainha dos Dragões', 'status': 'Morta'}, 'Tyrion Lannister': {'casa': 'Lannister', 'título': 'Mão da Rainha', 'status': 'Vivo'}, 'Arya Stark': {'casa': 'Stark', 'título': 'Sem Rosto', 'status': 'Viva'}, 'Cersei Lannister': {'casa': 'Lannister', 'título': 'Rainha Regente', 'status': 'Morta'}}\n"
     ]
    }
   ],
   "source": [
    "personagens = {\n",
    "    \"Jon Snow\": {\n",
    "        \"casa\": \"Stark\",\n",
    "        \"título\": \"Rei do Norte\",\n",
    "        \"status\": \"Vivo\"\n",
    "    },\n",
    "    \"Daenerys Targaryen\": {\n",
    "        \"casa\": \"Targaryen\",\n",
    "        \"título\": \"Rainha dos Dragões\",\n",
    "        \"status\": \"Morta\"\n",
    "    },\n",
    "    \"Tyrion Lannister\": {\n",
    "        \"casa\": \"Lannister\",\n",
    "        \"título\": \"Mão da Rainha\",\n",
    "        \"status\": \"Vivo\"\n",
    "    }\n",
    "}\n",
    "\n",
    "novos_personagens = {\n",
    "    \"Arya Stark\": {\n",
    "        \"casa\": \"Stark\",\n",
    "        \"título\": \"Sem Rosto\",\n",
    "        \"status\": \"Viva\"\n",
    "    },\n",
    "    \"Cersei Lannister\": {\n",
    "        \"casa\": \"Lannister\",\n",
    "        \"título\": \"Rainha Regente\",\n",
    "        \"status\": \"Morta\"\n",
    "    }\n",
    "}\n",
    "\n",
    "personagens.update(novos_personagens)\n",
    "\n",
    "print(personagens)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}